Profª Angelina V.S.

Melaré
1

PROI³. ANGILINA V.S. MILARÉ
ANGILINAMILARI@GMAIL.COM






2011
FATEC ITU



Linguagem
C
Profª Angelina V.S.Melaré
2
SUMÁRIO

Lógica de Programação ................................................................................................................... 7
Algoritmo ........................................................................................................................................ 8
Estruturas dos Algoritmos: Linear / Seletiva/ Repetição ............................................................. 10
Método para a construção de Algoritmo ....................................................................................... 10
Etapas de Desenvolvimento .......................................................................................................... 12
Tipos de Algoritmos ...................................................................................................................... 14
1. Tipos de Algoritmos ........................................................................................................... 14
Pseudocódigo ................................................................................................................................ 15
Fluxograma .................................................................................................................................... 16
Diagrama de Chapin ...................................................................................................................... 18
Paradigmas de Programação – forma de programar ...................................................................... 19
1. Programação Não Estruturada: ........................................................................................... 19
2. Programação Estruturada (Procedural): ............................................................................. 19
3. Programação Orientada a Objetos ...................................................................................... 20
Modularidade ................................................................................................................................ 20
4. Estratégia de Decomposição ou “Dividir para Conquistar” ............................................... 20
5. Módulos .............................................................................................................................. 21
Linguagem C ................................................................................................................................. 23
Processo de Compilação e Ciclo de Vida do Programa ................................................................ 24
6. Linguagem C Compiladora ou Interpretadora? ............................................................. 24
7. Ciclo de Vida do Programa ................................................................................................ 24
Ambiente de Desenvolvimento DEV-C++ ................................................................................... 26
1. Ambiente integrado ............................................................................................................ 26
2. Configurando o ambiente e o editor ................................................................................... 26
3. Configurações para o Windows Vista/7 ............................................................................. 27
4. Digitação do programa ....................................................................................................... 27
5. Gravação do programa ....................................................................................................... 27
6. Compilação e execução do programa ................................................................................. 27
7. Criando um código fonte padrão ........................................................................................ 28
Estrutura do Programa na Linguagem C ....................................................................................... 29
1. Estrutura básica .................................................................................................................. 29
2. Diretivas ............................................................................................................................. 29
3. Arquivos de Cabeçalho (header) ........................................................................................ 30
4. Biblioteca ........................................................................................................................... 31
5. Bloco de instruções e Função MAIN() ............................................................................... 31
6. Projeto ................................................................................................................................ 31
7. Regras de Digitação e Dicas da Estrutura em C ................................................................. 31
8. Comentários ....................................................................................................................... 32
Variáveis ........................................................................................................................................ 33
1. O que são variáveis? ........................................................................................................... 33
2. Mas em que parte da memória vão os dados? .................................................................... 33
Identificadores ........................................................................................................................... 33
3. Declaração de variável ....................................................................................................... 34
Constantes ..................................................................................................................................... 35
Tipos de dados ............................................................................................................................... 36
Profª Angelina V.S.Melaré
3
1. Numérico ............................................................................................................................ 36
2. Literal/ Cadeia de Caracteres .............................................................................................. 36
3. Lógicas ............................................................................................................................... 37
4. Caracter .............................................................................................................................. 37
5. Espaço Alocado de Memória ............................................................................................. 37
6. Modificadores de Tipos ...................................................................................................... 38
Dica: Pode-se definir valores em outras bases (diferente da decimal): ..................................... 38
7. Tabela ASCII (American Standard Code for Information Interchange) ............................ 39
8. Código de Barra Invertida .................................................................................................. 40
Operadores Aritméticos ................................................................................................................. 42
1. Operadores Aritméticos ...................................................................................................... 42
Os operadores aritméticos são os operadores usados nas operações básicas da matemática.
Esses operadores são usados para representar as expressões matemáticas, os resultados são
valores numéricos. ..................................................................................................................... 42
Eles são: +, -, *, /. ...................................................................................................................... 42
Ainda existem o mod e o div, que representam o resto da divisão e o quociente da divisão na
respectiva ordem. Esses operadores somente podem ser usados para números inteiros. .......... 42
Operadores Aritméticos da Linguagem C ................................................................................. 43
2. Operadores de Incremento e Decremento .......................................................................... 43
3. Operadores Aritméticos de Atribuição ou C Reduzido ...................................................... 43
4. Conversão de Tipo ............................................................................................................. 43
Prioridade dos Operadores Aritméticos ........................................................................................ 44
Funções Matemáticas e Operadores Bit a Bit ................................................................................ 47
1. Funções Matemáticas ......................................................................................................... 47
2. Operadores de deslocamento de bits .................................................................................. 47
1. Função Rand() e SRand() ................................................................................................... 48
Estrutura de Controle Linear/ Sequencial...................................................................................... 49
Funções de Entrada e Saída Formatada ......................................................................................... 50
1. Função de Saída - printf() ................................................................................................... 50
2. Função de Entrada – scanf() ............................................................................................... 51
1. Função de Entrada de caracter– getch() e getchar() ........................................................... 52
Exemplos ....................................................................................................................................... 52
Exercícios Resolvidos e Propostos ................................................................................................ 55
Operador Relacional e Lógico ....................................................................................................... 56
1. Operadores Relacionais ...................................................................................................... 56
2. Operadores Lógicos ............................................................................................................ 56
3. Tabela Verdade: é o conjunto das possibilidades combinatórias dos operadores lógicos. 57
4. Prioridade dos Operadores ................................................................................................. 57
Estrutura de Decisão /Condicional/ Seleção ................................................................................. 58
Exercício Resolvido ...................................................................................................................... 59
Tipos de Estruturas de Decisão ..................................................................................................... 60
1. Estrutura de Decisão Simples ............................................................................................. 60
2. Estrutura de Decisão Composta: ........................................................................................ 61
3. Estrutura de Decisão Encadeada: ....................................................................................... 62
Intervalos ....................................................................................................................................... 63
Operador Ternário ......................................................................................................................... 64
Seleção Múltipla ............................................................................................................................ 65
Exercícios Resolvidos ................................................................................................................... 67
Profª Angelina V.S.Melaré
4
Variáveis de Bloco ........................................................................................................................ 68
Estrutura de Repetição................................................................................................................... 69
Estrutura de Repetição Condicional (Enquanto..Faça / Faça..Enquanto / Repita..até) ................ 70
1. Repetição com Pré-condição- Enquanto..faça .................................................................... 70
2. Repetição com Pós-condição - Faça..Enquanto ................................................................. 71
3. Repetição com Pós-condição - Repita..até ......................................................................... 71
4. Comandos Break, Continue função Exit() ........................................................................ 72
5. Enquanto Verdadeiro .......................................................................................................... 73
Repetição Pré-Definida – Para ...................................................................................................... 75
6. Estrutura em C .................................................................................................................... 76
Variáveis Contadoras e Acumuladoras ......................................................................................... 78
SubAlgoritmos/ Modularização .................................................................................................... 79
1. Sub-Rotinas (Módulos) ...................................................................................................... 79
2. Declaração da Função......................................................................................................... 79
3. A função principal - main() ................................................................................................ 80
4. Comando Return ................................................................................................................ 81
5. Tipo Void ........................................................................................................................... 81
6. Protótipos de Funções ........................................................................................................ 82
7. Chamada (ativação) da Função ......................................................................................... 82
8. Exemplo Completo de Função ........................................................................................... 83
9. Classes de Armazenamento de Variáveis ........................................................................... 83
Função com Passagem de Parâmetro por Valor ............................................................................ 85
Funções Recursivas ....................................................................................................................... 89
Vetores .......................................................................................................................................... 91
1. Conceito ............................................................................................................................. 91
2. Exemplos: ........................................................................................................................... 91
3. Declaração: ......................................................................................................................... 91
4. Acessando os elementos ..................................................................................................... 92
5. Armazenando os elementos ................................................................................................ 92
6. Endereço do vetor ou matriz unidimensional ..................................................................... 92
7. Exercícios Resolvidos: ....................................................................................................... 93
Vetor String (Cadeias de Caracteres) ............................................................................................ 94
Matriz ............................................................................................................................................ 98
1. Matriz Bidimensional ......................................................................................................... 98
2. Declaração: ......................................................................................................................... 98
3. Armazenando os elementos ................................................................................................ 98
4. Armazenamento feito via teclado ....................................................................................... 99
5. Mostrando os elementos ..................................................................................................... 99
Ponteiros ...................................................................................................................................... 100
1. Variáveis ponteiros ........................................................................................................... 100
2. Trabalhando com Matriz através de Ponteiros ................................................................. 103
Funções com Passagem de Parâmetros por Referência ............................................................... 105
3. Passagem de Matriz por Referência ................................................................................. 106
Estruturas ..................................................................................................................................... 108
União e Enumeração ................................................................................................................... 116
1. União – union ................................................................................................................... 116
2. Tipo enumeração .............................................................................................................. 117
Arquivos ...................................................................................................................................... 118
Profª Angelina V.S.Melaré
5
3. Abertura do arquivo.......................................................................................................... 118
4. Fechamento do arquivo .................................................................................................... 119
5. Leitura .............................................................................................................................. 119
6. Gravação ........................................................................................................................... 120
Posicionamento e Pesquisa em arquivo binário ...................................................................... 125
7. Verificando o final do arquivo binário ............................................................................. 125
8. Para apagar um arquivo .................................................................................................... 125
Conceitos Básicos ....................................................................................................................... 126
Nível de Programação das Linguagens ....................................................................................... 128
Bibliografia Consultada e Referenciada ...................................................................................... 129


Profª Angelina V.S.Melaré
6



PRIMEIRA PARTE


ALGORITMOS




















Profª Angelina V.S.Melaré
7
Lógica de Programação

A lógica usada na programação é a mesma lógica usada diariamente pelas pessoas. É a
lógica uma das características que diferencia um ser humano de outro, capaz de torná-lo mais
coerente e racional nas suas ações e com bom senso para tomar as decisões.

Mas como é essa lógica? De onde ela vem?
A palavra lógica vem do grego ‘logos’, que significa “expressão, pensamento, conceito,
discurso, razão”. Uma das definições de lógica encontrada no dicionário Aurélio é “a coerência
do raciocínio de idéias”.
O estudo da lógica começou na Grécia antiga com o filósofo Aristóteles, que definiu
lógica como sendo “a ciência da demonstração”. Segundo Aristóteles, a lógica estuda a razão
como instrumento da ciência ou meio de adquirir a verdade. Como o objetivo da razão é o
raciocínio, a lógica está ligada ao raciocínio, uma operação discursiva do pensamento que
consiste em encadear logicamente juízos e dele tirar uma conclusão.
O escritor Othon Manoel Garcia define lógica como a ciência das leis ideais do
pensamento, a arte que nos faz proceder, com ordem, facilmente e sem erro, no ato próprio da
razão.
O que é ter lógica?
Ter lógica é estar em uma determinada situação e saber a melhor maneira de proceder. É
conseguir visualizar todas as possibilidades existentes daquele momento e decidir pela mais
adequada.
Quanto mais a pessoa tenta raciocinar corretamente ela estará procurando ter lógica.
Forbellone, destaca a lógica usada no dia-a-dia, pois quando pensamos, falamos, agimos estamos
criando uma ordem no pensamento e nas ações, isto é utilizar lógica.

Mas e a Lógica de Programação?
Segundo Forbellone, é a aplicação das leis do pensamento e de processos simbolizados de
maneira formal nos computadores, onde são empregadas técnicas para a produção de soluções
logicamente válidas e que resolvem problemas que serão programados. Para isso serão
desenvolvidos os Algoritmos.

O que é um bom programa/sistema?
O importante na programação é desenvolver programas que atendam as necessidades do
usuário, com funcionalidade, rapidez, desempenho e confiabilidade. Um bom programa não
depende exclusivamente da linguagem de programação.
Segundo Forbellone, “...fundamental à formação do
profissional de programação estão a desenvolver a lógica e a
construção de algoritmos...”

É preciso ter Lógica de Programação:
“Ter lógica é raciocinar coerentemente, avaliar as ações
tomadas, organizar o pensamento, visualizar todas as
possibilidades, atualizar as informações e traçar um objetivo”

Mas como passar a nossa lógica para o computador?
Uma das ferramentas para isso é o Algoritmo.
O que eu devo fazer agora?????
Profª Angelina V.S.Melaré
8
Algoritmo

O objetivo de todo o estudo da Lógica de Programação é a construção de Algoritmos
coerentes e válidos.
O algoritmo é um processo onde você organiza e coloca passo a passo suas idéias para
atingir um objetivo pré-definido. Também pode-se definir como uma sequência de passos. Esse
processo é feito numa linguagem fácil, em seqüências ordenadas e encadeadas, de forma que as
pessoas possam usá-la sem problemas.
O algoritmo é uma das primeiras e melhores formas usadas para se conseguir resolver
problemas no computador ou mesmo na sua vida cotidiana. Quando você precisar solucionar um
problema a primeira coisa que deverá fazer é fazer uma análise do mesmo, coletar os dados e
estruturar as operações que devem ser realizadas.
Pense na sua vida real, num problema comum a todos. Vamos imaginar que você irá
organizar uma festa. Quais são os procedimentos a serem tomados?
Para fazer um algoritmo desse problema é preciso antes coletar as idéias:
- você precisa convidar os amigos;
- arrumar um som e músicas;
- comprar salgados e bebidas;
- procurar o local da festa;

Depois organizá-las de acordo com suas prioridades. É preciso saber qual o primeiro
passo a se tomar para depois ver o momento de executar o segundo, não esquecendo que o
primeiro deve já estar pronto.
É como fazer um pudim gostoso de forma rápida. Como você faria? Você colocaria a
forma no forno aceso antes de fazer a massa? Como você usaria seu raciocínio lógico nesse
procedimento?

É por isso que devemos aprender a ter um raciocínio lógico. Será através dele que você
conseguirá ser um bom programador.

Quando começarmos a desenvolver algoritmos estaremos desenvolvendo nosso raciocínio
lógico, pois começaremos a prestar mais atenção aos detalhes. Observaremos que cada situação,
por mais simples que seja pode-se tornar complicada. Mas como assim? Vocês devem estar
pensando.

Estado inicial ações empregadas de Estado final
forma clara e precisa





Algoritmo
Período de tempo finito
Objetivo
Atingido
Profª Angelina V.S.Melaré
9

Pensem neste problema: Como você faria para comer uma banana?
Podemos fazer um Algoritmo que usa o português coloquial para resolver isso:
1º Você terá que saber onde está a banana
2º Pegar a banana
3º Descascar a banana
4º Por fim, comer a banana.
Parece ser simples resolver esse problema, onde citamos quatro etapas ordenados de
procedimentos. Mas será que você pensou em tudo? Será que a sua lógica está bem
desenvolvida? Se você acha que sim, errou. Você ainda precisará desenvolver muito o seu
raciocínio lógico.
Mas por quê? Você deve estar fazendo está pergunta. Eu respondo na criação de um novo
algoritmo:
• Você terá que saber onde está a banana
• Pegar a banana
• Descascar a banana
• Verificar se a banana não está estragada por dentro
• Se estiver estragada
o Você deverá jogá-la
• Senão, se estiver inteira boa
o Você deverá comer a banana.
Nesse caso a sua lógica está mais elaborada, verificando uma situação que pode ocorrer.
Mas ainda não está totalmente completa. Pois, você não acha que a pessoa na hora de pegar a
banana já deveria ver o estado da banana por fora? Se ela estiver preta ou amassada, então a
pessoa já deveria tê-la jogado fora e pegado outra, de forma que todo o processo seria repetido
novamente. Veja no algoritmo abaixo:
1º Você terá que saber onde está a banana
2º Pegar a banana
3º Verificar o estado da banana por fora
4º Se a banana estiver preta ou amassada
- deverá ser jogada fora
- e pegar outra banana
- verificar o estado da banana
- se a banana estiver preta, amassada
.....
5º Se a banana estiver com aparência bonita por fora deverá ser descascada
6º Verificar se a banana não está estragada por dentro
7º Se estiver estragada você deverá
- jogá-la
- pegar outra banana
- verificar o estado da banana por fora
- se a banana estiver preta, amassada
- deverá ser jogada fora
- pegar outra banana
- verificar o estado da banana
- se a banana estiver preta, amassada
.....
Profª Angelina V.S.Melaré
10


Estruturas dos Algoritmos: Linear / Seletiva/ Repetição

Perceba que ao fazer o primeiro algoritmo se pensava numa sequência de ações (passos)
de forma linear, ou seja, uma ação sendo executada após a outra. Mas, muitas vezes isso não
pode ser realizado, pois, surgem verificações, testes que precisam ser feitos e de acordo com o
resultado deste é que serão definidas as ações que serão executadas.
O primeiro algoritmo - pegar a banana e comê-la. O segundo faz uma verificação, um
teste quanto ao estado da banana. São duas estruturas de algoritmos diferentes: uma linear e outra
de seleção.

o Sequência define o fluxo de execução do algoritmo

o Sequência Linear ou Estrutura Sequencial: onde um conjunto de ações são executadas
uma após a outra, passo a passo, num fluxo contínuo do começo ao fim. A execução
começa de cima para baixo, da esquerda para a direita

o Estrutura Condicional ou Estrutura de Seleção ou Estrutura de Decisão: a ordem de
execução e as ações dependem do valor resultante de uma verificação. Nem sempre se
quer que todas as ações sejam executadas, de forma que se pode fazer uma seleção e
desvio delas de acordo com um teste condicional.

o Estrutura de Repetição: algumas ações podem ser repetidas, executadas várias vezes.
Nessa estrutura a sequência de execução dependerá de uma condição, onde dependendo
do resultado dela, será mudada ou não a sequência de execução.



Método para a construção de Algoritmo

• •• • Leia e releia atentamente todo o enunciado do problema, procurando
identificar e entender todos os detalhes. Não passe para a outra fase se tiver
dúvidas no enunciado. É preciso ter convicção no entendimento do que foi lido.
Muitas vezes o enunciado é grande, complexo, cheio de valores e
informações, mas depois de lido e avaliado percebe-se que sua solução é simples e que muitas
informações contidas são desnecessárias.

• Faça uma análise de tudo, procurando definir explicitamente o que está contido
no enunciado, destacando os pontos mais importantes.

• Elimine os detalhes supérfluos.

• •• • Identifique as informações necessárias para a solução do problema: as entradas.
Veja se essas informações já estão contidas no enunciado ou precisarão ser recebidas.
Para isso é importante ler até o final o enunciado, sem tomar decisões precipitadas. Selecione as
informações e fique apenas com as mais importantes, as que serão necessárias e usadas nas
Profª Angelina V.S.Melaré
11
operações. Lembre-se que quando você precisar de uma informação e ela não estiver no
enunciado, isso significa que ela é uma entrada.

• •• • Verifique as regras que estão explicitas e implícitas: o processamento
As saídas podem ser consultas ou operações de transformação dos dados de entradas em
saídas.

• •• • Defina as informações que devem ser mostradas no final, ou seja, as respostas do
problema.

• •• • Desenvolva o algoritmo.

• Verifique se o algoritmo feito está atingindo o seu objetivo: teste
Para isso faça alguns testes com dados fictícios e verifique se o algoritmo está mostrando
corretamente a solução do problema. Se o resultado não for satisfatório, leia novamente o
enunciado, revise o algoritmo e efetue novos testes, até conseguir o resultado desejado.

ABSTRAÇÃO
Existe dentro da resolução de problemas o termo Abstração. Ao desenvolver um
algoritmo você está preocupado em desenvolver e representar o raciocínio lógico de
programação, mas sem se ater a detalhes computacionais, que serão depois pensados e acrescidos
na codificação. Então ao abstrair, se deixa de lado as informações supérfluas, se atem ao que é
importante para chegar a resolução do problema.
A abstração tem como objetivo tirar informações supérfluas e introduzir uma notação
concisa. Para esse objetivo ser alcançado devem-se identificar os objetos e os aspectos
importantes, dar-lhes nomes e definir operações que possam ser aplicadas aos objetos,
permitindo assim realizar uma consistência em relação as regras do problema.

Profª Angelina V.S.Melaré
12

Etapas de Desenvolvimento
No Processamento de Dados se recebem os dados, se realizam as operações sobre esses
dados e no final são geradas as respostas ou resultados como saída.

Entrada Processamento Saída


Entrada: A entrada é o processo onde você avalia o enunciado do problema e verifica quais
dados estão presentes no enunciado e quais não estão, mas que são essenciais para a solução do
problema. Quando faltar algum dado você terá que recebê-lo de alguma maneira. Sem as
entradas não há como resolver um problema.
O número de entradas é muito variado e depende do objetivo do programa.
A entrada pode ser recebida por vários dispositivos de entradas. Pode ser lida de um
arquivo ou de qualquer outro periférico de entrada, como teclado ou scanner. Então, a entrada
pode ser direta, através do usuário (receber o salário) ou indireta, através da máquina (pegar a
data do sistema).
Cuidado: não são entradas os dados que podem ser gerados através de um cálculo
ou de outras entradas.

Processamento: É um processo que pega os dados de entrada e efetua uma operação (que pode
ou não ser matemática), ou uma atribuiçã. Nessa etapa também podem ser feitas comparações e
consultas, gerando dessa forma o resultado e a solução do problema.

Saída: É a parte mais fácil e mais importante de todo o processo, onde devem ser exibidos os
resultados de todo o processamento. A saída pode ser feita por qualquer dispositivo de saída,
desde o monitor até a caixa de som.

Vamos mostrar as etapas de desenvolvimento com um exemplo muito simples e fácil de
resolver. Depois aumentaremos o grau de complexidade, mostrando sempre as alterações.

1º Exemplo:
O Analista de Sistemas Joaquim pediu para o programador Júlio fazer um programa que efetue
a multiplicação de dois números.
1º É necessário ler atentamente todo o exercício.
2º Retire o que é supérfluo, fique apenas com os dados necessários.
3º Defina as três etapas principais de seu algoritmo:

Entrada: Quais os dados de entrada necessários?
Lendo o enunciado verificamos que para fazer o cálculo é necessário ter dois números, só
que estes não foram especificados e não sabemos quais são, por isso devemos recebê-los.
Outro detalhe importante é ignorar/desprezar a história colocada no enunciado, como os
nomes e funções dos personagens.

Processamento: Qual cálculo deve ser feito com os dados de entrada?
Lendo o enunciado vemos que a operação a ser feita com os dados de entrada é a
multiplicação.
Profª Angelina V.S.Melaré
13

Saída: O que deverá ser mostrado? Qual o objetivo do enunciado?
O objetivo do enunciado é calcular e mostrar o resultado da multiplicação de dois
números.

Tendo as idéias é só montar o algoritmo:
1º Saber o valor do primeiro número
2º Saber o valor do segundo número
3º Fazer a multiplicação dos dois números
Número 1 x Número 2 = ???
4º Mostrar o resultado da multiplicação

2º exemplo:
Juracema foi a livraria e comprou dois livros iguais de programação. Quanto ela pagará?
Entrada: Quais são os dados de entrada necessários?
Saber o preço do livro

Processamento: Qual cálculo deve ser feito com os dados de entrada?
Multiplicar o preço pela quantidade comprada, no caso 2. Veja que nessa situação
a quantidade já foi informada (2 livros), por isso, já a temos e não devemos solicitá-la como
entrada.

Saída: O que deverá ser mostrado? Qual o objetivo do enunciado?
Descobrir o valor que Juracema terá que pagar no caixa.

Algoritmo:
1º Receber o valor do livro
2º Multiplicar o valor do livro por dois (2).
3º Mostrar o resultado do cálculo da multiplicação
Profª Angelina V.S.Melaré
14

Tipos de Algoritmos

Os algoritmos podem ser escritos de diferentes maneiras, dependendo da sua aplicação.
Nesta apostila desenvolveremos os algoritmos de forma estruturada e padronizada
(pseudocódigo), possibilitando com isso um melhor entendimento dos processos.

1. Tipos de Algoritmos
Os tipos de algoritmos mais conhecidos são:
• Descrição Narrativa
• Fluxograma
• Pseudocódigo
• Diagrama de Chapin
Todos esses tipos de algoritmos consistem em analisar o enunciado do problema e
descrever os passos necessários para a resolução do problema. O que os diferencia é a forma de
descrever e simbolizar esses passos. Até o momento todos os algoritmos feitos foram através da
Descrição Narrativa.

• Descrição Narrativa ou Linguagem Natural: A Descrição Narrativa consiste em
analisar o enunciado e escrever os passos utilizando uma linguagem natural, usada
diariamente pelas pessoas.
Vantagem: não é necessário aprender nenhum conceito novo, pois a língua natural
(português) já é conhecida.
Desvantagem: a ambigüidade da linguagem coloquial, o uso de adjetivos ou a falta
de clareza quanto as fórmulas matemáticas. A língua natural abre espaço para várias
interpretações (dependendo da pessoa que o ler), o que posteriormente dificultará a
transcrição desse algoritmo para programa.

• Fluxograma: O Fluxograma consiste em analisar o enunciado e escrever os passos
utilizando símbolos gráficos predefinidos.
Vantagem: o entendimento de elementos gráficos é mais fácil que o entendimento
de textos.
Desvantagem: é necessário aprender a simbologia gráfica do fluxograma e as
correções são mais trabalhosas por se tratar de representação gráfica.

• Pseudocódigo (português estruturado - portugol - pseudolinguagem): O
Pseudocódigo consiste em analisar o enunciado e escrever os passos por meio de
regras pré-definidas. As regras usadas neste material são estruturadas de acordo
com a programação na linguagem C.
Vantagem: a passagem do algoritmo para qualquer linguagem de programação é
quase imediata, bastando conhecer as palavras reservadas da linguagem de programação
que será utilizada. Será como uma tradução, já que será criada a estrutura do algoritmo
baseada na linguagem.
Desvantagem: é necessário aprender as regras do pseudocódigo.


Profª Angelina V.S.Melaré
15
Pseudocódigo

Como já foi mencionada acima a passagem do pseudocódigo para uma linguagem de
programação é mais rápida e a probabilidade de erros menor.

Regras de criação do Pseudocódigo
1. Todos os programas têm um começo, um meio e um fim. Dessa forma, deve ser indicado
o início e o fim, internamente as ações que serão executadas.
2. Deve ser usado o recurso de endentação, que é deslocamento horizontal, transmitindo o
sentido de hierarquia de execução.
3. Deve ser feito uso de termos únicos que definem uma ação, como: escreva, leia, se..então.
4. Deve ser feito uso do conceito de variáveis, assim como sua declaração.


Exemplo de Problema: Receba um número real e verifique se este é positivo, negativo ou
nulo

Descrição Narrativa
1º Receber um número
2º Se o número for maior que zero, então, mostre uma mensagem alertando que o número é
positivo.
3º Se o número for menor ou igual 0 então, deve aparecer uma mensagem avisando que o número
é negativo ou nulo.

Pseudocódigo
Início
real num;
escreva (“Digite um número”);
leia (num);
se (num > 0) então
escreva (“Número positivo”);
senão
escreva (“Número negativo ou nulo”);
Fim

Qual das formas anteriores você escolheria para construir um algoritmo? Qual desses
exemplos mostra de forma mais clara as ações?


Profª Angelina V.S.Melaré
16
Fluxograma

O fluxograma é um tipo de Algoritmo que representa graficamente (figuras geométricas)
os passos necessários para a resolução do problema. Para cada passo efetuado, seja o de entrada,
o de processamento, o de saída ou condição tem-se um símbolo de representação. Algumas
empresas adotam símbolos padronizados no fluxograma.
Com a representação por símbolos gráficos fica mais rápida a visualização da lógica
empregada para resolver o problema.


Símbolo

Nome


Finalidade





















Terminal


Processamento


Conexão

Direção do Fluxo


Decisão


Processamento
Prédefinido


Teclado de Linha


Entrada/Saída


Documento ou
Relatório

Exibição


Conector de Página


Subrotina

Indica o início, continuidade ou fim


Indica operação, cálculo ou atribuição


Utilizado para ligar pontos do fluxograma

Utilizado para indicar a seqüência da execução, conecta os
símbolos

Indica a tomada de uma decisão ou comparação. Podendo
provocar desvios na seqüência lógica de execução


Utilizado nas estruturas de repetição


Indica a entrada de dados por via teclado


Pode ser usado tanto para entrada quanto para a saída de
informações

Indica operação de saída via impressora


Indica as saídas de informações por dispositivos visuais


Usado para indicar a sequência em outra folha/página


Específica a chamada de uma subrotina

Profª Angelina V.S.Melaré
17
SENHA = “MARTH”
O fluxograma para ser feito com êxito, mostrando claramente os processos, deve seguir algumas
regras:
_ ser bem confeccionado;
_ ser legível;
_ ter símbolos bem dimensionados e alinhados;
_ ter setas que indiquem a direção do fluxo das informações;
_ a direção dos lados para as condições devem ser fixos;
_ o fluxo deve começar de cima para baixo e da esquerda para a direita;
_ não pode haver encontro das linhas de indicação do fluxo.
_ as informações escritas dentro dos símbolos devem ser claras, resumidas e bem
entendidas.

Estrutura a ser usada
Veja os símbolos a serem usados e uma explicação mais detalhada de suas finalidades.

TERMINAL: A principal representação desse símbolo é indicar o início e o
fim de uma série de procedimentos. Quando usarmos este símbolo devemos
identificar sua função escrevendo dentro dele as palavras INÍCIO, FIM.

DIREÇÃO DE FLUXO: Essas setas indicam a direção do próximo passo a ser
executado, que pode estar a direita, a esquerda, em baixo ou em cima. Ele conecta os
símbolos e o fluxo de execução, ou seja a sequência da ação a ser executada.

TECLADO DE LINHA: Existem vários símbolos que
representam a entrada de dados, mas como a maioria dos
programas a serem feitos terão os dados digitados via teclado
usaremos o símbolo do trapézio.

PROCESSAMENTO: O símbolo do retângulo deve ser usado toda vez que existir
qualquer tipo de processamento; seja um cálculo, uma atribuição de valores as
variáveis, ou mesmo alteração de qualquer dado.
B = 6

C = A + B



EXIBIÇÃO: O símbolo de Exibição é um símbolo gráfico que representada
saída,e serve para mostrar uma mensagem, um resultado.

Receber
SALARIO
Profª Angelina V.S.Melaré
18
CONEXÃO: Algumas vezes o espaço reservado para fazer o fluxograma é pequeno e
temos que dividi-lo em partes, usando o símbolo gráfico do conector.

A = 3 B = 6
1
1
C = A + B
K
K
FIM
INÍCIO




Diagrama de Chapin

O Diagrama de Chapin utiliza poucos símbolos e não precisa de nenhum conhecimento
específico. A desvantagem de uso ocorre quando precisa de muito espaço na horizontal e fica
mais difícil a compreensão. Veja os exemplos abaixo:

a)
Início
Escreva “Mensagem”
Fim

b)
Início
Escreva “Digite seu nome”
Leia NOME pelo teclado
Escreva “Bom Dia” + NOME
Fim

c)
Início
Leia A e B no teclado
A é maior que B?

Sim Não
Escreva
“A é maior que B”
Escreva
“B é maior que A”
Fim


Profª Angelina V.S.Melaré
19
Paradigmas de Programação – forma de programar

As Linguagens de Programação adotam um estilo (padrão) de desenvolvimento. Esse
estilo que possui características comuns identificam a linguagem, podendo ser: programação não
estruturada, programação estruturada, programação orientada à objetos/eventos, programação
lógica. De acordo com o Paradigma de Programação será desenvolvida a Lógica de Programação.

1. Programação Não Estruturada:

Nessa programação a sequência de ações que serão executadas são seqüenciais,
obedecendo uma numeração de linhas. O único modo de fazer desvios é usando o Vá Para
(codificando é GOTO). Essa linguagem não possui estruturas de controle de repetição como
Faça..Enquanto (while) e não permite a estratégia de modularização.
Exemplo de linguagem não estruturada: Assembly e Basic

Algoritmo Não Estruturado:
1. Vá para DESVIO2
2. DESVIO1.
3. Se precisar comprar então
4. Vá para DESVIO3
5. Vá para DESVIO5
6. DESVIO3.
7. Procure a chave do carro
8. Se achou então
9. Vá para DESVIO 2
10. Vá para DESVIO 4
11. DESVIO2.


2. Programação Estruturada (Procedural):

• Em 1965 Edward Dijkstra apresentou um artigo que sugere a programação estruturada e a
eliminação de comandos de desvio.
• Esse paradigma foi desenvolvido por Bohm e Jacopine em 1966, onde eles demonstraram
que a lógica pode ser expressa através de algumas estruturas básicas.
• Possuem as estruturas: linear (seqüencial), decisão (condição ou escolha), de iteração
(repetição ou laço)
• Em 1967, Floyd sugeriu o uso de comentários intercalados.
• Em 1970, Nicklaus Wirth sugeriu o processo de decomposição (refinamento sucessivo
das etapas).
• A linguagem estruturada foi desenvolvida em grande parte pela má legibilidade causada
pelas instruções de controle de algumas linguagens não estruturadas.
• Na programação não estruturada se usava muito a instrução de desvio GOTO para criar
estruturas de laços (iterações).
• Segundo Rinaldi, o que caracteriza a programação estruturada é a possibilidade de divisão
de tarefas em rotinas ou blocos independentes entre si. A primeira regra para fazer um
programa é a decomposição lógica do problema em partes independentes.
o Exemplo:
Profª Angelina V.S.Melaré
20
Rotina: Calculo do desconto de IR
• Bloco de verificação da faixa das alíquotas

• Nesse paradigma o programa tem uma seqüência de instruções executadas linearmente e
seus dados tratados de forma independente das funções, diferente da Programação
Orientada a Objetos.
• Na programação estruturada é permitido incluir sentenças em qualquer parte da linha.
• A linguagem C não é totalmente estruturada em blocos, porque não permite criar uma
função dentro da outra.


3. Programação Orientada a Objetos
• Nessa programação existe a definição de classes, encapsulamento, herança, que está
relacionada com a reutilização e padronização de código.
• A orientação a objetos vem propiciar o aumento de produtividade, diminuição do custo
de desenvolvimento e manutenção (manutenção evolutiva e não corretiva).
• As classes são criadas para representar (categorizar) um conjunto de entidades (objetos)
que possuem as mesmas características e comportamento (ou mesmo similares) dentro de
um contexto.


Quando você for escolher uma linguagem de programação, considere também a:
FORMA DE EXECUÇAO (Compilador ou Interpretador) e o NÍVEL DE
PROGRAMAÇÃO (baixo, alto)

Modularidade

4. Estratégia de Decomposição ou “Dividir para Conquistar”
A decomposição é uma estratégia de resolução de problemas. A idéia é dividir o
problema em problemas menores (subproblemas), até que cada parte (subdivisão) seja pequena o
bastante para que a solução seja facilmente encontrada.
Segundo Villas, o termo Dividir para Conquistar veio da guerra, onde é mais fácil vencer
grupos isolados de inimigos do que todos os inimigos juntos.
A decomposição de um problema reduz a complexidade do mesmo, pois a complexidade
também é dividida. O foco da atenção fica isolado, de forma que se concentra em um problema
por vez. Quando se tem todos de uma vez, o desenvolvimento da lógica se dispersa e não se
chega a nenhum resultado.
A solução é mais rápida, já que a complexidade é menor que ao original.
Como exemplo, podemos destacar o exemplo Folha de Pagamento de uma empresa.
Supondo que o objetivo principal é gerar o demonstrativo de um funcionário. Inicialmente parece
ser bem complexo, mas se você analisar com calma tem como dividir esse problema, em
problemas menores, como o de calculo de descontos e cálculos de benefícios.

Esse processo deve ser feito da seguinte maneira:
1. Divida o problema em suas partes principais – no caso da folha, descontos,
benefícios seria um subproblema.
2. Analise a divisão e veja a coerência da divisão
Profª Angelina V.S.Melaré
21
3. Se uma divisão ainda estiver complexa, decomponha novamente. – os descontos
podem ser divididos por especialidade
4. Reavalie tudo novamente.

Essa decomposição continua também é conhecida como refinamento sucessivo. Porque
parte de um problema complexo e abrangente que é sucessivamente dividido em problemas mais
simples e específicos.
A técnica de Refinamento Sucessivo também pode se chamar Top-down (de cima para
baixo), uma vez que parte de um problema mais abrangente (abstrato) até atingir um nível mais
detalhado e específico. Normalmente essa técnica é a mais fácil de compreender.
Automóvel inteiropeças separadas parafusos

Existe a técnica Bottom-up (de baixo para cima), que é o inverso dessa. Essa parte dos
conceitos mais detalhados e específicos e vai agrupando em níveis mais abrangentes (abstratos),
até atingir o nível desejado.
Potenciação multiplicar somar
o Segundo Rinaldo, a modulação é uma técnica de resolução de problemas, onde se
divide o problema maior (principal) em problemas menores. A solução do
problema maior ocorre em decorrência da solução dos menores.

5. Módulos
Cada subproblema é um módulo ou podemos dizer que é um subalgoritmo ou subproblema
que realiza tarefas específicas. Em termos funcionais, existem dois tipos de módulos:

1. Procedimento: é um módulo que executa uma tarefa específica, que pode ou não gerar
várias saídas usando as variáveis globais ou locais. Ele não retorna valores para o
módulo que o chamou.

2. Função: é um modulo que irá gerar uma única saída e que será devolvida para a função
principal ou módulo que o chamou.

Resumo das vantagens:

• Subdivisão dos algoritmos complexos: facilita o entendimento;
• Estruturação de algoritmos: facilita detecção de erros e a documentação do sistema
• Modularização de sistemas: facilita a manutenção e reutilização do algoritmo
Profª Angelina V.S.Melaré
22





SEGUNDA PARTE


LINGUAGEM C



















Profª Angelina V.S.Melaré
23
Linguagem C

A linguagem C foi desenvolvida por programadores para programadores. Ela se
popularizou rapidamente devido a sua velocidade, segurança e eficiência. Com ela é possível
desenvolver desde um simples programa (uma calculadora) até um sistema operacional.

Origens da linguagem C
A linguagem C foi criada por Dennis Ritchie em 1972. Sua origem foi através da
linguagem BCPL, desenvolvida por Martin Richards, que influenciou Ken Thompson a criar o B,
que levou a linguagem C.
Com a popularização dos microcomputadores houve um aumento no desenvolvimento de
implementações em C, criando discrepâncias entre elas. Para resolver essa situação, o órgão
americano de padronização (American National Standards Institute), em 1983, criou C padrão
ANSI, estabelecendo uma definição padronizada da linguagem C. A maioria dos compiladores
são compatíveis com esse padrão.
A linguagem C++ foi construída sobre os fundamentos da linguagem C e dá suporte para
a Programação Orientada a Objetos.
Existem vários ambientes de desenvolvimento para a linguagem C, como: DEV-C++,
Visual C++, Turbo C, CodeBlocks. O ambiente a ser usado é o Dev-C++, cujo compilador é a
implementação Mingw do GCC (Gnu C Compiler).

Resumo histórico
• 1966 – BCPL (Martin Richards)
• 1970 - B (Ken Thompson)
• 1972 – C (Dennis Ritchie)
• 1978 – Livro The C Programming Language (Brian Kernigham e Dennis Ritchie)
• 1983 - C padrão ANSI - órgão americano de padronização (American National Standards
Institute) – O padrão ANSI definiu o conteúdo da biblioteca padrão C, palavras
reservadas, estrutura da linguagem (protótipo da função).
• 1985 - C++ (é o C projetado para suportar Programação Orientada a Objetos).

Características e Vantagens:
• Facilidade para aprendizagem de outras linguagens de programação, inclusive as
orientadas a objetos
• Constituído por funções
• Linguagem de programação estruturada
• Ferramenta poderosa de desenvolvimento (pode desenvolver um editor de texto, um
aplicativo comercial, um programa para microcontrolador)
• Portabilidade- em relação a mudança do código para plataforma Windows ou Linux
• Linguagem compiladora
Profª Angelina V.S.Melaré
24

Processo de Compilação e Ciclo de Vida do Programa


6. Linguagem C Compiladora ou Interpretadora?

Uma linguagem de programação pode ser compiladora ou interpretadora. O que as
distingue é a forma com que elas executam o programa.
O interpretador lê o código fonte linha a linha, executando-as em seguida. Já o
compilador, lê o código fonte inteiro e se este não tiver erros de sintaxe, será convertido em um
código de máquina, fazendo com que o processador consiga entendê-lo e executá-lo. Se forem
feitas alterações no programa, este terá que ser compilado novamente, gerando um novo código
de máquina.
Um computador só pode executar programas em linguagem de máquina. Cada programa
executável é uma seqüência de instruções que o processador interpreta e executa as operações
correspondentes.
O código fonte é a tradução dos comandos do pseudocódigo para as respectivas
instruções da linguagem de programação (por exemplo, linguagem C). Essas instruções depois
são traduzidas para a linguagem da máquina (que é a linguagem interna que o computador
entende).
O arquivo objeto somente é gerado quando o arquivo fonte não possui erro de sintaxe.


7. Ciclo de Vida do Programa

Criação do programa
Para se fazer um programa deve-se escrever uma sequência correta de instruções que
deverão se executados pelo computador. Para se chegar nessa sequência deve-se desenvolver o
Algoritmo. Essa lógica deve ser desenvolvida numa linguagem natural, parecida com a do ser
humano, que pode ser a Descrição Narrativa e o Pseudocódigo.
Depois de solucionado o problema e escrito o algoritmo em pseudocódigo, este deve ser
passado para uma linguagem de programação, ou seja, codificado. Na nossa disciplina será
usada a linguagem de programação C. O programa codificado e digitado se chama Arquivo
Fonte. Este deve ser salvo com a extensão “.C”. Se não for digitada a extensão, será assumirá a
extensão .cpp que é padrão do ambiente de desenvolvimento (cpp – significa c plus plus ou c++).
Para executar esse programa é necessário compilá-lo e linká-lo. Na compilação as
instruções (linhas) são verificadas e interpretadas pela máquina (CPU), se não houver erros de
sintaxe, será gerado o arquivo executável (extensão .exe).
O linkeditor (linker) une os códigos dos arquivos de bibliotecas usados pela linguagem C
com os arquivos fontes criados pelo programador. Para ver o programa funcionando basta digitar
seu nome ou dar um duplo clique no ícone do programa, de acordo com o ambiente que você
estiver (texto ou gráfico).
Os erros de lógica só podem ser detectados pelo programador depois de gerado o arquivo
executável.
Profª Angelina V.S.Melaré
25
Resumo das etapas da criação de um programa
1. Necessidade de um programa
2. Enunciado do problema
3. Descrição das idéias numa linguagem natural –Descrição Narrativa
4. Criação da sequência correta de instruções – Pseudocódigo - de acordo
com o método da linguagem a ser usada (estruturada)
5. Codificação para uma linguagem de programação – Linguagem C
6. Processo de compilação – Verificação dos erros de sintaxe, geração do arquivo
objeto, união com as bibliotecas
7. Criação do arquivo executável

O ciclo de criação de um programa em C pode ser analisado abaixo, na seqüência de
figuras abaixo.


arquivo objeto arquivo objeto
arquivo fonte
arquivo biblioteca
arquivo fonte
...
Linkedição
arquivo executável
arquivo objeto arquivo objeto
arquivo fonte
arquivo biblioteca
arquivo fonte
...
Linkedição
arquivo executável
Algoritmo
Profª Angelina V.S.Melaré
26

Ambiente de Desenvolvimento DEV-C++

1. Ambiente integrado
O DEV-C++ é um ambiente integrado de desenvolvimento para a linguagem de
programação C e C++, que inclui um local para digitação do programa (editor de texto), um
compilador (gcc - Gnu C Compiler), um linkeeditor e janela de visualização do executável.
Nesse ambiente é possível desenvolver aplicações console (Console Application), cuja
interface é texto ou aplicações gráficas (GUI Application) que usam janelas e elementos visuais
como interface.
Pode-se digitar o programa em outro editor de texto, como o Bloco de Notas, o Word,
devendo ter o cuidado de salvá-lo como um arquivo texto, sem qualquer tipo de formatação.
O DEV-C++ pode ser adquirido gratuitamente pelo site
http://www.bloodshed.net/devcpp.html. A versão mencionada nesta apostila é a versão 4.9.8.0,
em português.



2. Configurando o ambiente e o editor
As configurações padrões do compilador, do ambiente e do editor
de texto podem ser alteradas através do menu Ferramentas. Se o seu
ambiente está em inglês mude-o para português através do menu Tools
(ferramentas) opção Environment Options (Opções do Ambiente) – guia
Interface – escolha o português.
Procure personalizar o seu ambiente de trabalho, criando atalhos e
facilidades no processo de digitação. Por exemplo:
Menu Ferramentas – Opções do Editor – Ative a opção Destacar as
chaves e os parênteses. Na guia Display ative a opção Números das linhas.
No menu Exibir desabilite a exibição do Navegador de classes/projetos clicando apenas
uma vez nessa opção.


Profª Angelina V.S.Melaré
27
3. Configurações para o Windows Vista/7
Para que o Dev funcione corretamente no
Windows Vista, algumas configurações devem ser
feitas:
No menu Ferramentas escolha a opção
Opcões do Compilador na guia Diretórios, em
Binários deve ser adicionado o caminho C:\Dev-
Cpp\libexec\gcc\mingw32.2 (se não houver).
Na guia Programas deve ser colocado
C:\Dev-Cpp\bin\ em cada linha. Por exemplo, a
primeira linha fica assim: C:\Dev-Cpp\bin\gcc.exe

4. Digitação do programa
Para a digitação do programa no DEV-
C++ é necessário seguir os seguintes passos:
1. No menu escolha a opção Arquivo (File);
2. Escolha a opção Novo e depois Arquivo Fonte ou se preferir a tecla de atalho
<CTRL> e <N> simultaneamente;
3. Aparecerá uma nova janela, com o título: (*) Sem Título 1, onde deve ser feita a
digitação do programa fonte.
4. Dependendo da versão, ou mesmo da configuração pré-definida no editor, aparece
um programa inicial. Pode-se apagá-lo ou deixá-lo, aproveitando as linhas de
código já digitadas.

5. Gravação do programa
Após a digitação do programa, ele deverá ser salvo antes de ser executado, de acordo com
as etapas abaixo:
1. No menu Arquivo escolha a opção Salvar ou use a tecla de atalho <CTRL> e <S>
simultaneamente.
2. Escolha o diretório de trabalho, digite o nome do arquivo fonte e pressione o
botão Salvar. Observe que a extensão padrão do DEV-C++ é o .cpp.
Ao salvar o arquivo fonte, cuidado para não salva-lo com nome inválido (com espaço
entre as palavras, iniciado com número.
Toda vez que você pressionar o F9 para compilar e executar o Dev estará salvando
automaticamente seu programa.
6. Compilação e execução do programa
Existem diversas maneiras de ver se o programa está sem erros e funcionando, entre elas:
1. Escolhendo a opção Executar (Execute) do menu e dentro dela a opção Compilar e
Executar (Compile and Run); ou
2. Pressionando a tecla de função <F9> ou na barra de ferramentas a opção Compilar
e Executar.
Se você quiser apenas verificar se existem erros no programa, poderá inicialmente
compilá-lo (através do menu Executar, opção Compilar) e futuramente executá-lo (através do
menu Executar, opção Executar).


Profª Angelina V.S.Melaré
28
7. Criando um código fonte padrão

Uma boa forma de configurar o editor é criar um
modelo inicial de programa fonte, ou seja, toda vez que
for iniciado um novo arquivo irá aparecer o modelo que
você definiu. As linhas de comandos e bibliotecas mais
comuns ficam digitadas neste modelo.
Para criar o modelo de código padrão escolha a
opção Ferramentas, depois Opções do Editor e a guia
Código. Na parte inferior clique no Código Fonte
Padrão e digite seu código fonte.


Os caracteres especiais – acentos, cedilha nesse ambiente console são convertidos.
Profª Angelina V.S.Melaré
29

Estrutura do Programa na Linguagem C

Um programa codificado na linguagem C tem uma sintaxe e estrutura um pouco diferente
de um programa escrito em outra linguagem, como Pascal. Em C, se trabalha com várias funções
e bibliotecas. Um programa precisa ter necessariamente uma função principal (main), que tem as
instruções e funções iniciais do programa. Veja o exemplo abaixo:





1. Estrutura básica
Um programa feito na linguagem C é constituído basicamente de:
Documentação do programa: comentários que o programador considera importante,
como objetivo do programa.
Cabeçalho:
• Diretivas de pré-processamento, onde serão definidas “as constantes” e
incluídos os arquivos de cabeçalho.
• Declaração e inicialização de variáveis globais.
Blocos de instruções: um bloco principal (função main) e outros blocos de rotinas
(outras funções chamadas a partir da main()).


2. Diretivas
As diretivas do pré-processador iniciam com o símbolo # e cada diretiva deve ser escrita
em linha distinta. As diretivas instruem o compilador a execução de uma ação dentro do código-
fonte do programa em C. As diretivas do padrão C ANSI a serem usadas são: #include, #define.
O pré-processador do C é um programa que examina o arquivo fonte e executa as devidas
modificações com base nas diretivas. Como por exemplo, ao encontrar a diretiva #include ele faz
um desvio, localiza a função na biblioteca e adiciona seu código ao código do arquivo fonte.
Profª Angelina V.S.Melaré
30
#include
Essa diretiva quando lida faz a inclusão de um arquivo de cabeçalho ao arquivo-fonte.
Exemplo:
#include <stdio.h>
arquivo de cabeçalho: stdio.h

– STD standard padrão
– I input
– O output
– Funções padrões de entrada e saída
– Funções associadas: scanf(), printf()

#define
Essa diretiva define um identificador (constante simbólica) e uma string que o substituirá
toda vez que for encontrado no código-fonte.
Estrutura: #define identificador string

Exemplo: #define EXIBA printf
#define TEXTO “\nProgramação de Computadores na Fatec”
main()
{
EXIBA(TEXTO);
}

Ao ser executada a diretiva #define, o compilador associa a palavra EXIBA a palavra
printf e toda vez que aparecer a palavra EXIBA ele a substituída por printf e a palavra TEXTO
será substituída por “\nProgramação de Computadores”.


3. Arquivos de Cabeçalho (header)
Cada função definida na biblioteca C tem seu respectivo arquivo de cabeçalho (como
citado acima), ou seja, se você utilizar uma função de entrada -scanf()- terá que incluir seu
respectivo arquivo de cabeçalho (stdio.h) no início do programa. Esse arquivo possui a definição
de tipo e o protótipo da função.
Os arquivos com a extensão .h, são chamados de arquivos de cabeçalho, ou header files.










Dica: O arquivo de cabeçalho feito pelo programador é colocados entre “ ”.
Exemplo: #include “funccondicao.h”

Arquivo de
cabeçalho
Finalidade
stdio.h
conio.h/conio.c
math.h
stdlib.h
time.h
string.h
Suporta entrada e saída com arquivos
Suporta E/S pelo console
Possui diversas funções matemáticas
Declarações miscelâneas
Funções de horário do sistema
Funções de string
Profª Angelina V.S.Melaré
31
4. Biblioteca
Uma biblioteca é uma coleção de funções. Um arquivo de biblioteca armazena o nome de
cada função, mais as informações necessárias para o processo de linkagem. Quando o programa
se referencia a uma função, o linkeditor procura a função na biblioteca (que possuem várias) e
adiciona a parte do seu código ao programa.
As funções padrões existentes na biblioteca do compilador C foram definidas pela ANSI.
Algumas empresas criaram funções novas e acrescentaram ao compilador, como por exemplo, a
Borland, acrescentou ao Turbo C a biblioteca CONIO (Console Input/Output).

5. Bloco de instruções e Função MAIN()
Todos os programas na linguagem C começam executando o conteúdo descrito na função
principal (main) e finalizam com o término dessa função. Essa função determina a execução e
ordem de execução das demais funções que existirem.
As funções possuem um conjunto de instruções (bloco de comandos) com uma tarefa
específica, como por exemplo, uma função para calcular um desconto ou logaritmo de um
número. O conteúdo de uma função é delimitado por chaves { }- início e fim. O código que
estiver dentro das chaves será executado seqüencialmente quando a função for chamada.

6. Projeto
Pode ser criado um projeto em C, onde podem existir vários programas (arquivos fontes),
mas um único arquivo executável gerado pelo compilador.
Nos projetos sempre haverá um arquivo com a função principal (main()) que indicará o
início do projeto.

7. Regras de Digitação e Dicas da Estrutura em C
• Espaços em branco são desconsiderados
Dê preferência para um código limpo, fácil de entender, com alinhamento e endentação. Como
no exemplo que segue:
Com espaços Sem espaços
(correto e incompreensível) (correto e compreensível)
#include <stdio.h> #include <stdio.h>
main() { ….} main()
{
….
}

• Há diferenciação de letras maiúsculas e minúsculas (case sensitive)
A linguagem C é case sensitive, ou seja, diferencia letra maiúscula da minúscula. Exemplo:
NOME é diferente de Nome que é diferente de nome.
As palavras-chaves de C são minúsculas. (else é palavra-chave, mas ELSE ou Else não
são).

• Os parênteses após o nome de uma função, como a função main() é obrigatório.

• As chaves { } servem para delimitar um bloco de instruções. As variáveis devem ser
declaradas no início.

Profª Angelina V.S.Melaré
32
• No C para indicar o final de uma instrução deve ser usado o ;(ponto-e-vírgula). Se for
necessário podem ser digitadas várias instruções numa mesma linha.
Como por exemplo: printf “Exemplo da Estrutura “; printf “de um Programa em C”;

• Cuidado com as palavras reservadas, exemplo: include, printf, main. Na linguagem C tem
32 palavras, sendo que 27 criadas pelo Dennis Ritchie e 5 do padrão ANSI.


8. Comentários
Para facilitar a compreensão coloque comentários ao decorrer do código. Esses comentários
podem ser feitos de duas maneiras:
• usando duas barras para comentários de uma única linha
• barra asterisco para comentários de mais de uma linha.

Exemplos:
a) Comentário de uma linha
#include <stdio.h> //Essa linha inclui a biblioteca que tem funções de entrada e saída

O comentário também pode ser iniciado no começo da linha
soma = n1 / n2;
//o operador de divisão é a barra

b) Comentário com várias linhas
/*
Autor: Julia Melaré
Data: 15/07/2007
Sistema: Cadastro de Fornecedores
*/
Profª Angelina V.S.Melaré
33
Variáveis

Os dados armazenados no computador podem ser apresentados de duas formas diferentes:
como constantes ou variáveis.

1. O que são variáveis?
Os dados fornecidos pelos dispositivos de entrada ou aqueles dados processados são
armazenados numa área da memória do computador chamada de variável.
A variável é uma posição reservada da memória que é usada para armazenar um valor
(tipo de dado) temporariamente. Esse valor pode ser alterado a qualquer momento durante a
execução do programa. Essas variáveis são utilizadas como áreas de trabalho, ou seja, como uma
lousa, onde podemos escrever, modificar e apagar quantas vezes for necessário. Cuidado: cada
variável armazena um único conteúdo por vez, quando for inserido um novo valor, o anterior é
apagado.








2. Mas em que parte da memória vão os dados?
Cada dado será armazenado em uma posição diferente da memória, essa posição é um
endereço físico da memória RAM. Todos esses endeeços precisam ser identificadas, ou seja, ter
um nome de referência para cada alocação feita na memória. O nome (identificador) da
variável torna-se o seu endereço.
Imaginem como você encontraria uma pessoa sem ter seu endereço ou telefone? Imagine
ter que ser saber endereços físicos: 10CF, 2A00?

Identificadores
Os identificadores são os nomes dados para as variáveis, constantes e funções.
A melhor forma de nomear é verificar qual será seu conteúdo e definir o nome de acordo com
ele. Por exemplo, se for definir uma variável para armazenar o resultado da soma identifique
como soma.
Imagine as variáveis como gavetas etiquetadas, cada uma com um nome, você somente deve
colocar conteúdos (objetos) nas gavetas de acordo com a identificação e tipo definido para ela.
Em C existem algumas regras para a formação dos identificadores:
_ o primeira caracter tem que ser obrigatoriamente uma letra ou um sublinhado;
_ o nome pode ser formado por números, só que estes não podem ser colocados na
primeira posição.
_ não pode ter caracteres especiais ou espaço, com exceção do caracter _ (underline);
_ as letras maiúsculas e minúsculas são tratadas diferentemente (case sensitive).
_ não pode ser igual a uma palavra reservada da linguagem.
_ não pode ter acento e cedilha (ç)
__ somente os 31 caracteres são válidos

Memória
Variáveis
Profª Angelina V.S.Melaré
34
3. Declaração de variável

A declaração de variáveis é obrigatória em quase todas as linguagens de programação,
onde nela é feita a definição do nome/local de armazenamento (ligada ao endereço físico) e
quanto de espaço será reservado para o conteúdo a ser armazenado (tipo de dado).
A declaração da variável deve ser feita obrigatoriamente antes da sua utilização, podendo
ser declaradas em lugares diferentes: dentro da função (variável local), fora da função (variável
global), ou dentro de um bloco de instruções.

Não se esqueça que ao definir o tipo de variável está se determinado a quantidade de espaço
(bytes) que será alocado na memória e o intervalo de valores que ela poderá armazenar.

Observação:




Exemplos de Declaração de Variável:
tipo_de_variável nome_variável, nome_variável;
Pseudocódigo C Dicas em C
real salario;
inteiro num_filho;
caracter sexo;
real porc_aum 5.5;

inteiro qtd_pao, qtd_leite;
float salario;
int num_filho;
char sexo;
float porc_aum =5.5;

int qtd_pao, qtd_leite;



Pode ser atribuído um conteúdo a variável
quando ela for declarada.
Podem ser declaradas diversas variáveis do
mesmo tipo ao mesmo tempo.



No pseudocódigo o símbolo significa atribuição.
Na linguagem C ela é representada com o símbolo =.
Profª Angelina V.S.Melaré
35
CONSTANTE
VARIÁVEL
Constantes

Constantes são dados com valores fixos que não podem ser alterados durante a execução do
programa. Dentro de um programa podem existir várias constantes, como por exemplo, o ano
atual, o valor de PI.
As constantes podem ser definidas sem identificador, sendo inseridas diretamente. É como na
expressão matemática:




X + Y + 3


O X e o Y seriam as variáveis do programa, pois são as incógnitas e contém um valor
sujeito a alteração, já o número 3 é uma constante, o seu valor já é conhecido e não poderá ser
alterado. Em todas as execuções ele sempre será 3.

Exemplos:
A) Data_atual = 1990
Valor_aumento = 1000
Porc_desconto = 0.10
PI = 3.141592

B)
#include <stdio.h>
#include <stdlib.h>
const int ANO_ATUAL = 1990;
main()
{
// ANO_ATUAL = 300; //não permite mudança de valor
printf("%i", ANO_ATUAL);
_sleep(2000);
}


Profª Angelina V.S.Melaré
36
Tipos de dados


Quando colocamos o termo tipos de
dados básicos nos referimos aos tipos
primitivos da linguagem. Cada linguagem
tem seus tipos primitivos e a partir deles
podem criar novos.
Lembre-se que o computador
processa dados. Pense que quando se agrega
valor a um dado tem-se uma informação.
Exemplo: 22 de março é dado, não informa
nada, mas se colocarmos o Dia da Água, que
ocorre no dia 22 de março, ele tem outro
valor, traz uma informação muito importante,
de conscientização e valorização do meio de
sobrevivência da espécie humana.
Quando você define o tipo de variável
o computador reserva (aloca) um espaço
(quantidade de bytes) de acordo com o esse
tipo. Mesmo que o valor recebido e
armazenado seja menor que o espaço
reservado o computador ainda conserva o
mesmo tamanho pré-definido, havendo um
desperdício de memória.
Defina de forma correta o tipo de
dado, para que não ocorra falta de memória
durante a execução do programa ou lentidão
de processamento.
Na linguagem C os tipos primitivos
são: caracter (char), inteiro (int), real (float e
double) e sem valor (void).
É possível em C manusear dados
numéricos nas bases binária, octal, decimal e
hexadecimal.


1. Numérico
O tipo numérico armazena apenas valores numéricos, que podem ser: inteiros ou reais.

Numérico Inteiro - int
Contém números que não possuem a parte decimal, podendo ser positivos, negativos ou
nulos. A representação desse tipo no pseudocódigo será int, abreviação de inteiro. Na linguagem
C é int, abreviação de integer.
Pseudocódigo
int num= -4;
Codificação em C
int num1 = 6000, num2;

Numérico Real- real
São os números positivos, negativos ou nulos que possuem a parte fracionária (parte
decimal). O separador decimal é o ponto e não a vírgula (padrão americano).
O tipo real pode ser representado pelo real simples ou duplo, a diferença está na precisão
e no número de casas decimais. O real simples é identificado como float na linguagem C e tem
até 6 dígitos de casas decimais. Se for necessária uma precisão dupla é necessário usar o tipo
double, que suporta até 11 digitos. No pseudocódigo será definido apenas como real.
Pseudocódigo
real salario= 350.50;
Codificação em C
float n1=20.0, n2 = -15.50;
float n1=0.0, n2, soma;

2. Literal/ Cadeia de Caracteres
Na linguagem C não existe o tipo literal, também conhecido como alfanumérico, string,
que aceita armazenar vários caracteres. Quando houver necessidade do armazenamento de um
nome deverá ser feito uso de uma matriz de caracteres.

Profª Angelina V.S.Melaré
37
3. Lógicas
As variáveis definidas como lógicas (booleanas) podem guardar apenas um dos dois
estados: Verdadeiro ou Falso, sempre armazenando apenas um dígito. Na linguagem C não existe
um tipo específico para a representação de valores lógicos. O dígito 0 representa o valor lógico
falso e 1 representa o valor lógico verdade (todo valor diferente de 1 é falso) .
Pseudocódigo
lógico estado_lampada;
Codificação em C
while (1) //loop infinito

4. Caracter
O tipo char é usado para armazenar um caracter da tabela ASCII, que possui letras (a..z,
A..Z), números (0..9) e caracteres especiais (º, ^, &, =, #, :). Na maioria dos ambientes não pode
ser usado para cálculo, mesmo tendo armazenado um número.
Quando for um único caracter colocamos seu conteúdo obrigatoriamente entre
apostrofe(‘). Quando for uma cadeia de caracteres, colocamos entre aspas (“).

Pseudocódigo
caracter sexo;
caracter opção = ‘a’;

Codificação em C
char sexo = ‘f’;
char flag = ‘!’;


Exemplo de programa:
main()
{
char a='1', b=1;
printf("%c - %c", a, b);
_sleep(2000);
}
Perceba que a variável a armazena o símbolo 1 e a variável b armazena o primeiro
símbolo da tabela ASCII que é a carinha.
printf("\n%c - %c - %i - %i\n", a, b, a,b);
//Resultado:1 carinha 49 1 1
//caracter 1 e o primeiro símbolo na ASCIII - o símbolo 1 é a carinha
//o símbolo 1 na ASCII tem seu decimal o 49
//o 1 inteiro é o 1 na exibição definida como inteiro

5. Espaço Alocado de Memória
Não se esqueça que cada byte ocupa 8 bits (de 0 a 7). Cada bit possui dois estados ( 0 ou
1 )- base 2. Então, um byte possui 2
8
= 256 combinações possíveis.
Então o tipo caracter que ocupa 1 byte pode armazenar 256 combinações diferentes de
bits.Se a cada 8 bits pode-se ter a representação de um número inteiro, então, o char pode
armazenar valores de 0 a 255.
Número Decimal 49 – Caracter 1 (ASCII)
Bit 7 6 5 4 3 2 1 0
Base Decimal 128 64 32 16 8 4 2 1
Estado - valor 0 0 1 1 0 0 0 1

Profª Angelina V.S.Melaré
38
Um tipo que armazena 2 bytes pode ter 2
8
x 2
8
combinações diferentes de bits, que
equivale a 65538. O que armazena 4 bytes pode ter 2
8
x 2
8
x 2
8
x 2
8
combinações diferentes,
que equivale a 2.147.483.647 (+- 2 bilhões de combinações).


6. Modificadores de Tipos
Os modificadores de tipos são usados para modificar o tipo primitivo, fazendo com que
ele aceite outra faixa de valores, aceitando números negativos e positivos.
O tipo signed faz com que o tipo represente os números positivos e negativos. O
unsigned somente aceita os números positivos. A representação de números negativos é feita
tomando o bit MSB (Most Significant Bit), onde msb=1 o sinal é negativo e msb=0 o sinal é
positivo. Como é utilizado bit para representação de sinal os valores a serem representado são
metade da faixa padrão. Por exemplo, o tipo char que vai de 0 a 255 do tipo signed (só
positivos), para aceitar tipos negativos tem que ser unsigned e seus valores vão de -128..0..+127.
O padrão C padrão ANSI define que os tipos são signed e no compilador CCS,
MikroC o padrão é unsigned.
O tipo short (reduz) e long (amplia) são usados para aumentar ou diminuir a faixa de
valores dos tipos bases.

Exemplo:
a) unsigned char n1= 255;
char n2= 255; //padrão é signed
printf("Unsigned %i - signed %i", n1, n2);
Resultado: 255 e -1


Dica: Pode-se definir valores em outras bases (diferente da decimal):
int hex = 0x80
int oct = 012
128 em decimal
10 em decimal
Valor = 50
Valor = 050
Valor = 0x50
Valor = 0b01010000

Decimal
Octal
Hexadecimal
Binário
Tipo de
Variável
Qtd de
bytes
Qtd de
bits
Exemplo de
valores
char
int
float
double
void
1
4
4
8
0
8
32
32
64
0
‘f’ 1
14 -23
15.655 10.0
-14.7688665

Profª Angelina V.S.Melaré
39
7. Tabela ASCII (American Standard Code for Information Interchange)
Cada combinação de byte pode representar internamente um símbolo (letra, dígito numérico
ou caracter especial). Veja no final dessa apostila a explicação detalhada da ASCII.

FATEC


Exemplo de Código que mostra a ASCII Estendida – Unicode Latim I Suplementar (8 bits)
main()
{
int tab;
printf("Caracter Decimal Hexadecimal\n");
for(tab=0;tab<=255;tab++)
printf("\t%c - %i - %x ", tab, tab, tab);
}

































F A T E C
70 65 84 69 67
01000100 01000001 01010010 01000101 01000011
Profª Angelina V.S.Melaré
40
8. Código de Barra Invertida
Algumas combinações e representações da tabela ASCII não podem ser exibidos na tela,
pois tem uma função especial- função de controle. Por exemplo, o retorno de carro (return ou
enter) cujo código decimal é o valor 13. Para inserir esses códigos deve-se usar a barra
invertida juntamente com o código desejado.












Sufixos usados: long int – L, unsigned int –U, float– F, long double- L

Exemplos de Códigos:
#include <stdio.h>
#include <stdlib.h>
#include <conio.c>
main()
{
char ch;
ch = getch();
if (ch == 13) printf ("Enter %c", ch);
if (ch == 27) printf ("ESC %c", ch);
if (ch == 9) printf ("TAB %c", ch);
if (ch == 8) printf ("Backspace %c", ch);
if (ch == 127) printf ("Del %c", ch);_sleep(2000);
}

main()
{
char ch1= '\a', ch2='\t';
printf("%s", "Alo\n");
printf("%cVeja que esta na proxima linha %c", ch2,ch1);_sleep(2000);
}
/* Exibe o alfabeto em minúsculo, usando um contador definido como char.*/
main()
{
char ch;
for (ch='a'; ch <='z'; ch++)
printf("\t%c", ch);_sleep(2000);
}

Códigos de Controle
Código Formato
\a
\b
\n
\r
\t
\b
\”
\
\’
\v
soa um sinal sonoro- alarme
o cursor retrocede uma coluna
o cursor avança para uma nova linha
o cursor retrocede para a primeira coluna da linha
o cursor avança para próxima marca de tabulação
retrocede - backspace
exibe uma aspas duplas
exibe a barra invertida
exibe a aspas simples
faz a tabulação vertical
Profª Angelina V.S.Melaré
41
Exercícios de Variáveis
1) Defina quais são as variáveis e constantes das expressões abaixo:
a) 15 + 14 * y + 3
_____________________________________________________________

b) x + 5 + x + x
_______________________________________________________________

2) Quais identificadores das variáveis estão corretos? Explique.

a) 5teste
b) n_rg
c) c.p.f
d) valor-sal
e) cod1
f) cidade/uf
g) $salario
h) _ir
i) n sapato
j) num2cod2
k) nome
l) x
m) my


3) Identifique o tipo ideal para as variáveis abaixo. A letra F identifica como número real, o I como
numérico inteiro, o C como caracter e o E quando estiver incorreta a alternativa.
a) -8
b) ‘0’
c) “X”
d) “ “
e) .V.
f) “9”
( )
( )
( )
( )
( )
( )

g) -600
h) 500.33
i) 789003983
j) 300.00
k) -92.34
l) 945

( )
( )
( )
( )
( )
( )


4) Identifique as variáveis nomeando-as e definindo o tipo de dado ideal para armazenamento.

Informação

Estado civil
Número que calça
Peso
Altura
Valor da conta de luz
Salário
Valor pago pela refeição

Nome da Variável

________________
_________________
_________________
_________________
_________________
_________________
_________________

Tipo de Variável

_________________
_________________
_________________
_________________
_________________
_________________
_________________


Profª Angelina V.S.Melaré
42
Operadores Aritméticos

1. Operadores Aritméticos

Os operadores aritméticos são os operadores usados nas operações básicas da matemática.
Esses operadores são usados para representar as expressões matemáticas, os resultados são
valores numéricos.
Eles são: +, -, *, /.
Ainda existem o mod e o div, que representam o resto da divisão e o quociente da divisão
na respectiva ordem. Esses operadores somente podem ser usados para números inteiros.

Exponenciação: é usada para elevar um número a outro. O operador pode ser o sinal circunflexo
(^) ou dois asteriscos (**) ou uma função (pow ou exp), dependendo da linguagem de
programação.
Na linguagem escrita quando elevamos um número a outro, como o exemplo 2³. Desta
forma entendemos que o número 2 é a base e o 3 o expoente. No computador a representação é
diferente. No lugar de colocarmos o 3 em cima , o colocamos do lado, e no meio o símbolo, que
representa o operador de potenciação, ficando da seguinte forma: 3 ** 2 ou 3 ^ 2.
A exponenciação tem maior prioridade que os demais operadores.
Exemplo: 2 ^ 3 ou 2 ** 3
O resultado dessa operação é 8, ou seja, o 2³ é igual a 8.
No C é pow(2,3), e em Pascal é exp(2 * ln(3)).

Mod e Div
Em muitas linguagens de programação existem o operador div e mod, que tem a função
de trabalhar com números inteiros. Esses operadores têm a mesma prioridade e devem ser
efetuados antes da adição ou subtração.
Quando estivermos fazendo cálculos de divisão com números inteiros (10, 4500, -900, -
15) podemos utilizar o operador DIV. O resultado da expressão onde foi usado o DIV é sempre
um número inteiro, o quociente.
5 DIV 2 = 2
5 MOD 2 = 1
Obs: Na linguagem C é usado o operador % para representar o MOD.






Exemplos:
22 DIV 5 = 4
22 MOD 5 = 2 ou em C 22 % 5 = 2
70 MOD 10 = 0
2 DIV 2 = 1
-400 DIV 4 = 100

5 2
2 1
Parte Inteira da Divisão
(Quociente)
Resto da Divisão
Profª Angelina V.S.Melaré
43
Operadores Aritméticos da Linguagem C
Os operadores aritméticos da linguagem C são: ++, --,*, /, %, +, -. Esses operadores já
estão na ordem de precedência de execução. O ponto (.) representa o separador decimal e a
vírgula (,) o separador de milhar. Os operadores com a mesma precedência são executados da
esquerda para a direita.

2. Operadores de Incremento e Decremento
Esses operadores podem ser usados como prefixo ou sufixo, como, ++n1 ou n1++.
Quando o operador precede a variável ((++n1), ele executa a operação (incremento ou
decremento) antes de usar o conteúdo da variável. Se o operador estiver depois da variável
(n1++), o computador primeiro usa o valor armazenado na variável para depois executar a
operação.
Exemplos:
a) n1 = 10 n2 = ++ n1 resultado n2 = 11
b) n1 = 10 n2 = n1++ resultado n2 = 10 somente a próxima vez o x vale 11

3. Operadores Aritméticos de Atribuição ou C Reduzido
Na linguagem C pode ser feito usado de um operador aritmético com o comando de
atribuição, dessa forma simplificando a programação.
Exemplo: num = num + 2 pode ser escrito da seguinte maneira: num+=2;
num2 = num1 = 10 o valor 10 é atribuído a num1 e, em seguida o valor de num1
é atribuído da num2 (da direita para a esquerda).

No exemplo acima o operador += acrescenta 2 ao valor da variável num e o armazena a
variável num. Esse forma de calculo pode ser usada para qualquer operador aritmético, como:
num-=2 ou num = num – 2;
num*=2 ou num = num * 2;
num/=2 ou num = num / 2;
num%=2 ou num = num % 2;

4. Conversão de Tipo
A linguagem C oferece o recuso de conversão automática de valores. A conversão pode
ser feita usando o operador cast (operador de molde de tipo). Esse operador é colocado entre
parênteses antes do valor a ser convertido.
Exemplo:
a) float x = 5;
o valor de x é convertido para 5.0;

Operador Operação Exemplo
+
-
*
/
%
- -
++
Adição
Subtração
Multiplicação
Divisão
Módulo
Decremento
Incremento
1 + 1 = 2
1 – 1 = 0
2 * 2 = 4
2 / 2 = 1
2 % 2 = 0
--x é x = x - 1
++x é x = x + 1
**Cuidado, ao ser usado o
operador de divisão a um tipo
inteiro, será retornado um valor
inteiro. Por exemplo, 5/2 será
igual a 2.

**Sempre será retornado um valor
real quando houver pelo menos um
número real envolvido.
Profª Angelina V.S.Melaré
44
b) 5 / 2.0
o valor de 5 é convertido para 5.0, porque o segundo operando é 2.0. O
resultado da expressão é 2.5

c) int a, b;
a = (int) 3.5; -- é atribuído o valor 3 para a variável a
b = (int) 3.5 % 2; -- é convertido o valor 3.5 para 3 para depois fazer a
operação módulo, que só pode ser feita com valores do tipo inteiro.


Prioridade dos Operadores Aritméticos

A precedência (maior prioridade) de operadores segue a ordem: *, /, %, +, -. Os
operadores com a mesma precedência são executados da esquerda para a direita.

Operador Finalidade Prioridade Linguagem C
^ ou **
*
/
div
mod
+
-
Exponenciação
Multiplicação
Divisão
Divisão inteira
Resto da divisão
Adição
Subtração
1
2
2
3
3
4
4
Função pow(b, e)
*
/

%
+
-

Exemplos de Prioridades:
1) 3 + 4 = 7
A operação da adição pode ser efetuada em primeiro lugar quando não existir nenhuma
outra operação com maior prioridade.

2) 9 - 4 * 2 =
O operador de maior prioridade nesta expressão é a multiplicação, devendo ser realizada
em primeiro lugar. 4 * 2 = 8
Depois, substituímos a expressão calculada (4 * 2) pelo seu resultado ( 8 ) e efetuamos a
segunda operação, que é a subtração.
9 - 4*2
9 - 8 = 1
O resultado é 1
Percebam que não foi realizada a operação pela ordem que foi escrita, mas sim pela ordem de
prioridades, como na matemática convencional.
Se não fosse aplicada a prioridade dos operadores o resultado da expressão seria 10, um
valor diferente de 1, o correto.
9 – 4 * 2 =
5 * 2 = 10

3) 4 * 3 - 4 / 2 ** 2 =
Deve ser realizada em primeiro lugar a operação que tem o operador de maior prioridade,
ou seja, a potenciação 2 ** 2.
4
Profª Angelina V.S.Melaré
45
Depois, substituímos a expressão de potenciação (2 ** 2) pelo seu resultado (4).
4 * 3 - 4/ 2* 2
4 * 3 - 4/ 4
Agora os operadores de maior prioridade são a multiplicação e a divisão. Esses dois
operadores têm valor de prioridade igual, então tanto faz a ordem de execução.
4 * 3
12
Então, substituindo a operação pelo resultado, temos:
4 * 3 - 4 / 2 ** 2
4 * 3 - 4 / 4
12 - 4 / 4
Restaram duas operações a serem feitas: a subtração e a divisão. Como a divisão tem
maior prioridade a efetuaremos primeiro.
4 / 4
1

4 * 3 - 4 / 2 ** 2
4 * 3 - 4 / 4
12 - 4 / 4
12 - 1 = 11
O resultado da expressão foi 11.
Vamos supor que você não se lembra das prioridades dos operadores e faça pela ordem
escrita. Será que o resultado será o mesmo? Veja a seguir a execução da mesma expressão.
4 * 3 - 4 / 2 ** 2 =
12 - 2 ** 2 =
12 - 4
8
O resultado não é o mesmo que na resolução anterior.

4) 5 * 2 ^ (4 - 2) =
Neste exercício temos uma expressão dentro de parênteses. O operador que está dentro do
parêntese deve ser sempre efetuado em primeiro lugar.
( 4 - 2)
2
Vamos substituir o resultado da expressão dentro de parênteses na expressão geral.
5 * 2 ^ (4 - 2)
5 * 2 ^ 2
Agora, como não temos mais nenhum parênteses, efetuaremos o cálculo da expressão
que tem o operador com maior prioridade.
2 ^ 2
4
Substituindo o resultado da potenciação:
5 * 2 ^ (4 - 2)
5 * 2 ^ 2
5 * 4
20
O resultado é 20. Se o cálculo fosse feito sem priorizar o parêntese o resultado da
expressão seria 100.
Profª Angelina V.S.Melaré
46

Exercícios de Expressões Aritméticas e Prioridades de Operadores

1. 3 + 4 * 4 + 8 / 2 =
2. (3 + 4 ) * 4 + (8 / 2) =
3. 64 / 8 - 3 =
4. 4 ^ 3 + 2 * 3 =
5. 81 / 3 ^ 2 =
6. 2 ^ (2 * 1 + 2) / 2 =
7. 4 * 2 ** (4 / 2) =
8. 66 DIV 4 * 2 + 2=
9. 15 MOD 3 * 1 =
10. 27 MOD (3 ** 2) =
11. 17 MOD 2 + 7 DIV 3 =
12. 21 * 16 /4 =
13. 70 DIV 7 =
14. (21 / 2) / 2 * 3 =
15. [12 - (4 * 2) ] + 2 =

Profª Angelina V.S.Melaré
47

Funções Matemáticas e Operadores Bit a Bit

1. Funções Matemáticas
Existem várias funções matemáticas já programadas que estão na biblioteca Math.h,
como funções para calculo da exponenciação, raiz quadrada, logaritmo. Os valores do ângulo são
em radianos.
Função Explicação Exemplo Exibição
Abs()
pow()
Sin()
Cos()
Tan()
Sqrt()
Log()
Log10()
Retorna o valor absoluto
Calcula exponenciação (potência)
Calculo o seno do ângulo
Calculo o cosseno do ângulo
Calculo tangente do ângulo
Calcula a raiz quadrada
Calculo o logaritmo natural
Calculo o logaritmo decimal

Abs(-200)
pow(3,2)
sin(90)
cos(90)
tan(90)
sqrt(25)
log(100)
log10(100)
200
9
0.8939
-0.448
-1.9952
5
4.6051
2

2. Operadores de deslocamento de bits
Podem ser feitas operações lógicas bit a bit com variáveis, para isso deve-se usar o
operador de acordo com a operação desejada.
Os operadores << e >> manipulam os bits do tipo int e char, sejam à esquerda ou à
direita.








Exemplo: a) int v1=100, v2;
v2= v1 & 15;

100 decimal = 0 1 1 0 0 1 0 0
&
15 decimal 0 0 0 0 1 1 1 1
____________
0 0 0 0 0 1 0 0 4 decimal

O estado zero do bit fará com que o bit resultante seja 0




Operador Ação
&
|
^
~
>>
<<
Conjunção – e -and
Disjunção – ou - or
Ou exclusivo - xor
Negação - not
Deslocamento à direita
Deslocamento à direita
Exemplo:
bit = 00000011
bit << 2 00001100

bit = 01100000
bit >> 2 00011000

Profª Angelina V.S.Melaré
48
1. Função Rand() e SRand()
A função rand() é usada para gerar números aleatórios. Os números gerados aleatoriamente vão
de 0 a 32767.
main()
{
int num;
num = rand();
printf("%i", num); _sleep(2000);
}

Para haver a delimitação dos números gerados.
rand()%10 + 1; // ajustado para gerar números entre 1 e 10 (soma 1 pois começa no 0)

main()
{
int num;
num = rand()%10+1;
printf("%i", num); _sleep(2000);
}


A função srand() permite a geração de números diferentes a cada nova execução.

srand((unsigned int)time((time_t *)NULL));

#include <stdio.h>
#include <stdlib.h>
#include <time.h>

main()
{
srand((unsigned int)time((time_t *)NULL));
int num;
num = rand()%10+1;
printf("%i", num); _sleep(2000);
}

//srand(time(NULL));

Profª Angelina V.S.Melaré
49
Estrutura de Controle Linear/ Sequencial

Nesta estrutura a execução das instruções é linear, seqüenciais, ou seja, onde uma ação
deve ser executada após a outra. Não existe desvio na execução.
O conjunto de passos é executado num fluxo contínuo do começo ao fim. A execução
começa de cima para baixo, da esquerda para a direita Nessa estrutura temos as entradas, os
processamentos e as saídas.

Entrada: é a leitura de dados feita através de dispositivos de entrada (teclado, mouse, arquivo,
entre outros). Essa leitura é feita e depois o dado é transportado para a memória principal
(RAM). A entrada no pseudocódigo é denominada como leia. O dispositivo de entrada a ser
utilizado é o teclado.
Pseudocódigo:
inteiro num;
leia (num) ;
Será reservado na memória RAM um endereço para num. Depois será feita a leitura do teclado e
armazenado o valor na variável num.

Processamento: o processamento pode ser realizado através de uma atribuição, ou uma
expressão matemática, que resultará num valor. O processamento pode ser realizado com as
entradas. O resultado gerado também poderá ser armazenado na memória.
A atribuição no pseudocódigo é representada pela seta ( )e o operador em C para
atribuição é o igual ( = ).
Pseudocódigo:
num 4;
Variável num recebe o valor 4 ou é atribuído 4 a variável num
Codificação em C
num = 4;

Saída: pode ser a exibição de uma mensagem, ou a recuperação de um conteúdo que está na
memória e será transmitido para um dispositivo de saída (monitor, impressora, caixa de som,
entre outros).
A saída no pseudocódigo é denominada como escreva ou exiba. O dispositivo de saída
a ser utilizado é o monitor.
Pseudocódigo:
Escreva (“Informe um número”);
Escreva (“Salário calculado “, sal);

Bloco de instruções/comandos
Um bloco de comandos ou instruções determina o conjunto de ações a serem executadas.
Ele serve para definir os limites de existência de uma variável, ou seja, o escopo de uma variável.
Podemos ter diversas variáveis declaradas no decorrer do algoritmo/programa, podendo ter duas
com o mesmo nome, mas valores diferentes, dependendo do bloco em que foram declaradas.
As ações dentro do bloco são separadas pelo ponto e vírgula ( ; ). Servindo para organizar
e determinar a execução ou encerramento de uma ação.

Profª Angelina V.S.Melaré
50
Funções de Entrada e Saída Formatada

1. Função de Saída - printf()
A função printf() realiza a saída de dados em vários formatos, de acordo com a
configuração feita pelo programador. O protótipo da função está no arquivo de cabeçalho
STDIO.H. Com essa função é possível exibir mensagens, resultados de cálculos, endereços de
memória.
O protótipo do printf() é: printf(“string_de_controle”, lista_de_argumentos);
• Na string de controle é definido tudo que será exibido na tela: cadeia de caracteres, o
formato das variáveis (usando-se o comando de formato - %) e os caracteres de
controle (usando o símbolo \).
• Na lista de argumentos definem os formatos que serão exibidos os valores.

Comandos de Formato mais usados
Código Formato
%c
%d
%i
%f
%lf
%s
%x
%u
%p
%o
%e
%g
%%
um único caracter
inteiros decimais com sinal
inteiros decimais com sinal
ponto flutuante decimal
double
string – cadeia de caracteres
hexadecimal sem sinal
inteiro decimal sem sinal
ponteiro
octal
float exponencial
ponto flutuante curto
%
É possível especificar o tamanho dos campos que serão exibidos. Como nos exemplos
abaixo:
%4d _ _ 3 3
%7.2f _ _ _ 5 . 3 0

7 possíveis no total, sendo fixadas 2 para o número de casas decimais

Comando Exibição Explicação
printf("%8i", 10); ( 10) As posições definidas a mais
são preenchidas com espaço
em branco e o valor é alinhado
à direita do campo.
printf("%-8i", 10); (10 ) Se o tamanho do campo for
precedido por um - (menos),
então, o valor será alinhado à
esquerda do campo.
printf("%08i", 10);

(0000010) Se o tamanho do campo for
precedido com o 0 (zero),
então as posições excedentes
Profª Angelina V.S.Melaré
51
são preenchidas com zeros.
printf(“%.1f”,1910.10) 1910.1 Deve ser colocada a
quantidade de casas decimais a
serem exibidas junto com o
comando de formato, como no
exemplo %.1f
printf(“O resultado da soma é:”); O resultado da soma é
soma =4.51;
printf(“O resultado é: %6.2f”, soma);
O resultado da soma é
4.51

printf (“Mostra o símbolo %% %%") %%
printf ("Um tipo caractere é %c e um
tipo inteiro é %i",‘A',20)
Um tipo caractere é A e
um tipo inteiro é 20

printf ("%s é uma string","Este") Este é um exemplo string
printf ("%s%d%%","Juros de ",10) Juros de 10%


2. Função de Entrada – scanf()
A função scanf() é usada para fazer entrada de dados. Essa função captura o valor
digitado no teclado e armazená-o em uma variável. Os valores capturados são convertidos para o
formato interno apropriado. O protótipo dessa função está no arquivo de cabeçalho STDIO.H.

Sua estrutura e: scanf(“string_de_controle”, &lista_de_argumentos);
• Primeiro se define o tipo de variável a ser recebido
• Deve ser colocado o operador & (endereço de memória) antes de cada
uma das variáveis da lista de argumentos (exceto para strings).
• Deve ser colocado o mesmo número de argumentos e de string de
controle.
• Num tipo string, o espaço em branco finaliza a entrada.

Podem ser recebidos vários valores ao mesmo tempo, usando como separador de entrada
um espaço em branco ou o caracter dois pontos ( : ). Os especificadores %d, %f, %e pulam
automaticamente os brancos que precedem os valores numéricos.








Exemplo: float nota1, nota2;
scanf(“%f”, &nota1); scanf(“%f”, &nota2);
ou
scanf(“%f%f ”, &nota1, &nota2);

int hora, minuto;
scanf(“%i:%i”, &hora,&minuto);
Comandos de Formato mais usados
Código Formato
%c
%d , %i
%f , %e, %g
%s

caracter
inteiros decimais com sinal
ponto flutuante decimal
string de caracteres

Profª Angelina V.S.Melaré
52
1. Função de Entrada de caracter– getch() e getchar()
As funções getch() e getchar() estão na biblioteca conio.c. Elas são usadas para a entrada de
um caracter. A diferença entre elas é que a getchar() espera após o caracter digitado a tecla enter
e o getch() não.

#include <stdio.h>
#include <stdlib.h>
#include <conio.c>
main()
{
char caracter;
caracter=getch();
printf ("Voce pressionou a tecla %c que equivale ao numero %i Asc",caracter, caracter );
_sleep(2000);
}


Exemplos

Exemplo 1
Faça um programa que receba dois números inteiros e efetue as operações: adição, subtração,
multiplicação, divisão, resto da divisão e exponenciação.

Pseudocódigo Codificação em C
Início
inteiro n1, n2, soma, subtr, mult, divisao,
expo, resto;
escreva (“Informe primeiro número”);
leia (n1);
escreva (“Informe segundo número”);
leia (n2);
soma n1+ n2;
subtr n1 - n2;
mult n1 * n2;
divisao n1 / n2;
resto n1 mod n2;
expo = (n1, n2);
escreva (“Soma:”, soma);
escreva (“Subtracao:”, subtr);
escreva (“Multiplicacao:”, mult);
escreva (“Divisao:”, divisao);
escreva (“Resto da divisão:”, resto);
escreva (“Exponenciação:”, expo);
Fim

#include <stdio.h>
#include <stdlib.h>
#define escreva printf

main()
{
int n1, n2, soma, subtr, mult, divisao,
expon, resto;
escreva ("Informe 2 numeros");
scanf("%i%i", &n1, &n2);
soma= n1+ n2;
subtr= n1 - n2;
mult= n1 * n2;
divisao= n1 / n2;
resto= n1 % n2;
escreva ("Soma: %i - Subtracao: %i \n",
soma, subtr);
escreva ("Multiplicacao: %i \n", mult);
escreva ("Divisao: %i – Resto da divisão:
%i\n", divisão, resto);
_sleep(8000);
}
Profª Angelina V.S.Melaré
53
Receber
ANO_NASC
Mostrar
IDADE
IDADE = ANO_ATUAL - ANO_NASC
INÍCIO
FIM
Receber
ANO_ATUAL
IDADE30 = IDADE + 30
Mostrar
IDADE30
Exemplo 2

1) Calcular a idade atual e daqui a 30 anos de uma pessoa.


Descrição Narrativa:
Receber o ano de nascimento
Receber o ano atual
Subtrair o ano atual do ano de nascimento para saber a idade
Somar o valor da idade com 30 para saber quantos anos terá daqui 30 anos
Mostrar idade atual
Mostrar idade daqui a 30 anos.

Pseudocódigo
Inicio
inteiro ano_nasc, ano_atual, idade, idade30;
Escreva (“Digite o ano atual”);
Leia (ano_nasc);
Escreva (“Digite o ano de nascimento”);
Leia (ano_atual);
Idade ano_atual – ano_nasc;
Idade30 idade +30;
Escreva (“A sua idade é ”, idade);
Escreva (“Daqui a 30 anos você terá:”,Idade30);
Fim


Linguagem C

#include <stdio.h>
#include <stdlib.h>
main()
{
int ano_nasc, ano_atual, idade, idade30;
printf(“\nDigite o ano atual”);
scanf(“%i”,&ano_nasc);
printf(“\nDigite o ano de nascimento”);
scanf(“%i”,&ano_atual);
idade = ano_atual – ano_nasc;
idade30= idade +30;
printf(“A sua idade é %i”, idade);
printf(“Daqui a 30 anos você terá:
%i”,idade30);
}

Linguagem Pascal
Program idade;
Var
ano_nasc, ano_atual, idade, idade30: integer;

begin
write(‘Digite o ano atual’);
readln(ano_nasc);
write(‘Digite o ano de nascimento’);
readln(ano_atual);
idade := ano_atual – ano_nasc;
idade30 := idade +30;
writeln(‘A sua idade é ‘, idade);
writeln(‘Daqui a 30 anos você terá:’, idade30);
end

Profª Angelina V.S.Melaré
54
Teste de Mesa

MEMÓRIA
ANO_NASC ANO_ATUAL
ENTRADA SAÍDA
PROCESSAMENTOS
VALORES
SIMULADOS
1998
1980
18
48
1980 1998
IDADE
18
IDADE = ANO_ATUAL - ANO_NASC
IDADE = 1998 - 1980
IDADE = 18
IDADE30
48
IDADE30 = IDADE + 30
IDADE30 = 18 + 30
IDADE30 = 48
Profª Angelina V.S.Melaré
55

Exercícios Resolvidos e Propostos



01) Uma loja de telefone celular paga aos seus vendedores um salário fixo mais uma comissão de R$
50,00 por cada aparelho vendido. Faça o pseudocódigo e fluxograma que receba o nome do vendedor, o
número de aparelhos vendidos e calcule o salário total do vendedor.

Entrada:
• nome do vendedor
• número de aparelhos vendidos
• valor do salário fixo (mesmo não sendo pedido no enunciado, o valor do salário fixo deve ser
recebido para o cálculo do salário total)

Processamento:
• calcular o valor da comissão
_ quantidade de aparelhos vendidos * 50
• calcular o salário total
_ o valor da comissão + o valor do salário fixo

Saída: Fluxograma:
• mostrar o salário total do vendedor


Pseudocódigo

INÍCIO
caracter nome;
inteiro quant;
real sal_bruto, comis, sal_total;
escreva (“Nome do Funcionário:”);
leia nome;
escreva (“Quantos aparelhos foram vendidos”);
leia quant;
escreva (“Qual o valor do salário fixo”);
leia sal_bruto;
comis quant * 50;
sal_total sal_bruto + comis;
escreva (“O salário final é:”, sal_total);
FIM

Receber
NOME_VEND
COMIS = QUANT * 50
INÍCIO
FIM
SAL_TOTAL = SAL_BRUTO + COMIS
Mostrar
SAL_TOTAL
Receber
QUANT
Receber
SAL_BRUTO
Profª Angelina V.S.Melaré
56
Operador Relacional e Lógico

1. Operadores Relacionais

Os operadores relacionais são utilizados em expressões de lógicas, para comparação e
testes condicionais de valores de constantes ou conteúdo de variáveis. Eles podem ser usados
numa expressão que também tenha operadores aritméticos. Esses operadores relacionais geram
um resultado lógico (Verdadeiro ou Falso) quando aplicados nas expressões.
Operador (pseudocódigo) Significado C
=
>
<
<=
>=
<>
Igual
Maior
Menor
Menor ou igual
Maior ou igual
Diferente de
= =
>
<
<=
>=
!=

A precedência de execução é: <. <=, >, >=, !=, ==

Expressão em pseudocódigo Expressão em C Resultado
3 = 5
15 > 5
5+ 6 = 11
7 < 4-5
‘s’ = ‘n’
3 = = 5
15 > 5
5 + 6 = = 11
7 < 4-5
‘s’ = = ‘n’
0 - Falso
1- Verdadeiro
1- Verdadeiro
0 - Falso
0 - Falso

Na linguagem C não existe o tipo lógico (booleano) com os valores true e false
(verdadeiro ou falso). Ao verificar uma expressão, o compilador compara e retorna o valor zero
ou um. O valor zero representa o falso e, qualquer valor diferente de zero, no caso o valor um,
representa o verdadeiro.

2. Operadores Lógicos
As expressões lógicas são aquelas que operam com valores lógicos e resultam também
num valor lógico. Elas podem ser utilizadas em testes de variáveis, tomada de decisão e
expressões matemáticas. A função do operador lógico “NÃO” pode modificar valores e
expressões, pois ele serve para negar a expressão.

Operador Operação Prioridade C
NÃO
E
OU
Negação
Conjunção
Disjunção
1
2
3
!
&&
||
Profª Angelina V.S.Melaré
57
3. Tabela Verdade: é o conjunto das possibilidades combinatórias dos operadores lógicos.
E OU NÃO
V e V = V
V e F = F
F e V = F
F e F = F
V ou V = V
V ou F = V
F ou V = V
F ou F = F
Não F = V
Não V =F

Exemplos:
Pseudocódigo C Explicação
Não ( Idade = 5 ) ! ( Idade = = 5 ) Nessa expressão temos o resultado “Falso”, pois o
operador lógico “NÃO” negou a expressão contida
dentro do parênteses.
num1 5
num2 6

num1 > 7 E num2 > 5
num1 = 5;
num2 = 6;

num1> 7 &&
num2>5
O resultado dessa expressão é “Falso”, pois o
operador “E” exige que as duas condições sejam
verdadeiras para o resultado ser “Verdadeiro”. Veja
que a primeira condição está indicando que o
Número1 é maior que 7, mas isso não é verdadeiro,
pois o valor do Número1 é 5, e 5 é menor que 7. A
segunda condição é verdadeira, pois 6 é maior que 5.

num1 5
num2 6

num1> 7 OU num2> 5
num1 = 5;
num2 = 6;

num1>7 || num2>5
O resultado dessa expressão é “Verdadeiro”, pois o
operador “OU” indica que apenas uma das condições
precisa ser verdadeira para o resultado ser
“Verdadeiro”. Observem a diferença do operador
“OU” com o operador anterior “E”.


4. Prioridade dos Operadores
A prioridade de execução pode ser diferente em algumas linguagens de programação
Prioridade Operador
1
2
3
4
Parênteses
Aritméticos
Relacionais
Lógicos

Exercício: Descubra se as expressões abaixo são falsas ou verdadeiras:
a) 5 + 6 = 10
b) 5 mod 2 = 2
c) 15 <> 5 + 5
d) 33 > 3 OU carol = carolina
e) 16 > 5 * 2
f) 20 < 2
g) 56 > 45 + 4
h) feijão = feijoada
i) 56 < = 4
j) 70 > = 3 ** 2
k) 5 >= 5 E 4 = 5
l) 12 + 1 = 13 OU 4 + 2 = 7
m) 18 > 7 E 19 < 7
n) 90 = 3 OU 80 > 5

Profª Angelina V.S.Melaré
58
Estrutura de Decisão /Condicional/ Seleção

Todas as complexidades de um
problema não podem ser passadas no
computador baseadas apenas numa
estrutura linear, pois esta estrutura não
prevê a possibilidade de desvios de
instruções. Para o desenvolvimento de
programas mais completos estudaremos a
partir de agora uma nova estrutura, a de
decisão.
As condições, ou verificações e
testes estão presentes em quase todos os
programas, devido à grande flexibilidade e
poder de ação que tais estruturas
proporcionam.
As decisões são representadas
pelas expressões relacionais/lógicas e
essas podem ter dois resultados, a do
Verdadeiro ou a do Falso. Conforme o
resultado um dos caminhos deve ser
executado, sendo obrigatório existir o do
verdadeiro, mas não o do falso.
Na verdade a decisão é uma condição
ou expressão lógica que é testada e verificada,
podendo ser verdadeira ou falsa. Se depois de
avaliada a condição e o resultado for
verdadeiro, então, os passos a serem
executados são diferentes daquele em que se o
resultado fosse falso.
Existem diversas estruturas
condicionais: simples, composta encadeada,
múltipla escolha.


Algoritmos (Descrição Narrativa)
Estrutura Linear
INÍCIO
Pegar o doce
Tirar da embalagem
Comer o doce
FIM
Estrutura Condicional
INÍCIO
Pegar o doce
Tirar da embalagem
SE o doce estiver estragado então
Jogar fora o doce
SENÃO
Comer o doce
FIM

PEGAR O DOCE
INÍCIO
FIM
TIRAR DA EMBALAGEM
COMER O DOCE
PEGAR O DOCE
INÍCIO
FIM
TIRAR DA EMBALAGEM
ESTÁ
ESTRAGADO?
JOGAR FORA O DOCE
F V
COMER O DOCE

Profª Angelina V.S.Melaré
59
MEMÓRIA
NUM1 NUM2
ENTRADA
SAÍDA
PROCESSAMENTO
VALORES
SIMULADOS
5
100
100
100 5
No exemplo acima podemos ver facilmente a importância da estrutura de decisão. Na
primeira estrutura, a linear, existe apenas três procedimentos e não há verificação das
informações. Na segunda estrutura foi possível fazer a verificação de possíveis falhas na
seqüência de processos, onde, foi constatada a falta do procedimento que verificasse se o doce
estava ou não estragado.

Exercício Resolvido

Elabore um programa que receba dois números e no final mostre o maior número digitado.
Entrada:
Receber dois números
Processamento:
Verificar qual o maior número digitado
Saída:
Mostrar o número maior

Pseudocódigo
Inicio
Real num1, num2;
Escreva (“Digite o primeiro número”);
Leia num1;
Escreva (“Digite o segundo número”);
Leia num2;
SE (num1 > num2) então
Escreva (“O maior número é: ”, num1);
Senão
Escreva (“O maior número é: ”, num2);
Fim


Teste de Mesa















Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
float num1, num2;
printf(“\nDigite o primeiro número”);
scanf(“%f”,&num1);
printf(“\nDigite o segundo número”);
scanf(“%f”,&num2);
if (num1 > num2)
printf(“O maior número é %f”, num1);
else
printf(“O maior número é %f”, num2);
}

Profª Angelina V.S.Melaré
60
Tipos de Estruturas de Decisão

1. Estrutura de Decisão Simples
A instrução somente será executada se a condição testada for Verdadeira. Quando for
mais de uma instrução a ser executada deve ser delimitado o bloco de instruções, com seu início
e fim.

SE (condição) ENTÃO SE (condição) ENTÃO
instrução; Início
instrução 1;
instrução 2;
instrução n;
Fim

if (condição) if (condição)
instrução; {
instrução 1;
instrução n;
}

Exemplo:
a) if (n1 > n2)
printf (“O primeiro número é maior que o segundo”);

b) if (n1> n2)
{
printf(“O primeiro número é maior que o segundo”);
printf(“Informe outro valor”);
scanf(“%i”, &n3);
}
Profª Angelina V.S.Melaré
61

2. Estrutura de Decisão Composta:
A condição será testada e de acordo com o seu resultado (verdadeiro ou falso) será
executado um caminho (instrução) diferente. Essa estrutura é usada quando as duas
possibilidades dependem de uma mesma condição. Onde uma contradiz a outra.

SE (condição) ENTÃO SE (condição) ENTÃO
instrução; Início
SENÃO instrução 1;
instrução; instrução n;
Fim
SENÃO
Início
Instrução 1;
Instrução n;
Fim


if (condição) if (condição)
instrução; {
else instrução 1;
instrução; instrução n;
}
else
{
Instrução 1;
Instrução n;
}
Exemplo:
a) if (n1 > n2)
printf (“O primeiro número é maior que o segundo”);
else if (n1 == n2)
printf (“Os dois número são iguais”);
else
printf (“O segundo número é maior que o primeiro”);




Profª Angelina V.S.Melaré
62

3. Estrutura de Decisão Encadeada:

Essa estrutura é usada quando existem várias verificações a serem feitas e uma pode
depender da outra. Pode ser executada uma condição simples ou composta dentro de outra
condição.
Pode existir a Estrutura de Decisão Heterogênea, quando não existe um padrão lógico no
encadeamento. Exemplo: se..senão...se...se...senão.
Quando existe um padrão lógico das estruturas de decisão é chamada Estrutura de
Decisão Homogênea. Exemplo: se..senão..se..senão..se..senão.

SE (condição) ENTÃO
Início
instrução;
SE (condição) ENTÃO
instrução;
Fim
SENÃO
Início
Instrução 1;
Instrução n;
Fim

if (condição)
instrução;
else if (condição)
{
instrução 1;
instrução n;
}
else if (condição)
instrução;

Exemplo:
If (n1 > n2)
printf(“O primeiro número é maior que o segundo”);
else if (n2 == 0)
{
printf (“O segundo número não pode ser zero”);
printf(“Informe outro número”);
scanf(“%i”, &n2);
}
else if (n1 == n2)
{
printf (“Os dois número são iguais”);
printf(“Informe outro número”);
scanf(“%i”, &n3);
}

Profª Angelina V.S.Melaré
63
INÍCIO
FIM
Receber
IDADE
Mostrar
“Deve ser vacinada”
V F
IDADE
<=
5
...
Intervalos
Dentro da estrutura de decisão existe a definição de intervalos. Estes intervalos definem
as faixas que estão enquadrados os valores. Elas podem ser definidas de diferentes formas, como
nos exemplos abaixo:

Exemplo 1: Receba uma idade qualquer e mostre uma mensagem de acordo com ela. Se a
idade for igual ou menos de 5 anos a criança deve ser
vacinada.

Pseudocódigo
Inicio
Inteiro idade;
Escreva (“Digite sua idade”);
Leia (idade);
SE (idade <= 5) então
Escreva (“Deve ser vacinada”);
Fim




Exemplo 2: Receba a idade de uma pessoa e mostre uma mensagem de acordo com ela. As
pessoas que tem mais de 11 anos e menos de 18 são consideradas adolescentes.

Pseudocódigo

Inicio
Inteiro idade;
Escreva (“Digite sua idade”);
Leia idade;
SE (idade >= 11) então
SE (idade <= 18) então
Escreva
(“Adolescente”);
Fim
Nesse programa apenas as pessoas que tiverem
idade menor ou igual a 5 anos devem ser vacinadas.
Ficando excluídas as com idade superior a 5 anos. Esse é
um exemplo de intervalo que contém todos os valores
menores ou iguais a 5.
No exemplo anterior todos os valores menores que 5
seriam válidos. Já nesse exemplo, somente os números que vão
de 11 a 18 são válidos. Nessa expressão pode ser usado o
operador lógico E.
SE idade >= 11 E idade <= 18 então
Profª Angelina V.S.Melaré
64

Exemplo 3: Receba a idade de uma pessoa e mostre uma mensagem de acordo com ela. As
pessoas que tiverem menos de 18 anos e mais de 85 não estão aptas a dirigir e devem ser
alertadas com uma mensagem.

Pseudocódigo
Inicio
Inteiro idade;
Escreva (“Digite sua idade”);
Leia idade;
SE (idade < 18) então
Escreva (“Não pode dirigir”);
SE (idade > 85) então
Escreva (“Não pode dirigir”);
Fim


Operador Ternário
Em C existe o operador ? (operador condicional) que facilita a verificação de sentenças
simples (únicas).
Estrutura: condição ? expressão1 : expressão2;
A condição é avaliada;
Se ela for verdadeira o resultado é a execução da expressão1;
Se a condição for falsa o resultado é a execução da expressão2.

1) /* O reajuste será de acordo com o salário.
Se este for maior que 2000 o reajuste será de
10%, senão, de 30% */

#define escreva printf
main()
{
int sal = 1000;
float reajuste;
sal>2000 ? reajuste = 0.10 : reajuste = 0.30;
escreva ("reajuste : %g\n", reajuste);
_sleep(2000);
}

2) /*Mostra o quadrado de um número
diferente de zero. Se o número digitado for
zero aparece a mensagem Erro */

#define escreva printf
main()
{
int x;
escreva("Entre com o valor de x");
scanf("%i", &x);
x!= 0 ? printf("\n Quadrado de x = %i",
(x*x)) : printf("\nErro");
_sleep(2000);
}

As faixas acima mostram claramente que há dois tipos de intervalo diferentes: um
intervalo com valores menores de 18 e outro intervalo com valores superiores a 85. Sendo
excluídos todos os valores internos da faixa. Este tipo de intervalo pode ser definido com o
operador lógico OU.

SE idade < 18 OU idade > 85 então
Profª Angelina V.S.Melaré
65
Seleção Múltipla
As linguagens de programação possuem um comando exclusivo para seleção múltipla
(verifique...caso). Nessa estrutura o computador fará um teste sucessivo, verificando o valor da
expressão numa lista seqüencial de constantes, ao encontrá-lo ele executará o bloco de comandos
que estão associados à constante.
Dependendo da linguagem que for utilizada essa estrutura pode ser exclusiva, ou seja,
quando for executado um caso, os demais serão excluídos. Na linguagem C se faz a exclusão
pelo comando break e somente pode ser usada essa estrutura para verificações de valores de uma
variável do tipo inteiro ou caracter, não existe teste de intervalos, ou mesmo várias verificações
ao mesmo tempo.

Pseudocódigo:
verifique <variável>
início
caso <valor> : <instruções> ; pare;
caso <valor> : <instruções >; pare;
....
caso não seja nenhuma das opções anteriores: < instruções>; pare;
fim do verifique

** tem linguagens que permite o teste de intervalo de valores como:
caso valor 1..valor n:
case valor1, valor 3, valor 7:

Codificação em C:
switch (variável)
{
case <valor>:
instruções;
break;
case <valor>:
instruções;
break;
...
default:
instruções;
}

O comando default é executado se nenhum valor for encontrado nos case anteriores, ou
seja, nas comparações ele não encontrar um valor verdadeiro. O uso do default é opcional.
O comando break serve como um desvio de execução. Ao ser executado dentro do switch
ele finaliza a seqüência de instruções do case e sai do switch. Se não for usado o break o
computador continuará dentro do switch executando as instruções dos outros case.

Profª Angelina V.S.Melaré
66
Exemplos:
a)
#include <stdio.h>
#include <conio.c>
main()
{
int num;
printf("Informe um valor inteiro");
scanf("%i", &num);
switch(num)
{
case 1:case 2:printf("Valor baixo");
break;
case 5:case 8:printf("Valor alto");
break;
default:
printf("Valor Invalido\n");
break;
}
getch();
}


b)
case ‘/’ :
if( n2 = = 0 )
printf(“Não existe divisão por zero”);
else
r= n1 / n2;
break;



Curiosidade:




Pode existir case sem instrução associada.
Caso isso ocorra o computador executará
as instruções do próximo case.
Profª Angelina V.S.Melaré
67

Exercícios Resolvidos

01) Faça um programa que classifique as máquinas conforme a produção de cabo para telefones.
Veja a tabela abaixo:

Pseudocódigo
Início
Real quantpro;
Leia quantpro;
SE (quantpro >= 60000) então
Escreva (“Produção Boa”);
SENÃO SE (quantpro > 40000) então
Escreva (“Produção Regular”);
SENÃO
Escreva (“Produção Ruim”);
Fim










Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
float quantpro;
printf(“\nDigite a quantidade produzida”);
scanf(“%f”,&quantpro);
if (quantpro >= 60000)
printf (“Produção Boa”);
else if (quantpro > 40000)
printf(“Produção Regular”);
else
printf(“Produção Ruim”);
}
02) Receba um número inteiro e classifique-o como negativo, positivo ou nulo. Essa classificação deverá
ser exibida por uma mensagem.

main()
{
int numero;
scanf(“%i”, &numero);
if (numero = = 0)
printf(“Número Nulo”);
else
if (numero > 0)
printf (“Número Positivo”);
else
printf(“Número Negativo”);
}

Ou...




Produção Classificação
maior ou igual a 60.000
menor que 60.000 e maior que 40.000
menor ou igual a 40.000
“Boa”
“Regular”
“Ruim”
main()
{
int numero;
scanf(“%i”, &numero);
if (numero = = 0)
printf(“Número Nulo”);
if (numero > 0)
printf (“Número Positivo”);
if (numero < 0)
printf(“Número Negativo”);
}

Profª Angelina V.S.Melaré
68
Variáveis de Bloco

Os blocos de instruções que são delimitados pelas {}, podem ser descritos dentro de uma
estrutura condicional, de repetição, entre outras. Dentro desse bloco podemos definir variáveis
locais a eles, de forma que essas são variáveis locais ao bloco, ou seja, definidas e acessadas
somente no bloco. Podemos ter várias variáveis com o mesmo nome no mesmo código fonte,
sendo todas variáveis distintas, de acordo com a sua declaração.

/* Exemplo do uso de variáveis de bloco
e a exibição do endereço da memória*/

#include <stdio.h>
#include <stdlib.h>
main()
{
int cont=0;
printf("\nValor do contador %i", cont);
printf("\nEndereco de cont %i\n", &cont);
if (cont == 0)
{
int cont = 5;
printf("\n\tValor do contador do bloco %i", cont);
printf("\n\tEndereco de cont do bloco %i\n", &cont);
}
printf("\nValor do contador fora do bloco %i", cont);
printf("\nEndereco de cont fora do bloco %i", &cont);
getch();
}



Profª Angelina V.S.Melaré
69

Estrutura de Repetição

Laço (Loop)
Toda vez que você ler ou ouvir a palavra loop saiba que ela significa retornar, igual o
loop de uma montanha russa, onde você gira, e gira e repete essa volta várias vezes. Então, loop
na programação significa repetição, iteração, volta a executar um procedimento já executado.

Pode ser feita a repetição de apenas uma instrução ou de um conjunto de instruções,
podendo ser ou não definida a quantidade de vezes que irá repetir.

Tome cuidado na hora da definição dos processos a serem repetidos. Se você quiser que a
tela seja limpa toda vez que for exibida uma mensagem; então a instrução para limpar a tela deve
estar dentro do corpo do loop, senão, a tela será limpa apenas uma vez.

A estrutura que aprenderemos a partir de agora é usada para tornar automática a repetição
de um programa inteiro ou apenas uma parte dele. Com a repetição automática os programas
tornam-se mais rápidos e ágeis, não existindo linhas de comandos idênticas repetidas.


A estrutura de repetição pode ser pré-definida com contador ou condicional


Quando for repetido um trecho do programa e já se souber a quantidade de vezes que ele
será executado, então, você usará a estrutura de repetição pré-definida com contador. Um
exemplo onde podemos usar esta estrutura é num programa que faz a exibição do número 1 até
300.
Mas, quando não é conhecido de antemão o número de vezes a ser repetido um conjunto
de instruções, então você usará a estrutura com condição. Essa estrutura consiste em executar as
instruções enquanto uma condição pré-definida for verdadeira.


Símbolo de repetição no fluxograma
Esse símbolo é usado para representar estruturas de repetição, sejam elas
pré-definidas ou não.
Profª Angelina V.S.Melaré
70
N = 3
INSTRUÇÕES
ENQUANTO
N < =20
Receber
N
INSTRUÇÕES
Condição
V
a
lid
a
ç
ã
o
d
a
c
o
n
d

ã
o

Estrutura de Repetição Condicional (Enquanto..Faça /
Faça..Enquanto / Repita..até)

Essa estrutura de repetição é usada quando a quantidade de vezes um determinado trecho
do programa é desconhecida. O que determina o término é o resultado da verificação de uma
condição.
Existe a repetição pré-condição, com teste no início, e a pós-condição, com teste no final.

1. Repetição com Pré-condição- Enquanto..faça
Neste tipo de estrutura de repetição, o bloco de
instruções será repetido enquanto a condição testada no laço
for verdadeira. Quando ela se tornar falsa pára a repetição e o
fluxo de execução passa para a próxima linha depois do laço.
O teste da condição é feito no início antes de começar o bloco
de instruções que serão repetidos.

Cuidado ao usar o Enquanto: Se na primeira vez a
condição testada já for falsa, então, não ocorrerá nenhuma vez
a execução das instruções dentro do laço. Para que isso não
ocorra é necessário fazer a validação da condição, ou seja,
torná-la verdadeira antes de testar.

Enquanto .. Faça

Início
...
Instrução;
validação da condição;
ENQUANTO (condição) FAÇA
Instrução;
Fim


Obs:Estrutura que repete apenas uma
instrução



Estrutura em C

while (condição)
instrução;

Início
...
Instrução;
validação da condição;
ENQUANTO (condição) FAÇA
Início
Instrução;
Instrução;
Fim
Fim

Obs: Serão repetidas várias instruções, por isso
há a necessidade de haver um delimitador
(inicio/fim) do bloco de repetição.

while (condição)
{
Instrução1;
Instrução2;
...
Instrução n;
}
Profª Angelina V.S.Melaré
71

2. Repetição com Pós-condição - Faça..Enquanto


Início
...
Instrução;
Faça
Início
Instrução1;
Instrução2;
...
Instrução n;
Fim
ENQUANTO (condição);
Fim

3. Repetição com Pós-condição - Repita..até
Na linguagem Pascal existe o tipo de repetição Repeat..until, que no pseudocódigo
representamos pelo repita..até. Essa estrutura também faz a verificação da condição no final do
bloco de instruções, como a estrutura do Faça..enquanto. A diferença é que no repita..até, a
repetição é feito até a condição testada se torne verdadeira, ou seja, enquanto for falsa a condição
continua repetindo a execução.

Início
Instrução;
Repita
Instrução1;
Instrução2;
...
Instrução n;
até (condição);
Fim





Na linguagem C existe o teste da condição no final do bloco de repetição:

Faça .. Enquanto

Nesta estrutura a execução das instruções ocorrerá pelo menos uma vez, pois a condição
que determina o fim da repetição está no final do bloco de instruções. De forma, que não é
preciso validar a condição no início.
Enquanto a condição testada for verdadeira será feita a execução das instruções
repetidamente.

Profª Angelina V.S.Melaré
72
PENSE:












Exemplos de Pseudocódigo

a) num 1; b) resp ‘s’;
enquanto (num >0) faça enquanto (resp = ‘s’) faça
início
...
fim

c) faça
início
....
fim
enquanto (num >0);



Exemplos em C
a) num = 1; b) resp = ‘s’; c) do
while (num >0) while (resp = ‘s’) { ….
{ { ....
.... ... }while(num >0);
} }



4. Comandos Break, Continue função Exit()
Esses comandos são usados para se fazer um desvio na execução. O break e o continue
são usados dentro de laços (for, while).
Break: pode ser usado para terminar um case(switch) ou para forçar o término de um
laço. Depois de encerrado o laço ele retorna para o comando seguinte fora do laço.

Continue: ele encerra apenas a iteração atual do laço- não executa as instruções após ele -
voltando ao início da repetição.

Exit(): finaliza a aplicação, podendo retornar um valor, qualquer valor diferente de 0
significa deu algum tipo de erro.


Imagine a situação: Você tem que desenvolver o módulo de
Saque para um Banco. Como você faria?
– permite o saque quantas vezes quiserem e depois deduz do
saldo
Ou...
– primeiro faria o programa verificar o saldo para depois
permitir o saque.

Profª Angelina V.S.Melaré
73
5. Enquanto Verdadeiro
O valor 1 significa verdadeiro, de forma que você pode colocar uma condição sem
definição da expressão lógica.

Exemplo 1: para criar um loop infinito:
while (1)
{
printf("Programação de um loop ");
}

Exemplo 2: para criar um loop com a condição de término definida dentro do estrutura de
repetição:

#include <stdio.h>
#include <stdlib.h>
int main()
{
int num;

while (1)
{
scanf("%d", &num);
if (num ==0)
exit(0);
}

_sleep(7000);

}



Dica: O exit(0) irá finalizar o programa direto. Se for usado o break no lugar do exit(0) ele irá
finalizar a repetição e irá continuar o programa executando o _sleep(7000), e as demais
instruções que houverem após a estrutura de repetição.

Profª Angelina V.S.Melaré
74

Faça um programa que receba as notas e faltas de 2 alunos. Faça a consistência da nota,
alertando quando for digitada uma nota inválida (menor que 0 ou maior que 10).

#include <stdio.h>
#include <stdlib.h>
main()
{
float cont=1, nota=0, falta;
while (cont <= 2)
{
printf("\nDigite a nota do aluno:");
scanf("%f", &nota);
if ((nota < 0) || (nota > 10))
{
printf("\nA nota digitada deve estar entre 0 e 10");
continue;
}
printf("\nDigite a frequencia do aluno:");
scanf("%f", &falta);
cont++;
}
system("pause");
}

Profª Angelina V.S.Melaré
75

Repetição Pré-Definida – Para

Essa estrutura de repetição é usada quando é conhecida a quantidade de vezes em que
uma determinada parte do programa será repetida. Essa parte pode ser formada por uma ou várias
instruções.




PARA <variável_controlevalor inicial> ATÉ <valor_final> INC <incremento> FAÇA
Instrução;


PARA variável_controle DE valor inicial ATÉ valor_final PASSO valor_incremento FAÇA
Instrução;


Variável de controle ou Variável Contadora
É através dessa variável que se
controla a repetição. Essa variável pode
ser iniciada tanto com valores negativos
como positivos, dependendo da forma
que é feita a contagem e controle da
variável: regressiva ou progressiva.
Na linguagem C podem existir
diversas variáveis de controle.
Valor inicial: O valor inicial
indica qual o primeiro valor a ser
armazenado dentro da variável de
controle.
Valor final: É através desse valor
que é determinado o fim a repetição. Na
linguagem C o que existe no lugar do
valor final é uma condição. Enquanto
essa condição for verdadeira continua a
repetição, quando ela se torna falsa o
laço é finalizado.
Incremento ou decremento: O incremento ou decremento é um valor ou uma fórmula que
muda o valor da variável de controle, de maneira que essa variável saia do valor inicial e atinja o
valor final, e dessa maneira torne falsa a condição testada.

C
CONDIÇÂO

INSTRUÇÕES
INSTRUÇÕES
REPITA
N = 1, 20, 1
Variável de repetição
Valor inicial
Valor final
Valor de Incremento
PRÓXIMO N
Profª Angelina V.S.Melaré
76


6. Estrutura em C

for (variável de controle = valor inicial; condição que define o fim do laço; valor do
incremento ou decremento)
instrução;
ou,

for (variável de controle = valor inicial; condição que define o fim do laço; valor do
incremento ou decremento)
{
Instrução 1;
Instrução 2 ;
...
Instrução n;
}

Exemplos:
a) for (cont =1; cont <=10; cont ++)
printf(“Ordem crescente: %i”, cont);

b) for (cont =10; cont >=1; cont --)
{
printf(“Ordem decrescente: %i ”, cont);
_sleep(500);
system(“cls”);
}
Dicas:
• O break encerra o laço a qualquer momento.

• O continue faz com que o laço seja finalizado sem executar as instruções abaixo
e volte ao início, fazendo um novo ciclo.

• O uso de mais de uma variável dentro do for deve ser feito com o uso da vírgula
(,).
for (n1=1, n2=1; n1+n2 < 10; n1++, n2++)

• Não é obrigatória a definição dos três parâmetros, podendo ser feito um laço
infinito.
for ( ; ; )
printf(“Oi!”);

• O laço for pode ser usado para criar um atraso de tempo. Para isso ele não deve
possuir nenhuma instrução associada a ele.
for (atraso =0 ; atraso < 100; atraso++);


Profª Angelina V.S.Melaré
77
Cuidado: Se a condição a ser testada já inicia sendo falsa, as instruções dentro do laço
nunca serão executadas.
int cont = 100;
for (; cont <1 ; cont++)


Cadastre o número de identificação das 200 peças.

Início
int numiden, cont;
PARA contl ATÉ 200 INC contcont +1 FAÇA
Início
Escreva (“Número de identificação do funcionário:”);
Leia (numiden);
Fim
Fim

Linguagem C
#include <stdio.h>
#include <stdlib.h>
main()
{
int numiden, cont;
for (cont=1;cont <=200;cont++)
{
printf (“Número de identificação do funcionário”);
scanf (“%i”, &numiden);
system(“pause”);
}
}

Explicação:
1. No exemplo acima inicialmente é feita a atribuição do valor 1 a variável de controle
com o valor.
2. Em seguida é feita a verificação da condição que determina o fim da repetição, se ela
for Verdadeira inicia a execução do código que está no bloco. Se for falsa já finaliza
(mesmo se nunca executou o código dentro do bloco de comandos).
3. Executa o bloco de instruções, que contém a entrada do número de identificação. No
final da execução do bloco é automaticamente adicionado ao conteúdo da variável de
controle o valor 1 (anteriormente valia 1, mais 1 de agora, a variável passa a ter o valor
2).
4. Depois é verificado o valor da variável com o valor final pré-definido (200), como no
passo 2. Repetindo todo o processo várias vezes. Até que ...
5. o valor da variável de controle atinja o valor maior que o definido no intervalo (201).
Quando isso ocorrer a repetição pára e será iniciada uma nova seqüência de comandos
definidos fora da repetição, após o bloco de comandos.

Condição de término da repetição:
Repete até que o valor de cont fique maior que 200
Ou
Enquanto o valor de cont for menor ou igual a 200 repete

Profª Angelina V.S.Melaré
78

Variáveis Contadoras e Acumuladoras


Variáveis Contadoras:
É o nome dado a uma variável
numérica que tem a função de "contar"
valores, ocorrências, ou mesmo, um
determinado fenômeno. Esse recurso de
programação é usado em programas de
cadastro, pesquisa, controles. Através dessas
variáveis é possível contar o número de
pessoas cadastradas, o número de peças com
defeito.

Cuidados:
• todas as variáveis contadoras
devem ser zeradas no início;
• o conteúdo da variável
contadora deve ser
incrementado com o valor de
uma constante (normalmente
o valor 1);
• para a variável contadora ser
incrementada várias vezes ela
deve ser colocada dentro de
um laço.

Exemplo:
ContPessoas ContPessoas + 1;

Variáveis Acumuladoras:
Para cada situação deve-se usar uma
regra, um procedimento. Quando se faz a
contagem de algum dado usa-se a variável
contadora, incrementando o seu conteúdo
com o valor 1. Mas, se houver a necessidade
de acumular o valor de uma variável, então,
usa-se a variável acumuladora, onde elas são
incrementadas não pelo valor 1, mas sim
pelo valor de outra variável.

Cuidados:
• todas as variáveis
acumuladoras devem ser
zeradas no início do processo;
• o conteúdo de uma variável
acumuladora deve ser
incrementado com o valor de
outra variável;
• para a variável acumuladora
ser incrementada várias vezes
ela deve ser colocada dentro
de um laço.

Exemplo:
Somanota Somanota + Nota;



Variável Contadora = Variável contadora + 1
cont++;

Variável Acumuladora = Variável acumuladora + valor de outra variável
Soma += nota;

Profª Angelina V.S.Melaré
79

SubAlgoritmos/ Modularização

1. Sub-Rotinas (Módulos)
As sub-rotinas, também chamadas de módulos ou subprogramas, são trechos de
instruções que realizam tarefas específicas e que podem ser realizadas diversas vezes durante a
execução do programa.
Ao ser decomposto um programa em subprogramas ou sub-rotinas este tem sua
complexidade também dividida. Desta forma é possível focalizar a atenção em um problema de
cada vez, fazer os programas ficarem mais organizados e menores.
A linguagem C possibilita o uso de sub-rotinas por meio das funções. Na linguagem C
existe a função principal main(), que é sempre a primeira rotina executada, e a partir desta as
outras rotinas são executas. A linguagem C é formada por funções, como printf(), scanf(),
system(), que são incluídas através da diretiva #include (já explicada anteriormente).

2. Declaração da Função
tipo_de_retorno nome_da_função (tipo_de_parâmetro nome_do_parâmetro, ....)
{
declaração das variáveis locais;
corpo da função;
retorno;
}

O tipo_retorno especifica o tipo de valor (int, float) que a função retornará através do
return. Os tipos podem ser inteiros (int), reais (float), char (caracter) ou mesmo void (não
retorna nada). Se não especificado o tipo o compilador assume um retorno inteiro.
O nome_da_função é o identificador da função. Através dele é possível saber o que a
função executará, por exemplo, se a função for criada para fazer uma adição ela pode ser
chamada de soma(). O compilador procura pelo nome da função para fazer o desvio de execução.
A lista de parâmetros é separada por vírgula. O tipo_de_parâmetro e o seu nome são
respectivamente o tipo e o nome da variável que serão passados para a função. Uma função
pode não ter parâmetros. Esses parâmetros estabelecem a comunicação bidirecional entre o
subalgoritmo e o algoritmo que o chamou.
O corpo da função contém todas as instruções que deverão ser executadas pela função.
Ele deve estar entre chaves { }. A chaves de abertura { marca o início da função e a chaves
fechada } marca o final da função.

As variáveis locais são variáveis declaradas dentro (internamente) da função onde serão
usadas e somente são conhecidas (visíveis e acessíveis) pela função que as criou.

Exemplo:
float media_notas (float nota1, float nota2)
{
float media;
media = (nota1+nota2)/2;
return media;
}
Profª Angelina V.S.Melaré
80
3. A função principal - main()
Por padrão a função main() deve ser do tipo inteiro, ou seja seu retorno é um valor inteiro.
Esse valor pode ser usado pelo sistema operacional para verificar se a execução do programa foi
bem sucedida. Quando o valor retornado é zero 0 significa que a execução foi bem sucedida,
caso contrário ocorreu algum erro.
int main()
{
return 0;
}
A função principal pode receber vários valores (argumentos) quando executada, que
depois podem ser processadas. Veja a explicação no exemplo a seguir:
Na linha de comando serão passados o nome do programa e 2 números inteiros, como:
ANGELINA 8 27
O programa ANGELINA iniciará executando a função main() que estará recebendo 3
argumentos, o nome do programa, o número 8 e o número 27. Para que ele possa receber esses
valores foi definido da seguinte maneira:








int main (int argc, char * argv[])
No caso acima o argc teria o valor 3 e o argv a matriz formada por ANGELINA, 8 e 27.

Exemplo 1 :
int main(int argc, char *argv[])
{
printf("Total de argumentos passados %i", argc);
printf("Nome do programa %s", argv[0]);
_sleep(3000); return 0;
}

Exemplo 2:
int main(int argc, char *argv[])
{
int i=0;
printf("Total de argumentos passados %i", argc);
while (i< argc)
{
printf("\n%d - string informadas %s", argc, argv[i]);
i++;
}
_sleep(3000);
return 0;
}
Contém o total de
argumentos passados
(lembre do c como
contador)
É um ponteiro de uma matriz de
caracteres. Cada elemento está
direcionado para um argumento
Profª Angelina V.S.Melaré
81

Exemplo 3:
int main(int argc, char *argv[])
{
int i=0;
if (atoi(argv[1]) > 0)
printf("\nNumero positivo");
_sleep(3000);
return 0;
}


4. Comando Return
Tem duas formas de uso:
• ele provoca uma saída imediata das função que o contém, retornando a função anterior.
• retornar um valor para outra função


5. Tipo Void
• Todas as funções que não devolvem valores devem ser declaradas como tipo void.
• Quando uma função não tem parâmetros, deve ser colocado o void entre parênteses.
• Quando não existe um retorno o tipo de função é void.
As funções podem ser usadas como rotinas de entrada, rotinas de criação de ela ou rotinas
de exibição de dados. Muitas rotinas são específicas e independem dos valores de variáveis de
outras rotinas, por isso o uso do tipo void na especificação das funções.

Exemplo:
void entrada(void);
main()
{
entrada();
....
system(“pause);
}


void entrada(void)
{
system(“cls”);
printf(“\n\n\n”); printf(“<1> - Adição \n”); printf(“<2> - Subtração \n”);
printf(“<3> - Multiplicação \n”); printf(“<4> - Divisão \n”);
printf(“<5> - Sair \n”);
}
O void no parâmetro é opcional.
O void na definição do tipo de função é
obrigatório
Profª Angelina V.S.Melaré
82
6. Protótipos de Funções
O protótipo da função foi acrescido com o padrão C ANSI. O protótipo da função deve
ser usado quando a função for definida após a função principal main(). Ele é um cabeçalho que
indica ao compilador a existência de uma função dentro do programa, podendo estar no meio ou
no final.
Definição do Protótipo
tipo_de_retorno nome_da_função (tipo_de_parâmetro nome_do_parâmetro, ....)
float media_notas (float nota1, float nota2);

main()
{
}

** Se a função for descrita no início do programa, antes da função principal main(), não
precisa ser feito o seu protótipo.

7. Chamada (ativação) da Função
A chamada de função existe quando há uma referência de uma função dentro do
programa. Durante o acionamento da função, o fluxo de execução é desviado para ele, e logo
após sua conclusão, o fluxo de execução retorna a linha de origem (a que o desviou).
Na linha de chamada da função pode haver o envio ou não de argumentos para outra
função. Esses argumentos são valores de variáveis, que podem ser usadas na outra função.
Não são definidos os tipos de dados dos argumentos, pois os mesmos são definidos no
início da função.

Exemplo: float media_notas (float nota1, float nota2);
main()
{
float n1,n2,media;
media= media_notas (n1, n2);

}

float media_notas (float nota1, float nota2)
{ ....}

Os argumentos enviados para a função devem ser compatíveis com os parâmetros, ou
seja, se foram enviadas duas variáveis (argumentos) – exemplo nota1 e nota2 – devem ser
definidos na função a ser executada duas variáveis (parâmetros) para estar recebendo os
conteúdos das variáveis. Os tipos de variáveis devem ser iguais, ou seja, se os dados enviados
são inteiros, então a variáveis definidas para recebê-los também devem ser inteiros.


n1 e n2 são argumentos (enviam)
nota1 e nota2 são parâmetros (recebem)
Profª Angelina V.S.Melaré
83
8. Exemplo Completo de Função
#include <stdio.h>
#include <stdlib.h>

float media_notas (float nota1, float nota2); //protótipo da função

main( ) // início da função principal
{
float n1, n2, media; // definição das variáveis locais
printf("\n Este programa calcula a média de duas notas");
printf("\n\n Primeiro nota");
scanf("%f", &n1);
printf("\n\n Segunda nota");
scanf("%f", &n2);
media= media_notas (n1, n2); // chamada da função media_notas()
printf("\n\n A média das notas é %.2f \n", media);
system("pause");
} // fim da função principal


float media_notas (float nota1, float nota2) // declaração da função media_notas
{
float media; // definição das variáveis locais
media = (nota1+nota2)/2;
return media; //retorna o resultado da média para a
função principal
} // fim da função media_notas()

** A função media_notas() é do tipo float porque o retorno dela será uma variável do tipo float
(media).
** Os parâmetros (nota1 e nota2) são do tipo float porque seus respectivos argumentos (n1,n2) são
do tipo float.

9. Classes de Armazenamento de Variáveis
• Variáveis Globais: São variáveis definidas fora de qualquer função específica, no início
do programa, antes da função principal. Elas poderão ser manipuladas por qualquer
função e parte do programa e seus endereços e alocações de memória permanecem até o
final do programa- ou seja ficam ocupando espaço. Essas variáveis são definidas como
extern. Elas são inicializadas com zero, caso o programador não as inicialize.

• Variáveis Locais: São variáveis declaradas dentro de uma função específica e são
visíveis apenas na função em que foram criadas. Funções distintas podem ter variáveis
locais com o mesmo nome. Quando a função é iniciada as variáveis locais são criadas e
quando essas funções são finalizadas as variáveis locais são destruídas e liberados os
endereços de memória. Essas variáveis são automáticas definidas e são definidas
como auto. Elas não são inicializadas com zero.
• Então, a variável local será visível apenas na função que a cria e a variável global será
visível por todas as funções existentes no programa. Isso pode ser alterado se você definir
a variável como estática.

Profª Angelina V.S.Melaré
84
• Variáveis Estáticas: essas variáveis são visíveis e definidas internamente dentro de uma
função (localmente), mas não perde seu valor depois de finalizada a função.

/* Exemplo do uso de variáveis estáticas*/
#include <stdio.h>
#include <stdlib.h>
void contador ();
main()
{
contador();
contador();
contador();
_sleep(2000);
}

void contador ()
{
static int cont=0;
printf("\nValor do contador %i", cont++);
}

*** Perceba que a inicialização somente ocorre a primeira vez que a função é executada.
Também existe a static definida fora da função que pode ser usada em qualquer parte do código-
fonte atual, mas não pode ser usada por outros arquivos fontes. Isso quando for usada uma estrutura de
projetos.

• Register: as variáveis definidas como register são armazenadas num registrador do
processador e não na memória RAM. Dessa maneira é aumentada a velocidade de
processamento, já que não precisa do acesso a memória. Essas variáveis devem ser int ou
char.


Profª Angelina V.S.Melaré
85

Função com Passagem de Parâmetro por Valor

Quando uma função é chamada, os parâmetros dessa função copiam os valores dos
argumentos que são passados pela função que a chama.
Essa passagem de parâmetro é denominada Passagem de Parâmetros por Valor. Isto
ocorre porque são passados para a função apenas os valores dos parâmetros e não os próprios
parâmetros.
Os valores dos argumentos não são alterados fora da função que os criou.
No exemplo abaixo vemos que o valor mostrado da variável num a primeira vez (na
função main()) é diferente do valor mostrado na função quadrado(), pois, são duas variáveis
diferentes. O valor da variável num é alterado na função quadrado(), mas permanece inalterada
na função main().

Exemplo: Programa que calcula o quadrado de um número qualquer, usando função.
#include <stdio.h>
#include <stdlib.h>
float quadrado (float num); //protótipo da função quadrado()

main()
{
float num, qd; //declaração das variáveis locais
printf ("Entre com um numero: ");
scanf ("%f",&num);
printf ("Na função MAIN a variável num vale %.2f \n", num);
qd= quadrado(num); //chama a função quadrado() e envia o
argumento num
printf ("O quadrado do %.2f é = %.2f\n",num, qd);
system(“pause”);
}

float quadrado(float num) //declaração da função quadrado() e
do
{ parâmetro num
num = num*num;
printf ("Na função QUADRADO a variável num vale %.2f \n", num);
return num; //retorna a função que a chamou
retornando um valor (num) que será
} atribuído a variável qd.

** A função quadrado() é do tipo float porque o retorno dela será uma variável do tipo float (num).
** O parâmetro (num) é do tipo float porque o argumento (num) é do tipo float.
Profª Angelina V.S.Melaré
86

Exercícios Resolvidos

1) Faça uma função que calcule a soma de dois números recebidos na função principal.
#include <stdio.h>
#include <stdlib.h>
float soma (float a, float b); // protótipo da função soma
main( ) // início da função principal
{
float n1, n2, total; // definição das variáveis locais
printf("\n Este programa calcula a soma de dois números");
printf("\n\n Digite o valor do primeiro número");
scanf("%f", &n1);
printf("\n\n Digite o valor do segundo número");
scanf("%f", &n2);
total=soma(n1, n2); // chamada da função soma()
printf("\n\n A soma de %.2f com %.2f é %.2f \n", n1, n2,total);
system("pause");
} // fim da função principal

float soma (float a, float b) // definição da função soma
{
float res; // definição das variáveis locais
res= a+b;
return(res); // retorna o resultado da soma dos
números enviados
} // fim da função soma()

]

2) Elabore um programa que tenha as seguintes funções:
_ na função principal deve ser recebidas pedidas duas notas e feitas às chamadas de
funções.
_ uma função que receba a nota do aluno e faça a consistência;
_ uma função que calcule a média;
_ uma função que exiba o resultado, se o aluno está aprovado, reprovado ou em exame.
#include <stdio.h>
#include <stdlib.h>
float ler_nota(void); /* protótipos das funções*/
float calcula_media(float p1, float p2);
void exibe_resultado(float med);
void pausa(void);
main()
{
float n1, n2, med;
printf("Primeira prova: "); n1=ler_nota();
printf("Segunda prova : "); n2=ler_nota();
med=calcula_media(n1, n2);
exibe_resultado(med); pausa();
}


Profª Angelina V.S.Melaré
87
float ler_nota(void)
{
float n;
do
{
scanf("%f", &n);
if (n<0.0 || n>10.0)
printf("Número Inválido! Redigite..:");
}while (n<0.0 || n>10.0);
return(n);
}

float calcula_media(float p1, float p2)
{
float res;
res = (p1 + p2) / 2; /* Calcula a média*/
return(res);
}

void exibe_resultado(float med)
{
printf("Media %.1f: ", med);
if (med < 3.0)
printf("Aluno reprovado\n");
else if (med >= 3.0 && med < 7.0)
printf("Aluno em exame\n");
else if(med >= 7.0)
printf("Aluno aprovado\n");
}

void pausa(void)
{
system(“pause”);
system(“cls”);
}

3) Exemplo completo de validação de dados, sem usar a função atoi() ou atof().

int caractermaiusculo(char ch)
{
return (ch >= 'A' && ch <= 'Z');
}

int caracterminusculo(char ch)
{
return (ch >= 'a' && ch <= 'z');
}

int digitonumerico(char ch)
{
return (ch >= '0' && ch <= '9');
}
Profª Angelina V.S.Melaré
88
int main(void)
{
char c;
while(1)
{
c=getch( );
putchar(c);
if (digitonumerico(c) == 1)
puts("Valor Numerico\n");
else if (caractermaiusculo(c) == 1)
puts("Caracter Maiusculo\n");
else if (caracterminusculo(c) == 1)
puts("Caracter Minusculo\n");
else
puts("Caracter especial\n");
}
system("pause");
return 0;
}
Profª Angelina V.S.Melaré
89
Funções Recursivas

Essas funções têm esse nome por poderem chamar a si mesmas de forma direta ou indireta. Por
exemplo, para calcular o fatorial de um número pode ser feita uma função e ela precisar chamar a si
mesma (forma direta). Quando uma função chama outra e depois essa outra chama a que a chamou é
definida como função recursiva indireta.
As variáveis locais de chamadas recursivas são independentes entre si, como se tivessem
chamando funções diferentes.

Exemplo: Calculo do fatorial de um número qualquer.
/* N! = N * (N-1)!
4! = 4 * 3* 2 * 1
4! = 4 * 3! 3! = 3 * 2! 2! = 2*1 ! 1!= 1
Se N! for 0 o resultado é 1
Senão, N * (N-1)
*/
#include <stdio.h>
#include <stdlib.h>

main()
{
int num, r_fatorial;
printf("Informe valor: ");
scanf("%i", &num);
r_fatorial = 1;
if (num == 0)
r_fatorial = 1;
else
{
do
{
r_fatorial *= num;
num--;
}while (num !=0);
}
printf("O fatorial desse numero e %i", r_fatorial);

_sleep(2000);
}

Usando função recursiva direta
#include <stdio.h>
#include <stdlib.h>

int f_fatorial(int num);

main()
{
int num;
printf("Informe valor");
scanf("%i", &num);
Profª Angelina V.S.Melaré
90
printf("O fatorial desse numero %i", f_fatorial(num));
_sleep(3000);
}

int f_fatorial(int num)
{
if (num == 0)
return 1;
else
return num*f_fatorial(num-1);
}

As variáveis locais de chamadas recursivas são independentes entre si, como se tivessem chamando
funções diferentes.

Simulação da execução:
Fatorial do número 2
A)- envia o argumento 2
- na função testa o valor
- tem o return 2 * f_fatorial(2-1)
*** não retorna, pois primeiro tem um função a ser executada.

B) -envia o argumento 1 (do calculo anterior 2-1)
- na função testa o valor
- tem o return 1 * f_fatorial(1-1)
*** não retorna, pois primeiro tem um função a ser executada.

C) - envia o argumento 0 (do calculo anterior 1-1)
- na função testa o valor
- veja que agora tem o return 1

-- esse retorna o valor 1 passo B
- tem o return 1 * 1
--esse também retorna o valor calculado 1 ao passo A, que calcula return 2 * 1 e retorna
o valor 2 a função principal e exibe o resultado.



Profª Angelina V.S.Melaré
91
Vetores

1. Conceito

• Os vetores são matrizes unidirecionais homogêneas e podem ser chamadas de: arranjos
unidimensionais, variáveis indexadas, variáveis compostas homogêneas unidimensionais ou
arrays.
• O vetor é um mecanismo de estruturação de dados usado para representar variáveis do
mesmo tipo de dado, que são referenciados pelo mesmo nome e cada elemento através de sua
posição dentro dela.
• Consiste em locações contíguas de memória. O endereço mais baixo corresponde ao primeiro
elemento e o mais alto ao último.
• Os vetores são variáveis indexadas por apenas um índice (uma dimensão, unidimensional).
• O elemento do vetor é acessado por meio de um índice.
• O índice 0 contém o primeiro elemento armazenado.
• Uma string (cadeia de caracteres) é um vetor de caracteres.

2. Exemplos:

float media[10]; // vetor com 10 elementos do tipo real

0 1 2 3 4 5 6 7 8 9
2.5 4.5 6.5 3.5 10 8 7 5.5 6 8.5

char nome[4]; // vetor com 4 elementos do tipo caracter (string)
A N A ###BOT_TEXT###

int notas[4]; //vetor com 4 elementos do tipo inteiro
6 3 10 5


3. Declaração:
A declaração de um vetor pode ser feita da seguinte maneira:
tipo_da_variável nome_da_variável [tamanho];
Onde:
• tipo_da_variável é o tipo base do vetor (int, float, char, etc), ou seja, qual tipo de
conteúdo será armazenado na variável;
• tamanho_da_variável é a quantidade de elementos que o vetor armazenará.

Exemplo:
float medias[45];

- A linguagem C reservará 180 bytes (45 x 4), ou seja, são 45 variáveis do tipo
float, onde cada float ocupa 4 bytes. Estes bytes são reservados de maneira contígua.
Profª Angelina V.S.Melaré
92
4. Acessando os elementos
Cada elemento do vetor é um elemento individual, ou seja, seu conteúdo não está
vinculado com os outros. Para acessá-lo eu preciso de uma referência a mais do que somente seu
nome, é preciso saber onde se localiza o elemento dentro do vetor. Para isso acessamos os
elementos do vetor, individualmente, através de um índice.
Na linguagem C os índices iniciam no 0 e finalizam valendo o tamanho do vetor -1,
devendo ser colocados entre colchetes.
Exemplo: float media[10];

A primeira média será armazenada na posição 0 do vetor e a última será na posição 9;
0 1 2 3 4 5 6 7 8 9
2.5 4.5 6.5 3.5 10 8 7 5.5 6 8.5

media[0] acessa o primeiro elemento do vetor;
media[9] acessa o último elemento do vetor;
media[2] acessa o terceiro elemento do vetor;

5. Armazenando os elementos
Para ser feito o armazenamento no vetor é necessário de definir seu nome e em qual
posição deverá ser armazenada (qual índice). O armazenamento pode ser feito separadamente ou
em conjunto, de uma vez só. Veja os exemplos abaixo:
media[0] = 2.5;
float media[10]= {2.5,4.5,6.5,3.5,10,8,7,5.5,6,8.5};
float media[]= {2.5,4.5,6.5,3.5,10,8,7,5.5,6,8.5};
media[1] = 4.5;


** Cuidado: Não se esqueça que o índice sempre inicia no 0.
Ao declarar um vetor você coloca o tamanho total.

6. Endereço do vetor ou matriz unidimensional
Quando se refere ao endereço do vetor, pense que o primeiro elemento dá início ao vetor, ou seja,
media equivale ao endereço inicial do vetor (media[0] é igual a media). Por isso quando for feita
a entrada de uma string não se pode colocar o &.


Exemplos
a) Recebendo elementos de um vetor do tipo inteiro digitados via teclado
for ( i=0; i<100; i++ )
{
printf(“Digite %i elemento do vetor”, i++);
scanf( “%i”, &vet[i] );
}

b) Mostrando os elementos de um vetor na tela:
for ( i=0; i<100; i++ )
printf( “%i”, vet[i] );

Profª Angelina V.S.Melaré
93
c) Inicializando um vetor com zeros
for ( i=0; i<100; i++ )
valores[i] = 0;


7. Exercícios Resolvidos:
1) Crie um vetor com 10 elementos do tipo inteiro e depois armazene automaticamente os
valores de 0 a 9.
main()
{
int x[10]; //definição do vetor
int i; //definição da variável para controlar o índice
for (i = 0; i < 10; i ++) //definição do laço para gerar o vetor
x [i] = i; //atribuição do valor da variável i ao vetor x
system(“pause”); }

2) Crie um vetor com 10 elementos do tipo inteiro e depois armazene automaticamente os
resultados da tabuada do número 2.
main()
{
int r[10];
int t;
for(t=0;t<10;t++)
{
r[t]=t*2;
printf("%i\n",r[t]);
}
system("pause");
}

3) O professor de Programação de Computadores precisa de um programa que calcule a média
geral da sala, verificando dessa forma o desempenho dos alunos. O programa deve receber e
armazenar as notas dos 35 alunos e calcular a média geral da sala.
main()
{
int notas[35],i,soma =0;
for(i=0;i<5;i++)
{
printf("Digite a nota do aluno %d: ",i);
scanf("%f",&notas[i]);
soma=soma+notas[i];
}
printf("Media das notas: %f.",soma/5);
system("pause");
}
Profª Angelina V.S.Melaré
94

Vetor String (Cadeias de Caracteres)

Na linguagem C não existe o tipo de dado string, dessa forma é necessário criar um vetor
de caracteres para armazenar uma cadeia de caracteres (string).
Ao usar esse tipo de vetor deve-se tomar cuidado para o fato de que as strings têm o seu
último elemento como caracter null (###BOT_TEXT###). Para declarar a string, devemos declarar sempre um
elemento a mais para o terminador. Cada caracter é um elemento independente e pode ser
acessado de um índice.
Existem bibliotecas e funções especiais para o tratamento e manipulação de strings. O
cabeçalho padrão é string.h.

Exemplos de declaração e atribuição:
a) char nome[7];
b) char nome[] = {‘b’,’i’,’a’,’n’,’c’,’a’};
d) char mensagem[10] = “Exemplo”;

Armazenamento e entrada de strings
Função scanf()
A função scanf(“%s”, &nome) recebe apenas o primeiro nome. Quando o usuário
pressionar o espaço ele finaliza essa string, ignorando o sobrenome. Então a função scanf() é
usada para receber uma palavra, apenas uma string.

Função gets()
A função gets() é usada para receber uma séria de strings, que podem ser separadas,
digitadas, com ou sem espaço. Exemplo: gets(nome);
Cuidado: não coloque o índice do vetor, pois, a função se encarrega de separar cada
caracter na sua respectiva posição dentro do vetor ou matriz.

Exemplo: Faça um programa que receba um texto e depois mostre quantas vogais foram
digitadas.
main()
{
char texto[10];
int vogais=0,t;
printf ("Digite um texto\n");
gets(texto);

for (t=0;t<10;t++) // ou for (t=0; texto[i] != '###BOT_TEXT###';t++)
{
if (texto[t] == 'a' || texto[t] == 'e' || texto[t] == 'i' || texto[t] == 'o' || texto[t] == 'u')
vogais++;
}

printf ("Total de vogais: %i\n", vogais); system ("pause");
}

Profª Angelina V.S.Melaré
95
Função strlen() Retorna o tamanho da string
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
main()
{
char nome[40];
printf(“Digite seu nome: ”); gets(nome);
printf(“O tamanho do nome é: %i\n”, strlen(str));
}

Função strcat() União de variáveis string
main()
{
char nome[40], sobrenome[15];
int i;
printf ("\nEntre com um nome: "); scanf ("%s", nome);
printf ("\nEntre com um sobrenome: "); scanf ("%s", sobrenome);
strcat(nome, " ");
strcat(nome, sobrenome);
printf ("\nO seu nome é %s \n", nome);
}

Funções: atoi(), atof()
Essas funções fazem a conversão de uma string em um valor numérico. A atoi() converte
a string para um valor inteiro. A atof() converte para um número ponto flutuante.
Cuidado com o valor informado se for usado o atoi ele somente aceita o valor inteiro e
ignora a parte decimal. Exemplo: 287.455 somente aceita o 287
Uma string inválida retorna na conversão o valor zero.

Dica: Quando você quiser que não trave o programa na entrada de dados, de forma que o usuário
informe uma letra no lugar de entrar com o número, use uma dessas funções.

int main()
{
char num1[3], num2[3];
int inum1;
float fnum2;
printf("\nInforme o valor"); gets(num1);
printf("\nInforme o valor"); gets(num2);
inum1= atoi(num1);
fnum2= atof(num2);
printf("\nOs numeros validos informados sao %i e %.2f",inum1, fnum2);
_sleep(3000);
}
Profª Angelina V.S.Melaré
96
Função strcmp() é usada para comparar strings. Ela recebe e compara duas strings. Essa
função retorna 0 se as duas forem iguais, senão, se a primeira string for maior que a segunda
retorna um valor positivo, senão, retorna um valor negativo.
main()
{
char senha1[10], senha2[10];
printf("\nCadastro de senha\n");
printf("Informe sua senha:"); gets(senha1);
printf("Redigite sua senha: "); gets(senha2);
if ( strcmp(senha1,senha2) == 0 )
printf ("\nSenha válida");
else if ( strcmp(senha1,senha2) >0 )
printf ("\nA primeira senha e maior");
if ( strcmp(senha1,senha2) < 0 )
printf ("\nA primeira senha e menor");
getch();
}

Ou
int i=0, i =0;
char nomes[20];
gets(nome_pes);
while(i<20 || !achou) //poderia ser ! (achou == 0)
{
if (!strcmp(nomes[i], valor)
{
achou = 1;
break;
}
else
i++;
}

Função puts() é usada para mostrar uma única string por vez, mas com a vantagem de pular
a linha automaticamente.
main()
{
char senha1[10]= "Fatec", senha2[10]= "Fatec Itu";
puts("Senhas cadastradas\n");
puts(senha1); //aparece Fatec
puts(senha2); //aparece Fatec Itu
puts(&senha1[4]); //aparece c itu – a partir do índice 4.
}

Função strstr() procura uma string dentro de outra string
Exemplo: if (strstr(string_lida, string_pesq) != NULL)
break;
Profª Angelina V.S.Melaré
97
Função strchr() procura um caracter dentro de uma string
Exemplo com as duas funções de pesquisa:
int main()
{
char nome[20]="Ana carolina";

if (strstr(nome, "Ana"))
printf("O nome possui o Ana");
else
printf("O nome não possui o Ana");

if (strchr(nome, 'a'))
printf("O nome possui o caracter a");
else
printf("O nome não possui o caracter a");
getchar();
return 0;
}

Função fgets() A função fgets() efetua a leitura de dados do tipo string fornecidos via teclado
delimitando seu tamanho. Ela aceita caracteres em branco no meio do string, colocando o
caractere de controle “###BOT_TEXT###” apenas quando for pressionada a tecla <Enter>.
Para utilizar esta função, é preciso informar três parâmetros, sendo o nome da matriz-
string, o seu tamanho e o nome do buffer em uso:
fgets(VARIAVEL, TAMANHO, stdin);

puts("Informe seu nome ........: "); fgets(NOME, 20, stdin);


Profª Angelina V.S.Melaré
98
Matriz
Segundo Giovanni e Bonjorno: Matriz é o conjunto ordenado dos números que formam uma
tabela, onde cada número é um elemento.
Matriz transposta: é quando temos uma matriz de origem m x n e a transposta é n x m

1. Matriz Bidimensional
A linguagem C permite que seja declarada uma matriz bidimensional (variável composta
homogênea bidirecional) ou mesmo multidimensional.
Na matriz bidimensional o primeiro índice indica a linha e o segundo a coluna. Os índices
iniciam no zero(0). Para calcular o espaço de memória necessário para armazenar a matriz é
necessário fazer o seguinte calculo:
int pontos_jogos [2] [4];

qtd de linhas * qtd de colunas * qtd do tipo (inteiro)
tamanho = 2 * 4 * 2
tamanho = 16
Lembre-se que internamente essa matriz tem seus valores armazenados linearmente, de
forma continua na memória, cada elemente armazenado em um endereço, cujo próximo elemento
está no endereço seguinte da memória.

2. Declaração:
A declaração de uma matriz bidimensional pode ser feita da seguinte maneira:
tipo nome [dimensão1] [dimensão2];
ou
tipo nome [linha] [coluna];

Exemplos:
1) char tabela[5][5];

2) int pontos_jogos [2] [4];

0 1 2 3
0
1
pontos_jogos [0,1]

3. Armazenando os elementos
A inicialização e armazenamento de uma matriz pode ser individual ou coletivo. Como
nos exemplos abaixo:

• pontos_jogos [0] [1] = 5;
• pontos_jogos [1] [3] = 60
• int i[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
• int quadrados[5][2] = {1, 1, 2, 4, 3, 9, 4, 16, 5, 25};
• float nota[2][3] = {{9, 8, 7} , {6.5, 4, 2}};


pontos_jogos [1,3]

Profª Angelina V.S.Melaré
99
4. Armazenamento feito via teclado
A leitura e armazenamento dos elementos de uma matriz via teclado deve ser usando uma
estrutura de repetição (laço). O for é o mais usado.
Supondo que a matriz foi declarada como: int mat [2] [3];

O laço da linha (1ª dimensão) inicia no 0 e finaliza no 1 e o laço da coluna (2ª
dimensão) inicia no 0 e finaliza no 2.

for (l=0; l<2; l++)
{
for (c=0; c<3; c++)
scanf (“%i”, &mat[ l ] [c ]);
}


5. Mostrando os elementos
Para mostrar os valores armazenados dentro de uma matriz também é usada a estrutura do
for. Para exibir a matriz mat declarada acima.

for (l=0; l<2; l++)
{
for (c=0; c<3; c++)
printf (“%i”, mat [ l ] [c ] );
}

Profª Angelina V.S.Melaré
100
Ponteiros

1. Variáveis ponteiros
Uma variável ponteiro é um tipo especial de variável, que tem como conteúdo um
endereço de memória de outra variável, esse endereço é em hexadecimal. O tipo dessa variável
ponteiro deve ser o mesmo tipo da variável para a qual está apontando, por exemplo se ela estiver
apontando para um endereço de uma variável cujo conteúdo é float então ela (a variável ponteiro)
deve ser definida como float.
Para trabalhar com ponteiros é usado os operadores unários & e * antes da variável. O
formato de exibição usado na função printf() pode ser %p, %x, u %X, a diferença é apenas
quanto ao formato de exibição.

Definição e declaração do ponteiro
Define o tipo da variável e do ponteiro dessa variável

int *p, v;

O que define que a variável é um ponteiro é o * antes do nome. O * também poderia estar
junto com o tipo: int* p.

Atribuição do endereço ou direcionado o ponteiro
O endereço de memória da variável v é armazenado no ponteiro p

p = &v;


int main()
{
int *p, v;
v= 8;
p= &v;

printf("\nO endereco de v e %p", &v);
printf("\nO conteudo do p e %p", p);
printf("\nO endereco do p e %p", &p);
getchar();
}
Profª Angelina V.S.Melaré
101
Cuidado com o uso do operador *.
O * pode ser usado tanto para declarar o ponteiro quanto para indicar o conteúdo da
variável para qual ele está apontando.
main()
{
int *p, v;
v= 8;
p= &v;
printf("\nO endereco de v e %p", &v);
printf("\nO conteudo do p e %p", p); //é o endereço memória de v
printf("\nO endereco do p e %p", &p);
printf("\nO valor de v %d", v);
printf("\nO valor de v mostrado atraves do ponteiro p %d", *p);
}


Podemos usar mais ponteiros para direcionar para o mesmo local da memória.
main()
{
int *p, *p2, v;
v= 8;
p= &v;
p2= p; //não usa o & para pegar o endereço do outro ponteiro
printf("\nO endereco de v e %p", &v);
printf("\nO conteudo do p e %p", p);
printf("\nO endereco do p e %p", &p);
printf("\nO valor de v %d", v);
printf("\nO valor de v mostrado atraves do ponteiro p %d", *p);
printf("\nO valor de v mostrado atraves do ponteiro p2 %d", *p2);
}

Aritmética de ponteiros
Pode ser feito uso das operações de adição e subtração com os ponteiros. Mas cuidado
para não pegar o conteúdo da variável para o qual ele está apontando e sim seu endereço. Se
acrescentarmos no programa anterior o código abaixo:
int t;
t= sizeof(t); //ver o tamanho do tipo int e quantos bytes vai avançar
p++; printf("\nO conteúdo de p e %p", p);
printf("\nO conteúdo apontado pelo ponteiro p %d", *p);

Está sendo feito uma adição no ponteiro p++, de forma que ele irá avançar 4 bytes na
memória, pois, a cada incremento ele acrescentar ao seu endereço a quantidade de bytes de seu
tipo.
De forma que quiser retroceder e voltar a apontar para v, basta fazer uma subtração com o
ponteiro.
p--;

Cuidado: você tem que atribuir
um endereço para o ponteiro
Profª Angelina V.S.Melaré
102


Vendo o conteúdo da variável através de seu ponteiro – de forma indireta
main()
{
double *p, v;
v= 8;
p= &v;
printf("\nO conteúdo de p e %p", p); //endereço de v
printf("\nO conteúdo apontado pelo ponteiro p %f", *p);
p--; printf("\nO conteúdo de p e %p", p);
printf("\nO conteúdo apontado pelo ponteiro p %f", *p);
}



Perceba que o tipo Double oculpa 8 bytes, quando subraímos o ponteiro ele voltou 8 bytes.
main()
{
int *p, v;
v= 8;
p= &v;
printf("\nP %d e V %d", *p, v);
v+= 10; //somando 10 ao valor de v
printf("\nP %d e V %d", *p, v);
*p= *p+1;//somando 1 ao valor de v através do ponteiro
printf("\nP %d e V %d", *p, v);
(*p)++; //somando 1 ao valor de v através do ponteiro --use ()
printf("\nP %d e V %d", *p, v);
*p++; //erradoooo - você acrescentou 1 ao valor do ponteiro
printf("\nP %d e V %d", *p, v);
}
Profª Angelina V.S.Melaré
103
Cuidado para não errar
*p++; //errado - você acrescentou 1 ao valor do
ponteiro
printf("\nP %d e V %d", *p, v);
*p--; //errado - você subtraiu 1 ao valor do ponteiro
printf("\nP %d e V %d", *p, v);

2. Trabalhando com Matriz através de Ponteiros
É muito usado em matriz, a passagem do endereço dessa matriz para outra função, através
de ponteiros. Para isso você deve direcionar o ponteiro para o primeiro elemento da matriz. Isso
pode ser feito de duas maneiras:
int main()
{
int mat[4]={10,20,30,40}, *pm;
pm = mat; //direciona para o índice 0
printf("\n1o elemento: %d", *pm);
//ou
pm = &mat[0]; //tem que colocar o & para informar o índice 0
printf("\n1o elemento: %d", *pm);
printf("\n1o elemento: %d", mat[0]);
}

Veja o programa abaixo:
int mat[4]={10,20,30,40}, *pm;
pm = mat;
printf("\n1o elemento: %d", *pm);
//ou
pm = &mat[0]; //tem que colocar o & para informar a posição 0
printf("\n1o elemento pelo pm %d e pelo mat[0]", *pm, mat[0]);
pm= &mat[1]; //apontando para o 2 elemento
printf("\n2o elemento pelo pm %d", *pm);
pm++; //somando 4 bytes ao endereço do ponteiro e indo para o 3 elemento
printf("\n3o elemento pelo pm %d", *pm);
*pm = *pm *2; //multiplicando por 2 o conteúdo do 3 elemento
printf("\n3o elemento pelo pm %d", *pm);
*(pm++); //apontando para o próximo endereço
printf("\n4o elemento pelo pm %d", *pm);




Profª Angelina V.S.Melaré
104
Você pode fazer o calculo diretamente na exibição
int mat[3] = {10, 20, 30}, *pmat;
pmat = mat;
printf("mat[0] = %d \n", *(pmat));
printf("mat[1] = %d \n", *(++pmat));
printf("mat[2] = %d \n", *(++pmat));
printf("mat[0] = %d \n", *(pmat-=2));
getchar();


Recebendo valores de uma matriz através de seu ponteiro
#define E 3
main()
{
int mat[3], *pmat, i;
pmat = mat;
printf("Informe os valores da unidimensional\n");
for (i=0; i<E; i++)
{
printf("\n%d valor", i+1); scanf("%d", pmat);
pmat++;
}

for (i=0; i<E; i++)
{
pmat--;
printf("\n%d", *pmat);
}
getchar();
}


1ª. Trabalhando com ponteiro e string
main()
{
char *pnome, nome[20];
int compr=0;
printf("Digite um nome: "); gets(nome);
pnome = nome;
while (*pnome != '###BOT_TEXT###' )
{
printf("%c- %p\n", *pnome, pnome);
compr++;
pnome++;
}
printf("\nQuant caracteres %i\n", compr);
system("pause");
}
Profª Angelina V.S.Melaré
105
Funções com Passagem de Parâmetros por Referência

A diferente da Passagem de Parâmetros por Referência em relação a Passagem de
Parâmetro por Valor é que nesse tipo de passagem não se passa para a função os valores das
variáveis, mas sim suas referências (seus endereços de memória).

Usando a passagem por referência fica mais simples a mudança dos valores das variáveis,
que deve ter seu valor usado e alterado independente da função. Para que isso ocorra deve-se
declara as variáveis como ponteiros. Os ponteiros são a referência para poder alterar o valor da
variável fora da função. Não se esqueça quando usar a função deve colocar um &(endereço) na
frente das variáveis que estiverem sendo passadas para a função.

No programa abaixo o que é passado para a função quadrado é o endereço das variáveis
num1 e num2. Estes endereços são copiados nos ponteiros pa e pb. Através do operador * é
acessando o conteúdo apontado pelos ponteiros e modificando-o. Os valores armazenados em
num1 e num2 são modificados.


void quadrado(int *pnum1,int *pnum2);

main()
{
int num1,num2;
printf("\nDigite o primeiro número"); scanf("%d",&num1);
printf("\nDigite o segundo número"); scanf("%d",&num2);
printf("\n\nAntes da chamada da função Quadrado - os números são %i
%i\n",num1,num2);
quadrado(&num1,&num2);
printf("\n\Depois da chamada da função Quadrado - os números são %i
%i\n",num1,num2);
system("pause");
}

void quadrado(int *pnum1,int *pnum2)
{ *pnum1=*pnum1 * *pnum1;
*pnum2=*pnum2 + 5;
}


Profª Angelina V.S.Melaré
106
3. Passagem de Matriz por Referência
Na passagem da matriz, você irá enviar o endereço do elemento 0. Quando for definido o
ponteiro para receber o endereço de uma matriz unidimensional, você não precisa colocar a
dimensão (quantidade de elementos) que essa matriz terá, porque na linguagem C ele apenas
precisa saber o tipo dessa matriz. Você é que fará o controle dos elementos.
Quando a matriz for bidimensional é obrigatório informar a quantidade de elementos da
segunda dimensão.





void recebe(int pmat[], int t); /////////void recebe(int *pmat[], int t);

int main()
{
int mat[3], i ;
recebe(mat, 3);
for (i=0; i<3; i++)
printf("\n%d", mat[i]);

_sleep(20000);
}

void recebe(int pmat[], int t)
{
int i;
for (i=0; i<t; i++)
{
scanf("%d", pmat);
pmat++;
}
}

Na matriz bidimensional veja a definição da segunda dimensão

void calculamedia(float notas[][3])
{
int i;
for (i=0; i<3; i++)
{
notas[i][2]= (notas[i][0]+ notas[i][1])/2.0;
}
}




O operador * não precisa ser colocado, pois quando se passa um matriz
unidimensional ou bidimensional sempre será por referência.

Profª Angelina V.S.Melaré
107
int main()
{
float notas[3][3];
int l, c, i;
for (l=0; l<3; l++)
{
printf("\n\nAluno %d\n", l+1);
for (c=0; c<2;c++)
{
printf("%d Nota", c+1);
scanf("%f", &notas[l][c]);
}
}
calculamedia(notas);
printf("\nMedias dos alunos");
for (i=0; i<3; i++)
{
printf("\n%d aluno teve %.2f", i+1, notas[i][2]);;
}
_sleep(20000);
}

Profª Angelina V.S.Melaré
108
Estruturas

ESTRUTURAS (Struct) – VARIÁVEIS COMPOSTAS HETEROGÊNEAS
Muitas vezes precisamos manipular dados compostos, mas que identificam uma única
representação. Para isso é necessário ter um mecanismo de agrupamento, estruturando os dados
em um único contexto, como por exemplo um ponto é representado tanto pela coordenada x
quanto pelas coordenada y, elas são “dependentes” (não devem ser tratadas de forma isolada).
Assim como um data, que é formada tanto pelo dia, quanto pelo mês e pelo ano.

A sintaxe da deinição de uma estrutura é:
struct nome_da_estrutura
{
Componentes/membros dessa estrutura;
tipo nome_da_variável;
};

Estruturas permitem definir estruturas complexas de dados, com campos de tipos
diferentes. Por meio da palavra-chave struct e type def definimos um novo tipo de dado. Definir
um tipo de dado significa informar ao compilador o seu nome, o seu tamanho em bytes e o
formato em que ele deve ser armazenado e recuperado na memória. Após ter sido definido, o
novo tipo existe e pode ser utilizado para criar variáveis de modo similar a qualquer tipo simples.

struct Dados_Pessoais
{
char nome[81];
int idade;
float peso;
} P1; foi feita a declaração da variável P1 que é do tipo
Dados_Pessoais no final da definição da estrutura, mas, essa
declaração poderia ser feito de outra forma, como abaixo:

/* Declaração de variáveis do tipo struct Dados_Pessoais*/
struct Dados_Pessoais P2, P3;

Definindo um novo tipo de dado com o typedef

typedef struct Dados_Pessoais
{
char Nome [ 81];
int Idade;
float Peso;
} Pessoa;

/* A declaração das variáveis do tipo Dados_Pessoais/
Pessoa Cliente, Funcionario;

Profª Angelina V.S.Melaré
109
Uma vez criada a variável composta heterogênea, denominada estrutura, seus membros podem
ser acessados por meio do operador de acesso ponto (.). Esse conecta o nome da variável
estrutura a um dos seus membros.
estrutura membro

gets(Pessoa.Nome);
Pessoa.Idade = 41;
Pessoa.Peso = 75.6;

Outro exemplo direto de denominação de um tipo de dado:
int main()
{
typedef float R; //o nome R é um mneumônico do tipo float
R n1;
scanf("%f", &n1); printf("Numero digitado %g", n1);
}

Resumindo
struct ponto
{
float x;
float y;
};
typedef struct ponto P;
typedef struct ponto
{
float x;
float y;
} P;
ou struct ponto P;


scanf (%f%f”, &p.x, &p.y); printf(“As coordenadas são %.2f - %.2f”, p.x, p.y)

Exemplos de uso:
2ª. Recebendo dados
main()
{
struct dados_pessoais
{
char nome[81];
int idade;
float peso;
};
struct dados_pessoais aluno;

printf("\nNome do aluno:"); gets(aluno.nome);
printf("\nIdade:"); scanf("%i", &aluno.idade);
printf("\nPeso:"); scanf("%f", &aluno.peso);
printf("%i %s %.2f \n", aluno.idade, aluno.nome, aluno.peso);
}
Profª Angelina V.S.Melaré
110
3ª. Recebe e mostra uma estrutura de horas
main()
{
struct evento
{
int h, m;
float s;
};
struct evento ev;
printf("Entre com a hora de um evento(hh:mm:sec): ");
scanf("%i:%i:%f", &ev.h, &ev.m, &ev.s);
printf("A hora fornecida foi: %d:%d:%.2f\n", ev.h, ev.m, ev.s);
}

4ª. Igualando estruturas
main()
{
struct data
{
int dia;
char mes[10];
int ano;
};
data natal = { 25, "Dezembro", 1994};
data aniversario = { 30, "Julho", 1998};
printf("%i %s %i \n", aniversario.dia, aniversario.mes, aniversario.ano);

aniversario = natal;
printf("%i %s %i \n", natal.dia, natal.mes, natal.ano);
printf("%i %s %i \n", aniversario.dia, aniversario.mes, aniversario.ano);
}

5ª. Recebendo e verificando dados
#include <stdio.h>
#include <stdlib.h>
int main()
{
struct dados_pessoais
{
char nome[81];
int idade;
float peso;
};

typedef struct dados_pessoais Aluno; //define o novo tipo Aluno
Aluno A; //define a variável A que é do tipo Aluno

printf("\nNome do aluno:"); gets(A.nome);
Profª Angelina V.S.Melaré
111
printf("\nIdade:"); scanf("%i", &A.idade);
printf("\nPeso:"); scanf("%f", &A.peso);
printf("%i %s %.2f \n", A.idade, A.nome, A.peso);
if (A.peso >30)
printf("Precisa comer mais\n\n");
system("pause");return 0;
}

Ou
typedef struct dados_pessoais{
char nome[81];
int idade;
float peso;
}Aluno; //define o tipo Aluno

Aluno A; //define a variável a que é do tipo Aluno


6ª. Usando uma matriz do tipo estrutura
struct dados_pessoais
{
char nome[81];
int idade;
float peso;
} aluno[3];

int main()
{
int i;
for (i=0;i<3;i++)
{
printf("\nCadastro n: %i\n", i+1);
fflush(stdin); printf("\nNome do aluno:"); gets(aluno[i].nome);
printf("\nIdade:"); scanf("%i", &aluno[i].idade);
printf("\nPeso:"); scanf("%f", &aluno[i].peso);
printf("%i %s %.2f \n", aluno[i].idade, aluno[i].nome, aluno[i].peso);
}
system("pause"); return 0;
}

Ou
main()
{
int i;
struct dados_pessoais
{
char nome[81];
int idade;
Profª Angelina V.S.Melaré
112
float peso;
};

struct dados_pessoais aluno, *paluno;

paluno = &aluno;

for (i=0;i<3;i++)
{
printf("\nCadastro n: %i\n", i+1);
fflush(stdin);
printf("\nNome do aluno:"); gets(paluno->nome);
printf("\nIdade:"); scanf("%i", paluno->idade);
printf("\nPeso:"); scanf("%f", paluno->peso);
printf("%i %s %.2f \n", *paluno->idade, *paluno->nome, *paluno->peso);
}
system("pause");
}

Usando uma estrutura dentro da outra estrutura
typedef data
{
int dia;
int mes;
int ano;
};

struct dados_pessoais
{
char nome[81];
int idade;
float peso;
data data_niver ;
} aluno[3];

main()
{
int i;
for (i=0;i<3;i++)
{
printf("\nCadastro n: %i\n", i+1);
fflush(stdin);
printf("\nNome do aluno:"); gets(aluno[i].nome);
printf("\nIdade:"); scanf("%i", &aluno[i].idade);
printf("\nPeso:"); scanf("%f", &aluno[i].peso);
printf("\nData de Aniversario:"); scanf("%i-%i%i", &aluno[i].data_niver);
printf("%i %s %.2f \n", aluno[i].idade, aluno[i].nome, aluno[i].peso);
}
Profª Angelina V.S.Melaré
113
7ª. Usando estrutura e função
void exibedesenho(struct desenho xtrapezio);

struct desenho
{
int basemenor;
int basemaior;
int altura;
float area;
};
main()
{
struct desenho trapezio;
trapezio.basemenor =2;
trapezio.basemaior= 7;
trapezio.altura = 5;
trapezio.area= (trapezio.basemenor + trapezio.basemaior) * trapezio.altura/2;
exibedesenho(trapezio);
}

void exibedesenho(struct desenho trapezio)
{
printf("Base menor: %i \n \r", trapezio.basemenor);
printf("Base maior: %i \n \r", trapezio.basemaior);
printf("Altura : %i \n \r", trapezio.altura);
printf("Area do Trapezio: %.f \n \r", trapezio.area);
}

8ª. Fazendo a referência de estrutura em uma função
void calculadesenho(struct desenho *ptrapezio);
struct desenho
{
int basemenor;
int basemaior;
int altura;
float area;
};

main()
{
struct desenho trapezio;
calculadesenho(&trapezio);
printf("Base menor: %i \n \r", trapezio.basemenor);
printf("Base maior: %i \n \r", trapezio.basemaior);
printf("Altura : %i \n \r", trapezio.altura);
printf("Area do Trapezio: %.f \n \r", trapezio.area);
system("pause");
}
Profª Angelina V.S.Melaré
114

void calculadesenho(struct desenho *ptrapezio)
{
(*ptrapezio).basemenor =2;
(*ptrapezio).basemaior= 7;
(*ptrapezio).altura = 5;
(*ptrapezio).area= ((*ptrapezio).basemenor + (*ptrapezio).basemaior) * (*ptrapezio).altura/2;
}

ou
void calculadesenho(struct desenho *ptrapezio)
{
ptrapezio->basemenor =2;
ptrapezio->basemaior= 7;
ptrapezio->altura = 5;
ptrapezio->area= (ptrapezio->basemenor + ptrapezio->basemaior) * ptrapezio->altura/2;
}

9ª. Fazendo a referência de estrutura em uma função
void exibe(struct ponto *pponto);
struct ponto
{
float x;
float y;
};

main()
{
struct ponto vponto;
printf("\nDigite as coordenadas dos pontos x e y: ");
scanf("%f %f", &vponto.x, &vponto.y);
exibe(&vponto);
vponto.x= 5.7; printf("\nOs pontos digitados foram %.2f e %.2f \n", vponto.x, vponto.y);
system("pause");
}

void exibe(struct ponto *pponto)
{
printf("\nOs pontos digitados foram %.2f e %.2f \n", pponto->x, pponto->y);
}

Ou
void exibe(struct ponto cponto);
struct ponto
{
float x;
float y;
};
Profª Angelina V.S.Melaré
115
main()
{
struct ponto vponto;
printf("\nDigite as coordenadas dos pontos x e y: "); scanf("%f %f", &vponto.x, &vponto.y);
exibe(vponto);
printf("\nOs pontos digitados foram %.2f e %.2f \n", vponto.x, vponto.y);
}

void exibe(struct ponto cponto)
{
printf("\nOs pontos digitados foram %.2f e %.2f \n", cponto.x, cponto.y);
cponto.x= 5.7;
}

10ª. Fazendo Alocação Dinâmica de Memória
float media(int n, float *v);
main()
{
int i, n;
float *v, med;
printf("Quantos elementos serao armazenados: "); scanf("%i", &n);
v= (float *) malloc(n * sizeof(float)); //aloca 4*n bytes de memória em tempo de execução
if (v==NULL)
{
printf ("Memoria Insuficiente"); system("pause"); return 1;
}

for (i=0; i<n; i++)
{
printf(" %i - ", i+1); scanf("%f", &v[i]);
}
med= media(n,v); printf("Media %.2f \n\n", med);
free(v); //libera a memória
}

float media(int n, float *v)
{
int i;
float s=0;
for (i=0; i<n;i++)
s+= v[i];
return s/n;
}


main()
{
int i, n; float *nota = NULL;
printf(“Entre com tamanho n: ”); scanf(“%d”,&n);
nota=(float *)malloc(n*sizeof(float));
for (i=0; i < n; i++)
{
printf(“ Entre a nota %i:”, i+1); scanf(“%f”, nota+i);
}
for (i=0; i < n; i++)
printf(“\n %.2f \n”, *(nota+i));
free(nota);
}

Profª Angelina V.S.Melaré
116
União e Enumeração

1. União – union

O tipo união é usado para compartilhar um mesmo endereço de memória para várias variáveis,
que podem ser de tipos diferentes.
void main()
{
union variavel
{
float valor_hora;
float valor_mensal;
};
union variavel var;
var.valor_hora = 5.5; printf("\nValor da Hora %.2f", var.valor_hora);
var.valor_mensal = 346.5; printf("\nValor Mensal%f", var.valor_mensal);
printf("Valor da Hora %.2f", var.valor_hora); //permanece o último valor atribuído
ao endereço de memória, que é o valor 346.5 (mensal)
getchar();
}
Cuidado: Somente uma variável pode ser usada por vez, se for usado um outro membro da
união o anterior se perde (sobrescreve).

#include <stdio.h>
#include <stdlib.h>
void main()
{
union variavel
{
int valor_hora;
float valor_mensal;
} var;
printf("\nInforme o valor da hora"); scanf("%i", &var.valor_hora);
printf("\nValor da Hora informado: %i", var.valor_hora);
var.valor_mensal = 346.5; printf("\nValor Mensal pre-definido: %f", var.valor_mensal);
printf("\nUltimo valor armazenado %g", var.valor_hora); //permanece o último valor atribuído ao
endereço de memória, que é o valor 346.5 (mensal)
}

Profª Angelina V.S.Melaré
117
2. Tipo enumeração

É uma forma de definir inicialmente os valores, ou seja, pré-definidos.
enum Mes { Jan = 1, Fev, Mar, Abr, Mai,Jun, Jul, Ago, Set, Out,Nov, Dez};

Se não for definido um valor inial da sequência definida, ele sempre inicia a partir do zero.

enum meses {Jan = 1, Fev, Mar,Abr, Mai, Jun, Jul, Ago, Set, Out,Nov, Dez};
main()
{
int dia;
meses mes;
mes = Set; //ou mes = meses(9);
if (mes == Jan || mes == Mar || mes == Mai || mes == Jul || mes == Ago || mes == Out || mes ==
Dez)
dia = 31;
else if (mes == Fev)
dia = 28;
else
dia = 30;
printf(“Numero dias: %d \n”,dia);
}






Profª Angelina V.S.Melaré
118
Arquivos

A manipulação de um arquivo é feita através da associação de uma variável ponteiro
(FILE) a um arquivo físico (Stream), esse arquivo pode ser um arquivo texto (uma planilha do
excel, um documento do Word) ou um arquivo binário (um arquivo do sistema, um arquivo de
dados).
O conteúdo do arquivo depende da forma de criação do mesmo, pondendo ser criado e
armazenado:
• Modo binário, com uma sequência de bytes gravados, desconhecidos numa
leitura pelo usuário.
• Modo texto, com uma sequência de caracteres da tabela ASCII, compreensível
numa leitura pelo usuário.

Os arquivos gravados em modo binário tem um tamanho menor, já que estão convertidos
em bytes, enquanto que se for gravado em modo texto, cada caracter terá que ser convertido para
binário. A pesquisa de dados em um arquivo binário é mais rápida e fácil. Dessa forma, usamos
arquivo binários para armazenar uma grande quantidade de dados, como vários cadastros
(registros) e que não sejam compreensíveis por questão de segurança, e o modo texto para gravar
arquivos que podem ser compreensíveis pelo usuário e abertos por qualquer editor.

3. Abertura do arquivo
Para abrir ou mesmo criar um arquivo é usada a função fopen(). Para fazer uso dessa
função é necessário antes criar um variável ponteiro (FILE) que direcionará para um endereço de
memória do arquivo.
FILE *parq;
A função fopen recebe dois argumentos string: a localização (diretório) junto com o nome
do arquivo, e o modo de abertura do arquivo. A localização padrão é o local onde está o arquivo
executável.
fopen (nome, modo)
parq = fopen(“nome_arq”, modo );

Existe vários modo com o quais o arquivo pode ser aberto ou criado.
r
w


a


rt
rb
- +

wt
wb
at

Abre arquivo já existente para leitura
Abre para leitura e gravação. Caso o arquivo já exista ele sobrescreve os dados,
destruindo os dados armazenados anteriormente, senão, existir ele cria um novo arquivo.
Abre para leitura e gravação, mas, antes de tudo se posiciona no final dele. Se o arquivo
já existir o abre e depois começa a gravar, acrescentando os dados no final. Se o arquivo
não existir ele cria um novo arquivo para gravação.
Abre o arquivo texto para leitura. Esse arquivo já deve existir
Abre o arquivo binário para leitura. Esse arquivo já deve existir
Abre e grava no arquivo (a opção r+ abre o arquivo, e faz gravação no início do
arquivo—diferente do modo append (a))
Cria um novo arquivo texto e o abre para leitura e gravação.
Cria um novo arquivo binário e o abre para leitura e gravação. Se o arquivo não existir,
ele será criado. Se já existir, o conteúdo anterior será destruído.
Abre um arquivo texto já existente e adiciona as informações no final do arquivo (se o
arquivo não existir, ele é criado).
Profª Angelina V.S.Melaré
119
rt
ab
Abre um arquivo texto já existente para leitura
Abre o arquivo binário para leitura e gravação (usa os mesmos conceitos anteriores

parq = fopen(var_nome, const_modo ); OU parq = fopen( “C:\LOCAL\ARQUIVO.TXT”, w);

A função fopen() retorna um endereço de memória do arquivo quando esta for executada
com sucesso, ou um valor NULL quando der erro (erro de abertura ou criação do arquivo). Com
esse retorno é possível fazer verificações e exibição de mensagem de alerta para o usuário.
if (parq == NULL)
{
printf(“Erro de abertura do arquivo”);
exit(1);
}

4. Fechamento do arquivo
Para fechar o arquivo é usada a função fclose(). Essa função atualiza o arquivo com as
informações que estão no buffer (memória) e depois libera a memória. Resumindo efetiva a
gravação, fecha o arquivo e libera a memória.
fclose(parq);

5. Leitura
É muito importante definir a forma de leitura e gravação de um arquivo, pois, se for
necessário fazer uma consulta de todos os dados armazenados deve-se iniciar a leitura desde o
início do arquivo (percorrendo todo o arquivo até o final).

Leitura de um arquivo binário
A leitura de um arquivo binário é sempre feita de um registro por vez, o computador fará
a leiutura por intervalos de bytes, onde cada registro tem um tamanho fixo. Essa leitura é feita a
partir de seu posicionamento no arquivo, por isso é importante saber como será feita a abertura
do arquivo (posicionamento no início ou no final do arquivo).

parq = fopen( “C:\LOCAL\ARQUIVO.TXT”, rb);

fread(o endereço onde será armazenado o conteúdo lido,
tamanho em bytes a ser avançado o cursor,
o número de registros que vai ler por vez,
o ponteiro que indica o nome do arquivo que tem o conteúdo lido






fread(&devedores, sizeof(devedores), 1, parq);

Resumindo: é feita a leitura de uma quantidade sequencial de bytes do arquivo físico e depois é
guardado na memória através de um tipo estrutura. Após a leitura de um registro o ponteiro fica
posicionado no próximo registro do arquivo, podendo ser feita ou não sua leitura.
o nome da estrutura (registro) que
armazenará o conteúdo lido
qtd de bytes lidos
(tamanho da estrutura)
qtd de registros
lidos (sempre 1)
nome do ponteiro
do arquivo que está
sendo lido
Profª Angelina V.S.Melaré
120
Leitura de um arquivo texto

Função fgets() lê uma string de caracteres de um arquivo aberto.
fgets (variável que recebe a entrada, número de caracteres lidos, ponteirodearquivo);

fgets(CAD.nome, 20, parq); //faz a leitura da string e a carrega no ponteiro

Cuidado: O tamanho sempre é considerando o valor inicial no zero. Se o tamanho total é 20,
então se coloca 19, sempre é total - 1.

Obs: O posicionamento fica no fim da linha atual no arquivo se o caracter de mudança de linha
ocorrer antes de serem lidos todos os caracteres. Toda vez que executa o fgets() é atualizada a
posição de leitura corrente do arquivo aberto. Retornando NULL quando não há mais dados para
serem lidos.

Também existe as funções: fscanf(), fgetc() para leitura de um arquivo texto. Abaixo estão
alguns trechos de código com essas funções:

FILE *parq
char nome[35];
parq = fopen("dados.txt", rt);
fscanf (parq,"Nome: %s",nome);
puts(“Nome gravado”); printf(“%s”, nome);
fclose(fp);


6. Gravação

Gravação em modo binário
A gravação no modo binário é realizada através da função fwrite(). Para usar essa função
é necessário passar alguns argumentos, como descrito abaixo:
parq = fopen( “C:\LOCAL\ARQUIVO.TXT”, ab);

fwrite (o endereço onde está o conteúdo a ser gravado,
tamanho em bytes a ser gravado,
o número de elementos que vai gravar(número de registros que serão gravados)
o ponteiro que indica o endereço para onde vai copiar- nome do arquivo físico)






fwrite(&devedores, sizeof(devedores), 1, parq);

Cuidado: Se a estrutura foi definida para armazenar um único registro não se coloca o &.

nome da estrutura (registro)
que contém os dados
qtd de bytes a
serem gravados
qtd de registros a
serem gravados
ponteiro que
direciona para o
arquivo a ser gravado
Profª Angelina V.S.Melaré
121
Resumindo: O fwrite pega o conteúdo que está posicionado na memória, em um registro, e o
grava em um arquivo que está direcionado através do ponteiro.


Exemplos em modo binário:
1ª. Gravação dos dados em modo binário
struct entrada
{
char nome[40];
float valor;
} devedores[4];

main()
{
int i;
FILE *fp;
for (i=0; i<4; i++)
{
fflush(stdin); printf("Digite o nome: "); gets(devedores[i].nome);
printf("Valor da Divida: R$"); scanf("%f", &devedores[i].valor);
}

fp = fopen("devedores.txt","w"); //Etapa de abertura e gravação do arquivo
if (fp == NULL)
{
printf(“Erro de abertura do arquivo”);
exit(1);
}
fwrite(&devedores, sizeof(devedores), 1, fp);
//se for um único devedor não se deve colocar o &devedores
fclose(fp);
_sleep(3000);
}

2ª. Leitura dos dados em modo binário
struct entrada
{
char nome[40];
float valor;
} devedores[4];

main()
{
int i;
FILE *fp;
printf("Segunga etapa – Exibicao dos devedores ");
fp = fopen("devedores.txt","r");
fread(&devedores, sizeof(devedores),1,fp);
Profª Angelina V.S.Melaré
122
for (i=0; i<4; i++)
{
printf("\n%s - R$ %.2f",devedores[i].nome,devedores[i].valor);
}
fclose(fp);
}

3ª. Exemplos diversos
f= 3.1415;
fwrite (&f, sizeof(f), 1, fp)

float m[10][2];
fwrite (m, sizeof(m), 1, fp)


Gravação em modo Texto
Função fprintf(): Essa função grava dados em um arquivo aberto. O retorno da função é o total
de bytes gravados.

fprintf ( ponteiro do arquivo a ser gravado, formato de gravação, valores a serem gravados)
fprintf (parq,"<tr> <td>%d x %d = %d </td></tr>", num, tabuada, resultado);
fprintf(parq, “Cadastro de Alunos”);
fprintf(parq, “%s”, nome);

Exemplo de criação e gravação de arquivo texto
int main()
{
FILE *arquivo;
int t,c=0,r ;
printf ("Digite qual a tabuada...:"); scanf ("%d",&t);
arquivo = fopen("tabuada.xls","w");
printf (arquivo,"<table>");
do
{
r=c*t;
fprintf (arquivo,"<tr><td>%d x %d = %d</td></tr>",c,t,r);
c++;
} while (c<=10);

fprintf (arquivo,"</table>");
fclose(arquivo);
printf ("Arquivo gravado com sucesso");
_sleep(4000);
}

Profª Angelina V.S.Melaré
123
Exemplo de criação, leitura e gravação de um arquivo no modo texto
#include <stdio.h>
#include <stdlib.h>
int main()
{
typedef struct //definindo uma estrutura de dados-- conhecida como registro
{
char nome [20];
char senha [6];
} registro;
registro CAD;
FILE * parq; //definição do ponteiro de arquivo

char opcao, existe;
char nome_arquivo [15];
while(1)
{
system("cls");
printf("\nC- Cadastro");
printf("\nL- Consulta");
opcao = getch();
switch(opcao)
{
case 'c': case 'C':
printf ("\nInforme o nome do arquivo a ser criado: "); gets (nome_arquivo);
parq = fopen (nome_arquivo, "wt"); //abertura/criação do arquivo
while (1)
{
printf ("Nome:"); gets (CAD.nome);
if (!strcmp(CAD.nome,""))
{
puts("Não foi informado nome. Finalizando o cadastro!");
system("pause");
break;
}
else
{
printf ("Senha de acesso: "); gets (CAD.senha);
fprintf (parq, "%s", CAD.nome); fprintf (parq, "%s\n",
CAD.senha); //gravação dos dados
}
}
fclose (parq); //fechando o arquivo
break;
case 'l': case 'L':
printf ("\nInforme o nome do arquivo a ser aberto e consultado: ");
do
{
Profª Angelina V.S.Melaré
124
gets (nome_arquivo);
if (! strcmp(nome_arquivo,""))
{
puts("Não foi informado um nome correto de arquivo. Finalizando!");
exit(0);
}
existe = access(nome_arquivo,4);
if (existe)
printf("%s não existe \n",nome_arquivo);
} while (existe);
parq = fopen (nome_arquivo,"rt"); //abrindo o arquivo no modo leitura
while (!(feof (parq))) //enquanto não for final de arquivo continua lendo
{
fgets(CAD.nome, 20, parq); //faz a leitura da string e a carrega no ponteiro
fgets(CAD.senha, 6, parq);
printf ("%s%s", CAD.nome, CAD.senha);
}
fclose (parq);
system("pause");
break;
default:
printf("\nOpcao invalida\n");
exit(0);
}
system("pause");
}
}


Profª Angelina V.S.Melaré
125
Posicionamento e Pesquisa em arquivo binário

Para ser feita a leitura e a gravação de um arquivo é necessário saber a posição ideal para
que esse processo seja realizado. Existe a função fseek() que define um ponto específico de
posicionamento no arquivo:

fseek( ponteiro do arquivo, quantos bytes irá avançar, qual a relação de avanço)
Você tem que definir através do segundo argumento a quantidade certa de bytes para atingir a
posição desejada (registro).
O terceiro argumento define a posição que se deve estar para depois avançar. Eles podem ser:
SEEK_CUR – avanço a partir a posição corrente (atual)
SEEK_SET – avanço a partir do início do arquivo
SEEK_END – avanço iniciando do final do arquivo

fseek( parq, 3*sizeof(devedores), SEEK_SET);

Primeiro se posiciona para depois fazer a leitura do registro. No exemplo acima, está se
posicionando 4º registro.
fread(&devedores, sizeof(devedores), 1, fp);

É possível posicionar no final do arquivo para fazer uma gravação com o fseek:
fseek(pdevedores, 0, SEEK_END);

A função rewind() posiciona no início do arquivo.
Rewind(pdevedores);

7. Verificando o final do arquivo binário
É usada a função feof() para verificar se está ou não no final do arquivo. Esse função tem
um valor de retorno, podendo ser 0 se ainda não está no final do arquivo, ou outro valor (no caso
consideramos 1) para indicar o posicionamento no final do arquivo.

while ( !(feof (parq))) ou while (feof (parq) == 0)
Usamos essa função dentro de estruturas de repetição, no exemplo acima é feita a leitura
enquanto não for final de arquivo.

8. Para apagar um arquivo
Para apagar um arquivo físico é usada a função remove(nomedoarquivo). Esse
comando só pode ser executado se o arquivo estiver fechado.
remove(“devedores.bin”);

Profª Angelina V.S.Melaré
126

Conceitos Básicos

BIT
Cada letra do alfabeto, número ou símbolo pode ser representado no computador por um
conjunto de sinais elétricos, chamados de Bits. Toda instrução e controle que deve ser executada
pelo computador é transmitido através desses Bits.
O termo BIT, vem de Binary Digit, cuja tradução é Digito Binário, usado para representar
a passagem ou não da corrente elétrica no computador (ou campo magnético: positivo ou
negativo), tendo apenas dois estados. A passagem da corrente ou impulso elétrico pode ser
desginado pelo digito 1 e a não passagem da corrente elétrica pelo digito 0.
O BIT é a menor unidade de medida de dados que o computador tem.Como um único
BIT não consegue representar todas as letras, digitos binários e símbolos são feitos os
agrupamentos de Bits. O conjunto de 8 Bits forma um agrupamento denominado Byte.
As informações em formato binário são representadas(codificadas) de acordo com
algumas tabelas. Existe representação de código de 4 bits (BCD, Gray), código 5 bits
(BAUDOT- serviços de telex), código de 7 btis (ASCII) e 8 bits (EBCDIC). O número de bits
utilizado no código determina o número máximo de caracteres possíveis a serem representados.
Exemplo 7 bits = 2
7
= 128 combinações.
Algumas tabelas foram criadas pelos fabricantes de computadores. Exemplo: ASCII e
EBCDIC

ASCII
A Tabela ou Código ASCII (American Standard Code for Information Interchange –
Código Padrão Americano para o Intercâmbio de Informação), criada (1963) e atualizada (1968)
na década de 60, para representar os caracteres (letra, digito ou caracter especial), essa tabela é
baseada na combinação 7 bits e para representação o inglês. Com essas combinações é possível
fazer 128 representações válidas. Existe 1 bit de paridade para verificação de erros.
Quando se pressiona a tecla F (01000100), os circuitos do teclado geram um sinal de 8
voltagens diferentes correspondentes ao seu código de 8 bits, é feita a verificação da sua
representação ASCII e depois produzido o eco na tela do caracter F.
Nessa tabela tem:
• 128 representações, cujo valor decimal vai de 0 a 127.
o 33 representações não são imprimíveis, pois são caracteres de controle,
como as representações: 13 do ENTER, 27 do ESC, 9 do TAB, 127 do
DEL.
• 93 são representações dos caracteres imprimíveis (do código 33 ao 126), como o
alfabeto em maiúsculas e em minúsculas, os números de 0 a 9.
Mudanças na tabela de código ASCII – ASCII Estendido
Profª Angelina V.S.Melaré
127
A ASCII inicialmente não atendia a representação do texto em português, não
considerava o á, é, ô, ç, ü.
Com o tempo, a tabela ASCII foi expandida até o número 255, considerando a
combinação do 8 bits, essa tabela foi denominada ASCII Estendida. Mas ainda assim, ela não
permite representar ao mesmo tempo os grafemas do sistema latino e de outros como o grego,
hebraico. Em função disso, foram criadas várias tabelas ASCII, cada uma adaptada a uma
ortografia específica.


EBCDIC
O código EBCDIC (Extended Binary Coded Decimal Interchange Code- Código BCD
Ampliado para Intercâmbio) foi criado pela IBM e utiliza 8 bit para fazer uma representação,
existindo a possibilidade de fazer 256 combinações diferentes.


Unicode
Existe o padrão Unicode (www.unicode.org) que se propõe a desenvolver um sistema
abrangente e padronizado de representação de escrita em computadores. A tabela Unicode
abrange os mais variados sistemas de escrita (latino, chinês, etc), além de considerar símbolos
matemáticos, musicais, de moeda, etc.
Ela é subdividida em blocos, como: Unicode Latim Básico, Unicode Latim I
Suplementar, Unicode Latim Estendido A, Unicode Latim Estendido B, Unicode Extensões IPA,
Unicode Letras modificadoras de espaçamento, Unicode Sinais diacríticos combinados
A Unicode Latim Básico equivale exatamente à tabela ASCII de 7 bits. A Unicode Latim
I Suplementar equivale a ASCII estendida, de 8 bits. Os blocos Extensões IPA, Letras
Modificadoras de Espaçamento e Sinais Diacríticos combinados são de especial interesse dos
lingüistas porque trazem a simbologia do Alfabeto Fonético Internacional.

Unidade de Medida
Nós temos na nossa vida diária as unidades de medidas metro, litro, hertz e no
computador os bits. Como a contagem de medida do computador é binária (base 2- 2 estados 0 e
1) e o nosso sistema métrico de medida é decimal tem-se:
2
10
– 1.024bytes – KB Kilo K(mil)
2
20
– 1.048.576 bytes – MB Mega M(milhão)
2
30
– 1.073.741.824 bytes – GB Giga G(bilhão)

Hz (hertz)- 1 Hertz equivale a uma oscilação de sinal – corrente- em 1 segundo. Então
GHz equivale a mudança do estado – 0 e 1- mais de 1 bilhão de vezes por segundo (pulsos).
Convencionou a usar o digito 1 ( corrente elétrica alta) – para a representar a voltagem de 1,2V e
o digito 0 para a corrente elétrica baixa, de 0,2V.


Profª Angelina V.S.Melaré
128

Nível de Programação das Linguagens


Os programas podem ser escritos em diferentes linguagens, as quais o computador
consegue interpretar as instruções e executá-las. Essas linguagens possuem conjuntos de regras
(sintaxe) e comandos.
Os códigos dos programas são um conjunto de instruções que sinalizam à CPU para
realizar operações de conexão de circuito.


Linguagem de Máquina: São instruções escritas em formato binário, descrevendo exatamente
quais circuitos ligar ou desligar. É uma linguagem mais complexa de aprender, porém, a CPU
somente executa essa linguagem, somente pode ser instruída por ela. Todas as outras linguagens
devem ser traduzidas para essa, para poderem ser executadas. Isso é feito através do uso de um
compilador ou interpretador.
Exemplo de código: 00010101

Linguagem de Baixo Nível: Assembly é uma linguagem que associa mnemônicos-códigos às
instruções de linguagem de máquina. Nela foi possível simbolizar os endereços de memória,
dando um nome para uma área da memória.
Exemplo de código: A significa adicionar

Linguagem de Alto Nível: é uma linguagem que utiliza comandos na forma de palavras (o
idioma empregado é o inglês). Um único comando pode executar várias instruções em linguagem
de máquina.
A linguagem C e C++ são consideradas por alguns escritores de Nível Médio, pois ele
tem recursos de baixo nível, como acesso direto a endereços de memória, manipulação do
hardware, mas também tem uma linguagem com uma sintaxe mais parecida com a do ser
humano.
Exemplo de código: printf(“Professora Angelina\n”);

Alguns enquadram as linguagens dentro das gerações. Nessas gerações existe a
diferenciação do uso ou não, de características como: banco de dados, interface gráfica,
linguagem mais natural (inteligência artificial).

Exemplos de linguagens de alto nível: Pascal, Delphi, Visual C#, Cobol.
Profª Angelina V.S.Melaré
129
Bibliografia Consultada e Referenciada


ASCENCIO, Ana F. G. e CAMPOS, Edilene A. V. Fundamentos da Programação de
Computadores. Ed. Pearson, 2002

CELES, Waldemar; CERQUEIRA, Renato e RANGEL, José L. Introdução a Estrutura de
Dados. Ed. Campus, 2004

FORBELLONE, A. L. V.; et.al. Lógica de Programação - A Construção de Algoritmos e
Estruturas de Dados. 2ª ed. Makron Books. 2000.

PEREIRA, Fabio. PIC – Programação em C, São Paulo, 7ed. Érica, 2007

SCHILDT, Herbert. C Completo e Total. 3ª ed. Ed. Makron Books. 1996.

SENAI-SP. MDI. Tecnologia de Elaboração de Material Didático Impresso. São Paulo, 1996

VILLAS, Marcos Vianna e VILLASBOAS, Luiz Felipe P. Programação: conceitos, técnicas e
linguagens. Rio de Janeiro, Ed. Campus, 1988

RINALDI, ROBERTO. Turbo Pascal 7.0 Comandos e Funções. Ed. Érica, São Paulo, 1993

CARIBÉ, Roberto e CARIBÉ Carlos. Introdução à Computação. Ed. FTD, 1996 SP

STAIR, Ralph M. Princípios de Sistemas de Informação. Ed. LTC, 2ed, 1996. RJ

SUMÁRIO
Lógica de Programação ................................................................................................................... 7 Algoritmo ........................................................................................................................................ 8 Estruturas dos Algoritmos: Linear / Seletiva/ Repetição ............................................................. 10 Método para a construção de Algoritmo ....................................................................................... 10 Etapas de Desenvolvimento .......................................................................................................... 12 Tipos de Algoritmos ...................................................................................................................... 14 1. Tipos de Algoritmos ........................................................................................................... 14 Pseudocódigo ................................................................................................................................ 15 Fluxograma.................................................................................................................................... 16 Diagrama de Chapin ...................................................................................................................... 18 Paradigmas de Programação – forma de programar ...................................................................... 19 1. Programação Não Estruturada: ........................................................................................... 19 2. Programação Estruturada (Procedural): ............................................................................. 19 3. Programação Orientada a Objetos ...................................................................................... 20 Modularidade ................................................................................................................................ 20 4. Estratégia de Decomposição ou “Dividir para Conquistar” ............................................... 20 5. Módulos .............................................................................................................................. 21 Linguagem C ................................................................................................................................. 23 Processo de Compilação e Ciclo de Vida do Programa ................................................................ 24 6. Linguagem C Compiladora ou Interpretadora? ............................................................. 24 7. Ciclo de Vida do Programa ................................................................................................ 24 Ambiente de Desenvolvimento DEV-C++ ................................................................................... 26 1. Ambiente integrado ............................................................................................................ 26 2. Configurando o ambiente e o editor ................................................................................... 26 3. Configurações para o Windows Vista/7 ............................................................................. 27 4. Digitação do programa ....................................................................................................... 27 5. Gravação do programa ....................................................................................................... 27 6. Compilação e execução do programa ................................................................................. 27 7. Criando um código fonte padrão ........................................................................................ 28 Estrutura do Programa na Linguagem C ....................................................................................... 29 1. Estrutura básica .................................................................................................................. 29 2. Diretivas ............................................................................................................................. 29 3. Arquivos de Cabeçalho (header) ........................................................................................ 30 4. Biblioteca ........................................................................................................................... 31 5. Bloco de instruções e Função MAIN() ............................................................................... 31 6. Projeto ................................................................................................................................ 31 7. Regras de Digitação e Dicas da Estrutura em C ................................................................. 31 8. Comentários ....................................................................................................................... 32 Variáveis........................................................................................................................................ 33 1. O que são variáveis? ........................................................................................................... 33 2. Mas em que parte da memória vão os dados? .................................................................... 33 Identificadores ........................................................................................................................... 33 3. Declaração de variável ....................................................................................................... 34 Constantes ..................................................................................................................................... 35 Tipos de dados ............................................................................................................................... 36 Profª Angelina V.S.Melaré 2

1. Numérico ............................................................................................................................ 36 2. Literal/ Cadeia de Caracteres.............................................................................................. 36 3. Lógicas ............................................................................................................................... 37 4. Caracter .............................................................................................................................. 37 5. Espaço Alocado de Memória ............................................................................................. 37 6. Modificadores de Tipos ...................................................................................................... 38 Dica: Pode-se definir valores em outras bases (diferente da decimal): ..................................... 38 7. Tabela ASCII (American Standard Code for Information Interchange) ............................ 39 8. Código de Barra Invertida .................................................................................................. 40 Operadores Aritméticos................................................................................................................. 42 1. Operadores Aritméticos ...................................................................................................... 42 Os operadores aritméticos são os operadores usados nas operações básicas da matemática. Esses operadores são usados para representar as expressões matemáticas, os resultados são valores numéricos. ..................................................................................................................... 42 Eles são: +, -, *, /. ...................................................................................................................... 42 Ainda existem o mod e o div, que representam o resto da divisão e o quociente da divisão na respectiva ordem. Esses operadores somente podem ser usados para números inteiros. .......... 42 Operadores Aritméticos da Linguagem C ................................................................................. 43 2. Operadores de Incremento e Decremento .......................................................................... 43 3. Operadores Aritméticos de Atribuição ou C Reduzido ...................................................... 43 4. Conversão de Tipo ............................................................................................................. 43 Prioridade dos Operadores Aritméticos ........................................................................................ 44 Funções Matemáticas e Operadores Bit a Bit................................................................................ 47 1. Funções Matemáticas ......................................................................................................... 47 2. Operadores de deslocamento de bits .................................................................................. 47 1. Função Rand() e SRand() ................................................................................................... 48 Estrutura de Controle Linear/ Sequencial...................................................................................... 49 Funções de Entrada e Saída Formatada ......................................................................................... 50 1. Função de Saída - printf() ................................................................................................... 50 2. Função de Entrada – scanf() ............................................................................................... 51 1. Função de Entrada de caracter– getch() e getchar() ........................................................... 52 Exemplos ....................................................................................................................................... 52 Exercícios Resolvidos e Propostos ................................................................................................ 55 Operador Relacional e Lógico ....................................................................................................... 56 1. Operadores Relacionais ...................................................................................................... 56 2. Operadores Lógicos ............................................................................................................ 56 3. Tabela Verdade: é o conjunto das possibilidades combinatórias dos operadores lógicos. 57 4. Prioridade dos Operadores ................................................................................................. 57 Estrutura de Decisão /Condicional/ Seleção ................................................................................. 58 Exercício Resolvido ...................................................................................................................... 59 Tipos de Estruturas de Decisão ..................................................................................................... 60 1. Estrutura de Decisão Simples ............................................................................................. 60 2. Estrutura de Decisão Composta: ........................................................................................ 61 3. Estrutura de Decisão Encadeada: ....................................................................................... 62 Intervalos ....................................................................................................................................... 63 Operador Ternário ......................................................................................................................... 64 Seleção Múltipla ............................................................................................................................ 65 Exercícios Resolvidos ................................................................................................................... 67 Profª Angelina V.S.Melaré 3

........S............ A função principal ........ 118 Profª Angelina V................................ 83 Função com Passagem de Parâmetro por Valor . Repetição com Pós-condição ......................................................... 98 2.................................................................................................. Tipo Void .............. 85 Funções Recursivas .......................... 106 Estruturas ..............................................................até .......................................................................................... Matriz Bidimensional ...........Enquanto................................................... 99 5.. 94 Matriz ................................. 105 3....................................................................................................Melaré 4 .......... Acessando os elementos ............... Comando Return .............. 91 1..............................................................................................................................................Faça / Faça.... Declaração: .............................................................................................................. Passagem de Matriz por Referência ........... 80 4............. 72 5................................................................ Comandos Break.................................................................................................................... 83 9................... 91 2................................................................. Exercícios Resolvidos: ............................................................ 71 4....................................................................................... 92 7..............................até) ................................. 98 4......................main() ..................................... Repetição com Pós-condição ..........................................................................Enquanto / Repita.......................... Armazenamento feito via teclado ............................................................................................................................ Exemplos: .................................. 79 3............................................................................................................... 92 6........................... Variáveis ponteiros .......... 81 6.................................................. 116 2........................... 91 4............................................................................................................................................................ 79 1........Repita...... Enquanto Verdadeiro ..............................Enquanto ................................................................... 70 1....................................... 81 5......................... Chamada (ativação) da Função ........................................................................ 78 SubAlgoritmos/ Modularização .......................................................... 108 União e Enumeração .............................................................faça ........................................................................................................... Trabalhando com Matriz através de Ponteiros .......................................................................................... 116 1........ 89 Vetores ...............................Variáveis de Bloco ................... 103 Funções com Passagem de Parâmetros por Referência ............. 76 Variáveis Contadoras e Acumuladoras ........................... Mostrando os elementos ...................... 69 Estrutura de Repetição Condicional (Enquanto........................................... Classes de Armazenamento de Variáveis ............................................................................. 82 8............................................................................ Tipo enumeração .................. 91 3................................................................ 100 2..................................................................................... Exemplo Completo de Função ..................................... Continue função Exit() ..................................................... 68 Estrutura de Repetição....................... Repetição com Pré-condição.................................... 73 Repetição Pré-Definida – Para ........ 70 2.............................................. 71 3................. 82 7............................................................ 98 1........... 75 6.................................................................................................................... Endereço do vetor ou matriz unidimensional .............................................................. 99 Ponteiros ....................... 92 5.................................................................................................................................................................... 98 3........................ Declaração da Função........................................................... 79 2................................................................................................................................................................................................................................................ 117 Arquivos ...................................... Estrutura em C .....Faça............................................................................................................................... Sub-Rotinas (Módulos) ............................................................................................................................................. Protótipos de Funções ......................................................................................................................... 93 Vetor String (Cadeias de Caracteres) ................................... Conceito ............................................ Armazenando os elementos ......... 100 1........................................................................................................................................ Armazenando os elementos ... União – union ....................................... Declaração: ..........................................

................................................................................................................................................................................................. 118 4................... 128 Bibliografia Consultada e Referenciada ....... 119 6..........................................................3......................Melaré 5 ....................................................................... 119 5........ Fechamento do arquivo ......... 126 Nível de Programação das Linguagens ............................................................... 125 Conceitos Básicos ........ Leitura ....... Verificando o final do arquivo binário ....................................................... 125 8.......................................................S........................................................................ Para apagar um arquivo ..................................... 120 Posicionamento e Pesquisa em arquivo binário .......................................................... 129 Profª Angelina V................................................................................................................................................................................................. Gravação ............. Abertura do arquivo.................................................. 125 7.....

S.Melaré 6 .PRIMEIRA PARTE ALGORITMOS Profª Angelina V.

no ato próprio da razão. facilmente e sem erro.Lógica de Programação A lógica usada na programação é a mesma lógica usada diariamente pelas pessoas. Como o objetivo da razão é o raciocínio. rapidez.. Para isso serão desenvolvidos os Algoritmos. atualizar as informações e traçar um objetivo” Mas como passar a nossa lógica para o computador? Uma das ferramentas para isso é o Algoritmo. desempenho e confiabilidade. Segundo Aristóteles. uma operação discursiva do pensamento que consiste em encadear logicamente juízos e dele tirar uma conclusão. “. destaca a lógica usada no dia-a-dia. avaliar as ações tomadas.S. O que eu devo fazer agora????? Segundo Forbellone. organizar o pensamento.” É preciso ter Lógica de Programação: “Ter lógica é raciocinar coerentemente. agimos estamos criando uma ordem no pensamento e nas ações. razão”.fundamental à formação do profissional de programação estão a desenvolver a lógica e a construção de algoritmos. que definiu lógica como sendo “a ciência da demonstração”. a lógica está ligada ao raciocínio. é a aplicação das leis do pensamento e de processos simbolizados de maneira formal nos computadores. que significa “expressão. O estudo da lógica começou na Grécia antiga com o filósofo Aristóteles. Quanto mais a pessoa tenta raciocinar corretamente ela estará procurando ter lógica.. isto é utilizar lógica. a lógica estuda a razão como instrumento da ciência ou meio de adquirir a verdade. Mas como é essa lógica? De onde ela vem? A palavra lógica vem do grego ‘logos’. com ordem. O que é um bom programa/sistema? O importante na programação é desenvolver programas que atendam as necessidades do usuário. Profª Angelina V. capaz de torná-lo mais coerente e racional nas suas ações e com bom senso para tomar as decisões. discurso. falamos. pensamento. conceito. Uma das definições de lógica encontrada no dicionário Aurélio é “a coerência do raciocínio de idéias”. Um bom programa não depende exclusivamente da linguagem de programação.Melaré 7 . a arte que nos faz proceder. O escritor Othon Manoel Garcia define lógica como a ciência das leis ideais do pensamento. O que é ter lógica? Ter lógica é estar em uma determinada situação e saber a melhor maneira de proceder. visualizar todas as possibilidades.. Mas e a Lógica de Programação? Segundo Forbellone. É conseguir visualizar todas as possibilidades existentes daquele momento e decidir pela mais adequada. onde são empregadas técnicas para a produção de soluções logicamente válidas e que resolvem problemas que serão programados. Forbellone.. pois quando pensamos. É a lógica uma das características que diferencia um ser humano de outro. com funcionalidade.

coletar os dados e estruturar as operações que devem ser realizadas. por mais simples que seja pode-se tornar complicada.comprar salgados e bebidas. pois começaremos a prestar mais atenção aos detalhes.S.arrumar um som e músicas. Esse processo é feito numa linguagem fácil. em seqüências ordenadas e encadeadas.Algoritmo O objetivo de todo o estudo da Lógica de Programação é a construção de Algoritmos coerentes e válidos. Estado inicial ações empregadas de forma clara e precisa Período de tempo finito Estado final Objetivo Atingido Algoritmo Profª Angelina V. . Pense na sua vida real. Como você faria? Você colocaria a forma no forno aceso antes de fazer a massa? Como você usaria seu raciocínio lógico nesse procedimento? É por isso que devemos aprender a ter um raciocínio lógico.você precisa convidar os amigos. Também pode-se definir como uma sequência de passos. Quando começarmos a desenvolver algoritmos estaremos desenvolvendo nosso raciocínio lógico. É como fazer um pudim gostoso de forma rápida. O algoritmo é um processo onde você organiza e coloca passo a passo suas idéias para atingir um objetivo pré-definido. Vamos imaginar que você irá organizar uma festa. Mas como assim? Vocês devem estar pensando. Será através dele que você conseguirá ser um bom programador. de forma que as pessoas possam usá-la sem problemas. Quando você precisar solucionar um problema a primeira coisa que deverá fazer é fazer uma análise do mesmo. Depois organizá-las de acordo com suas prioridades. É preciso saber qual o primeiro passo a se tomar para depois ver o momento de executar o segundo. O algoritmo é uma das primeiras e melhores formas usadas para se conseguir resolver problemas no computador ou mesmo na sua vida cotidiana. Observaremos que cada situação. Quais são os procedimentos a serem tomados? Para fazer um algoritmo desse problema é preciso antes coletar as idéias: . não esquecendo que o primeiro deve já estar pronto. num problema comum a todos. .Melaré 8 . .procurar o local da festa.

você não acha que a pessoa na hora de pegar a banana já deveria ver o estado da banana por fora? Se ela estiver preta ou amassada. onde citamos quatro etapas ordenados de procedimentos. Nesse caso a sua lógica está mais elaborada.pegar outra banana . Mas por quê? Você deve estar fazendo está pergunta.pegar outra banana . então a pessoa já deveria tê-la jogado fora e pegado outra....se a banana estiver preta.Pensem neste problema: Como você faria para comer uma banana? Podemos fazer um Algoritmo que usa o português coloquial para resolver isso: 1º Você terá que saber onde está a banana 2º Pegar a banana 3º Descascar a banana 4º Por fim. de forma que todo o processo seria repetido novamente..se a banana estiver preta. 5º Se a banana estiver com aparência bonita por fora deverá ser descascada 6º Verificar se a banana não está estragada por dentro 7º Se estiver estragada você deverá .e pegar outra banana . Pois.deverá ser jogada fora .. amassada . Mas ainda não está totalmente completa.Melaré 9 .se a banana estiver preta.verificar o estado da banana por fora . Veja no algoritmo abaixo: 1º Você terá que saber onde está a banana 2º Pegar a banana 3º Verificar o estado da banana por fora 4º Se a banana estiver preta ou amassada .jogá-la . amassada .. Parece ser simples resolver esse problema.S. Você ainda precisará desenvolver muito o seu raciocínio lógico.. Mas será que você pensou em tudo? Será que a sua lógica está bem desenvolvida? Se você acha que sim.verificar o estado da banana . amassada . se estiver inteira boa o Você deverá comer a banana.deverá ser jogada fora . comer a banana. errou. verificando uma situação que pode ocorrer. Profª Angelina V.verificar o estado da banana .. Eu respondo na criação de um novo algoritmo: • Você terá que saber onde está a banana • Pegar a banana • Descascar a banana • Verificar se a banana não está estragada por dentro • Se estiver estragada o Você deverá jogá-la • Senão.

A execução começa de cima para baixo. da esquerda para a direita o Estrutura Condicional ou Estrutura de Seleção ou Estrutura de Decisão: a ordem de execução e as ações dependem do valor resultante de uma verificação. executadas várias vezes. • Elimine os detalhes supérfluos. Selecione as informações e fique apenas com as mais importantes. destacando os pontos mais importantes. Nem sempre se quer que todas as ações sejam executadas. de forma que se pode fazer uma seleção e desvio delas de acordo com um teste condicional.Estruturas dos Algoritmos: Linear / Seletiva/ Repetição Perceba que ao fazer o primeiro algoritmo se pensava numa sequência de ações (passos) de forma linear. Método para a construção de Algoritmo • Leia e releia atentamente todo o enunciado do problema. São duas estruturas de algoritmos diferentes: uma linear e outra de seleção. muitas vezes isso não pode ser realizado. pois. o Sequência define o fluxo de execução do algoritmo o Sequência Linear ou Estrutura Sequencial: onde um conjunto de ações são executadas uma após a outra. procurando definir explicitamente o que está contido no enunciado. será mudada ou não a sequência de execução.Melaré 10 . Para isso é importante ler até o final o enunciado.pegar a banana e comê-la. • Identifique as informações necessárias para a solução do problema: as entradas. sem tomar decisões precipitadas. o Estrutura de Repetição: algumas ações podem ser repetidas. Veja se essas informações já estão contidas no enunciado ou precisarão ser recebidas. um teste quanto ao estado da banana. as que serão necessárias e usadas nas Profª Angelina V. Mas. É preciso ter convicção no entendimento do que foi lido. Muitas vezes o enunciado é grande. onde dependendo do resultado dela. procurando identificar e entender todos os detalhes. ou seja. complexo. passo a passo. O primeiro algoritmo . testes que precisam ser feitos e de acordo com o resultado deste é que serão definidas as ações que serão executadas. uma ação sendo executada após a outra. Nessa estrutura a sequência de execução dependerá de uma condição. cheio de valores e informações. • Faça uma análise de tudo. surgem verificações. O segundo faz uma verificação. Não passe para a outra fase se tiver dúvidas no enunciado.S. mas depois de lido e avaliado percebe-se que sua solução é simples e que muitas informações contidas são desnecessárias. num fluxo contínuo do começo ao fim.

permitindo assim realizar uma consistência em relação as regras do problema. Lembre-se que quando você precisar de uma informação e ela não estiver no enunciado. ABSTRAÇÃO Existe dentro da resolução de problemas o termo Abstração. se deixa de lado as informações supérfluas. se atem ao que é importante para chegar a resolução do problema. Então ao abstrair. leia novamente o enunciado.Melaré 11 . A abstração tem como objetivo tirar informações supérfluas e introduzir uma notação concisa. ou seja. • Verifique as regras que estão explicitas e implícitas: o processamento As saídas podem ser consultas ou operações de transformação dos dados de entradas em saídas. revise o algoritmo e efetue novos testes. isso significa que ela é uma entrada. • Verifique se o algoritmo feito está atingindo o seu objetivo: teste Para isso faça alguns testes com dados fictícios e verifique se o algoritmo está mostrando corretamente a solução do problema. Se o resultado não for satisfatório. dar-lhes nomes e definir operações que possam ser aplicadas aos objetos. Profª Angelina V. que serão depois pensados e acrescidos na codificação. • Desenvolva o algoritmo. • Defina as informações que devem ser mostradas no final. mas sem se ater a detalhes computacionais. as respostas do problema. Ao desenvolver um algoritmo você está preocupado em desenvolver e representar o raciocínio lógico de programação.operações. Para esse objetivo ser alcançado devem-se identificar os objetos e os aspectos importantes.S. até conseguir o resultado desejado.

mostrando sempre as alterações. 1º Exemplo: O Analista de Sistemas Joaquim pediu para o programador Júlio fazer um programa que efetue a multiplicação de dois números.Melaré 12 . ou uma atribuiçã. só que estes não foram especificados e não sabemos quais são. através do usuário (receber o salário) ou indireta. por isso devemos recebê-los. Profª Angelina V. A entrada pode ser recebida por vários dispositivos de entradas. Processamento: É um processo que pega os dados de entrada e efetua uma operação (que pode ou não ser matemática). como teclado ou scanner. como os nomes e funções dos personagens. Então. 2º Retire o que é supérfluo. Saída: É a parte mais fácil e mais importante de todo o processo. O número de entradas é muito variado e depende do objetivo do programa. desde o monitor até a caixa de som. Entrada Processamento Saída Entrada: A entrada é o processo onde você avalia o enunciado do problema e verifica quais dados estão presentes no enunciado e quais não estão. se realizam as operações sobre esses dados e no final são geradas as respostas ou resultados como saída. Cuidado: não são entradas os dados que podem ser gerados através de um cálculo ou de outras entradas. Nessa etapa também podem ser feitas comparações e consultas.S. Outro detalhe importante é ignorar/desprezar a história colocada no enunciado. A saída pode ser feita por qualquer dispositivo de saída. Vamos mostrar as etapas de desenvolvimento com um exemplo muito simples e fácil de resolver. Pode ser lida de um arquivo ou de qualquer outro periférico de entrada. a entrada pode ser direta. Quando faltar algum dado você terá que recebê-lo de alguma maneira. Sem as entradas não há como resolver um problema. através da máquina (pegar a data do sistema). fique apenas com os dados necessários. Depois aumentaremos o grau de complexidade.Etapas de Desenvolvimento No Processamento de Dados se recebem os dados. 3º Defina as três etapas principais de seu algoritmo: Entrada: Quais os dados de entrada necessários? Lendo o enunciado verificamos que para fazer o cálculo é necessário ter dois números. gerando dessa forma o resultado e a solução do problema. mas que são essenciais para a solução do problema. Processamento: Qual cálculo deve ser feito com os dados de entrada? Lendo o enunciado vemos que a operação a ser feita com os dados de entrada é a multiplicação. onde devem ser exibidos os resultados de todo o processamento. 1º É necessário ler atentamente todo o exercício.

Tendo as idéias é só montar o algoritmo: 1º Saber o valor do primeiro número 2º Saber o valor do segundo número 3º Fazer a multiplicação dos dois números Número 1 x Número 2 = ??? 4º Mostrar o resultado da multiplicação 2º exemplo: Juracema foi a livraria e comprou dois livros iguais de programação. Quanto ela pagará? Entrada: Quais são os dados de entrada necessários? Saber o preço do livro Processamento: Qual cálculo deve ser feito com os dados de entrada? Multiplicar o preço pela quantidade comprada.Melaré 13 . Algoritmo: 1º Receber o valor do livro 2º Multiplicar o valor do livro por dois (2). no caso 2.S. Veja que nessa situação a quantidade já foi informada (2 livros). por isso. já a temos e não devemos solicitá-la como entrada. Saída: O que deverá ser mostrado? Qual o objetivo do enunciado? Descobrir o valor que Juracema terá que pagar no caixa. 3º Mostrar o resultado do cálculo da multiplicação Profª Angelina V.Saída: O que deverá ser mostrado? Qual o objetivo do enunciado? O objetivo do enunciado é calcular e mostrar o resultado da multiplicação de dois números.

Melaré 14 . Desvantagem: a ambigüidade da linguagem coloquial. Profª Angelina V. o que posteriormente dificultará a transcrição desse algoritmo para programa. dependendo da sua aplicação. • • Pseudocódigo (português estruturado . A língua natural abre espaço para várias interpretações (dependendo da pessoa que o ler). o uso de adjetivos ou a falta de clareza quanto as fórmulas matemáticas. já que será criada a estrutura do algoritmo baseada na linguagem. Vantagem: a passagem do algoritmo para qualquer linguagem de programação é quase imediata.Tipos de Algoritmos Os algoritmos podem ser escritos de diferentes maneiras. Vantagem: não é necessário aprender nenhum conceito novo. O que os diferencia é a forma de descrever e simbolizar esses passos.portugol . pois a língua natural (português) já é conhecida. Vantagem: o entendimento de elementos gráficos é mais fácil que o entendimento de textos. Fluxograma: O Fluxograma consiste em analisar o enunciado e escrever os passos utilizando símbolos gráficos predefinidos. possibilitando com isso um melhor entendimento dos processos. usada diariamente pelas pessoas. Tipos de Algoritmos Os tipos de algoritmos mais conhecidos são: • Descrição Narrativa • Fluxograma • Pseudocódigo • Diagrama de Chapin Todos esses tipos de algoritmos consistem em analisar o enunciado do problema e descrever os passos necessários para a resolução do problema. bastando conhecer as palavras reservadas da linguagem de programação que será utilizada. 1. Desvantagem: é necessário aprender a simbologia gráfica do fluxograma e as correções são mais trabalhosas por se tratar de representação gráfica. Será como uma tradução.pseudolinguagem): O Pseudocódigo consiste em analisar o enunciado e escrever os passos por meio de regras pré-definidas. Desvantagem: é necessário aprender as regras do pseudocódigo. • Descrição Narrativa ou Linguagem Natural: A Descrição Narrativa consiste em analisar o enunciado e escrever os passos utilizando uma linguagem natural.S. Até o momento todos os algoritmos feitos foram através da Descrição Narrativa. As regras usadas neste material são estruturadas de acordo com a programação na linguagem C. Nesta apostila desenvolveremos os algoritmos de forma estruturada e padronizada (pseudocódigo).

Exemplo de Problema: Receba um número real e verifique se este é positivo. senão escreva (“Número negativo ou nulo”). 2. um meio e um fim. Dessa forma.. que é deslocamento horizontal. Regras de criação do Pseudocódigo 1. leia (num). se (num > 0) então escreva (“Número positivo”). então. Pseudocódigo Início real num. 3º Se o número for menor ou igual 0 então. deve aparecer uma mensagem avisando que o número é negativo ou nulo. como: escreva. negativo ou nulo Descrição Narrativa 1º Receber um número 2º Se o número for maior que zero. transmitindo o sentido de hierarquia de execução.Pseudocódigo Como já foi mencionada acima a passagem do pseudocódigo para uma linguagem de programação é mais rápida e a probabilidade de erros menor. Deve ser feito uso do conceito de variáveis. escreva (“Digite um número”). Deve ser usado o recurso de endentação. 4.então. assim como sua declaração. deve ser indicado o início e o fim.Melaré 15 . internamente as ações que serão executadas. Deve ser feito uso de termos únicos que definem uma ação. leia. Todos os programas têm um começo. mostre uma mensagem alertando que o número é positivo. se. Fim Qual das formas anteriores você escolheria para construir um algoritmo? Qual desses exemplos mostra de forma mais clara as ações? Profª Angelina V.S. 3.

Para cada passo efetuado. Símbolo Nome Terminal Processamento Conexão Direção do Fluxo Decisão Processamento Prédefinido Teclado de Linha Entrada/Saída Documento ou Relatório Exibição Conector de Página Subrotina Finalidade Indica o início. Podendo provocar desvios na seqüência lógica de execução Utilizado nas estruturas de repetição Indica a entrada de dados por via teclado Pode ser usado tanto para entrada quanto para a saída de informações Indica operação de saída via impressora Indica as saídas de informações por dispositivos visuais Usado para indicar a sequência em outra folha/página Específica a chamada de uma subrotina Profª Angelina V.Fluxograma O fluxograma é um tipo de Algoritmo que representa graficamente (figuras geométricas) os passos necessários para a resolução do problema. o de processamento.Melaré 16 . Algumas empresas adotam símbolos padronizados no fluxograma. seja o de entrada. o de saída ou condição tem-se um símbolo de representação. conecta os símbolos Indica a tomada de uma decisão ou comparação. cálculo ou atribuição Utilizado para ligar pontos do fluxograma Utilizado para indicar a seqüência da execução. Com a representação por símbolos gráficos fica mais rápida a visualização da lógica empregada para resolver o problema. continuidade ou fim Indica operação.S.

_ ter símbolos bem dimensionados e alinhados. que pode estar a direita.e serve para mostrar uma mensagem. a esquerda. FIM. resumidas e bem entendidas. ou mesmo alteração de qualquer dado. Profª Angelina V. ou seja a sequência da ação a ser executada. B=6 C=A+B SENHA = “MARTH” EXIBIÇÃO: O símbolo de Exibição é um símbolo gráfico que representada saída. _ não pode haver encontro das linhas de indicação do fluxo. em baixo ou em cima. um resultado. TECLADO DE LINHA: Receber SALARIO PROCESSAMENTO: O símbolo do retângulo deve ser usado toda vez que existir qualquer tipo de processamento.Melaré 17 . _ ser legível. Ele conecta os símbolos e o fluxo de execução. seja um cálculo. _ as informações escritas dentro dos símbolos devem ser claras. mas como a maioria dos programas a serem feitos terão os dados digitados via teclado usaremos o símbolo do trapézio. DIREÇÃO DE FLUXO: Essas setas indicam a direção do próximo passo a ser executado. Estrutura a ser usada Veja os símbolos a serem usados e uma explicação mais detalhada de suas finalidades. Existem vários símbolos que representam a entrada de dados. Quando usarmos este símbolo devemos identificar sua função escrevendo dentro dele as palavras INÍCIO. mostrando claramente os processos.S. deve seguir algumas regras: _ ser bem confeccionado.O fluxograma para ser feito com êxito. uma atribuição de valores as variáveis. _ a direção dos lados para as condições devem ser fixos. _ ter setas que indiquem a direção do fluxo das informações. TERMINAL: A principal representação desse símbolo é indicar o início e o fim de uma série de procedimentos. _ o fluxo deve começar de cima para baixo e da esquerda para a direita.

A desvantagem de uso ocorre quando precisa de muito espaço na horizontal e fica mais difícil a compreensão.S. Veja os exemplos abaixo: a) Início Escreva “Mensagem” Fim b) Início Escreva “Digite seu nome” Leia NOME pelo teclado Escreva “Bom Dia” + NOME Fim c) Início Leia A e B no teclado A é maior que B? Sim Escreva “A é maior que B” Fim Não Escreva “B é maior que A” Profª Angelina V.Melaré 18 . usando o símbolo gráfico do conector. INÍCIO K 1 A=3 B=6 C=A+B K 1 FIM Diagrama de Chapin O Diagrama de Chapin utiliza poucos símbolos e não precisa de nenhum conhecimento específico.CONEXÃO: Algumas vezes o espaço reservado para fazer o fluxograma é pequeno e temos que dividi-lo em partes.

• Esse paradigma foi desenvolvido por Bohm e Jacopine em 1966. • A linguagem estruturada foi desenvolvida em grande parte pela má legibilidade causada pelas instruções de controle de algumas linguagens não estruturadas. Floyd sugeriu o uso de comentários intercalados. onde eles demonstraram que a lógica pode ser expressa através de algumas estruturas básicas. decisão (condição ou escolha). Exemplo de linguagem não estruturada: Assembly e Basic Algoritmo Não Estruturado: 1. de iteração (repetição ou laço) • Em 1967. podendo ser: programação não estruturada. 2. Programação Estruturada (Procedural): • Em 1965 Edward Dijkstra apresentou um artigo que sugere a programação estruturada e a eliminação de comandos de desvio. • Possuem as estruturas: linear (seqüencial). Esse estilo que possui características comuns identificam a linguagem. DESVIO2. • Segundo Rinaldi.Paradigmas de Programação – forma de programar As Linguagens de Programação adotam um estilo (padrão) de desenvolvimento. De acordo com o Paradigma de Programação será desenvolvida a Lógica de Programação. Nicklaus Wirth sugeriu o processo de decomposição (refinamento sucessivo das etapas). Vá para DESVIO 2 10. Se precisar comprar então 4. DESVIO1.S. 7. programação estruturada. 3. Vá para DESVIO3 5. programação lógica. Vá para DESVIO2 2. O único modo de fazer desvios é usando o Vá Para (codificando é GOTO). • Na programação não estruturada se usava muito a instrução de desvio GOTO para criar estruturas de laços (iterações).Melaré 19 .Enquanto (while) e não permite a estratégia de modularização. Vá para DESVIO5 6.. o Exemplo: Profª Angelina V. 1. programação orientada à objetos/eventos. Procure a chave do carro 8. A primeira regra para fazer um programa é a decomposição lógica do problema em partes independentes. Se achou então 9. Essa linguagem não possui estruturas de controle de repetição como Faça. DESVIO3. • Em 1970. obedecendo uma numeração de linhas. Vá para DESVIO 4 11. o que caracteriza a programação estruturada é a possibilidade de divisão de tarefas em rotinas ou blocos independentes entre si. Programação Não Estruturada: Nessa programação a sequência de ações que serão executadas são seqüenciais.

Analise a divisão e veja a coerência da divisão Profª Angelina V. que está relacionada com a reutilização e padronização de código. A idéia é dividir o problema em problemas menores (subproblemas). Quando se tem todos de uma vez.S. de forma que se concentra em um problema por vez. pois a complexidade também é dividida. Esse processo deve ser feito da seguinte maneira: 1. onde é mais fácil vencer grupos isolados de inimigos do que todos os inimigos juntos. descontos. diferente da Programação Orientada a Objetos. Segundo Villas. em problemas menores. herança. alto) Modularidade 4. o desenvolvimento da lógica se dispersa e não se chega a nenhum resultado. já que a complexidade é menor que ao original. 3. Programação Orientada a Objetos • Nessa programação existe a definição de classes. • Na programação estruturada é permitido incluir sentenças em qualquer parte da linha. 2. Como exemplo. porque não permite criar uma função dentro da outra. • A orientação a objetos vem propiciar o aumento de produtividade. Divida o problema em suas partes principais – no caso da folha. Quando você for escolher uma linguagem de programação. diminuição do custo de desenvolvimento e manutenção (manutenção evolutiva e não corretiva). • As classes são criadas para representar (categorizar) um conjunto de entidades (objetos) que possuem as mesmas características e comportamento (ou mesmo similares) dentro de um contexto.Rotina: Calculo do desconto de IR • Bloco de verificação da faixa das alíquotas • Nesse paradigma o programa tem uma seqüência de instruções executadas linearmente e seus dados tratados de forma independente das funções. podemos destacar o exemplo Folha de Pagamento de uma empresa. considere também a: FORMA DE EXECUÇAO (Compilador ou Interpretador) e o NÍVEL DE PROGRAMAÇÃO (baixo.Melaré 20 . benefícios seria um subproblema. Supondo que o objetivo principal é gerar o demonstrativo de um funcionário. Inicialmente parece ser bem complexo. até que cada parte (subdivisão) seja pequena o bastante para que a solução seja facilmente encontrada. o termo Dividir para Conquistar veio da guerra. O foco da atenção fica isolado. encapsulamento. como o de calculo de descontos e cálculos de benefícios. • A linguagem C não é totalmente estruturada em blocos. Estratégia de Decomposição ou “Dividir para Conquistar” A decomposição é uma estratégia de resolução de problemas. A solução é mais rápida. A decomposição de um problema reduz a complexidade do mesmo. mas se você analisar com calma tem como dividir esse problema.

Porque parte de um problema complexo e abrangente que é sucessivamente dividido em problemas mais simples e específicos. A solução do problema maior ocorre em decorrência da solução dos menores. 5. Ele não retorna valores para o módulo que o chamou. Automóvel inteiro peças separadas parafusos Existe a técnica Bottom-up (de baixo para cima). 2. Função: é um modulo que irá gerar uma única saída e que será devolvida para a função principal ou módulo que o chamou. Módulos Cada subproblema é um módulo ou podemos dizer que é um subalgoritmo ou subproblema que realiza tarefas específicas. Se uma divisão ainda estiver complexa. A técnica de Refinamento Sucessivo também pode se chamar Top-down (de cima para baixo). Procedimento: é um módulo que executa uma tarefa específica. Essa decomposição continua também é conhecida como refinamento sucessivo. decomponha novamente.3. Em termos funcionais. onde se divide o problema maior (principal) em problemas menores. existem dois tipos de módulos: 1. Essa parte dos conceitos mais detalhados e específicos e vai agrupando em níveis mais abrangentes (abstratos). Reavalie tudo novamente. Resumo das vantagens: • • • Subdivisão dos algoritmos complexos: facilita o entendimento. – os descontos podem ser divididos por especialidade 4. até atingir o nível desejado.S. Potenciação multiplicar somar o Segundo Rinaldo. Normalmente essa técnica é a mais fácil de compreender.Melaré 21 . a modulação é uma técnica de resolução de problemas. que pode ou não gerar várias saídas usando as variáveis globais ou locais. que é o inverso dessa. uma vez que parte de um problema mais abrangente (abstrato) até atingir um nível mais detalhado e específico. Estruturação de algoritmos: facilita detecção de erros e a documentação do sistema Modularização de sistemas: facilita a manutenção e reutilização do algoritmo Profª Angelina V.

S.Melaré 22 .SEGUNDA PARTE LINGUAGEM C Profª Angelina V.

estrutura da linguagem (protótipo da função).Melaré 23 . Sua origem foi através da linguagem BCPL. CodeBlocks. inclusive as orientadas a objetos • Constituído por funções • Linguagem de programação estruturada • Ferramenta poderosa de desenvolvimento (pode desenvolver um editor de texto. O ambiente a ser usado é o Dev-C++. Com ela é possível desenvolver desde um simples programa (uma calculadora) até um sistema operacional. Turbo C. um aplicativo comercial.em relação a mudança do código para plataforma Windows ou Linux • Linguagem compiladora Profª Angelina V.S. palavras reservadas. estabelecendo uma definição padronizada da linguagem C. como: DEV-C++.C++ (é o C projetado para suportar Programação Orientada a Objetos). em 1983. Resumo histórico • 1966 – BCPL (Martin Richards) • 1970 . segurança e eficiência. • 1985 .B (Ken Thompson) • 1972 – C (Dennis Ritchie) • 1978 – Livro The C Programming Language (Brian Kernigham e Dennis Ritchie) • 1983 . Ela se popularizou rapidamente devido a sua velocidade. Existem vários ambientes de desenvolvimento para a linguagem C. o órgão americano de padronização (American National Standards Institute). A maioria dos compiladores são compatíveis com esse padrão.órgão americano de padronização (American National Standards Institute) – O padrão ANSI definiu o conteúdo da biblioteca padrão C. que levou a linguagem C. que influenciou Ken Thompson a criar o B. criando discrepâncias entre elas. um programa para microcontrolador) • Portabilidade. Para resolver essa situação. Visual C++. cujo compilador é a implementação Mingw do GCC (Gnu C Compiler). desenvolvida por Martin Richards. Características e Vantagens: • Facilidade para aprendizagem de outras linguagens de programação. criou C padrão ANSI. A linguagem C++ foi construída sobre os fundamentos da linguagem C e dá suporte para a Programação Orientada a Objetos. Com a popularização dos microcomputadores houve um aumento no desenvolvimento de implementações em C.C padrão ANSI .Linguagem C A linguagem C foi desenvolvida por programadores para programadores. Origens da linguagem C A linguagem C foi criada por Dennis Ritchie em 1972.

gerando um novo código de máquina. Este deve ser salvo com a extensão “. Cada programa executável é uma seqüência de instruções que o processador interpreta e executa as operações correspondentes. parecida com a do ser humano. O código fonte é a tradução dos comandos do pseudocódigo para as respectivas instruções da linguagem de programação (por exemplo. Na nossa disciplina será usada a linguagem de programação C. que pode ser a Descrição Narrativa e o Pseudocódigo. Os erros de lógica só podem ser detectados pelo programador depois de gerado o arquivo executável. O que as distingue é a forma com que elas executam o programa. Já o compilador. Depois de solucionado o problema e escrito o algoritmo em pseudocódigo. linguagem C). Para ver o programa funcionando basta digitar seu nome ou dar um duplo clique no ícone do programa. se não houver erros de sintaxe. Profª Angelina V. Ciclo de Vida do Programa Criação do programa Para se fazer um programa deve-se escrever uma sequência correta de instruções que deverão se executados pelo computador. de acordo com o ambiente que você estiver (texto ou gráfico). será assumirá a extensão . codificado. executando-as em seguida. O arquivo objeto somente é gerado quando o arquivo fonte não possui erro de sintaxe. Linguagem C Compiladora ou Interpretadora? Uma linguagem de programação pode ser compiladora ou interpretadora. Para se chegar nessa sequência deve-se desenvolver o Algoritmo.S.Melaré 24 . lê o código fonte inteiro e se este não tiver erros de sintaxe.cpp que é padrão do ambiente de desenvolvimento (cpp – significa c plus plus ou c++). 7. Um computador só pode executar programas em linguagem de máquina.exe). Essa lógica deve ser desenvolvida numa linguagem natural. fazendo com que o processador consiga entendê-lo e executá-lo. ou seja.C”.Processo de Compilação e Ciclo de Vida do Programa 6. Se não for digitada a extensão. este terá que ser compilado novamente. este deve ser passado para uma linguagem de programação. será gerado o arquivo executável (extensão . será convertido em um código de máquina. Para executar esse programa é necessário compilá-lo e linká-lo. Se forem feitas alterações no programa. Na compilação as instruções (linhas) são verificadas e interpretadas pela máquina (CPU). Essas instruções depois são traduzidas para a linguagem da máquina (que é a linguagem interna que o computador entende). O interpretador lê o código fonte linha a linha. O linkeditor (linker) une os códigos dos arquivos de bibliotecas usados pela linguagem C com os arquivos fontes criados pelo programador. O programa codificado e digitado se chama Arquivo Fonte.

união com as bibliotecas 7. Necessidade de um programa 2.Resumo das etapas da criação de um programa 1.. Processo de compilação – Verificação dos erros de sintaxe. Descrição das idéias numa linguagem natural –Descrição Narrativa Algoritmo 4.. Criação da sequência correta de instruções – Pseudocódigo . Codificação para uma linguagem de programação – Linguagem C 6. Enunciado do problema 3.de acordo com o método da linguagem a ser usada (estruturada) 5. Criação do arquivo executável O ciclo de criação de um programa em C pode ser analisado abaixo.S.Melaré 25 . geração do arquivo objeto. na seqüência de figuras abaixo. arquivo objeto arquivo biblioteca Linkedição arquivo executável Profª Angelina V. arquivo fonte arquivo objeto arquivo fonte .

Na guia Display ative a opção Números das linhas.Ambiente de Desenvolvimento DEV-C++ 1. Procure personalizar o seu ambiente de trabalho. devendo ter o cuidado de salvá-lo como um arquivo texto.8. que inclui um local para digitação do programa (editor de texto). sem qualquer tipo de formatação. 2. Configurando o ambiente e o editor As configurações padrões do compilador. O DEV-C++ pode ser adquirido gratuitamente pelo site http://www. o Word.0. Pode-se digitar o programa em outro editor de texto. como o Bloco de Notas. A versão mencionada nesta apostila é a versão 4. criando atalhos e facilidades no processo de digitação.S.Melaré 26 . Ambiente integrado O DEV-C++ é um ambiente integrado de desenvolvimento para a linguagem de programação C e C++. em português. Profª Angelina V.html. Nesse ambiente é possível desenvolver aplicações console (Console Application). No menu Exibir desabilite a exibição do Navegador de classes/projetos clicando apenas uma vez nessa opção.net/devcpp. cuja interface é texto ou aplicações gráficas (GUI Application) que usam janelas e elementos visuais como interface. um compilador (gcc . do ambiente e do editor de texto podem ser alteradas através do menu Ferramentas.bloodshed. Por exemplo: Menu Ferramentas – Opções do Editor – Ative a opção Destacar as chaves e os parênteses. Se o seu ambiente está em inglês mude-o para português através do menu Tools (ferramentas) opção Environment Options (Opções do Ambiente) – guia Interface – escolha o português.Gnu C Compiler).9. um linkeeditor e janela de visualização do executável.

cuidado para não salva-lo com nome inválido (com espaço entre as palavras. Ao salvar o arquivo fonte. 4. No menu Arquivo escolha a opção Salvar ou use a tecla de atalho <CTRL> e <S> simultaneamente. algumas configurações devem ser feitas: No menu Ferramentas escolha a opção Opcões do Compilador na guia Diretórios. Digitação do programa Para a digitação do programa no DEVC++ é necessário seguir os seguintes passos: 1. Toda vez que você pressionar o F9 para compilar e executar o Dev estará salvando automaticamente seu programa. ele deverá ser salvo antes de ser executado. Configurações para o Windows Vista/7 Para que o Dev funcione corretamente no Windows Vista. 5. Escolhendo a opção Executar (Execute) do menu e dentro dela a opção Compilar e Executar (Compile and Run). Compilação e execução do programa Existem diversas maneiras de ver se o programa está sem erros e funcionando. Observe que a extensão padrão do DEV-C++ é o . 6.cpp. 2. ou mesmo da configuração pré-definida no editor. Gravação do programa Após a digitação do programa. a primeira linha fica assim: C:\Dev-Cpp\bin\gcc. aparece um programa inicial. digite o nome do arquivo fonte e pressione o botão Salvar. aproveitando as linhas de código já digitadas. opção Compilar) e futuramente executá-lo (através do menu Executar. Na guia Programas deve ser colocado C:\Dev-Cpp\bin\ em cada linha.Melaré 27 . em Binários deve ser adicionado o caminho C:\DevCpp\libexec\gcc\mingw32. com o título: (*) Sem Título 1.3. Por exemplo.exe 4. Profª Angelina V. ou 2. No menu escolha a opção Arquivo (File). entre elas: 1. de acordo com as etapas abaixo: 1. Escolha a opção Novo e depois Arquivo Fonte ou se preferir a tecla de atalho <CTRL> e <N> simultaneamente. Pode-se apagá-lo ou deixá-lo. poderá inicialmente compilá-lo (através do menu Executar. Pressionando a tecla de função <F9> ou na barra de ferramentas a opção Compilar e Executar. opção Executar).S.2 (se não houver). Escolha o diretório de trabalho. Aparecerá uma nova janela. 2. iniciado com número. Dependendo da versão. 3. Se você quiser apenas verificar se existem erros no programa. onde deve ser feita a digitação do programa fonte.

Na parte inferior clique no Código Fonte Padrão e digite seu código fonte. Criando um código fonte padrão Uma boa forma de configurar o editor é criar um modelo inicial de programa fonte. Para criar o modelo de código padrão escolha a opção Ferramentas. cedilha nesse ambiente console são convertidos.7. Profª Angelina V.Melaré 28 . depois Opções do Editor e a guia Código. As linhas de comandos e bibliotecas mais comuns ficam digitadas neste modelo. toda vez que for iniciado um novo arquivo irá aparecer o modelo que você definiu. ou seja.S. Os caracteres especiais – acentos.

Diretivas As diretivas do pré-processador iniciam com o símbolo # e cada diretiva deve ser escrita em linha distinta. Profª Angelina V. como Pascal. 2. Cabeçalho: • Diretivas de pré-processamento. que tem as instruções e funções iniciais do programa. como objetivo do programa. Blocos de instruções: um bloco principal (função main) e outros blocos de rotinas (outras funções chamadas a partir da main()).S. As diretivas instruem o compilador a execução de uma ação dentro do códigofonte do programa em C. onde serão definidas “as constantes” e incluídos os arquivos de cabeçalho.Estrutura do Programa na Linguagem C Um programa codificado na linguagem C tem uma sintaxe e estrutura um pouco diferente de um programa escrito em outra linguagem. Em C. Um programa precisa ter necessariamente uma função principal (main). #define. Como por exemplo. ao encontrar a diretiva #include ele faz um desvio. As diretivas do padrão C ANSI a serem usadas são: #include. localiza a função na biblioteca e adiciona seu código ao código do arquivo fonte. Veja o exemplo abaixo: 1. Estrutura básica Um programa feito na linguagem C é constituído basicamente de: Documentação do programa: comentários que o programador considera importante. • Declaração e inicialização de variáveis globais. se trabalha com várias funções e bibliotecas.Melaré 29 . O pré-processador do C é um programa que examina o arquivo fonte e executa as devidas modificações com base nas diretivas.

h stdlib.h conio.h> arquivo de cabeçalho: stdio. ou seja.h – – – – – STD standard padrão I input O output Funções padrões de entrada e saída Funções associadas: scanf().Melaré 30 .#include Essa diretiva quando lida faz a inclusão de um arquivo de cabeçalho ao arquivo-fonte.h” Profª Angelina V. } Ao ser executada a diretiva #define.h/conio.h string.h.terá que incluir seu respectivo arquivo de cabeçalho (stdio. se você utilizar uma função de entrada -scanf().h time. Exemplo: #include “funccondicao. Arquivo de cabeçalho stdio. Os arquivos com a extensão . ou header files.h) no início do programa. Estrutura: #define identificador string Exemplo: #define EXIBA printf #define TEXTO “\nProgramação de Computadores na Fatec” main() { EXIBA(TEXTO). Esse arquivo possui a definição de tipo e o protótipo da função. Exemplo: #include <stdio. o compilador associa a palavra EXIBA a palavra printf e toda vez que aparecer a palavra EXIBA ele a substituída por printf e a palavra TEXTO será substituída por “\nProgramação de Computadores”.S. Arquivos de Cabeçalho (header) Cada função definida na biblioteca C tem seu respectivo arquivo de cabeçalho (como citado acima).c math. são chamados de arquivos de cabeçalho. printf() #define Essa diretiva define um identificador (constante simbólica) e uma string que o substituirá toda vez que for encontrado no código-fonte.h Finalidade Suporta entrada e saída com arquivos Suporta E/S pelo console Possui diversas funções matemáticas Declarações miscelâneas Funções de horário do sistema Funções de string Dica: O arquivo de cabeçalho feito pelo programador é colocados entre “ ”. 3.

As funções padrões existentes na biblioteca do compilador C foram definidas pela ANSI. mas um único arquivo executável gerado pelo compilador. Biblioteca Uma biblioteca é uma coleção de funções. uma função para calcular um desconto ou logaritmo de um número. (else é palavra-chave. Como no exemplo que segue: Com espaços Sem espaços (correto e incompreensível) (correto e compreensível) #include <stdio. Um arquivo de biblioteca armazena o nome de cada função.Melaré 31 . As palavras-chaves de C são minúsculas.} main() { …. } • Há diferenciação de letras maiúsculas e minúsculas (case sensitive) A linguagem C é case sensitive. ou seja.h> main() { …. Algumas empresas criaram funções novas e acrescentaram ao compilador. fácil de entender. Projeto Pode ser criado um projeto em C. como por exemplo. como a função main() é obrigatório. diferencia letra maiúscula da minúscula. Regras de Digitação e Dicas da Estrutura em C em branco são desconsiderados Dê preferência para um código limpo.h> #include <stdio. Essa função determina a execução e ordem de execução das demais funções que existirem. O código que estiver dentro das chaves será executado seqüencialmente quando a função for chamada. As chaves { } servem para delimitar um bloco de instruções. Bloco de instruções e Função MAIN() Todos os programas na linguagem C começam executando o conteúdo descrito na função principal (main) e finalizam com o término dessa função. Nos projetos sempre haverá um arquivo com a função principal (main()) que indicará o início do projeto. 6. As funções possuem um conjunto de instruções (bloco de comandos) com uma tarefa específica.S. mais as informações necessárias para o processo de linkagem. • Espaços 7. • • Profª Angelina V. Quando o programa se referencia a uma função. 5.início e fim. a Borland. As variáveis devem ser declaradas no início. como por exemplo. mas ELSE ou Else não são). o linkeditor procura a função na biblioteca (que possuem várias) e adiciona a parte do seu código ao programa. onde podem existir vários programas (arquivos fontes).4. O conteúdo de uma função é delimitado por chaves { }. acrescentou ao Turbo C a biblioteca CONIO (Console Input/Output). com alinhamento e endentação. Exemplo: NOME é diferente de Nome que é diferente de nome. Os parênteses após o nome de uma função.

Comentários Para facilitar a compreensão coloque comentários ao decorrer do código. exemplo: include.(ponto-e-vírgula).• No C para indicar o final de uma instrução deve ser usado o . //o operador de divisão é a barra b) Comentário com várias linhas /* Autor: Julia Melaré Data: 15/07/2007 Sistema: Cadastro de Fornecedores */ Profª Angelina V. • Cuidado com as palavras reservadas. sendo que 27 criadas pelo Dennis Ritchie e 5 do padrão ANSI. printf. Como por exemplo: printf “Exemplo da Estrutura “.h> //Essa linha inclui a biblioteca que tem funções de entrada e saída O comentário também pode ser iniciado no começo da linha soma = n1 / n2. Exemplos: a) Comentário de uma linha #include <stdio. Na linguagem C tem 32 palavras.Melaré 32 . 8. printf “de um Programa em C”. Se for necessário podem ser digitadas várias instruções numa mesma linha. main.S. Esses comentários podem ser feitos de duas maneiras: • usando duas barras para comentários de uma única linha • barra asterisco para comentários de mais de uma linha.

_ as letras maiúsculas e minúsculas são tratadas diferentemente (case sensitive). o anterior é apagado. Por exemplo. Imagine as variáveis como gavetas etiquetadas. constantes e funções. _ não pode ser igual a uma palavra reservada da linguagem. você somente deve colocar conteúdos (objetos) nas gavetas de acordo com a identificação e tipo definido para ela. só que estes não podem ser colocados na primeira posição.Melaré 33 . como uma lousa. modificar e apagar quantas vezes for necessário. se for definir uma variável para armazenar o resultado da soma identifique como soma. cada uma com um nome. Todos esses endeeços precisam ser identificadas. Mas em que parte da memória vão os dados? Cada dado será armazenado em uma posição diferente da memória. ou seja. _ não pode ter acento e cedilha (ç) __ somente os 31 caracteres são válidos Profª Angelina V. 1. onde podemos escrever. _ o nome pode ser formado por números. A variável é uma posição reservada da memória que é usada para armazenar um valor (tipo de dado) temporariamente. Esse valor pode ser alterado a qualquer momento durante a execução do programa. 2A00? Identificadores Os identificadores são os nomes dados para as variáveis. Cuidado: cada variável armazena um único conteúdo por vez. ou seja. ter um nome de referência para cada alocação feita na memória. A melhor forma de nomear é verificar qual será seu conteúdo e definir o nome de acordo com ele. Memória Variáveis 2. essa posição é um endereço físico da memória RAM. quando for inserido um novo valor.S. Essas variáveis são utilizadas como áreas de trabalho. O nome (identificador) da variável torna-se o seu endereço. com exceção do caracter _ (underline). Em C existem algumas regras para a formação dos identificadores: _ o primeira caracter tem que ser obrigatoriamente uma letra ou um sublinhado. Imaginem como você encontraria uma pessoa sem ter seu endereço ou telefone? Imagine ter que ser saber endereços físicos: 10CF. O que são variáveis? Os dados fornecidos pelos dispositivos de entrada ou aqueles dados processados são armazenados numa área da memória do computador chamada de variável. _ não pode ter caracteres especiais ou espaço.Variáveis Os dados armazenados no computador podem ser apresentados de duas formas diferentes: como constantes ou variáveis.

Profª Angelina V. Observação: No pseudocódigo o símbolo significa atribuição. A declaração da variável deve ser feita obrigatoriamente antes da sua utilização. Não se esqueça que ao definir o tipo de variável está se determinado a quantidade de espaço (bytes) que será alocado na memória e o intervalo de valores que ela poderá armazenar. real porc_aum 5. Na linguagem C ela é representada com o símbolo =.S. nome_variável. podendo ser declaradas em lugares diferentes: dentro da função (variável local). Exemplos de Declaração de Variável: tipo_de_variável nome_variável. fora da função (variável global). Pseudocódigo C Dicas em C real salario. quando ela for declarada. caracter sexo.Melaré 34 . ou dentro de um bloco de instruções. inteiro qtd_pao.3. qtd_leite.5. onde nela é feita a definição do nome/local de armazenamento (ligada ao endereço físico) e quanto de espaço será reservado para o conteúdo a ser armazenado (tipo de dado). int num_filho. Declaração de variável A declaração de variáveis é obrigatória em quase todas as linguagens de programação. qtd_leite. float salario. char sexo. Podem ser declaradas diversas variáveis do mesmo tipo ao mesmo tempo. Pode ser atribuído um conteúdo a variável float porc_aum =5. int qtd_pao.5. inteiro num_filho.

como por exemplo.S. ANO_ATUAL).Melaré 35 . //não permite mudança de valor printf("%i".Constantes Constantes são dados com valores fixos que não podem ser alterados durante a execução do programa. Exemplos: A) Data_atual = 1990 Valor_aumento = 1000 Porc_desconto = 0. o valor de PI. _sleep(2000). main() { // ANO_ATUAL = 300.h> #include <stdlib. já o número 3 é uma constante. pois são as incógnitas e contém um valor sujeito a alteração. o seu valor já é conhecido e não poderá ser alterado. É como na expressão matemática: VARIÁVEL CONSTANTE X +Y+3 O X e o Y seriam as variáveis do programa. } Profª Angelina V.141592 B) #include <stdio. o ano atual.h> const int ANO_ATUAL = 1990. As constantes podem ser definidas sem identificador.10 PI = 3. Em todas as execuções ele sempre será 3. sendo inseridas diretamente. Dentro de um programa podem existir várias constantes.

Pense que quando se agrega valor a um dado tem-se uma informação. No pseudocódigo será definido apenas como real. decimal e hexadecimal. 2. de conscientização e valorização do meio de sobrevivência da espécie humana. Numérico O tipo numérico armazena apenas valores numéricos. float n1=20. Cada linguagem tem seus tipos primitivos e a partir deles podem criar novos.0.int Contém números que não possuem a parte decimal. float n1=0. Literal/ Cadeia de Caracteres Na linguagem C não existe o tipo literal. soma.S. n2 = -15. Numérico Inteiro . também conhecido como alfanumérico. octal.Tipos de dados Quando colocamos o termo tipos de dados básicos nos referimos aos tipos primitivos da linguagem. que podem ser: inteiros ou reais.Melaré 36 . Defina de forma correta o tipo de dado. Na linguagem C os tipos primitivos são: caracter (char). mas se colocarmos o Dia da Água. podendo ser positivos. havendo um desperdício de memória.50. Quando houver necessidade do armazenamento de um nome deverá ser feito uso de uma matriz de caracteres. que ocorre no dia 22 de março. Se for necessária uma precisão dupla é necessário usar o tipo double. num2. traz uma informação muito importante. não informa nada. Profª Angelina V. A representação desse tipo no pseudocódigo será int. Exemplo: 22 de março é dado. 1.real São os números positivos.50. Na linguagem C é int. Pseudocódigo Codificação em C int num= -4. inteiro (int). n2. negativos ou nulos que possuem a parte fracionária (parte decimal). O tipo real pode ser representado pelo real simples ou duplo. string. Numérico Real. Mesmo que o valor recebido e armazenado seja menor que o espaço reservado o computador ainda conserva o mesmo tamanho pré-definido. negativos ou nulos. abreviação de inteiro. Lembre-se que o computador processa dados. ele tem outro valor. Pseudocódigo Codificação em C real salario= 350. para que não ocorra falta de memória durante a execução do programa ou lentidão de processamento. Quando você define o tipo de variável o computador reserva (aloca) um espaço (quantidade de bytes) de acordo com o esse tipo. que suporta até 11 digitos. O separador decimal é o ponto e não a vírgula (padrão americano). que aceita armazenar vários caracteres. int num1 = 6000. real (float e double) e sem valor (void). a diferença está na precisão e no número de casas decimais.0. É possível em C manusear dados numéricos nas bases binária. O real simples é identificado como float na linguagem C e tem até 6 dígitos de casas decimais. abreviação de integer.

A. que possui letras (a. Quando for uma cadeia de caracteres.z. b.S. colocamos entre aspas (“). mesmo tendo armazenado um número.%i . char flag = ‘!’. b=1. #.. sempre armazenando apenas um dígito.Z). O dígito 0 representa o valor lógico falso e 1 representa o valor lógico verdade (todo valor diferente de 1 é falso) .9) e caracteres especiais (º.%i\n". Então.valor 0 0 1 1 0 0 0 1 Profª Angelina V. Quando for um único caracter colocamos seu conteúdo obrigatoriamente entre apostrofe(‘).%c . caracter opção = ‘a’.base 2. } Perceba que a variável a armazena o símbolo 1 e a variável b armazena o primeiro símbolo da tabela ASCII que é a carinha. //Resultado:1 carinha 49 1 1 //caracter 1 e o primeiro símbolo na ASCIII . então. a. printf("%c . ^.o símbolo 1 é a carinha //o símbolo 1 na ASCII tem seu decimal o 49 //o 1 inteiro é o 1 na exibição definida como inteiro 5. a. Exemplo de programa: main() { char a='1'. números (0.b). printf("\n%c . :). b). Codificação em C while (1) //loop infinito 4.. Então o tipo caracter que ocupa 1 byte pode armazenar 256 combinações diferentes de bits. um byte possui 28 = 256 combinações possíveis.. Espaço Alocado de Memória Não se esqueça que cada byte ocupa 8 bits (de 0 a 7). Codificação em C char sexo = ‘f’. Lógicas As variáveis definidas como lógicas (booleanas) podem guardar apenas um dos dois estados: Verdadeiro ou Falso. Pseudocódigo caracter sexo. Número Decimal 49 – Caracter 1 (ASCII) Bit 7 6 5 4 3 2 1 0 Base Decimal 128 64 32 16 8 4 2 1 Estado . Pseudocódigo lógico estado_lampada. Na linguagem C não existe um tipo específico para a representação de valores lógicos. &.%c". Na maioria dos ambientes não pode ser usado para cálculo. _sleep(2000).Melaré 37 . a.Se a cada 8 bits pode-se ter a representação de um número inteiro. o char pode armazenar valores de 0 a 255. Cada bit possui dois estados ( 0 ou 1 ). Caracter O tipo char é usado para armazenar um caracter da tabela ASCII.3. =.

para aceitar tipos negativos tem que ser unsigned e seus valores vão de -128.0 -14. //padrão é signed printf("Unsigned %i . Tipo de Variável char int float double void Qtd de bytes 1 4 4 8 0 Qtd de bits 8 32 32 64 0 Exemplo de valores ‘f’ 1 14 -23 15. o tipo char que vai de 0 a 255 do tipo signed (só positivos).Um tipo que armazena 2 bytes pode ter 28 x 28 combinações diferentes de bits. O tipo short (reduz) e long (amplia) são usados para aumentar ou diminuir a faixa de valores dos tipos bases. char n2= 255. MikroC o padrão é unsigned. que equivale a 2.483. Modificadores de Tipos Os modificadores de tipos são usados para modificar o tipo primitivo.0..147.+127. a) Exemplo: unsigned char n1= 255.signed %i". Por exemplo. Resultado: 255 e -1 Dica: Pode-se definir valores em outras bases (diferente da decimal): 128 em decimal int hex = 0x80 int oct = 012 10 em decimal Decimal Valor = 50 Octal Valor = 050 Hexadecimal Valor = 0x50 Binário Valor = 0b01010000 Profª Angelina V.655 10.7688665 6. O unsigned somente aceita os números positivos. que equivale a 65538. n1. fazendo com que ele aceite outra faixa de valores. O tipo signed faz com que o tipo represente os números positivos e negativos. Como é utilizado bit para representação de sinal os valores a serem representado são metade da faixa padrão.2 bilhões de combinações).. n2). O padrão C padrão ANSI define que os tipos são signed e no compilador CCS.Melaré 38 . A representação de números negativos é feita tomando o bit MSB (Most Significant Bit).647 (+. onde msb=1 o sinal é negativo e msb=0 o sinal é positivo.S. aceitando números negativos e positivos. O que armazena 4 bytes pode ter 28 x 28 x 28 x 28 combinações diferentes.

} Profª Angelina V. tab).Melaré 39 . for(tab=0.7.tab<=255. dígito numérico ou caracter especial). Veja no final dessa apostila a explicação detalhada da ASCII. tab.tab++) printf("\t%c .%i .S. FATEC F A T E C 70 65 84 69 67 01000100 01000001 01010010 01000101 01000011 Exemplo de Código que mostra a ASCII Estendida – Unicode Latim I Suplementar (8 bits) main() { int tab. Tabela ASCII (American Standard Code for Information Interchange) Cada combinação de byte pode representar internamente um símbolo (letra. printf("Caracter Decimal Hexadecimal\n"). tab.%x ".

printf("%s". if (ch == 9) printf ("TAB %c".alarme o cursor retrocede uma coluna o cursor avança para uma nova linha o cursor retrocede para a primeira coluna da linha o cursor avança para próxima marca de tabulação retrocede .h> #include <stdlib.h> #include <conio. o retorno de carro (return ou enter) cujo código decimal é o valor 13. ch2='\t'. ch = getch(). } Profª Angelina V.c> main() { char ch.ch1). "Alo\n")._sleep(2000). ch++) printf("\t%c". ch). Para inserir esses códigos deve-se usar a barra invertida juntamente com o código desejado. long double.*/ main() { char ch._sleep(2000). if (ch == 127) printf ("Del %c". ch2. Código de Barra Invertida Algumas combinações e representações da tabela ASCII não podem ser exibidos na tela.S. ch).8.L Exemplos de Códigos: #include <stdio. float– F._sleep(2000). ch). unsigned int –U. if (ch == 13) printf ("Enter %c". } main() { char ch1= '\a'.função de controle. ch). pois tem uma função especial. ch <='z'. ch). usando um contador definido como char.backspace exibe uma aspas duplas exibe a barra invertida exibe a aspas simples faz a tabulação vertical Sufixos usados: long int – L. if (ch == 27) printf ("ESC %c". Por exemplo. printf("%cVeja que esta na proxima linha %c". for (ch='a'. Código \a \b \n \r \t \b \” \ \’ \v Códigos de Controle Formato soa um sinal sonoro. ch). if (ch == 8) printf ("Backspace %c".Melaré 40 . } /* Exibe o alfabeto em minúsculo.

o I como numérico inteiro.f d) valor-sal e) cod1 f) cidade/uf g) $salario 3) Identifique o tipo ideal para as variáveis abaixo.p. Informação Estado civil Número que calça Peso Altura Valor da conta de luz Salário Valor pago pela refeição Nome da Variável ________________ _________________ _________________ _________________ _________________ _________________ _________________ Tipo de Variável _________________ _________________ _________________ _________________ _________________ _________________ _________________ Profª Angelina V.00 ( ) d) “ “ ( ) k) -92. A letra F identifica como número real.Exercícios de Variáveis 1) Defina quais são as variáveis e constantes das expressões abaixo: a) 15 + 14 * y + 3 _____________________________________________________________ b) x + 5 + x + x _______________________________________________________________ 2) Quais identificadores das variáveis estão corretos? Explique. o C como caracter e o E quando estiver incorreta a alternativa. ( ) g) -600 ( ) a) -8 ( ) h) 500. a) 5teste b) n_rg c) c.33 ( ) b) ‘0’ ( ) i) 789003983 ( ) c) “X” ( ) j) 300.Melaré 41 . ( ) l) 945 ( ) f) “9” h) _ir i) n sapato j) num2cod2 k) nome l) x m) my 4) Identifique as variáveis nomeando-as e definindo o tipo de dado ideal para armazenamento.34 ( ) e) .V.S.

ou seja. o 2³ é igual a 8. ficando da seguinte forma: 3 ** 2 ou 3 ^ 2.S. que representa o operador de potenciação. No computador a representação é diferente.Operadores Aritméticos 1. que representam o resto da divisão e o quociente da divisão na respectiva ordem. como o exemplo 2³. Esses operadores somente podem ser usados para números inteiros. A exponenciação tem maior prioridade que os demais operadores. Quando estivermos fazendo cálculos de divisão com números inteiros (10. Desta forma entendemos que o número 2 é a base e o 3 o expoente. No lugar de colocarmos o 3 em cima . Na linguagem escrita quando elevamos um número a outro. Exemplo: 2 ^ 3 ou 2 ** 3 O resultado dessa operação é 8. 4500. O resultado da expressão onde foi usado o DIV é sempre um número inteiro.3). dependendo da linguagem de programação. 5 DIV 2 = 2 5 MOD 2 = 1 Obs: Na linguagem C é usado o operador % para representar o MOD. 5 Resto da Divisão 2 2 Parte Inteira da Divisão (Quociente) 1 22 DIV 5 = 4 22 MOD 5 = 2 70 MOD 10 = 0 2 DIV 2 = 1 -400 DIV 4 = 100 Exemplos: ou em C 22 % 5 = 2 Profª Angelina V. o colocamos do lado. que tem a função de trabalhar com números inteiros. o quociente. No C é pow(2.Melaré 42 . os resultados são valores numéricos. e em Pascal é exp(2 * ln(3)). /. -900. Operadores Aritméticos Os operadores aritméticos são os operadores usados nas operações básicas da matemática. Ainda existem o mod e o div. Esses operadores são usados para representar as expressões matemáticas. Exponenciação: é usada para elevar um número a outro. Mod e Div Em muitas linguagens de programação existem o operador div e mod. Eles são: +. 15) podemos utilizar o operador DIV. Esses operadores têm a mesma prioridade e devem ser efetuados antes da adição ou subtração. e no meio o símbolo. -. O operador pode ser o sinal circunflexo (^) ou dois asteriscos (**) ou uma função (pow ou exp). *.

como. num*=2 ou num = num * 2. Quando o operador precede a variável ((++n1). No exemplo acima o operador += acrescenta 2 ao valor da variável num e o armazena a variável num. Módulo % 2%2=0 Decremento --x é x=x-1 -**Sempre será retornado um valor ++x é x = x + 1 Incremento ++ real quando houver pelo menos um número real envolvido. --. ele executa a operação (incremento ou decremento) antes de usar o conteúdo da variável. Conversão de Tipo A linguagem C oferece o recuso de conversão automática de valores. /.) o separador de milhar. o computador primeiro usa o valor armazenado na variável para depois executar a operação. 2. Operador Operação Exemplo **Cuidado.Operadores Aritméticos da Linguagem C Os operadores aritméticos da linguagem C são: ++. 5/2 será 2/2 =1 Divisão / igual a 2. 4. Exemplo: a) float x = 5. o valor de x é convertido para 5. Exemplo: num = num + 2 pode ser escrito da seguinte maneira: num+=2. ao ser usado o 1+1 =2 + Adição operador de divisão a um tipo 1–1 =0 Subtração inteiro. +. Exemplos: a) n1 = 10 n2 = ++ n1 resultado n2 = 11 b) n1 = 10 n2 = n1++ resultado n2 = 10 somente a próxima vez o x vale 11 3. Esse operador é colocado entre parênteses antes do valor a ser convertido. Esses operadores já estão na ordem de precedência de execução. Se o operador estiver depois da variável (n1++). Operadores Aritméticos de Atribuição ou C Reduzido Na linguagem C pode ser feito usado de um operador aritmético com o comando de atribuição. num2 = num1 = 10 o valor 10 é atribuído a num1 e. será retornado um valor Multiplicação 2 * 2 = 4 * inteiro.Melaré 43 . Operadores de Incremento e Decremento Esses operadores podem ser usados como prefixo ou sufixo. em seguida o valor de num1 é atribuído da num2 (da direita para a esquerda). -. A conversão pode ser feita usando o operador cast (operador de molde de tipo). como: num-=2 ou num = num – 2.) representa o separador decimal e a vírgula (. dessa forma simplificando a programação.S. ++n1 ou n1++. O ponto (. Profª Angelina V. num/=2 ou num = num / 2. Os operadores com a mesma precedência são executados da esquerda para a direita. %. Esse forma de calculo pode ser usada para qualquer operador aritmético. Por exemplo.0.*. num%=2 ou num = num % 2.

b) 5 / 2.0 o valor de 5 é convertido para 5.0, porque o segundo operando é 2.0. O resultado da expressão é 2.5 c) int a, b; a = (int) 3.5; -- é atribuído o valor 3 para a variável a b = (int) 3.5 % 2; -- é convertido o valor 3.5 para 3 para depois fazer a operação módulo, que só pode ser feita com valores do tipo inteiro.

Prioridade dos Operadores Aritméticos
A precedência (maior prioridade) de operadores segue a ordem: *, /, %, +, -. Os operadores com a mesma precedência são executados da esquerda para a direita.
Operador ^ ou ** * / div mod + Finalidade Exponenciação Multiplicação Divisão Divisão inteira Resto da divisão Adição Subtração Prioridade 1 2 2 3 3 4 4 Linguagem C Função pow(b, e) * / % + -

Exemplos de Prioridades: 1) 3 + 4 =7 A operação da adição pode ser efetuada em primeiro lugar quando não existir nenhuma outra operação com maior prioridade. 2) 9 - 4 * 2 = O operador de maior prioridade nesta expressão é a multiplicação, devendo ser realizada em primeiro lugar. 4*2=8 Depois, substituímos a expressão calculada (4 * 2) pelo seu resultado ( 8 ) e efetuamos a segunda operação, que é a subtração. 9 - 4*2 9-8=1 O resultado é 1 Percebam que não foi realizada a operação pela ordem que foi escrita, mas sim pela ordem de prioridades, como na matemática convencional. Se não fosse aplicada a prioridade dos operadores o resultado da expressão seria 10, um valor diferente de 1, o correto. 9–4*2= 5 * 2 = 10 3) 4 * 3 - 4 / 2 ** 2 = Deve ser realizada em primeiro lugar a operação que tem o operador de maior prioridade, ou seja, a potenciação 2 ** 2. 4 Profª Angelina V.S.Melaré 44

Depois, substituímos a expressão de potenciação (2 ** 2) pelo seu resultado (4). 4 * 3 - 4/ 2* 2 4 * 3 - 4/ 4 Agora os operadores de maior prioridade são a multiplicação e a divisão. Esses dois operadores têm valor de prioridade igual, então tanto faz a ordem de execução. 4*3 12 Então, substituindo a operação pelo resultado, temos: 4 * 3 - 4 / 2 ** 2 4*3-4/ 4 12 - 4 / 4 Restaram duas operações a serem feitas: a subtração e a divisão. Como a divisão tem maior prioridade a efetuaremos primeiro. 4/4 1 4 * 3 - 4 / 2 ** 2 4*3-4/ 4 12 - 4 / 4 12 - 1 = 11 O resultado da expressão foi 11. Vamos supor que você não se lembra das prioridades dos operadores e faça pela ordem escrita. Será que o resultado será o mesmo? Veja a seguir a execução da mesma expressão. 4 * 3 - 4 / 2 ** 2 = 12 - 2 ** 2 = 12 - 4 8 O resultado não é o mesmo que na resolução anterior.
4) 5 * 2 ^ (4 - 2) = Neste exercício temos uma expressão dentro de parênteses. O operador que está dentro do parêntese deve ser sempre efetuado em primeiro lugar. ( 4 - 2) 2 Vamos substituir o resultado da expressão dentro de parênteses na expressão geral. 5 * 2 ^ (4 - 2) 5*2^ 2 Agora, como não temos mais nenhum parênteses, efetuaremos o cálculo da expressão que tem o operador com maior prioridade. 2^2 4 Substituindo o resultado da potenciação: 5 * 2 ^ (4 - 2) 5*2^ 2 5* 4 20 O resultado é 20. Se o cálculo fosse feito sem priorizar o parêntese o resultado da expressão seria 100. Profª Angelina V.S.Melaré 45

Exercícios de Expressões Aritméticas e Prioridades de Operadores

1. 3 + 4 * 4 + 8 / 2 = 2. (3 + 4 ) * 4 + (8 / 2) = 3. 64 / 8 - 3 = 4. 4 ^ 3 + 2 * 3 = 5. 81 / 3 ^ 2 = 6. 2 ^ (2 * 1 + 2) / 2 = 7. 4 * 2 ** (4 / 2) = 8. 66 DIV 4 * 2 + 2= 9. 15 MOD 3 * 1 = 10. 27 MOD (3 ** 2) = 11. 17 MOD 2 + 7 DIV 3 = 12. 21 * 16 /4 = 13. 70 DIV 7 = 14. (21 / 2) / 2 * 3 = 15. [12 - (4 * 2) ] + 2 =

Profª Angelina V.S.Melaré 46

como funções para calculo da exponenciação.not Deslocamento à direita Deslocamento à direita Exemplo: bit = 00000011 bit << 2 00001100 bit = 01100000 bit >> 2 00011000 Exemplo: a) int v1=100. Os valores do ângulo são em radianos.xor Negação .or Ou exclusivo . v2. logaritmo. Função Explicação Exemplo Exibição Abs() Retorna o valor absoluto Abs(-200) 200 pow() Calcula exponenciação (potência) pow(3.6051 Log10() Calculo o logaritmo decimal log10(100) 2 2. 100 decimal = 0 1 1 0 0 1 0 0 & 15 decimal 00001111 ____________ 00000100 4 decimal O estado zero do bit fará com que o bit resultante seja 0 Profª Angelina V.h.2) 9 Sin() Calculo o seno do ângulo sin(90) 0. Operador & | ^ ~ >> << Ação Conjunção – e -and Disjunção – ou .Funções Matemáticas e Operadores Bit a Bit 1. Funções Matemáticas Existem várias funções matemáticas já programadas que estão na biblioteca Math.448 Tan() Calculo tangente do ângulo tan(90) -1. sejam à esquerda ou à direita.Melaré 47 .9952 Sqrt() Calcula a raiz quadrada sqrt(25) 5 Log() Calculo o logaritmo natural log(100) 4.8939 Cos() Calculo o cosseno do ângulo cos(90) -0. v2= v1 & 15.S. raiz quadrada. Os operadores << e >> manipulam os bits do tipo int e char. para isso deve-se usar o operador de acordo com a operação desejada. Operadores de deslocamento de bits Podem ser feitas operações lógicas bit a bit com variáveis.

#include <stdio.h> #include <time.h> main() { srand((unsigned int)time((time_t *)NULL)).1. rand()%10 + 1.S. _sleep(2000). printf("%i". printf("%i". Função Rand() e SRand() A função rand() é usada para gerar números aleatórios.h> #include <stdlib. num = rand()%10+1.Melaré 48 . num = rand(). printf("%i". int num. Profª Angelina V. srand((unsigned int)time((time_t *)NULL)). num). // ajustado para gerar números entre 1 e 10 (soma 1 pois começa no 0) main() { int num. _sleep(2000). num). Os números gerados aleatoriamente vão de 0 a 32767. _sleep(2000). main() { int num. } A função srand() permite a geração de números diferentes a cada nova execução. } //srand(time(NULL)). num = rand()%10+1. num). } Para haver a delimitação dos números gerados.

Ele serve para definir os limites de existência de uma variável. A execução começa de cima para baixo. arquivo. ou seja. A saída no pseudocódigo é denominada como escreva ou exiba. que resultará num valor. Pseudocódigo: Escreva (“Informe um número”). mouse. Entrada: é a leitura de dados feita através de dispositivos de entrada (teclado. Saída: pode ser a exibição de uma mensagem. O resultado gerado também poderá ser armazenado na memória. Profª Angelina V. As ações dentro do bloco são separadas pelo ponto e vírgula ( . mas valores diferentes. leia (num) . impressora. Podemos ter diversas variáveis declaradas no decorrer do algoritmo/programa. Pseudocódigo: num 4. onde uma ação deve ser executada após a outra.Estrutura de Controle Linear/ Sequencial Nesta estrutura a execução das instruções é linear. caixa de som. ). ou seja. Essa leitura é feita e depois o dado é transportado para a memória principal (RAM). ou uma expressão matemática. o escopo de uma variável. Não existe desvio na execução. Pseudocódigo: inteiro num. O processamento pode ser realizado com as entradas. entre outros). O dispositivo de saída a ser utilizado é o monitor. Depois será feita a leitura do teclado e armazenado o valor na variável num. O dispositivo de entrada a ser utilizado é o teclado. Escreva (“Salário calculado “. A atribuição no pseudocódigo é representada pela seta ( )e o operador em C para atribuição é o igual ( = ).Melaré 49 . ou a recuperação de um conteúdo que está na memória e será transmitido para um dispositivo de saída (monitor. Variável num recebe o valor 4 ou é atribuído 4 a variável num Codificação em C num = 4. Bloco de instruções/comandos Um bloco de comandos ou instruções determina o conjunto de ações a serem executadas. da esquerda para a direita Nessa estrutura temos as entradas. sal).S. Processamento: o processamento pode ser realizado através de uma atribuição. os processamentos e as saídas. O conjunto de passos é executado num fluxo contínuo do começo ao fim. Servindo para organizar e determinar a execução ou encerramento de uma ação. dependendo do bloco em que foram declaradas. seqüenciais. A entrada no pseudocódigo é denominada como leia. entre outros). podendo ter duas com o mesmo nome. Será reservado na memória RAM um endereço para num.

Função de Saída .S. (10 ) printf("%08i".printf() A função printf() realiza a saída de dados em vários formatos. O protótipo do printf() é: printf(“string_de_controle”.H. endereços de memória.(menos). o formato das variáveis (usando-se o comando de formato .Melaré . Se o tamanho do campo for precedido por um .3 0 7 possíveis no total. • Na lista de argumentos definem os formatos que serão exibidos os valores. (0000010) Profª Angelina V. Exibição ( 10) Explicação As posições definidas a mais são preenchidas com espaço em branco e o valor é alinhado à direita do campo. de acordo com a configuração feita pelo programador. O protótipo da função está no arquivo de cabeçalho STDIO. Se o tamanho do campo for precedido com o 0 (zero). o valor será alinhado à esquerda do campo. Como nos exemplos abaixo: %4d _ _ 3 3 %7. resultados de cálculos. 10). Com essa função é possível exibir mensagens. lista_de_argumentos).%) e os caracteres de controle (usando o símbolo \). 10).2f _ _ _ 5. • Na string de controle é definido tudo que será exibido na tela: cadeia de caracteres. então as posições excedentes 50 printf("%-8i". sendo fixadas 2 para o número de casas decimais Comando printf("%8i". Comandos de Formato mais usados Código Formato %c um único caracter %d inteiros decimais com sinal %i inteiros decimais com sinal %f ponto flutuante decimal %lf double %s string – cadeia de caracteres %x hexadecimal sem sinal %u inteiro decimal sem sinal %p ponteiro %o octal %e float exponencial %g ponto flutuante curto %% % É possível especificar o tamanho dos campos que serão exibidos.Funções de Entrada e Saída Formatada 1. então. 10).

Essa função captura o valor digitado no teclado e armazená-o em uma variável. • Deve ser colocado o mesmo número de argumentos e de string de controle. scanf(“%f”. printf(“O resultado é: %6. &lista_de_argumentos).10) 1910.1910.Melaré 51 . &nota2). %e."Juros de ". • Num tipo string. nota2. %g ponto flutuante decimal %s string de caracteres Exemplo: float nota1. %e pulam automaticamente os brancos que precedem os valores numéricos."Este") printf ("%s%d%%". scanf(“%i:%i”. Comandos de Formato mais usados Código Formato %c caracter %d .&minuto). ou Profª Angelina V. &hora.51 %% Um tipo caractere é A e um tipo inteiro é 20 Este é um exemplo string Juros de 10% 2.1f”. &nota1. • Primeiro se define o tipo de variável a ser recebido • Deve ser colocado o operador & (endereço de memória) antes de cada uma das variáveis da lista de argumentos (exceto para strings).20) printf ("%s é uma string".1f printf(“O resultado da soma é:”).1 são preenchidas com zeros. o espaço em branco finaliza a entrada. %f. &nota2). O protótipo dessa função está no arquivo de cabeçalho STDIO. Os especificadores %d. int hora.‘A'.printf(“%.2f”.H. usando como separador de entrada um espaço em branco ou o caracter dois pontos ( : ). Deve ser colocada a quantidade de casas decimais a serem exibidas junto com o comando de formato. %i inteiros decimais com sinal %f . &nota1). como no exemplo %.10) O resultado da soma é O resultado da soma é 4. scanf(“%f%f ”. Os valores capturados são convertidos para o formato interno apropriado. Sua estrutura e: scanf(“string_de_controle”. scanf(“%f”. soma). printf (“Mostra o símbolo %% %%") printf ("Um tipo caractere é %c e um tipo inteiro é %i". soma =4.S. Podem ser recebidos vários valores ao mesmo tempo.51. minuto. Função de Entrada – scanf() A função scanf() é usada para fazer entrada de dados.

} Profª Angelina V.h> #include <conio.1. resto da divisão e exponenciação. escreva (“Exponenciação:”. escreva ("Multiplicacao: %i \n". escreva (“Subtracao:”.c. #include <stdio. resto= n1 % n2. soma). escreva (“Multiplicacao:”. } Exemplos Exemplo 1 Faça um programa que receba dois números inteiros e efetue as operações: adição. divisao n1 / n2. mult= n1 * n2. resto). caracter=getch(). mult n1 * n2. resto). mult). multiplicação. subtr n1 . divisão. escreva (“Divisao:”. soma. scanf("%i%i".h> #include <stdlib. subtr= n1 . escreva ("Soma: %i . _sleep(2000). escreva (“Informe segundo número”).h> #include <stdlib.Melaré 52 . subtração.h> #define escreva printf main() { int n1. leia (n2). _sleep(8000). divisao= n1 / n2. escreva (“Soma:”. leia (n1).n2.Subtracao: %i \n". Pseudocódigo Início inteiro n1. soma. expo).caracter. printf ("Voce pressionou a tecla %c que equivale ao numero %i Asc". escreva (“Informe primeiro número”). subtr). divisao. resto. expon. escreva ("Informe 2 numeros").c> main() { char caracter. subtr. divisão. n2.S. &n2). expo = (n1. divisao. soma= n1+ n2. divisao). mult. &n1. expo. Função de Entrada de caracter– getch() e getchar() As funções getch() e getchar() estão na biblioteca conio.n2. caracter ). Fim Codificação em C #include <stdio. mult). Elas são usadas para a entrada de um caracter. subtr. resto. soma n1+ n2. A diferença entre elas é que a getchar() espera após o caracter digitado a tecla enter e o getch() não. n2. soma. subtr). n2). resto n1 mod n2. mult. escreva (“Resto da divisão:”. escreva ("Divisao: %i – Resto da divisão: %i\n".

Escreva (“Daqui a 30 anos você terá:”. idade). } Linguagem Pascal Program idade.Melaré 53 . ano_atual. printf(“Daqui a 30 anos você terá: %i”. writeln(‘Daqui a 30 anos você terá:’. Leia (ano_nasc). Idade30 idade +30. idade30 := idade +30.S. idade. printf(“\nDigite o ano de nascimento”).h> #include <stdlib.Idade30).&ano_nasc). idade30. Escreva (“A sua idade é ”. Fim Linguagem C #include <stdio. Escreva (“Digite o ano atual”). idade := ano_atual – ano_nasc. printf(“A sua idade é %i”. Pseudocódigo Inicio inteiro ano_nasc. ano_atual.idade30). idade30= idade +30. write(‘Digite o ano de nascimento’). readln(ano_atual). begin write(‘Digite o ano atual’). Leia (ano_atual). writeln(‘A sua idade é ‘. idade). idade30. scanf(“%i”. ano_atual. idade.&ano_atual). idade).Exemplo 2 1) Calcular a idade atual e daqui a 30 anos de uma pessoa. scanf(“%i”. readln(ano_nasc). Idade ano_atual – ano_nasc. idade30). Escreva (“Digite o ano de nascimento”). printf(“\nDigite o ano atual”). INÍCIO Descrição Narrativa: ANO_NASC Receber o ano de nascimento Receber o ano atual Receber Subtrair o ano atual do ano de nascimento para saber a idade ANO_ATUAL Somar o valor da idade com 30 para saber quantos anos terá daqui 30 anos Mostrar idade atual IDADE = ANO_ATUAL .h> main() { int ano_nasc. idade = ano_atual – ano_nasc. end Receber IDADE30 = IDADE + 30 Mostrar IDADE Mostrar IDADE30 FIM Profª Angelina V. Var ano_nasc.ANO_NASC Mostrar idade daqui a 30 anos. idade. idade30: integer.

S.Melaré 54 .Teste de Mesa MEMÓRIA VALORES SIMULADOS ANO_NASC ANO_ATUAL 1980 IDADE 1998 IDADE30 1980 1998 18 48 ENTRADA SAÍDA PROCESSAMENTOS IDADE = ANO_ATUAL .ANO_NASC IDADE = 1998 1980 IDADE = 18 IDADE30 = IDADE + 30 IDADE30 = 18 + 30 IDADE30 = 48 18 48 Profª Angelina V.

Entrada: • nome do vendedor • número de aparelhos vendidos • valor do salário fixo (mesmo não sendo pedido no enunciado. real sal_bruto. leia nome. inteiro quant. leia quant. sal_total. escreva (“Quantos aparelhos foram vendidos”).S. o número de aparelhos vendidos e calcule o salário total do vendedor. escreva (“O salário final é:”. comis quant * 50. comis. escreva (“Qual o valor do salário fixo”).Melaré 55 . escreva (“Nome do Funcionário:”). FIM Fluxograma: INÍCIO Receber NOME_VEND Receber QUANT Receber SAL_BRUTO COMIS = QUANT * 50 SAL_TOTAL = SAL_BRUTO + COMIS Mostrar SAL_TOTAL FIM Profª Angelina V. sal_total).00 por cada aparelho vendido. sal_total sal_bruto + comis. o valor do salário fixo deve ser recebido para o cálculo do salário total) Processamento: • calcular o valor da comissão _ quantidade de aparelhos vendidos * 50 • calcular o salário total _ o valor da comissão + o valor do salário fixo Saída: • mostrar o salário total do vendedor Pseudocódigo INÍCIO caracter nome. leia sal_bruto.Exercícios Resolvidos e Propostos 01) Uma loja de telefone celular paga aos seus vendedores um salário fixo mais uma comissão de R$ 50. Faça o pseudocódigo e fluxograma que receba o nome do vendedor.

Verdadeiro 0 . para comparação e testes condicionais de valores de constantes ou conteúdo de variáveis. representa o verdadeiro. Ao verificar uma expressão.Melaré 56 . >=.Verdadeiro 1.S. no caso o valor um. Elas podem ser utilizadas em testes de variáveis.Operador Relacional e Lógico 1. pois ele serve para negar a expressão. == Expressão em pseudocódigo 3=5 15 > 5 5+ 6 = 11 7 < 4-5 ‘s’ = ‘n’ Expressão em C 3==5 15 > 5 5 + 6 = = 11 7 < 4-5 ‘s’ = = ‘n’ Resultado 0 . qualquer valor diferente de zero.Falso Na linguagem C não existe o tipo lógico (booleano) com os valores true e false (verdadeiro ou falso). <=. Eles podem ser usados numa expressão que também tenha operadores aritméticos.Falso 0 . o compilador compara e retorna o valor zero ou um. >. 2. Operadores Lógicos As expressões lógicas são aquelas que operam com valores lógicos e resultam também num valor lógico. Esses operadores relacionais geram um resultado lógico (Verdadeiro ou Falso) quando aplicados nas expressões. A função do operador lógico “NÃO” pode modificar valores e expressões. Operadores Relacionais Os operadores relacionais são utilizados em expressões de lógicas.Falso 1. tomada de decisão e expressões matemáticas. Operador (pseudocódigo) Significado C Igual == = Maior > > Menor < < Menor ou igual <= <= Maior ou igual >= >= Diferente de != <> A precedência de execução é: <. O valor zero representa o falso e. !=. Operador NÃO E OU Operação Negação Conjunção Disjunção Prioridade 1 2 3 C ! && || Profª Angelina V.

S. Prioridade dos Operadores A prioridade de execução pode ser diferente em algumas linguagens de programação Prioridade Operador 1 Parênteses Aritméticos 2 3 Relacionais 4 Lógicos Exercício: Descubra se as expressões abaixo são falsas ou verdadeiras: a) 5 + 6 = 10 b) 5 mod 2 = 2 c) 15 <> 5 + 5 d) 33 > 3 OU carol = carolina e) 16 > 5 * 2 f) 20 < 2 g) 56 > 45 + 4 h) feijão = feijoada i) 56 < = 4 j) 70 > = 3 ** 2 k) 5 >= 5 E 4 = 5 l) 12 + 1 = 13 OU 4 + 2 = 7 m) 18 > 7 E 19 < 7 n) 90 = 3 OU 80 > 5 Profª Angelina V. mas isso não é verdadeiro. A segunda condição é verdadeira. pois o valor do Número1 é 5. O resultado dessa expressão é “Falso”. pois 6 é maior que 5.Melaré 57 . num1>7 || num2>5 num1> 7 OU num2> 5 4. pois o operador lógico “NÃO” negou a expressão contida dentro do parênteses. Observem a diferença do operador “OU” com o operador anterior “E”. e 5 é menor que 7. num1> num2>5 7 Explicação Nessa expressão temos o resultado “Falso”. pois o operador “E” exige que as duas condições sejam verdadeiras para o resultado ser “Verdadeiro”. E OU NÃO VeV=V V ou V = V Não F = V VeF=F V ou F = V Não V =F FeV=F F ou V = V FeF=F F ou F = F Exemplos: Pseudocódigo Não ( Idade = 5 ) num1 num2 5 6 C ! ( Idade = = 5 ) num1 = 5. num2 = 6. Tabela Verdade: é o conjunto das possibilidades combinatórias dos operadores lógicos.3. pois o operador “OU” indica que apenas uma das condições precisa ser verdadeira para o resultado ser “Verdadeiro”. O resultado dessa expressão é “Verdadeiro”. Veja && que a primeira condição está indicando que o Número1 é maior que 7. num2 = 6. num1 > 7 E num2 > 5 num1 num2 5 6 num1 = 5.

a de decisão. As decisões são representadas pelas expressões relacionais/lógicas e Algoritmos (Descrição Narrativa) Estrutura Linear INÍCIO Pegar o doce Tirar da embalagem Comer o doce FIM essas podem ter dois resultados. podendo ser verdadeira ou falsa. devido à grande flexibilidade e poder de ação que tais estruturas proporcionam. ou verificações e testes estão presentes em quase todos os programas. os passos a serem executados são diferentes daquele em que se o resultado fosse falso. mas não o do falso. Estrutura Condicional INÍCIO Pegar o doce Tirar da embalagem SE o doce estiver estragado então Jogar fora o doce SENÃO Comer o doce FIM INÍCIO INÍCIO PEGAR O DOCE PEGAR O DOCE TIRAR DA EMBALAGEM TIRAR DA EMBALAGEM COMER O DOCE F FIM COMER O DOCE ESTÁ ESTRAGADO? V JOGAR FORA O DOCE FIM Profª Angelina V.Estrutura de Decisão /Condicional/ Seleção Todas as complexidades de um problema não podem ser passadas no computador baseadas apenas numa estrutura linear. Se depois de avaliada a condição e o resultado for verdadeiro. então. a do Verdadeiro ou a do Falso.S.Melaré 58 . pois esta estrutura não prevê a possibilidade de desvios de instruções. As condições. Conforme o resultado um dos caminhos deve ser executado. composta encadeada. sendo obrigatório existir o do verdadeiro. Existem diversas estruturas condicionais: simples. múltipla escolha. Para o desenvolvimento de programas mais completos estudaremos a partir de agora uma nova estrutura. Na verdade a decisão é uma condição ou expressão lógica que é testada e verificada.

scanf(“%f”. foi constatada a falta do procedimento que verificasse se o doce estava ou não estragado. Escreva (“O maior número é: ”. Na segunda estrutura foi possível fazer a verificação de possíveis falhas na seqüência de processos. Na primeira estrutura. Exercício Resolvido Elabore um programa que receba dois números e no final mostre o maior número digitado. else Senão printf(“O maior número é %f”. } Fim Teste de Mesa VALORES SIMULADOS MEMÓRIA NUM1 PROCESSAMENTO NUM2 100 5 100 5 SAÍDA ENTRADA 100 Profª Angelina V. printf(“\nDigite o primeiro número”). if (num1 > num2) SE (num1 > num2) então printf(“O maior número é %f”. num2. num1). num1). scanf(“%f”. existe apenas três procedimentos e não há verificação das informações. num2. printf(“\nDigite o segundo número”).h> Mostrar o número maior #include <stdlib.Melaré 59 . Escreva (“Digite o segundo número”).h> main() Pseudocódigo { Inicio float num1.&num2). Escreva (“O maior número é: ”. Leia num1. Leia num2. Escreva (“Digite o primeiro número”). num2).S.No exemplo acima podemos ver facilmente a importância da estrutura de decisão. num2). onde. a linear. Entrada: Receber dois números Processamento: Verificar qual o maior número digitado Linguagem C Saída: #include <stdio.&num1). Real num1.

SE (condição) ENTÃO Início instrução 1. instrução n. instrução 2.S. printf(“Informe outro valor”). Estrutura de Decisão Simples A instrução somente será executada se a condição testada for Verdadeira. com seu início e fim. Fim if (condição) instrução. SE (condição) ENTÃO instrução. scanf(“%i”. Quando for mais de uma instrução a ser executada deve ser delimitado o bloco de instruções.Tipos de Estruturas de Decisão 1.Melaré 60 . } Exemplo: a) if (n1 > n2) printf (“O primeiro número é maior que o segundo”). b) if (n1> n2) { printf(“O primeiro número é maior que o segundo”). } Profª Angelina V. if (condição) { instrução 1. &n3). instrução n.

S. else if (n1 == n2) printf (“Os dois número são iguais”). SE (condição) ENTÃO Início instrução 1. else instrução. Fim SENÃO Início Instrução 1. SE (condição) ENTÃO instrução. Instrução n. Instrução n. if (condição) { instrução 1. Onde uma contradiz a outra. SENÃO instrução. } Exemplo: a) if (n1 > n2) printf (“O primeiro número é maior que o segundo”).Melaré 61 . } else { Instrução 1. instrução n. Profª Angelina V.2. instrução n. Estrutura de Decisão Composta: A condição será testada e de acordo com o seu resultado (verdadeiro ou falso) será executado um caminho (instrução) diferente. Essa estrutura é usada quando as duas possibilidades dependem de uma mesma condição. Fim if (condição) instrução. else printf (“O segundo número é maior que o primeiro”).

senão. SE (condição) ENTÃO Início instrução.se.. Fim if (condição) instrução. &n2).. } else if (condição) instrução. SE (condição) ENTÃO instrução.senão..3. Estrutura de Decisão Encadeada: Essa estrutura é usada quando existem várias verificações a serem feitas e uma pode depender da outra.se.... Exemplo: se.. else if (n2 == 0) { printf (“O segundo número não pode ser zero”). scanf(“%i”. printf(“Informe outro número”). &n3). else if (condição) { instrução 1...S. instrução n.Melaré 62 .se.. Pode existir a Estrutura de Decisão Heterogênea. quando não existe um padrão lógico no encadeamento. Fim SENÃO Início Instrução 1. Pode ser executada uma condição simples ou composta dentro de outra condição. } Profª Angelina V. } else if (n1 == n2) { printf (“Os dois número são iguais”).se. Quando existe um padrão lógico das estruturas de decisão é chamada Estrutura de Decisão Homogênea. Instrução n.senão. Exemplo: If (n1 > n2) printf(“O primeiro número é maior que o segundo”). printf(“Informe outro número”). Exemplo: se.senão.senão. scanf(“%i”...

. SE idade >= 11 E idade <= 18 então Profª Angelina V. Pseudocódigo Inicio Inteiro idade. SE (idade <= 5) então Escreva (“Deve ser vacinada”). Leia (idade). SE (idade >= 11) então SE (idade <= 18) então Escreva (“Adolescente”). Escreva (“Digite sua idade”).S. Se a idade for igual ou menos de 5 anos a criança deve ser INÍCIO vacinada. somente os números que vão de 11 a 18 são válidos.Melaré 63 . Escreva (“Digite sua idade”). Ficando excluídas as com idade superior a 5 anos. como nos exemplos abaixo: Exemplo 1: Receba uma idade qualquer e mostre uma mensagem de acordo com ela. Estes intervalos definem as faixas que estão enquadrados os valores. Pseudocódigo Inicio Inteiro idade. Nessa expressão pode ser usado o operador lógico E. Fim No exemplo anterior todos os valores menores que 5 seriam válidos. Receber IDADE F IDADE <= 5 V Mostrar “Deve ser vacinada” FIM .Intervalos Dentro da estrutura de decisão existe a definição de intervalos.. Elas podem ser definidas de diferentes formas. Fim Nesse programa apenas as pessoas que tiverem idade menor ou igual a 5 anos devem ser vacinadas. Já nesse exemplo. Leia idade. Exemplo 2: Receba a idade de uma pessoa e mostre uma mensagem de acordo com ela. Esse é um exemplo de intervalo que contém todos os valores menores ou iguais a 5. As pessoas que tem mais de 11 anos e menos de 18 são consideradas adolescentes.

&x). Pseudocódigo Inicio Inteiro idade. escreva ("reajuste : %g\n". Fim As faixas acima mostram claramente que há dois tipos de intervalo diferentes: um intervalo com valores menores de 18 e outro intervalo com valores superiores a 85.30. (x*x)) : printf("\nErro"). x!= 0 ? printf("\n Quadrado de x = %i". 1) /* O reajuste será de acordo com o salário. _sleep(2000). As pessoas que tiverem menos de 18 anos e mais de 85 não estão aptas a dirigir e devem ser alertadas com uma mensagem.Melaré 64 . escreva("Entre com o valor de x"). } Profª Angelina V. } #define escreva printf main() { int x. reajuste). Escreva (“Digite sua idade”). scanf("%i". de 30% */ zero aparece a mensagem Erro */ #define escreva printf main() { int sal = 1000. Se ela for verdadeira o resultado é a execução da expressão1. SE (idade < 18) então Escreva (“Não pode dirigir”). 2) /*Mostra o quadrado de um número Se este for maior que 2000 o reajuste será de diferente de zero. _sleep(2000). Sendo excluídos todos os valores internos da faixa. Se a condição for falsa o resultado é a execução da expressão2. Este tipo de intervalo pode ser definido com o operador lógico OU. senão. Estrutura: condição ? expressão1 : expressão2. SE idade < 18 OU idade > 85 então Operador Ternário Em C existe o operador ? (operador condicional) que facilita a verificação de sentenças simples (únicas). sal>2000 ? reajuste = 0. A condição é avaliada.10 : reajuste = 0. Leia idade.Exemplo 3: Receba a idade de uma pessoa e mostre uma mensagem de acordo com ela. SE (idade > 85) então Escreva (“Não pode dirigir”). Se o número digitado for 10%.S. float reajuste.

ou seja.. pare. pare. . caso <valor> : <instruções >.. Se não for usado o break o computador continuará dentro do switch executando as instruções dos outros case.Melaré 65 . Na linguagem C se faz a exclusão pelo comando break e somente pode ser usada essa estrutura para verificações de valores de uma variável do tipo inteiro ou caracter.valor n: case valor1. Nessa estrutura o computador fará um teste sucessivo. } O comando default é executado se nenhum valor for encontrado nos case anteriores. Dependendo da linguagem que for utilizada essa estrutura pode ser exclusiva. caso não seja nenhuma das opções anteriores: < instruções>. verificando o valor da expressão numa lista seqüencial de constantes. Pseudocódigo: verifique <variável> início caso <valor> : <instruções> . valor 3. ou seja. ou mesmo várias verificações ao mesmo tempo. Ao ser executado dentro do switch ele finaliza a seqüência de instruções do case e sai do switch. ao encontrá-lo ele executará o bloco de comandos que estão associados à constante.caso). O comando break serve como um desvio de execução.. fim do verifique ** tem linguagens que permite o teste de intervalo de valores como: caso valor 1. case <valor>: instruções. pare.. . O uso do default é opcional. quando for executado um caso. default: instruções. os demais serão excluídos....Seleção Múltipla As linguagens de programação possuem um comando exclusivo para seleção múltipla (verifique. Profª Angelina V. break. break. nas comparações ele não encontrar um valor verdadeiro. valor 7: Codificação em C: switch (variável) { case <valor>: instruções.. não existe teste de intervalos.S.

scanf("%i". Profª Angelina V. break. printf("Informe um valor inteiro").S. switch(num) { case 1:case 2:printf("Valor baixo").h> #include <conio.Exemplos: a) #include <stdio. break. break.Melaré 66 . case 5:case 8:printf("Valor alto"). Caso isso ocorra o computador executará as instruções do próximo case. } b) case ‘/’ : if( n2 = = 0 ) printf(“Não existe divisão por zero”). &num). else r= n1 / n2. } getch(). default: printf("Valor Invalido\n"). Curiosidade: Pode existir case sem instrução associada.c> main() { int num. break.

h> #include <stdlib. if (quantpro >= 60000) printf (“Produção Boa”).h> main() { float quantpro. SENÃO SE (quantpro > 40000) então Escreva (“Produção Regular”). if (numero > 0) printf (“Número Positivo”). scanf(“%f”. Veja a tabela abaixo: Produção Classificação maior ou igual a 60.. else printf(“Número Negativo”). &numero). } Ou.Exercícios Resolvidos 01) Faça um programa que classifique as máquinas conforme a produção de cabo para telefones..000 “Ruim” Pseudocódigo Início Real quantpro. printf(“\nDigite a quantidade produzida”).000 “Boa” menor que 60.000 e maior que 40. SENÃO Escreva (“Produção Ruim”). else if (quantpro > 40000) printf(“Produção Regular”). main() { int numero. if (numero < 0) printf(“Número Negativo”). else if (numero > 0) printf (“Número Positivo”).Melaré 67 . } Profª Angelina V. &numero). Leia quantpro.S. else printf(“Produção Ruim”). positivo ou nulo. SE (quantpro >= 60000) então Escreva (“Produção Boa”).000 “Regular” menor ou igual a 40. if (numero = = 0) printf(“Número Nulo”). } 02) Receba um número inteiro e classifique-o como negativo.&quantpro). if (numero = = 0) printf(“Número Nulo”). Essa classificação deverá ser exibida por uma mensagem. Fim Linguagem C #include <stdio. scanf(“%i”. scanf(“%i”. main() { int numero.

ou seja. de repetição. cont). &cont). &cont).h> main() { int cont=0. de forma que essas são variáveis locais ao bloco.h> #include <stdlib. printf("\nEndereco de cont %i\n". podem ser descritos dentro de uma estrutura condicional. Podemos ter várias variáveis com o mesmo nome no mesmo código fonte. &cont). printf("\nEndereco de cont fora do bloco %i". /* Exemplo do uso de variáveis de bloco e a exibição do endereço da memória*/ #include <stdio.S. } printf("\nValor do contador fora do bloco %i".Variáveis de Bloco Os blocos de instruções que são delimitados pelas {}. de acordo com a sua declaração. } Profª Angelina V. definidas e acessadas somente no bloco. Dentro desse bloco podemos definir variáveis locais a eles. printf("\n\tEndereco de cont do bloco %i\n". cont). getch(). printf("\nValor do contador %i". printf("\n\tValor do contador do bloco %i". cont). if (cont == 0) { int cont = 5.Melaré 68 . sendo todas variáveis distintas. entre outras.

então você usará a estrutura com condição. A estrutura que aprenderemos a partir de agora é usada para tornar automática a repetição de um programa inteiro ou apenas uma parte dele. loop na programação significa repetição. onde você gira. e gira e repete essa volta várias vezes. igual o loop de uma montanha russa. volta a executar um procedimento já executado. Com a repetição automática os programas tornam-se mais rápidos e ágeis. Um exemplo onde podemos usar esta estrutura é num programa que faz a exibição do número 1 até 300. Então. sejam elas pré-definidas ou não. você usará a estrutura de repetição pré-definida com contador. então. podendo ser ou não definida a quantidade de vezes que irá repetir. não existindo linhas de comandos idênticas repetidas. A estrutura de repetição pode ser pré-definida com contador ou condicional Quando for repetido um trecho do programa e já se souber a quantidade de vezes que ele será executado. Tome cuidado na hora da definição dos processos a serem repetidos. senão. Essa estrutura consiste em executar as instruções enquanto uma condição pré-definida for verdadeira.Melaré 69 . então a instrução para limpar a tela deve estar dentro do corpo do loop.Estrutura de Repetição Laço (Loop) Toda vez que você ler ou ouvir a palavra loop saiba que ela significa retornar. Símbolo de repetição no fluxograma Esse símbolo é usado para representar estruturas de repetição. Mas. quando não é conhecido de antemão o número de vezes a ser repetido um conjunto de instruções.S. a tela será limpa apenas uma vez. Se você quiser que a tela seja limpa toda vez que for exibida uma mensagem. Pode ser feita a repetição de apenas uma instrução ou de um conjunto de instruções. iteração. Profª Angelina V.

.faça Neste tipo de estrutura de repetição.... Existe a repetição pré-condição. com teste no início. Fim Fim Obs: Serão repetidas várias instruções. 1. Instrução. validação da condição.Enquanto / Repita. validação da condição. Instrução. Enquanto .Enquanto... ou seja. .Faça / Faça... não ocorrerá nenhuma vez a execução das instruções dentro do laço. com teste no final. Instrução2. Cuidado ao usar o Enquanto: Se na primeira vez a condição testada já for falsa. o bloco de instruções será repetido enquanto a condição testada no laço for verdadeira.Melaré . Instrução n. Quando ela se tornar falsa pára a repetição e o fluxo de execução passa para a próxima linha depois do laço. } 70 Profª Angelina V.. e a pós-condição.Estrutura de Repetição Condicional (Enquanto. torná-la verdadeira antes de testar. Estrutura em C while (condição) instrução. O que determina o término é o resultado da verificação de uma condição. ENQUANTO (condição) FAÇA Instrução. Instrução. ENQUANTO (condição) FAÇA Início Instrução. Faça ac ão d lidaç Va çã ondi o Condição N=3 ENQUANTO N < =20 INSTRUÇÕES Receber N Início . Fim Obs:Estrutura que repete apenas uma instrução INSTRUÇÕES Início .S. Repetição com Pré-condição. então.. while (condição) { Instrução1..até) Essa estrutura de repetição é usada quando a quantidade de vezes um determinado trecho do programa é desconhecida. Para que isso não ocorra é necessário fazer a validação da condição. O teste da condição é feito no início antes de começar o bloco de instruções que serão repetidos. por isso há a necessidade de haver um delimitador (inicio/fim) do bloco de repetição.

De forma.. Enquanto Nesta estrutura a execução das instruções ocorrerá pelo menos uma vez. Início Instrução..until. Instrução2. Instrução n. A diferença é que no repita.S.. a repetição é feito até a condição testada se torne verdadeira. Fim ENQUANTO (condição). Fim Profª Angelina V.2.enquanto. Repita Instrução1. .. . como a estrutura do Faça.. pois a condição que determina o fim da repetição está no final do bloco de instruções.até.. enquanto for falsa a condição continua repetindo a execução..até. ou seja.Faça. que no pseudocódigo representamos pelo repita. Instrução2..Melaré 71 .. Repetição com Pós-condição . que não é preciso validar a condição no início. Instrução. Essa estrutura também faz a verificação da condição no final do bloco de instruções.. Repetição com Pós-condição .Repita.Enquanto Na linguagem C existe o teste da condição no final do bloco de repetição: Faça .. Instrução n. Fim 3. Enquanto a condição testada for verdadeira será feita a execução das instruções repetidamente... até (condição). Faça Início Instrução1. Início .até Na linguagem Pascal existe o tipo de repetição Repeat.

} c) do { …. b) resp ‘s’.. Continue: ele encerra apenas a iteração atual do laço... Continue função Exit() Esses comandos são usados para se fazer um desvio na execução.. }while(num >0). Comandos Break. while (num >0) { . Profª Angelina V.Melaré 72 . O break e o continue são usados dentro de laços (for. } b) Exemplos em C resp = ‘s’. 4.. while (resp = ‘s’) { . qualquer valor diferente de 0 significa deu algum tipo de erro.não executa as instruções após ele voltando ao início da repetição.. Exit(): finaliza a aplicação. enquanto (resp = ‘s’) faça c) a) num = 1. Break: pode ser usado para terminar um case(switch) ou para forçar o término de um laço. fim enquanto (num >0).. Depois de encerrado o laço ele retorna para o comando seguinte fora do laço..... podendo retornar um valor. fim faça início . – primeiro faria o programa verificar o saldo para depois permitir o saque. Como você faria? – permite o saque quantas vezes quiserem e depois deduz do saldo Ou..S.. Exemplos de Pseudocódigo a) num 1. enquanto (num >0) faça início . .PENSE: Imagine a situação: Você tem que desenvolver o módulo de Saque para um Banco... while).

Enquanto Verdadeiro O valor 1 significa verdadeiro. &num). while (1) { scanf("%d".h> #include <stdlib. Se for usado o break no lugar do exit(0) ele irá finalizar a repetição e irá continuar o programa executando o _sleep(7000). Profª Angelina V. } _sleep(7000). Exemplo 1: para criar um loop infinito: while (1) { printf("Programação de um loop ").h> int main() { int num.5.Melaré 73 . if (num ==0) exit(0). } Exemplo 2: para criar um loop com a condição de término definida dentro do estrutura de repetição: #include <stdio. de forma que você pode colocar uma condição sem definição da expressão lógica. e as demais instruções que houverem após a estrutura de repetição.S. } Dica: O exit(0) irá finalizar o programa direto.

if ((nota < 0) || (nota > 10)) { printf("\nA nota digitada deve estar entre 0 e 10"). continue.h> #include <stdlib. Faça a consistência da nota.S. } system("pause"). scanf("%f". falta.Faça um programa que receba as notas e faltas de 2 alunos. while (cont <= 2) { printf("\nDigite a nota do aluno:"). &falta). } Profª Angelina V. #include <stdio. &nota). nota=0. cont++. scanf("%f".Melaré 74 . alertando quando for digitada uma nota inválida (menor que 0 ou maior que 10).h> main() { float cont=1. } printf("\nDigite a frequencia do aluno:").

Valor inicial: O valor inicial INSTRUÇÕES indica qual o primeiro valor a ser armazenado dentro da variável de controle. Essa variável pode Variável de repetição ser iniciada tanto com valores negativos Valor final como positivos. C CONDIÇÂO PARA <variável_controle valor inicial> ATÉ <valor_final> INC <incremento> FAÇA Instrução. quando ela se torna falsa o laço é finalizado. PRÓXIMO N Valor final: É através desse valor que é determinado o fim a repetição.S.Melaré 75 . Enquanto essa condição for verdadeira continua a INSTRUÇÕES repetição.Repetição Pré-Definida – Para Essa estrutura de repetição é usada quando é conhecida a quantidade de vezes em que uma determinada parte do programa será repetida. dependendo da forma Valor de Incremento que é feita a contagem e controle da variável: regressiva ou progressiva. REPITA N = 1. e dessa maneira torne falsa a condição testada. 1 Na linguagem C podem existir diversas variáveis de controle. Na linguagem C o que existe no lugar do valor final é uma condição. PARA variável_controle DE valor inicial ATÉ valor_final PASSO valor_incremento FAÇA Instrução. 20. de maneira que essa variável saia do valor inicial e atinja o valor final. Incremento ou decremento: O incremento ou decremento é um valor ou uma fórmula que muda o valor da variável de controle. Variável de controle ou Variável Contadora É através dessa variável que se Valor inicial controla a repetição. Profª Angelina V. Essa parte pode ser formada por uma ou várias instruções.

cont <=10.. } Dicas: • • O break encerra o laço a qualquer momento. Instrução 2 . b) for (cont =10. condição que define o fim do laço. ou. n1+n2 < 10. _sleep(500). cont ++) printf(“Ordem crescente: %i”. atraso < 100. ) printf(“Oi!”). condição que define o fim do laço. • • • Profª Angelina V. for (atraso =0 . n2=1..S. Instrução n.). podendo ser feito um laço infinito. for (variável de controle = valor inicial. Para isso ele não deve possuir nenhuma instrução associada a ele. cont). . cont >=1.6. cont). } Exemplos: a) for (cont =1.Melaré 76 . system(“cls”). for (n1=1. O laço for pode ser usado para criar um atraso de tempo. for ( . . fazendo um novo ciclo. cont --) { printf(“Ordem decrescente: %i ”. n1++. valor do incremento ou decremento) instrução. valor do incremento ou decremento) { Instrução 1. O uso de mais de uma variável dentro do for deve ser feito com o uso da vírgula (. atraso++). n2++) Não é obrigatória a definição dos três parâmetros. O continue faz com que o laço seja finalizado sem executar as instruções abaixo e volte ao início. Estrutura em C for (variável de controle = valor inicial.

for (cont=1.. Quando isso ocorrer a repetição pára e será iniciada uma nova seqüência de comandos definidos fora da repetição. Depois é verificado o valor da variável com o valor final pré-definido (200). 5.S. Executa o bloco de instruções. cont. mais 1 de agora.h> Ou main() Enquanto o valor de cont for menor ou igual a 200 repete { int numiden. 2. após o bloco de comandos. Repetindo todo o processo várias vezes. No exemplo acima inicialmente é feita a atribuição do valor 1 a variável de controle com o valor. que contém a entrada do número de identificação. 3. Se for falsa já finaliza (mesmo se nunca executou o código dentro do bloco de comandos).cont <=200. o valor da variável de controle atinja o valor maior que o definido no intervalo (201). Até que . PARA cont l ATÉ 200 INC cont cont +1 FAÇA Início Escreva (“Número de identificação do funcionário:”).. system(“pause”). } } Explicação: 1. cont <1 .Cuidado: Se a condição a ser testada já inicia sendo falsa.Melaré 77 . for (. cont++) Cadastre o número de identificação das 200 peças. 4.cont++) { printf (“Número de identificação do funcionário”). se ela for Verdadeira inicia a execução do código que está no bloco. as instruções dentro do laço nunca serão executadas. Profª Angelina V. Em seguida é feita a verificação da condição que determina o fim da repetição. Leia (numiden). a variável passa a ter o valor 2).h> Repete até que o valor de cont fique maior que 200 #include <stdlib. Fim Fim Linguagem C Condição de término da repetição: #include <stdio. como no passo 2. cont. scanf (“%i”. No final da execução do bloco é automaticamente adicionado ao conteúdo da variável de controle o valor 1 (anteriormente valia 1. int cont = 100. Início int numiden. &numiden).

• • • todas as variáveis acumuladoras devem ser zeradas no início do processo. controles. se houver a necessidade de acumular o valor de uma variável. Somanota + Nota. usa-se a variável acumuladora. incrementando o seu conteúdo com o valor 1. ou mesmo. Mas. ContPessoas + 1. o conteúdo de uma variável acumuladora deve ser incrementado com o valor de outra variável. Esse recurso de programação é usado em programas de cadastro. onde elas são incrementadas não pelo valor 1. o número de peças com defeito. um determinado fenômeno. para a variável acumuladora ser incrementada várias vezes ela deve ser colocada dentro de um laço. Através dessas variáveis é possível contar o número de pessoas cadastradas.Melaré 78 . o conteúdo da variável contadora deve ser incrementado com o valor de uma constante (normalmente o valor 1). então.Variáveis Contadoras e Acumuladoras Variáveis Contadoras: É o nome dado a uma variável numérica que tem a função de "contar" valores. Cuidados: • • Variáveis Acumuladoras: Para cada situação deve-se usar uma regra. Cuidados: • todas as variáveis contadoras devem ser zeradas no início. um procedimento. mas sim pelo valor de outra variável. ocorrências. Quando se faz a contagem de algum dado usa-se a variável contadora.S. Profª Angelina V. Exemplo: ContPessoas Exemplo: Somanota Variável Contadora = Variável contadora + cont++. para a variável contadora ser incrementada várias vezes ela deve ser colocada dentro de um laço. pesquisa. 1 Variável Acumuladora = Variável acumuladora + valor de outra variável Soma += nota.

Na linguagem C existe a função principal main().Melaré 79 . Esses parâmetros estabelecem a comunicação bidirecional entre o subalgoritmo e o algoritmo que o chamou. . A lista de parâmetros é separada por vírgula. } Profª Angelina V. também chamadas de módulos ou subprogramas.. se a função for criada para fazer uma adição ela pode ser chamada de soma(). float nota2) { float media.S. return media. por exemplo. corpo da função. A linguagem C é formada por funções. O corpo da função contém todas as instruções que deverão ser executadas pela função. O tipo_de_parâmetro e o seu nome são respectivamente o tipo e o nome da variável que serão passados para a função. Sub-Rotinas (Módulos) As sub-rotinas. 2. como printf(). A chaves de abertura { marca o início da função e a chaves fechada } marca o final da função. Uma função pode não ter parâmetros. Declaração da Função tipo_de_retorno nome_da_função (tipo_de_parâmetro nome_do_parâmetro.. que são incluídas através da diretiva #include (já explicada anteriormente). float) que a função retornará através do return. Os tipos podem ser inteiros (int). As variáveis locais são variáveis declaradas dentro (internamente) da função onde serão usadas e somente são conhecidas (visíveis e acessíveis) pela função que as criou. Se não especificado o tipo o compilador assume um retorno inteiro.) { declaração das variáveis locais. char (caracter) ou mesmo void (não retorna nada). scanf().. system(). são trechos de instruções que realizam tarefas específicas e que podem ser realizadas diversas vezes durante a execução do programa. retorno. O compilador procura pelo nome da função para fazer o desvio de execução. reais (float). Desta forma é possível focalizar a atenção em um problema de cada vez. Ao ser decomposto um programa em subprogramas ou sub-rotinas este tem sua complexidade também dividida. Exemplo: float media_notas (float nota1. media = (nota1+nota2)/2. fazer os programas ficarem mais organizados e menores. A linguagem C possibilita o uso de sub-rotinas por meio das funções. Ele deve estar entre chaves { }. } O tipo_retorno especifica o tipo de valor (int. O nome_da_função é o identificador da função. e a partir desta as outras rotinas são executas. Através dele é possível saber o que a função executará. que é sempre a primeira rotina executada.SubAlgoritmos/ Modularização 1.

caso contrário ocorreu algum erro. } Profª Angelina V. Esse valor pode ser usado pelo sistema operacional para verificar se a execução do programa foi bem sucedida.string informadas %s". return 0. Veja a explicação no exemplo a seguir: Na linha de comando serão passados o nome do programa e 2 números inteiros.3.main() Por padrão a função main() deve ser do tipo inteiro. argv[0]). Quando o valor retornado é zero 0 significa que a execução foi bem sucedida. argc). que depois podem ser processadas. } _sleep(3000). A função principal . return 0.Melaré 80 . 8 e 27. while (i< argc) { printf("\n%d . o nome do programa. int main() { return 0. char *argv[]) { int i=0. como: ANGELINA 8 27 O programa ANGELINA iniciará executando a função main() que estará recebendo 3 argumentos. _sleep(3000). argc). argv[i]). printf("Nome do programa %s". } A função principal pode receber vários valores (argumentos) quando executada. Exemplo 1 : int main(int argc.S. Para que ele possa receber esses valores foi definido da seguinte maneira: Contém o total de argumentos passados (lembre do c como contador) É um ponteiro de uma matriz de caracteres. } Exemplo 2: int main(int argc. ou seja seu retorno é um valor inteiro. printf("Total de argumentos passados %i". i++. char *argv[]) { printf("Total de argumentos passados %i". char * argv[]) No caso acima o argc teria o valor 3 e o argv a matriz formada por ANGELINA. Cada elemento está direcionado para um argumento int main (int argc. o número 8 e o número 27. argc.

O void na definição do tipo de função é obrigatório void entrada(void) { system(“cls”). char *argv[]) { int i=0. _sleep(3000). Tipo Void • Todas as funções que não devolvem valores devem ser declaradas como tipo void.Subtração \n”).Multiplicação \n”).Adição \n”). printf(“\n\n\n”). • retornar um valor para outra função 5. Exemplo: void entrada(void). system(“pause). deve ser colocado o void entre parênteses.. por isso o uso do tipo void na especificação das funções.. printf(“<1> . printf(“<5> .Melaré 81 .S. } Profª Angelina V. } O void no parâmetro é opcional.. retornando a função anterior. if (atoi(argv[1]) > 0) printf("\nNumero positivo").Exemplo 3: int main(int argc. rotinas de criação de ela ou rotinas de exibição de dados. printf(“<2> . • Quando uma função não tem parâmetros.Sair \n”).Divisão \n”). main() { entrada(). Muitas rotinas são específicas e independem dos valores de variáveis de outras rotinas. As funções podem ser usadas como rotinas de entrada. • Quando não existe um retorno o tipo de função é void. printf(“<4> . return 0. Comando Return Tem duas formas de uso: • ele provoca uma saída imediata das função que o contém. . printf(“<3> . } 4.

Os tipos de variáveis devem ser iguais... então a variáveis definidas para recebê-los também devem ser inteiros.S. o fluxo de execução é desviado para ele. . Definição do Protótipo tipo_de_retorno nome_da_função (tipo_de_parâmetro nome_do_parâmetro.. se foram enviadas duas variáveis (argumentos) – exemplo nota1 e nota2 – devem ser definidos na função a ser executada duas variáveis (parâmetros) para estar recebendo os conteúdos das variáveis. pois os mesmos são definidos no início da função. Protótipos de Funções O protótipo da função foi acrescido com o padrão C ANSI.} são argumentos (enviam) são parâmetros (recebem) Os argumentos enviados para a função devem ser compatíveis com os parâmetros. main() n1 e n2 { nota1 e nota2 float n1. que podem ser usadas na outra função.. ou seja. Durante o acionamento da função. O protótipo da função deve ser usado quando a função for definida após a função principal main(). float nota2). Exemplo: float media_notas (float nota1. se os dados enviados são inteiros. 7. float nota2) { . e logo após sua conclusão. … } float media_notas (float nota1. Chamada (ativação) da Função A chamada de função existe quando há uma referência de uma função dentro do programa. Esses argumentos são valores de variáveis. antes da função principal main()..Melaré 82 . float nota2)..) float media_notas (float nota1. n2). ou seja. o fluxo de execução retorna a linha de origem (a que o desviou).6.media. podendo estar no meio ou no final.n2. media= media_notas (n1. Profª Angelina V. Não são definidos os tipos de dados dos argumentos. Ele é um cabeçalho que indica ao compilador a existência de uma função dentro do programa. Na linha de chamada da função pode haver o envio ou não de argumentos para outra função. main() { } ** Se a função for descrita no início do programa. não precisa ser feito o seu protótipo.

n2). } float media_notas (float nota1. Classes de Armazenamento de Variáveis • Variáveis Globais: São variáveis definidas fora de qualquer função específica. return media. } //protótipo da função // início da função principal // definição das variáveis locais // chamada da função media_notas() // fim da função principal // declaração da função media_notas // definição das variáveis locais //retorna o resultado da média para a função principal // fim da função media_notas() ** A função media_notas() é do tipo float porque o retorno dela será uma variável do tipo float (media). &n2). n2. Essas variáveis são definidas como extern. no início do programa. • • Variáveis Locais: São variáveis declaradas dentro de uma função específica e são visíveis apenas na função em que foram criadas. printf("\n Este programa calcula a média de duas notas"). media = (nota1+nota2)/2. printf("\n\n Segunda nota").Melaré 83 . Exemplo Completo de Função #include <stdio. printf("\n\n A média das notas é %. ** Os parâmetros (nota1 e nota2) são do tipo float porque seus respectivos argumentos (n1. media. 9. antes da função principal. Funções distintas podem ter variáveis locais com o mesmo nome. Isso pode ser alterado se você definir a variável como estática. &n1). float nota2).8. Elas são inicializadas com zero. a variável local será visível apenas na função que a cria e a variável global será visível por todas as funções existentes no programa. caso o programador não as inicialize.2f \n". Essas variáveis são automáticas definidas e são definidas como auto. main( ) { float n1. printf("\n\n Primeiro nota"). scanf("%f". Elas não são inicializadas com zero. Então.h> float media_notas (float nota1.h> #include <stdlib.S. scanf("%f". system("pause"). Profª Angelina V. Elas poderão ser manipuladas por qualquer função e parte do programa e seus endereços e alocações de memória permanecem até o final do programa. media).ou seja ficam ocupando espaço.n2) são do tipo float. Quando a função é iniciada as variáveis locais são criadas e quando essas funções são finalizadas as variáveis locais são destruídas e liberados os endereços de memória. media= media_notas (n1. float nota2) { float media.

printf("\nValor do contador %i". } void contador () { static int cont=0. } *** Perceba que a inicialização somente ocorre a primeira vez que a função é executada.h> #include <stdlib.h> void contador (). Profª Angelina V.• Variáveis Estáticas: essas variáveis são visíveis e definidas internamente dentro de uma função (localmente). • Register: as variáveis definidas como register são armazenadas num registrador do processador e não na memória RAM.Melaré 84 . Dessa maneira é aumentada a velocidade de processamento. cont++). _sleep(2000). já que não precisa do acesso a memória. mas não perde seu valor depois de finalizada a função. contador(). mas não pode ser usada por outros arquivos fontes.S. contador(). main() { contador(). Também existe a static definida fora da função que pode ser usada em qualquer parte do códigofonte atual. Isso quando for usada uma estrutura de projetos. Essas variáveis devem ser int ou char. /* Exemplo do uso de variáveis estáticas*/ #include <stdio.

No exemplo abaixo vemos que o valor mostrado da variável num a primeira vez (na função main()) é diferente do valor mostrado na função quadrado(). #include <stdio.2f \n". ** A função quadrado() é do tipo float porque o retorno dela será uma variável do tipo float (num). Isto ocorre porque são passados para a função apenas os valores dos parâmetros e não os próprios parâmetros. qd). //retorna a função que a chamou retornando um valor (num) que será } atribuído a variável qd. Profª Angelina V. ** O parâmetro (num) é do tipo float porque o argumento (num) é do tipo float. O valor da variável num é alterado na função quadrado().&num). Exemplo: Programa que calcula o quadrado de um número qualquer. printf ("Na função QUADRADO a variável num vale %. return num. } float quadrado(float num) //declaração da função quadrado() e do { parâmetro num num = num*num. mas permanece inalterada na função main(). system(“pause”). //protótipo da função quadrado() main() { float num. scanf ("%f". qd= quadrado(num). qd. Essa passagem de parâmetro é denominada Passagem de Parâmetros por Valor. num).S. os parâmetros dessa função copiam os valores dos argumentos que são passados pela função que a chama.2f é = %.Melaré 85 . são duas variáveis diferentes. Os valores dos argumentos não são alterados fora da função que os criou. printf ("Na função MAIN a variável num vale %.num.2f \n". usando função.2f\n". //chama a função quadrado() e envia o argumento num printf ("O quadrado do %.h> float quadrado (float num).h> #include <stdlib.Função com Passagem de Parâmetro por Valor Quando uma função é chamada. num). //declaração das variáveis locais printf ("Entre com um numero: "). pois.

se o aluno está aprovado. printf("\n\n Digite o valor do primeiro número"). _ uma função que calcule a média. n1=ler_nota(). // chamada da função soma() printf("\n\n A soma de %.total). n2. #include <stdio. printf("\n\n Digite o valor do segundo número"). total=soma(n1. res= a+b. n2). printf("Segunda prova : "). pausa(). n2. void pausa(void). scanf("%f". /* protótipos das funções*/ float calcula_media(float p1. med=calcula_media(n1. n2). med. _ uma função que receba a nota do aluno e faça a consistência. return(res). exibe_resultado(med). main() { float n1.Exercícios Resolvidos 1) Faça uma função que calcule a soma de dois números recebidos na função principal. float p2). _ uma função que exiba o resultado. float b) { float res. } ] 2) Elabore um programa que tenha as seguintes funções: _ na função principal deve ser recebidas pedidas duas notas e feitas às chamadas de funções. printf("Primeira prova: ").h> float soma (float a. scanf("%f". n1.h> float ler_nota(void). float b).h> #include <stdlib. system("pause"). } // fim da função principal float soma (float a.Melaré 86 .2f \n".h> #include <stdlib. reprovado ou em exame. } // definição da função soma // definição das variáveis locais // retorna o resultado da soma dos números enviados // fim da função soma() Profª Angelina V. // protótipo da função soma main( ) // início da função principal { float n1.2f com %. // definição das variáveis locais printf("\n Este programa calcula a soma de dois números"). #include <stdio. total. &n2). n2.2f é %. n2=ler_nota(). &n1).S. void exibe_resultado(float med).

if (med < 3.0) printf("Número Inválido! Redigite. /* Calcula a média*/ return(res). res = (p1 + p2) / 2. med).0 || n>10.:"). } 3) Exemplo completo de validação de dados. } Profª Angelina V. else if(med >= 7.0) printf("Aluno em exame\n").0 && med < 7.0 || n>10.0). } int caracterminusculo(char ch) { return (ch >= 'a' && ch <= 'z'). } int digitonumerico(char ch) { return (ch >= '0' && ch <= '9').Melaré 87 . } void pausa(void) { system(“pause”). sem usar a função atoi() ou atof(). int caractermaiusculo(char ch) { return (ch >= 'A' && ch <= 'Z'). }while (n<0.0) printf("Aluno aprovado\n").1f: ". system(“cls”). return(n). do { scanf("%f".float ler_nota(void) { float n.0) printf("Aluno reprovado\n"). &n). float p2) { float res.. } void exibe_resultado(float med) { printf("Media %. } float calcula_media(float p1. if (n<0.S. else if (med >= 3.

else if (caracterminusculo(c) == 1) puts("Caracter Minusculo\n"). } system("pause"). if (digitonumerico(c) == 1) puts("Valor Numerico\n"). } Profª Angelina V.S. else puts("Caracter especial\n"). return 0.int main(void) { char c. putchar(c).Melaré 88 . while(1) { c=getch( ). else if (caractermaiusculo(c) == 1) puts("Caracter Maiusculo\n").

num--. As variáveis locais de chamadas recursivas são independentes entre si. } Usando função recursiva direta #include <stdio.h> #include <stdlib. printf("Informe valor").Melaré 89 . Por exemplo. _sleep(2000). else { do { r_fatorial *= num. scanf("%i". if (num == 0) r_fatorial = 1. como se tivessem chamando funções diferentes. r_fatorial = 1. } printf("O fatorial desse numero e %i". /* N! = N * (N-1)! 4! = 4 * 3* 2 * 1 4! = 4 * 3! 3! = 3 * 2! 2! = 2*1 ! 1!= 1 Se N! for 0 o resultado é 1 Senão. N * (N-1) */ #include <stdio. scanf("%i". r_fatorial. para calcular o fatorial de um número pode ser feita uma função e ela precisar chamar a si mesma (forma direta). Profª Angelina V.S. &num). Quando uma função chama outra e depois essa outra chama a que a chamou é definida como função recursiva indireta. r_fatorial).h> int f_fatorial(int num). main() { int num. }while (num !=0).Funções Recursivas Essas funções têm esse nome por poderem chamar a si mesmas de forma direta ou indireta. &num). Exemplo: Calculo do fatorial de um número qualquer. printf("Informe valor: ").h> #include <stdlib.h> main() { int num.

Profª Angelina V. } int f_fatorial(int num) { if (num == 0) return 1.tem o return 2 * f_fatorial(2-1) *** não retorna.na função testa o valor .veja que agora tem o return 1 -.S. pois primeiro tem um função a ser executada.na função testa o valor .envia o argumento 0 (do calculo anterior 1-1) .tem o return 1 * 1 --esse também retorna o valor calculado 1 ao passo A. como se tivessem chamando funções diferentes.printf("O fatorial desse numero %i". } As variáveis locais de chamadas recursivas são independentes entre si. _sleep(3000).na função testa o valor . Simulação da execução: Fatorial do número 2 A). C) . B) -envia o argumento 1 (do calculo anterior 2-1) .tem o return 1 * f_fatorial(1-1) *** não retorna.envia o argumento 2 . que calcula return 2 * 1 e retorna o valor 2 a função principal e exibe o resultado.esse retorna o valor 1 passo B . f_fatorial(num)). pois primeiro tem um função a ser executada. else return num*f_fatorial(num-1).Melaré 90 .

Exemplo: float medias[45]. variáveis indexadas. . 2. Estes bytes são reservados de maneira contígua. 0 2.A linguagem C reservará 180 bytes (45 x 4). float. Uma string (cadeia de caracteres) é um vetor de caracteres. O índice 0 contém o primeiro elemento armazenado. unidimensional).5 char nome[4].5 3 3. A N A int notas[4]. Conceito • • • • • • • Os vetores são matrizes unidirecionais homogêneas e podem ser chamadas de: arranjos unidimensionais. O vetor é um mecanismo de estruturação de dados usado para representar variáveis do mesmo tipo de dado. Os vetores são variáveis indexadas por apenas um índice (uma dimensão.Melaré 91 .5 1 4. 6 3 10 // vetor com 4 elementos do tipo caracter (string) ###BOT_TEXT### //vetor com 4 elementos do tipo inteiro 5 3. qual tipo de conteúdo será armazenado na variável. char. O elemento do vetor é acessado por meio de um índice.S. que são referenciados pelo mesmo nome e cada elemento através de sua posição dentro dela. são 45 variáveis do tipo float. O endereço mais baixo corresponde ao primeiro elemento e o mais alto ao último. Declaração: A declaração de um vetor pode ser feita da seguinte maneira: tipo_da_variável nome_da_variável [tamanho]. Exemplos: float media[10].5 2 6.Vetores 1. ou seja.5 // vetor com 10 elementos do tipo real 4 10 5 8 6 7 7 5.5 8 6 9 8. onde cada float ocupa 4 bytes. variáveis compostas homogêneas unidimensionais ou arrays. Profª Angelina V. etc). Onde: • tipo_da_variável é o tipo base do vetor (int. Consiste em locações contíguas de memória. • tamanho_da_variável é a quantidade de elementos que o vetor armazenará. ou seja.

Na linguagem C os índices iniciam no 0 e finalizam valendo o tamanho do vetor -1. i<100. Exemplo: float media[10].8. devendo ser colocados entre colchetes. Por isso quando for feita a entrada de uma string não se pode colocar o &. Para isso acessamos os elementos do vetor. O armazenamento pode ser feito separadamente ou em conjunto. seu conteúdo não está vinculado com os outros. ou seja.4.5}.3. i++ ) printf( “%i”.5. Para acessá-lo eu preciso de uma referência a mais do que somente seu nome. Armazenando os elementos Para ser feito o armazenamento no vetor é necessário de definir seu nome e em qual posição deverá ser armazenada (qual índice). Exemplos a) Recebendo elementos de um vetor do tipo inteiro digitados via teclado for ( i=0.7. 6.5.5. i++).7.Melaré 92 . A primeira média será armazenada na posição 0 do vetor e a última será na posição 9.5. acessa o terceiro elemento do vetor. é preciso saber onde se localiza o elemento dentro do vetor.6.5.6. ou seja.6.5 3.5.5 6 8. 5.6. } b) Mostrando os elementos de um vetor na tela: for ( i=0. de uma vez só.5}.5. acessa o último elemento do vetor. media equivale ao endereço inicial do vetor (media[0] é igual a media).5 10 8 7 5.5. Profª Angelina V. scanf( “%i”.5. pense que o primeiro elemento dá início ao vetor. media[1] = 4.5.8.5 6. &vet[i] ).5.10. vet[i] ). float media[10]= {2.5. Endereço do vetor ou matriz unidimensional Quando se refere ao endereço do vetor.10. i<100.8.4. float media[]= {2. através de um índice.8.S.4. individualmente. Ao declarar um vetor você coloca o tamanho total. ** Cuidado: Não se esqueça que o índice sempre inicia no 0.5 media[0] media[9] media[2] acessa o primeiro elemento do vetor.5.5. Acessando os elementos Cada elemento do vetor é um elemento individual.3. Veja os exemplos abaixo: media[0] = 2.5 4. i++ ) { printf(“Digite %i elemento do vetor”. 0 1 2 3 4 5 6 7 8 9 2.

i).".c) Inicializando um vetor com zeros for ( i=0.S. printf("%i\n". //definição do vetor int i. verificando dessa forma o desempenho dos alunos. main() { int x[10]. Exercícios Resolvidos: 1) Crie um vetor com 10 elementos do tipo inteiro e depois armazene automaticamente os valores de 0 a 9. } 2) Crie um vetor com 10 elementos do tipo inteiro e depois armazene automaticamente os resultados da tabuada do número 2.&notas[i]). i<100.i++) { printf("Digite a nota do aluno %d: ". int t. scanf("%f". main() { int notas[35]. } 3) O professor de Programação de Computadores precisa de um programa que calcule a média geral da sala. system("pause").Melaré 93 . O programa deve receber e armazenar as notas dos 35 alunos e calcular a média geral da sala. i ++) //definição do laço para gerar o vetor x [i] = i. 7. soma=soma+notas[i].t<10. i++ ) valores[i] = 0.t++) { r[t]=t*2. } Profª Angelina V. //definição da variável para controlar o índice for (i = 0. //atribuição do valor da variável i ao vetor x system(“pause”). for(t=0. main() { int r[10].i<5. } system("pause").soma/5). for(i=0. i < 10.soma =0. } printf("Media das notas: %f.r[t]).i.

Exemplo: Faça um programa que receba um texto e depois mostre quantas vogais foram digitadas. texto[i] != '###BOT_TEXT###'. gets(texto). pois.’a’}.’a’. Para declarar a string. } printf ("Total de vogais: %i\n". Ao usar esse tipo de vetor deve-se tomar cuidado para o fato de que as strings têm o seu último elemento como caracter null (###BOT_TEXT###).t. Cada caracter é um elemento independente e pode ser acessado de um índice.h. d) char mensagem[10] = “Exemplo”.’n’. &nome) recebe apenas o primeiro nome. int vogais=0.Melaré 94 . a função se encarrega de separar cada caracter na sua respectiva posição dentro do vetor ou matriz. } Profª Angelina V.S. Existem bibliotecas e funções especiais para o tratamento e manipulação de strings.Vetor String (Cadeias de Caracteres) Na linguagem C não existe o tipo de dado string.’c’. apenas uma string. Exemplo: gets(nome). Função gets() A função gets() é usada para receber uma séria de strings. Cuidado: não coloque o índice do vetor. printf ("Digite um texto\n"). que podem ser separadas. for (t=0. ignorando o sobrenome. main() { char texto[10]. b) char nome[] = {‘b’.t<10.t++) { if (texto[t] == 'a' || texto[t] == 'e' || texto[t] == 'i' || texto[t] == 'o' || texto[t] == 'u') vogais++. devemos declarar sempre um elemento a mais para o terminador. Exemplos de declaração e atribuição: a) char nome[7]. Armazenamento e entrada de strings Função scanf() A função scanf(“%s”.t++) // ou for (t=0.’i’. digitadas. O cabeçalho padrão é string. dessa forma é necessário criar um vetor de caracteres para armazenar uma cadeia de caracteres (string). Quando o usuário pressionar o espaço ele finaliza essa string. Então a função scanf() é usada para receber uma palavra. com ou sem espaço. vogais). system ("pause").

gets(nome). sobrenome). scanf ("%s". } Função strcat() União de variáveis string main() { char nome[40]. printf(“O tamanho do nome é: %i\n”.2f". strlen(str)). A atoi() converte a string para um valor inteiro. use uma dessas funções. float fnum2. nome). fnum2). inum1= atoi(num1). sobrenome). Cuidado com o valor informado se for usado o atoi ele somente aceita o valor inteiro e ignora a parte decimal. sobrenome[15]. scanf ("%s". Exemplo: 287.Melaré 95 .455 somente aceita o 287 Uma string inválida retorna na conversão o valor zero. printf("\nInforme o valor"). strcat(nome. printf("\nInforme o valor").h> #include <string. printf ("\nEntre com um sobrenome: "). fnum2= atof(num2). int main() { char num1[3]. Dica: Quando você quiser que não trave o programa na entrada de dados. } Funções: atoi(). A atof() converte para um número ponto flutuante. gets(num1).Função strlen() Retorna o tamanho da string #include <stdio. int inum1.S. _sleep(3000). de forma que o usuário informe uma letra no lugar de entrar com o número.inum1. printf ("\nO seu nome é %s \n". } Profª Angelina V. int i. num2[3].h> #include <stdlib. printf(“Digite seu nome: ”). gets(num2).h> main() { char nome[40]. printf("\nOs numeros validos informados sao %i e %. printf ("\nEntre com um nome: "). atof() Essas funções fazem a conversão de uma string em um valor numérico. strcat(nome. nome). " ").

main() { char senha1[10]= "Fatec". retorna um valor negativo. break. } Função puts() é usada para mostrar uma única string por vez. while(i<20 || !achou) //poderia ser ! (achou == 0) { if (!strcmp(nomes[i]. mas com a vantagem de pular a linha automaticamente. //aparece c itu – a partir do índice 4.senha2) == 0 ) printf ("\nSenha válida"). } else i++. //aparece Fatec Itu puts(&senha1[4]). printf("Redigite sua senha: "). } Ou int i=0. printf("Informe sua senha:"). string_pesq) != NULL) break.Melaré 96 . senão. puts("Senhas cadastradas\n"). Ela recebe e compara duas strings.S. printf("\nCadastro de senha\n"). char nomes[20]. senha2[10]. if ( strcmp(senha1. puts(senha1). } Função strstr() procura uma string dentro de outra string Exemplo: if (strstr(string_lida. main() { char senha1[10].Função strcmp() é usada para comparar strings. valor) { achou = 1. senha2[10]= "Fatec Itu". //aparece Fatec puts(senha2). getch(). i =0. Essa função retorna 0 se as duas forem iguais.senha2) < 0 ) printf ("\nA primeira senha e menor"). gets(senha1).senha2) >0 ) printf ("\nA primeira senha e maior"). se a primeira string for maior que a segunda retorna um valor positivo. if ( strcmp(senha1. else if ( strcmp(senha1. senão. gets(senha2). Profª Angelina V. gets(nome_pes).

if (strchr(nome. colocando o caractere de controle “###BOT_TEXT###” apenas quando for pressionada a tecla <Enter>. TAMANHO. if (strstr(nome. Para utilizar esta função.. é preciso informar três parâmetros.. stdin). 'a')) printf("O nome possui o caracter a"). else printf("O nome não possui o caracter a"). "Ana")) printf("O nome possui o Ana").Melaré 97 .. stdin).S.Função strchr() procura um caracter dentro de uma string Exemplo com as duas funções de pesquisa: int main() { char nome[20]="Ana carolina". fgets(NOME... Profª Angelina V. 20. Ela aceita caracteres em branco no meio do string. sendo o nome da matrizstring. puts("Informe seu nome .: "). return 0. o seu tamanho e o nome do buffer em uso: fgets(VARIAVEL. } Função fgets() A função fgets() efetua a leitura de dados do tipo string fornecidos via teclado delimitando seu tamanho. else printf("O nome não possui o Ana"). getchar()...

4. Armazenando os elementos A inicialização e armazenamento de uma matriz pode ser individual ou coletivo.5. 16. pontos_jogos [1] [3] = 60 int i[10] = { 1. cujo próximo elemento está no endereço seguinte da memória. Para calcular o espaço de memória necessário para armazenar a matriz é necessário fazer o seguinte calculo: int pontos_jogos [2] [4]. Matriz transposta: é quando temos uma matriz de origem m x n e a transposta é n x m 1.Matriz Segundo Giovanni e Bonjorno: Matriz é o conjunto ordenado dos números que formam uma tabela. ou tipo nome [linha] [coluna]. 6. Na matriz bidimensional o primeiro índice indica a linha e o segundo a coluna.1] 1 2 3 pontos_jogos [1. 3. qtd de linhas * qtd de colunas * qtd do tipo (inteiro) tamanho = 2 * 4 * 2 tamanho = 16 Lembre-se que internamente essa matriz tem seus valores armazenados linearmente. cada elemente armazenado em um endereço. 7. Exemplos: 1) char tabela[5][5]. Os índices iniciam no zero(0). Declaração: A declaração de uma matriz bidimensional pode ser feita da seguinte maneira: tipo nome [dimensão1] [dimensão2]. 4. de forma continua na memória.S. 7} . Como nos exemplos abaixo: • • • • • pontos_jogos [0] [1] = 5. 2.3] 3. 10}. 2) int pontos_jogos [2] [4]. int quadrados[5][2] = {1. 9. onde cada número é um elemento.Melaré 98 . 3. 8. 4. 0 0 1 pontos_jogos [0. Profª Angelina V. 9. 4. 2. 1. Matriz Bidimensional A linguagem C permite que seja declarada uma matriz bidimensional (variável composta homogênea bidirecional) ou mesmo multidimensional. 5. 8. 2}}. 25}. 2. float nota[2][3] = {{9. 5. {6.

4. Armazenamento feito via teclado A leitura e armazenamento dos elementos de uma matriz via teclado deve ser usando uma estrutura de repetição (laço). O for é o mais usado. Supondo que a matriz foi declarada como: int mat [2] [3]; O laço da linha (1ª dimensão) inicia no 0 e finaliza no 1 e o laço da coluna (2ª dimensão) inicia no 0 e finaliza no 2.

for (l=0; l<2; l++) { for (c=0; c<3; c++) scanf (“%i”, &mat[ l ] [c ]); }
5. Mostrando os elementos Para mostrar os valores armazenados dentro de uma matriz também é usada a estrutura do for. Para exibir a matriz mat declarada acima.

for (l=0; l<2; l++) { for (c=0; c<3; c++) printf (“%i”, mat [ l ] [c ] ); }

Profª Angelina V.S.Melaré 99

Ponteiros
1. Variáveis ponteiros Uma variável ponteiro é um tipo especial de variável, que tem como conteúdo um endereço de memória de outra variável, esse endereço é em hexadecimal. O tipo dessa variável ponteiro deve ser o mesmo tipo da variável para a qual está apontando, por exemplo se ela estiver apontando para um endereço de uma variável cujo conteúdo é float então ela (a variável ponteiro) deve ser definida como float. Para trabalhar com ponteiros é usado os operadores unários & e * antes da variável. O formato de exibição usado na função printf() pode ser %p, %x, u %X, a diferença é apenas quanto ao formato de exibição. Definição e declaração do ponteiro Define o tipo da variável e do ponteiro dessa variável

int *p, v; O que define que a variável é um ponteiro é o * antes do nome. O * também poderia estar junto com o tipo: int* p.
Atribuição do endereço ou direcionado o ponteiro O endereço de memória da variável v é armazenado no ponteiro p

p = &v; int main() { int *p, v; v= 8; p= &v; printf("\nO endereco de v e %p", &v); printf("\nO conteudo do p e %p", p); printf("\nO endereco do p e %p", &p); getchar(); }

Profª Angelina V.S.Melaré 100

Cuidado com o uso do operador *. O * pode ser usado tanto para declarar o ponteiro quanto para indicar o conteúdo da variável para qual ele está apontando. main() Cuidado: você tem que atribuir { um endereço para o ponteiro int *p, v; v= 8; p= &v; printf("\nO endereco de v e %p", &v); printf("\nO conteudo do p e %p", p); //é o endereço memória de v printf("\nO endereco do p e %p", &p); printf("\nO valor de v %d", v); printf("\nO valor de v mostrado atraves do ponteiro p %d", *p); } Podemos usar mais ponteiros para direcionar para o mesmo local da memória. main() { int *p, *p2, v; v= 8; p= &v; p2= p; //não usa o & para pegar o endereço do outro ponteiro printf("\nO endereco de v e %p", &v); printf("\nO conteudo do p e %p", p); printf("\nO endereco do p e %p", &p); printf("\nO valor de v %d", v); printf("\nO valor de v mostrado atraves do ponteiro p %d", *p); printf("\nO valor de v mostrado atraves do ponteiro p2 %d", *p2); } Aritmética de ponteiros Pode ser feito uso das operações de adição e subtração com os ponteiros. Mas cuidado para não pegar o conteúdo da variável para o qual ele está apontando e sim seu endereço. Se acrescentarmos no programa anterior o código abaixo: int t; t= sizeof(t); //ver o tamanho do tipo int e quantos bytes vai avançar p++; printf("\nO conteúdo de p e %p", p); printf("\nO conteúdo apontado pelo ponteiro p %d", *p);

Está sendo feito uma adição no ponteiro p++, de forma que ele irá avançar 4 bytes na memória, pois, a cada incremento ele acrescentar ao seu endereço a quantidade de bytes de seu tipo. De forma que quiser retroceder e voltar a apontar para v, basta fazer uma subtração com o ponteiro. p--;

Profª Angelina V.S.Melaré 101

quando subraímos o ponteiro ele voltou 8 bytes. v. *p. //erradoooo .você acrescentou 1 ao valor do ponteiro printf("\nP %d e V %d". v). printf("\nP %d e V %d". p).//somando 1 ao valor de v através do ponteiro printf("\nP %d e V %d". //somando 1 ao valor de v através do ponteiro --use () printf("\nP %d e V %d". v= 8. p). printf("\nO conteúdo apontado pelo ponteiro p %f". *p).Vendo o conteúdo da variável através de seu ponteiro – de forma indireta main() { double *p. *p. } Perceba que o tipo Double oculpa 8 bytes. //endereço de v printf("\nO conteúdo apontado pelo ponteiro p %f". v= 8. } Profª Angelina V. v). *p++. v). *p). p= &v. //somando 10 ao valor de v printf("\nP %d e V %d".Melaré 102 . *p.S. p--. v). v+= 10. *p. *p. p= &v. printf("\nO conteúdo de p e %p". *p= *p+1. v. v). printf("\nO conteúdo de p e %p". main() { int *p. (*p)++.

*pm. *p. *pm).30. *pm. *pm).20.40}. printf("\n1o elemento: %d". pm++. *pm). *pm). mat[0]). v). //tem que colocar o & para informar o índice 0 printf("\n1o elemento: %d". //tem que colocar o & para informar a posição 0 printf("\n1o elemento pelo pm %d e pelo mat[0]". mat[0]). //ou pm = &mat[0]. através de ponteiros.S. //apontando para o 2 elemento printf("\n2o elemento pelo pm %d".30.40}. printf("\n1o elemento: %d". *p. //direciona para o índice 0 printf("\n1o elemento: %d". *pm. //errado . //multiplicando por 2 o conteúdo do 3 elemento printf("\n3o elemento pelo pm %d". a passagem do endereço dessa matriz para outra função.Cuidado para não errar *p++.20. *pm). *p--. *pm = *pm *2. Para isso você deve direcionar o ponteiro para o primeiro elemento da matriz. Isso pode ser feito de duas maneiras: int main() { int mat[4]={10. pm = mat. *pm). //ou pm = &mat[0]. //somando 4 bytes ao endereço do ponteiro e indo para o 3 elemento printf("\n3o elemento pelo pm %d". } Veja o programa abaixo: int mat[4]={10. //errado . pm= &mat[1].você subtraiu 1 ao valor do ponteiro printf("\nP %d e V %d".Melaré 103 .você acrescentou 1 ao valor do ponteiro printf("\nP %d e V %d". pm = mat. v). *(pm++). Profª Angelina V. *pm). Trabalhando com Matriz através de Ponteiros É muito usado em matriz. 2. //apontando para o próximo endereço printf("\n4o elemento pelo pm %d".

*(++pmat)). gets(nome). printf("\n%d". i<E. getchar(). i+1). i.%p\n". Recebendo valores de uma matriz através de seu ponteiro #define E 3 main() { int mat[3]. printf("mat[1] = %d \n". printf("Informe os valores da unidimensional\n"). *pmat). while (*pnome != '###BOT_TEXT###' ) { printf("%c. nome[20]. pnome++.S. scanf("%d".Você pode fazer o calculo diretamente na exibição int mat[3] = {10. *pmat. printf("mat[0] = %d \n". 20. int compr=0. *(pmat-=2)). pmat = mat. printf("mat[0] = %d \n". printf("Digite um nome: "). i++) { printf("\n%d valor". compr). Trabalhando com ponteiro e string main() { char *pnome. printf("mat[2] = %d \n". compr++.Melaré 104 . system("pause"). } 1ª. pmat++. *(pmat)). pmat). } for (i=0. } printf("\nQuant caracteres %i\n". i++) { pmat--. *(++pmat)). } Profª Angelina V. } getchar(). pnome = nome. i<E. pnome). *pnome. *pmat. for (i=0. pmat = mat. 30}.

printf("\n\nAntes da chamada da função Quadrado .Melaré 105 . } Profª Angelina V. No programa abaixo o que é passado para a função quadrado é o endereço das variáveis num1 e num2. printf("\nDigite o segundo número").&num2). system("pause"). scanf("%d". quadrado(&num1. mas sim suas referências (seus endereços de memória). que deve ter seu valor usado e alterado independente da função.num2). *pnum2=*pnum2 + 5.int *pnum2) { *pnum1=*pnum1 * *pnum1. Usando a passagem por referência fica mais simples a mudança dos valores das variáveis.int *pnum2).Funções com Passagem de Parâmetros por Referência A diferente da Passagem de Parâmetros por Referência em relação a Passagem de Parâmetro por Valor é que nesse tipo de passagem não se passa para a função os valores das variáveis. scanf("%d".num1. Para que isso ocorra deve-se declara as variáveis como ponteiros.os números são %i %i\n".&num2).&num1).num1. Através do operador * é acessando o conteúdo apontado pelos ponteiros e modificando-o. printf("\n\Depois da chamada da função Quadrado .os números são %i %i\n". Estes endereços são copiados nos ponteiros pa e pb.S. printf("\nDigite o primeiro número"). } void quadrado(int *pnum1. void quadrado(int *pnum1. Não se esqueça quando usar a função deve colocar um &(endereço) na frente das variáveis que estiverem sendo passadas para a função.num2). main() { int num1. Os ponteiros são a referência para poder alterar o valor da variável fora da função. Os valores armazenados em num1 e num2 são modificados.num2.

/////////void recebe(int *pmat[]. pmat++. for (i=0. i++) { scanf("%d". pmat). int t) { int i. Quando a matriz for bidimensional é obrigatório informar a quantidade de elementos da segunda dimensão.0. i<3. i . i<3. i++) printf("\n%d". Quando for definido o ponteiro para receber o endereço de uma matriz unidimensional. for (i=0.3. for (i=0. } void recebe(int pmat[]. i++) { notas[i][2]= (notas[i][0]+ notas[i][1])/2. int t). mat[i]). 3). recebe(mat. } } Na matriz bidimensional veja a definição da segunda dimensão void calculamedia(float notas[][3]) { int i. int t). porque na linguagem C ele apenas precisa saber o tipo dessa matriz. Você é que fará o controle dos elementos. você irá enviar o endereço do elemento 0. void recebe(int pmat[]. você não precisa colocar a dimensão (quantidade de elementos) que essa matriz terá. O operador * não precisa ser colocado. Passagem de Matriz por Referência Na passagem da matriz.S. int main() { int mat[3].Melaré 106 . } } Profª Angelina V. i<t. _sleep(20000). pois quando se passa um matriz unidimensional ou bidimensional sempre será por referência.

int main() { float notas[3][3]; int l, c, i; for (l=0; l<3; l++) { printf("\n\nAluno %d\n", l+1); for (c=0; c<2;c++) { printf("%d Nota", c+1); scanf("%f", &notas[l][c]); } } calculamedia(notas); printf("\nMedias dos alunos"); for (i=0; i<3; i++) { printf("\n%d aluno teve %.2f", i+1, notas[i][2]);; } _sleep(20000); }

Profª Angelina V.S.Melaré 107

Estruturas
ESTRUTURAS (Struct) – VARIÁVEIS COMPOSTAS HETEROGÊNEAS Muitas vezes precisamos manipular dados compostos, mas que identificam uma única representação. Para isso é necessário ter um mecanismo de agrupamento, estruturando os dados em um único contexto, como por exemplo um ponto é representado tanto pela coordenada x quanto pelas coordenada y, elas são “dependentes” (não devem ser tratadas de forma isolada). Assim como um data, que é formada tanto pelo dia, quanto pelo mês e pelo ano.

A sintaxe da deinição de uma estrutura é: struct nome_da_estrutura { Componentes/membros dessa estrutura; tipo nome_da_variável; }; Estruturas permitem definir estruturas complexas de dados, com campos de tipos diferentes. Por meio da palavra-chave struct e type def definimos um novo tipo de dado. Definir um tipo de dado significa informar ao compilador o seu nome, o seu tamanho em bytes e o formato em que ele deve ser armazenado e recuperado na memória. Após ter sido definido, o novo tipo existe e pode ser utilizado para criar variáveis de modo similar a qualquer tipo simples. struct Dados_Pessoais { char nome[81]; int idade; float peso; } P1; foi feita a declaração da variável P1 que é do tipo Dados_Pessoais no final da definição da estrutura, mas, essa declaração poderia ser feito de outra forma, como abaixo: /* Declaração de variáveis do tipo struct Dados_Pessoais*/ struct Dados_Pessoais P2, P3;
Definindo um novo tipo de dado com o typedef typedef struct Dados_Pessoais { char Nome [ 81]; int Idade; float Peso; } Pessoa;

/* A declaração das variáveis do tipo Dados_Pessoais/ Pessoa Cliente, Funcionario;

Profª Angelina V.S.Melaré 108

Uma vez criada a variável composta heterogênea, denominada estrutura, seus membros podem ser acessados por meio do operador de acesso ponto (.). Esse conecta o nome da variável estrutura a um dos seus membros. estrutura membro gets(Pessoa.Nome); Pessoa.Idade = 41; Pessoa.Peso = 75.6;
Outro exemplo direto de denominação de um tipo de dado: int main() { typedef float R; //o nome R é um mneumônico do tipo float R n1; scanf("%f", &n1); printf("Numero digitado %g", n1); } Resumindo struct ponto { float x; float y; }; typedef struct ponto P;

typedef struct ponto { float x; float y; } P; ou struct ponto P;

scanf (%f%f”, &p.x, &p.y); printf(“As coordenadas são %.2f - %.2f”, p.x, p.y)
Exemplos de uso: 2ª. Recebendo dados main() { struct dados_pessoais { char nome[81]; int idade; float peso; }; struct dados_pessoais aluno;

printf("\nNome do aluno:"); gets(aluno.nome); printf("\nIdade:"); scanf("%i", &aluno.idade); printf("\nPeso:"); scanf("%f", &aluno.peso); printf("%i %s %.2f \n", aluno.idade, aluno.nome, aluno.peso); }

Profª Angelina V.S.Melaré 109

ano). ev. printf("%i %s %i \n". Profª Angelina V. &ev. natal. float peso. aniversario. }. } 4ª. Recebendo e verificando dados #include <stdio. }. "Julho". typedef struct dados_pessoais Aluno. printf("%i %s %i \n". data aniversario = { 30. char mes[10]. 1994}.h> int main() { struct dados_pessoais { char nome[81]. printf("%i %s %i \n". Igualando estruturas main() { struct data { int dia.mes. aniversario = natal.ano). float s. natal. }.3ª. int ano. Recebe e mostra uma estrutura de horas main() { struct evento { int h.m. 1998}.S. ev.m. } 5ª. natal. ev. "Dezembro". aniversario.2f\n". printf("A hora fornecida foi: %d:%d:%. aniversario.ano).mes. m.h> #include <stdlib.nome).Melaré 110 . //define o novo tipo Aluno Aluno A.h.s). aniversario.dia. gets(A. aniversario.s). int idade. &ev. &ev.mes. printf("Entre com a hora de um evento(hh:mm:sec): ").h.dia.dia. //define a variável A que é do tipo Aluno printf("\nNome do aluno:"). struct evento ev. data natal = { 25. scanf("%i:%i:%f". aniversario.

}Aluno. &aluno[i]. printf("%i %s %.peso). &aluno[i].nome.peso). printf("\nPeso:").printf("\nIdade:").peso).Melaré 111 .i++) { printf("\nCadastro n: %i\n". A. int idade. printf("\nNome do aluno:"). Usando uma matriz do tipo estrutura struct dados_pessoais { char nome[81].2f \n". printf("%i %s %. system("pause"). aluno[i]. &A.2f \n". printf("\nPeso:"). int idade. float peso.peso >30) printf("Precisa comer mais\n\n"). aluno[i].idade. if (A. int main() { int i. struct dados_pessoais { char nome[81]. //define a variável a que é do tipo Aluno 6ª. return 0.idade). scanf("%i". A. scanf("%f". //define o tipo Aluno Aluno A. float peso.nome).idade).i<3. A. } system("pause"). aluno[i]. int idade. &A. scanf("%i". for (i=0.peso). Profª Angelina V. gets(aluno[i]. } Ou main() { int i. scanf("%f".return 0.S. } Ou typedef struct dados_pessoais{ char nome[81]. fflush(stdin). i+1). printf("\nIdade:"). } aluno[3].nome.idade.

main() { int i. &aluno[i]. printf("\nPeso:"). struct dados_pessoais aluno.i<3.i++) { printf("\nCadastro n: %i\n". aluno[i]. scanf("%i". }. *paluno->idade. scanf("%i-%i%i". paluno = &aluno. printf("\nIdade:"). struct dados_pessoais { char nome[81]. paluno->peso).2f \n". data data_niver . int mes. printf("\nPeso:"). *paluno->peso). gets(aluno[i]. float peso. } Profª Angelina V.idade. gets(paluno->nome). fflush(stdin). printf("\nIdade:"). &aluno[i]. &aluno[i]. printf("%i %s %. *paluno->nome. } Usando uma estrutura dentro da outra estrutura typedef data { int dia.data_niver).peso). i+1).peso). for (i=0. printf("\nData de Aniversario:"). int idade.idade). printf("\nNome do aluno:").nome).Melaré 112 . i+1). printf("\nNome do aluno:"). scanf("%f". } aluno[3]. for (i=0. } system("pause"). scanf("%i". printf("%i %s %. aluno[i].S. }. fflush(stdin). paluno->idade). aluno[i].i<3.nome.2f \n".float peso. scanf("%f".i++) { printf("\nCadastro n: %i\n". *paluno. int ano.

int basemaior.area).basemenor + trapezio. Usando estrutura e função void exibedesenho(struct desenho xtrapezio).f \n \r". system("pause"). printf("Area do Trapezio: %. } 8ª.altura). trapezio. printf("Base menor: %i \n \r". trapezio.f \n \r". trapezio. printf("Altura : %i \n \r". } Profª Angelina V.altura/2. main() { struct desenho trapezio. float area. trapezio.Melaré 113 .basemaior). int altura. Fazendo a referência de estrutura em uma função void calculadesenho(struct desenho *ptrapezio).basemenor =2. printf("Area do Trapezio: %. printf("Base maior: %i \n \r". calculadesenho(&trapezio). }. }. trapezio. int basemaior.area= (trapezio.area). struct desenho { int basemenor.basemenor). } void exibedesenho(struct desenho trapezio) { printf("Base menor: %i \n \r". trapezio.basemaior). trapezio. main() { struct desenho trapezio.altura).altura = 5. int altura. trapezio.7ª. float area.basemaior= 7.basemaior) * trapezio. trapezio. printf("Altura : %i \n \r". trapezio. struct desenho { int basemenor.S. trapezio. printf("Base maior: %i \n \r". trapezio. exibedesenho(trapezio).basemenor).

y). &vponto.basemenor =2. } Ou void exibe(struct ponto cponto).void calculadesenho(struct desenho *ptrapezio) { (*ptrapezio). &vponto.y).x= 5.basemenor + (*ptrapezio). (*ptrapezio). float y. (*ptrapezio). pponto->y). main() { struct ponto vponto.basemaior= 7.basemaior) * (*ptrapezio).7. }. ptrapezio->area= (ptrapezio->basemenor + ptrapezio->basemaior) * ptrapezio->altura/2. vponto. }.x. vponto. } void exibe(struct ponto *pponto) { printf("\nOs pontos digitados foram %. ptrapezio->basemaior= 7.2f e %. printf("\nOs pontos digitados foram %. Profª Angelina V.altura/2.2f \n". } 9ª. system("pause").2f e %. vponto. Fazendo a referência de estrutura em uma função void exibe(struct ponto *pponto). pponto->x. struct ponto { float x. scanf("%f %f". } ou void calculadesenho(struct desenho *ptrapezio) { ptrapezio->basemenor =2. struct ponto { float x. (*ptrapezio).2f \n".Melaré 114 .area= ((*ptrapezio). printf("\nDigite as coordenadas dos pontos x e y: "). exibe(&vponto). float y.x.S.altura = 5. ptrapezio->altura = 5.

vponto. &vponto. Fazendo Alocação Dinâmica de Memória float media(int n. scanf("%i". cponto. *(nota+i)).i++) { s+= v[i]. int i. //aloca 4*n bytes de memória em tempo de execução if (v==NULL) { printf ("Memoria Insuficiente").y). printf("\nOs pontos digitados foram %. { printf(“Entre com tamanho n: ”). v= (float *) malloc(n * sizeof(float)). //libera a memória } main() { float media(int n. return s/n. } 10ª. i++) printf(“\n %.". i+1). return 1. &vponto. vponto. free(v). i < n.x. i<n.x.main() { struct ponto vponto. for (i=0. cponto.y). } } for (i=0. &v[i]). } med= media(n. printf("\nDigite as coordenadas dos pontos x e y: "). } for (i=0.2f \n\n". float *v). i < n.x.2f \n". system("pause"). free(nota). med. float *nota = NULL. printf("Media %. } Profª Angelina V. exibe(vponto).Melaré 115 .7.x= 5. &n).S. scanf("%f". nota=(float *)malloc(n*sizeof(float)). float *v. i+1). scanf("%f %f". i++) { printf(" %i . scanf(“%f”.2f e %. n. i<n.2f \n”. main() { int i. nota+i). med). printf("Quantos elementos serao armazenados: "). } void exibe(struct ponto cponto) { printf("\nOs pontos digitados foram %. float *v) int i. scanf(“%d”.v).2f e %. printf(“ Entre a nota %i:”.&n). i++) for (i=0.y). n.2f \n". float s=0. cponto.

scanf("%i". União – union O tipo união é usado para compartilhar um mesmo endereço de memória para várias variáveis. }.h> void main() { union variavel { int valor_hora.5. float valor_mensal.S. var. union variavel var. var. void main() { union variavel { float valor_hora.Melaré 116 .valor_mensal).valor_hora). que é o valor 346. float valor_mensal. var.valor_mensal = 346. se for usado um outro membro da união o anterior se perde (sobrescreve).valor_hora). var. //permanece o último valor atribuído ao endereço de memória. var.valor_hora). //permanece o último valor atribuído ao endereço de memória. printf("\nValor da Hora %.5.valor_mensal = 346. que podem ser de tipos diferentes. } var.5 (mensal) } Profª Angelina V. &var. printf("\nUltimo valor armazenado %g". var.h> #include <stdlib.União e Enumeração 1. printf("Valor da Hora %. que é o valor 346. printf("\nInforme o valor da hora").5. #include <stdio.valor_hora). printf("\nValor Mensal%f".5 (mensal) getchar(). printf("\nValor Mensal pre-definido: %f".valor_hora = 5. printf("\nValor da Hora informado: %i". } Cuidado: Somente uma variável pode ser usada por vez.valor_mensal). var.2f". var. var.valor_hora).2f".

if (mes == Jan || mes == Mar || mes == Mai || mes == Jul || mes == Ago || mes == Out || mes == Dez) dia = 31. } Profª Angelina V. Mar. Out. Abr.Melaré 117 .Nov.S. Set. Set. ele sempre inicia a partir do zero. //ou mes = meses(9). else if (mes == Fev) dia = 28. Dez}.Nov. Dez}. enum meses {Jan = 1. ou seja. main() { int dia. Mar. Mai. Jul. printf(“Numero dias: %d \n”. Mai. Se não for definido um valor inial da sequência definida. meses mes. Ago. Jul. enum Mes { Jan = 1. Tipo enumeração É uma forma de definir inicialmente os valores. Jun. else dia = 30. Fev. Out.dia).Abr. mes = Set.Jun. Fev. pré-definidos. Ago.2.

Dessa forma. um arquivo de dados). cada caracter terá que ser convertido para binário. desconhecidos numa leitura pelo usuário. com uma sequência de bytes gravados. 118 Profª Angelina V. Se o arquivo não existir. Se o arquivo não existir ele cria um novo arquivo para gravação. destruindo os dados armazenados anteriormente. ele é criado). ele será criado. A pesquisa de dados em um arquivo binário é mais rápida e fácil. Se já existir.Arquivos A manipulação de um arquivo é feita através da associação de uma variável ponteiro (FILE) a um arquivo físico (Stream). Abre um arquivo texto já existente e adiciona as informações no final do arquivo (se o arquivo não existir. e faz gravação no início do arquivo—diferente do modo append (a)) Cria um novo arquivo texto e o abre para leitura e gravação.Melaré . A localização padrão é o local onde está o arquivo executável.S. enquanto que se for gravado em modo texto. compreensível numa leitura pelo usuário. Cria um novo arquivo binário e o abre para leitura e gravação. A função fopen recebe dois argumentos string: a localização (diretório) junto com o nome do arquivo. Caso o arquivo já exista ele sobrescreve os dados. acrescentando os dados no final. Abre para leitura e gravação. • Modo texto. r w a rt rb . Abre o arquivo texto para leitura. e o modo de abertura do arquivo. já que estão convertidos em bytes. como vários cadastros (registros) e que não sejam compreensíveis por questão de segurança. fopen (nome. O conteúdo do arquivo depende da forma de criação do mesmo. mas. Para fazer uso dessa função é necessário antes criar um variável ponteiro (FILE) que direcionará para um endereço de memória do arquivo. pondendo ser criado e armazenado: • Modo binário. modo ). existir ele cria um novo arquivo. 3. antes de tudo se posiciona no final dele. modo) parq = fopen(“nome_arq”. Se o arquivo já existir o abre e depois começa a gravar. senão.+ wt wb at Existe vários modo com o quais o arquivo pode ser aberto ou criado. usamos arquivo binários para armazenar uma grande quantidade de dados. FILE *parq. Os arquivos gravados em modo binário tem um tamanho menor. esse arquivo pode ser um arquivo texto (uma planilha do excel. Esse arquivo já deve existir Abre e grava no arquivo (a opção r+ abre o arquivo. com uma sequência de caracteres da tabela ASCII. Esse arquivo já deve existir Abre o arquivo binário para leitura. Abertura do arquivo Para abrir ou mesmo criar um arquivo é usada a função fopen(). o conteúdo anterior será destruído. Abre arquivo já existente para leitura Abre para leitura e gravação. e o modo texto para gravar arquivos que podem ser compreensíveis pelo usuário e abertos por qualquer editor. um documento do Word) ou um arquivo binário (um arquivo do sistema.

1. Fechamento do arquivo Para fechar o arquivo é usada a função fclose(). Com esse retorno é possível fazer verificações e exibição de mensagem de alerta para o usuário. parq). fclose(parq). se for necessário fazer uma consulta de todos os dados armazenados deve-se iniciar a leitura desde o início do arquivo (percorrendo todo o arquivo até o final). tamanho em bytes a ser avançado o cursor. pois. podendo ser feita ou não sua leitura. w).rt ab Abre um arquivo texto já existente para leitura Abre o arquivo binário para leitura e gravação (usa os mesmos conceitos anteriores parq = fopen(var_nome. Resumindo: é feita a leitura de uma quantidade sequencial de bytes do arquivo físico e depois é guardado na memória através de um tipo estrutura. rb). Essa leitura é feita a partir de seu posicionamento no arquivo. const_modo ). Após a leitura de um registro o ponteiro fica posicionado no próximo registro do arquivo. 5. ou um valor NULL quando der erro (erro de abertura ou criação do arquivo). o computador fará a leiutura por intervalos de bytes. } 4. Resumindo efetiva a gravação. fread(o endereço onde será armazenado o conteúdo lido. sizeof(devedores). Leitura de um arquivo binário A leitura de um arquivo binário é sempre feita de um registro por vez. fecha o arquivo e libera a memória. if (parq == NULL) { printf(“Erro de abertura do arquivo”). por isso é importante saber como será feita a abertura do arquivo (posicionamento no início ou no final do arquivo). OU parq = fopen( “C:\LOCAL\ARQUIVO.Melaré 119 .S.TXT”. Profª Angelina V. A função fopen() retorna um endereço de memória do arquivo quando esta for executada com sucesso. o ponteiro que indica o nome do arquivo que tem o conteúdo lido o nome da estrutura (registro) que nome do ponteiro armazenará o conteúdo lido qtd de registros do arquivo que está qtd de bytes lidos lidos (sempre 1) sendo lido (tamanho da estrutura) fread(&devedores. parq = fopen( “C:\LOCAL\ARQUIVO. o número de registros que vai ler por vez. Essa função atualiza o arquivo com as informações que estão no buffer (memória) e depois libera a memória. Leitura É muito importante definir a forma de leitura e gravação de um arquivo. exit(1). onde cada registro tem um tamanho fixo.TXT”.

"Nome: %s". nome). Para usar essa função é necessário passar alguns argumentos. número de caracteres lidos. 20.S. qtd de registros a serem gravados 1.nome). então se coloca 19. o número de elementos que vai gravar(número de registros que serão gravados) o ponteiro que indica o endereço para onde vai copiar. printf(“%s”. Também existe as funções: fscanf(). //faz a leitura da string e a carrega no ponteiro Cuidado: O tamanho sempre é considerando o valor inicial no zero. parq). Abaixo estão alguns trechos de código com essas funções: FILE *parq char nome[35]. ab).txt". rt). Obs: O posicionamento fica no fim da linha atual no arquivo se o caracter de mudança de linha ocorrer antes de serem lidos todos os caracteres. Toda vez que executa o fgets() é atualizada a posição de leitura corrente do arquivo aberto. como descrito abaixo: parq = fopen( “C:\LOCAL\ARQUIVO. fscanf (parq. sizeof(devedores). Cuidado: Se a estrutura foi definida para armazenar um único registro não se coloca o &.nome. Gravação Gravação em modo binário A gravação no modo binário é realizada através da função fwrite(). fclose(fp). puts(“Nome gravado”).Melaré 120 . ponteirodearquivo). tamanho em bytes a ser gravado.TXT”. Se o tamanho total é 20. ponteiro que direciona para o arquivo a ser gravado parq).1.nome do arquivo físico) nome da estrutura (registro) que contém os dados qtd de bytes a serem gravados fwrite(&devedores. fgets (variável que recebe a entrada. parq = fopen("dados. 6. sempre é total . fgetc() para leitura de um arquivo texto. fwrite (o endereço onde está o conteúdo a ser gravado. Profª Angelina V. fgets(CAD. Retornando NULL quando não há mais dados para serem lidos.Leitura de um arquivo texto Função fgets() lê uma string de caracteres de um arquivo aberto.

Melaré 121 . } devedores[4]. } fwrite(&devedores. //Etapa de abertura e gravação do arquivo if (fp == NULL) { printf(“Erro de abertura do arquivo”). fp). i<4. } fp = fopen("devedores. } devedores[4]. sizeof(devedores). main() { int i.valor). fp = fopen("devedores. float valor. fread(&devedores. gets(devedores[i]. 1. _sleep(3000). //se for um único devedor não se deve colocar o &devedores fclose(fp).1. em um registro. main() { int i. i++) { fflush(stdin). } 2ª. Exemplos em modo binário: 1ª."r"). printf("Valor da Divida: R$"). e o grava em um arquivo que está direcionado através do ponteiro. sizeof(devedores).S. printf("Segunga etapa – Exibicao dos devedores ").Resumindo: O fwrite pega o conteúdo que está posicionado na memória. FILE *fp. &devedores[i]. exit(1). Profª Angelina V. Leitura dos dados em modo binário struct entrada { char nome[40]."w").txt". printf("Digite o nome: ").nome). Gravação dos dados em modo binário struct entrada { char nome[40].fp).txt". float valor. for (i=0. FILE *fp. scanf("%f".

printf ("Arquivo gravado com sucesso"). O retorno da função é o total de bytes gravados. arquivo = fopen("tabuada.devedores[i]. i<4. 1.c=0. Exemplos diversos f= 3. } while (c<=10)."<tr> <td>%d x %d = %d </td></tr>".. int t. fprintf(parq. fprintf (arquivo. printf (arquivo. num. fp) Gravação em modo Texto Função fprintf(): Essa função grava dados em um arquivo aberto."<table>"). fwrite (m. fwrite (&f. } fclose(fp). sizeof(m). } Profª Angelina V."<tr><td>%d x %d = %d</td></tr>".:")."</table>").Melaré 122 . scanf ("%d".r ."w"). do { r=c*t. i++) { printf("\n%s . _sleep(4000). Exemplo de criação e gravação de arquivo texto int main() { FILE *arquivo. fclose(arquivo). tabuada.for (i=0. 1. fprintf (arquivo..xls".c. fp) float m[10][2].devedores[i].t.nome. nome). printf ("Digite qual a tabuada. resultado).valor). fprintf ( ponteiro do arquivo a ser gravado. valores a serem gravados) fprintf (parq.2f". sizeof(f). } 3ª.R$ %. “Cadastro de Alunos”). formato de gravação.1415.&t). fprintf(parq. c++. “%s”.r).S.

//gravação dos dados } } fclose (parq).h> int main() { typedef struct //definindo uma estrutura de dados-.nome).senha). break. system("pause"). registro CAD. //definição do ponteiro de arquivo char opcao. "%s\n". "%s".conhecida como registro { char nome [20]. gets (nome_arquivo). gets (CAD. gets (CAD. fprintf (parq. if (!strcmp(CAD. printf("\nC. CAD. fprintf (parq. switch(opcao) { case 'c': case 'C': printf ("\nInforme o nome do arquivo a ser criado: "). } registro.S. "wt"). while(1) { system("cls").nome.h> #include <stdlib. case 'l': case 'L': printf ("\nInforme o nome do arquivo a ser aberto e consultado: "). leitura e gravação de um arquivo no modo texto #include <stdio.Exemplo de criação. existe. //fechando o arquivo break. //abertura/criação do arquivo while (1) { printf ("Nome:"). FILE * parq. printf("\nL. char senha [6].senha).Cadastro"). CAD. char nome_arquivo [15].Melaré 123 . Finalizando o cadastro!"). opcao = getch(). do { Profª Angelina V. parq = fopen (nome_arquivo."")) { puts("Não foi informado nome.nome).Consulta"). } else { printf ("Senha de acesso: ").

parq). printf ("%s%s". default: printf("\nOpcao invalida\n")."rt").nome.nome_arquivo). } fclose (parq). exit(0). 6.Melaré 124 .S. system("pause")."")) { puts("Não foi informado um nome correto de arquivo.senha. CAD. break. 20.gets (nome_arquivo). parq = fopen (nome_arquivo.nome. } existe = access(nome_arquivo. if (existe) printf("%s não existe \n". exit(0). } while (existe). CAD. parq). //faz a leitura da string e a carrega no ponteiro fgets(CAD. //abrindo o arquivo no modo leitura while (!(feof (parq))) //enquanto não for final de arquivo continua lendo { fgets(CAD. } } Profª Angelina V.senha). Finalizando!"). } system("pause").4). if (! strcmp(nome_arquivo.

Melaré 125 . 7. remove(“devedores. Esse comando só pode ser executado se o arquivo estiver fechado. Eles podem ser: SEEK_CUR – avanço a partir a posição corrente (atual) SEEK_SET – avanço a partir do início do arquivo SEEK_END – avanço iniciando do final do arquivo fseek( parq.bin”). quantos bytes irá avançar.Posicionamento e Pesquisa em arquivo binário Para ser feita a leitura e a gravação de um arquivo é necessário saber a posição ideal para que esse processo seja realizado. 8. podendo ser 0 se ainda não está no final do arquivo. No exemplo acima. Existe a função fseek() que define um ponto específico de posicionamento no arquivo: fseek( ponteiro do arquivo. É possível posicionar no final do arquivo para fazer uma gravação com o fseek: fseek(pdevedores. O terceiro argumento define a posição que se deve estar para depois avançar. no exemplo acima é feita a leitura enquanto não for final de arquivo. fp). Primeiro se posiciona para depois fazer a leitura do registro. 3*sizeof(devedores). A função rewind() posiciona no início do arquivo. while ( !(feof (parq))) ou while (feof (parq) == 0) Usamos essa função dentro de estruturas de repetição. Rewind(pdevedores). Esse função tem um valor de retorno. qual a relação de avanço) Você tem que definir através do segundo argumento a quantidade certa de bytes para atingir a posição desejada (registro). 0. fread(&devedores. 1. Profª Angelina V.S. SEEK_END). Para apagar um arquivo Para apagar um arquivo físico é usada a função remove(nomedoarquivo). Verificando o final do arquivo binário É usada a função feof() para verificar se está ou não no final do arquivo. está se posicionando 4º registro. ou outro valor (no caso consideramos 1) para indicar o posicionamento no final do arquivo. SEEK_SET). sizeof(devedores).

tendo apenas dois estados. Quando se pressiona a tecla F (01000100). A passagem da corrente ou impulso elétrico pode ser desginado pelo digito 1 e a não passagem da corrente elétrica pelo digito 0. como o alfabeto em maiúsculas e em minúsculas.S. Com essas combinações é possível fazer 128 representações válidas. 9 do TAB. cujo valor decimal vai de 0 a 127. Existe 1 bit de paridade para verificação de erros. o 33 representações não são imprimíveis. os circuitos do teclado geram um sinal de 8 voltagens diferentes correspondentes ao seu código de 8 bits. As informações em formato binário são representadas(codificadas) de acordo com algumas tabelas. O termo BIT. código de 7 btis (ASCII) e 8 bits (EBCDIC).Melaré 126 . • 93 são representações dos caracteres imprimíveis (do código 33 ao 126). Toda instrução e controle que deve ser executada pelo computador é transmitido através desses Bits. pois são caracteres de controle. essa tabela é baseada na combinação 7 bits e para representação o inglês. Existe representação de código de 4 bits (BCD. número ou símbolo pode ser representado no computador por um conjunto de sinais elétricos. digito ou caracter especial). chamados de Bits. Mudanças na tabela de código ASCII – ASCII Estendido Profª Angelina V. é feita a verificação da sua representação ASCII e depois produzido o eco na tela do caracter F. O conjunto de 8 Bits forma um agrupamento denominado Byte. 27 do ESC. os números de 0 a 9. cuja tradução é Digito Binário. Gray). Algumas tabelas foram criadas pelos fabricantes de computadores. para representar os caracteres (letra. Nessa tabela tem: • 128 representações. vem de Binary Digit. Exemplo 7 bits = 27 = 128 combinações. usado para representar a passagem ou não da corrente elétrica no computador (ou campo magnético: positivo ou negativo). como as representações: 13 do ENTER. digitos binários e símbolos são feitos os agrupamentos de Bits.Conceitos Básicos BIT Cada letra do alfabeto.Como um único BIT não consegue representar todas as letras. criada (1963) e atualizada (1968) na década de 60.serviços de telex). código 5 bits (BAUDOT. O número de bits utilizado no código determina o número máximo de caracteres possíveis a serem representados. O BIT é a menor unidade de medida de dados que o computador tem. Exemplo: ASCII e EBCDIC ASCII A Tabela ou Código ASCII (American Standard Code for Information Interchange – Código Padrão Americano para o Intercâmbio de Informação). 127 do DEL.

litro. ô. etc. essa tabela foi denominada ASCII Estendida. Unicode Latim Estendido B.2 estados 0 e 1) e o nosso sistema métrico de medida é decimal tem-se: – KB Kilo K(mil) 210 – 1.824 bytes – GB Giga G(bilhão) Hz (hertz).2V. de 0. A tabela Unicode abrange os mais variados sistemas de escrita (latino. Unicode Existe o padrão Unicode (www. hertz e no computador os bits. Letras Modificadoras de Espaçamento e Sinais Diacríticos combinados são de especial interesse dos lingüistas porque trazem a simbologia do Alfabeto Fonético Internacional.A ASCII inicialmente não atendia a representação do texto em português. de moeda. EBCDIC O código EBCDIC (Extended Binary Coded Decimal Interchange Code.mais de 1 bilhão de vezes por segundo (pulsos).2V e o digito 0 para a corrente elétrica baixa.S.741. ü. não considerava o á. existindo a possibilidade de fazer 256 combinações diferentes. foram criadas várias tabelas ASCII. musicais. Unicode Latim Estendido A. Com o tempo. Unicode Sinais diacríticos combinados A Unicode Latim Básico equivale exatamente à tabela ASCII de 7 bits. é.org) que se propõe a desenvolver um sistema abrangente e padronizado de representação de escrita em computadores.073. hebraico.Melaré 127 .048.576 bytes 230 – 1.unicode. a tabela ASCII foi expandida até o número 255.em 1 segundo. Então GHz equivale a mudança do estado – 0 e 1. Mas ainda assim.Código BCD Ampliado para Intercâmbio) foi criado pela IBM e utiliza 8 bit para fazer uma representação. cada uma adaptada a uma ortografia específica. considerando a combinação do 8 bits. Ela é subdividida em blocos. além de considerar símbolos matemáticos. chinês. Unicode Letras modificadoras de espaçamento. ela não permite representar ao mesmo tempo os grafemas do sistema latino e de outros como o grego. ç. como: Unicode Latim Básico. Unicode Latim I Suplementar. de 8 bits. Os blocos Extensões IPA. etc). Em função disso. Convencionou a usar o digito 1 ( corrente elétrica alta) – para a representar a voltagem de 1. Profª Angelina V.024bytes – MB Mega M(milhão) 220 – 1. Unicode Extensões IPA. Unidade de Medida Nós temos na nossa vida diária as unidades de medidas metro. A Unicode Latim I Suplementar equivale a ASCII estendida.1 Hertz equivale a uma oscilação de sinal – corrente. Como a contagem de medida do computador é binária (base 2.

interface gráfica. pois ele tem recursos de baixo nível. mas também tem uma linguagem com uma sintaxe mais parecida com a do ser humano. manipulação do hardware. Delphi. Um único comando pode executar várias instruções em linguagem de máquina. Isso é feito através do uso de um compilador ou interpretador. É uma linguagem mais complexa de aprender. como acesso direto a endereços de memória. somente pode ser instruída por ela. Exemplo de código: printf(“Professora Angelina\n”). Exemplo de código: A significa adicionar Linguagem de Alto Nível: é uma linguagem que utiliza comandos na forma de palavras (o idioma empregado é o inglês). Exemplo de código: 00010101 Linguagem de Baixo Nível: Assembly é uma linguagem que associa mnemônicos-códigos às instruções de linguagem de máquina. Nela foi possível simbolizar os endereços de memória. dando um nome para uma área da memória. Alguns enquadram as linguagens dentro das gerações. descrevendo exatamente quais circuitos ligar ou desligar. Profª Angelina V.Melaré 128 . Os códigos dos programas são um conjunto de instruções que sinalizam à CPU para realizar operações de conexão de circuito. Linguagem de Máquina: São instruções escritas em formato binário. para poderem ser executadas. Exemplos de linguagens de alto nível: Pascal.S. Visual C#. A linguagem C e C++ são consideradas por alguns escritores de Nível Médio. a CPU somente executa essa linguagem. linguagem mais natural (inteligência artificial). Essas linguagens possuem conjuntos de regras (sintaxe) e comandos.Nível de Programação das Linguagens Os programas podem ser escritos em diferentes linguagens. Cobol. as quais o computador consegue interpretar as instruções e executá-las. porém. de características como: banco de dados. Todas as outras linguagens devem ser traduzidas para essa. Nessas gerações existe a diferenciação do uso ou não.

Marcos Vianna e VILLASBOAS.. 3ª ed. Introdução a Estrutura de Dados. Ralph M. 2ª ed. São Paulo. MDI. G. José L. São Paulo. A. Rio de Janeiro. Roberto e CARIBÉ Carlos. C Completo e Total. PEREIRA. ROBERTO. São Paulo. Edilene A. Ed. Princípios de Sistemas de Informação. Ed.S.Bibliografia Consultada e Referenciada ASCENCIO. PIC – Programação em C. Renato e RANGEL. Luiz Felipe P. 2007 SCHILDT. Érica. Fabio. 2004 FORBELLONE. Ed. 2002 CELES. Tecnologia de Elaboração de Material Didático Impresso. CERQUEIRA. Ed. FTD. 2000. Ed. Makron Books.Melaré 129 . Ed. Ana F. técnicas e linguagens. Programação: conceitos. Makron Books.A Construção de Algoritmos e Estruturas de Dados. 1996. 1996 SP STAIR. Lógica de Programação . Waldemar. 7ed. Campus. et. Érica. RJ Profª Angelina V. L. 1996 VILLAS. e CAMPOS. Introdução à Computação. 2ed. SENAI-SP. 1988 RINALDI. 1996. Ed.0 Comandos e Funções. Pearson. 1993 CARIBÉ. Fundamentos da Programação de Computadores. LTC. Turbo Pascal 7. Herbert. V. Campus. V.al.