Linguagem C

Prévia do material em texto

Linguagem C 
Parte 1 
 
Características da Linguagem C 
Idealizada a partir da linguagem BCPL, que influenciou posteriormente a linguagem B., sendo na 
década de 1970, criada como C, que era utilizada no sistema operacional UNIX, versão 5. 
Todo compilador C vem com uma biblioteca padrão com funções que realizam tarefas de 
propósito geral. Ex: operações de entrada e saída, operações matemáticas, etc. Essa biblioteca pode 
estar contida em diferentes arquivos menores. 
Uma função é uma rotina composta por um código que executa uma determinada tarefa específica. 
Uma função pode se encontrar pronta numa biblioteca ou então ser criada pelo programador em um 
programa. 
Quando se utiliza uma das funções de biblioteca, o compilador C apenas marca seu nome para que o 
linkeditor, posteriormente, combine o código do programa com o código dessas funções, na criação 
do código executável do programa. 
Além do uso de funções prontas, todo programa em C consiste de uma ou mais funções editadas e 
criadas pelo programador. A única que realmente tem que existir é a chamada função main, que 
significa principal, a qual normalmente contém a estrutura principal do programa, tendo as outras 
funções o objetivo de executar algumas tarefas para o programa. 
Passos para a criação de um programa em C: 
 editar o código fonte do programa em C 
 compilar o programa (código objeto) 
 linkeditar o programa com funções de bibliotecas necessárias (código executável). 
 
Formato geral de um programa: 
 
 declarações globais: - inclusão de bibiliotecas 
 - declarações de outras funções do programa 
 - declarações de variáveis globais 
 
 int main ( ) 
 { 
 corpo principal: - declarações de variáveis locais 
 - comandos e estruturas 
 } 
 
 ... corpo das outras funções se existirem 
 
onde, 
 inclusão de bibliotecas: indica quais as bibliotecas, de cujas funções o programa necessita, 
serão utilizadas. Declaração da inclusão: #include< nomeBibilioteca>. 
 declarações de outras funções do programa: protótipos de funções criadas pelo programador, 
se existirem no programa 
 declarações de variáveis globais: são variáveis que podem ser utilizadas por qualquer função 
criada pelo programador, dentro do programa. 
 declarações de variáveis locais: são variáveis que podem ser utilizadas apenas no código da 
função aonde elas se encontram. 
 comandos e estruturas: compreendem o código da tarefa executada na função 
 
Em C, todo corpo de comandos contidos numa função deve estar contido entre chaves { }. 
 
 
Comentários: 
São observações adicionadas ao programa com o intuito de documentar ou explicar algo. Não são 
interpretadas pelo compilador. Podem aparecer sozinhos numa linha ou junto em uma mesma linha 
de código. Forma de uso: 
 // aparecem no início de comentários de uma linha 
 /* iniciam e terminam comentários que 
 utilizam varias linhas */ 
 
Dados 
São representados em variáveis de memória ou por constantes. 
 
Os tipos básicos de dados são: 
 char (character): compreende 1 caracter que pode ser letras, dígitos numéricos, caracteres 
especiais. 
 int (integer): números inteiros positivos e negativos 
 float (floating): números reias (fracionários) 
 double: números reias (fracionários) com dupla precisão 
 
Modificadores dos tipos básicos: usado para alterar um tipo básico adaptando-o às necessidades de 
diversas situações. 
 signed: com sinal 
 unsigned: sem sinal 
 short: curto 
 long: longo 
 Ex: unsigned int 
 
Identificadores: são nomes fornecidos a funções e variáveis, contendo um ou mais caracteres, onde 
o primeiro deve ser um letra ou sublinhado e, os demais caracteres, letras, números ou sublinhado. 
Letras maiúsculas e minúsculas são tratados diferentemente. Não se pode utilizar palavras chaves da 
linguagem como identificadores. 
 
Variáveis: posições de memória para nomeadas para se armazenar dados, que podem ser alterados 
durante a execução do programa. Todas as variáveis devem ser declaradas antes de serem utilizadas. 
Declaração: 
 tipo listaVariáveis; 
onde, - tipo: um dos tipos básicos ou definidos com ou sem modificadores 
 - listaVariáveis: uma ou mais variáveis desse tipo separadas por virgulas. 
Ex: 
 int i, j; // declarações de duas variáveis do tipo int 
 double num, valor, total; // declarações de três variáveis do tipo double 
 
Inicialização de variáveis: uma variável pode ser inicializada no momento de sua declaração. 
Ex: char ch = 'a'; //a variável ch é inicializada com o caracter a 
 float x = 28.39; //a variável x é inicializada com o valor 28.39 
 
Constantes: valores fixos que não podem ser alterados durante a execução do programa. 
Ex: 65, 9.884, 'X', “Algoritmo” 
 
 
 
Variáveis do tipo constante: são constantes que podem ser nomeadas para uso em um programa. 
Se utilizam dos tipos básicos. Sua declaração é feita pela cláusula: const 
Ex: const int a = 10; // a variável constante a representa o valor 10 no programa 
 
Operador de Atribuição ( = ): 
atribui ou armazena um valor a uma variável assinalada à esquerda na expressão 
Ex: A = 8; // o valor 8 é armazenada na variável A 
 B = 'A'; // o caracter A é armazenada na variável B 
 num = A; // o conteúdo da variável A é armazenado na variável num 
 x = y = z = 0; // a valor 0 é armazenado nas variáveis x, y e z 
 
Operadores Aritméticos: 
 + soma 
 - subtração 
 * multiplicação 
 / divisão (retorna o quociente) 
 % divisão inteira (retorna o resto) 
 
Incrementos e decrementos: 
 ++ incremento de 1 unidade o conteúdo de uma variável. 
 Ex: x++; // é o mesmo que x = x + 1; 
 -- decremento de 1 unidade o conteúdo de uma variável. 
 Ex: x--; // é o mesmo que x = x – 1; 
 += incrementa unidades especificadas no conteúdo de uma variável. 
 Ex: x+=3; //incrementa de 3 unidades o conteúdo da 
 variável x ( x = x + 3;) 
 -= decrementa unidades especificadas no conteúdo de uma variável. 
 Ex: x-=5; //decrementa de 5 unidades o conteúdo da 
 variável x ( x = x - 5;) 
 *= multiplica uma quantidade especificada no conteúdo de uma variável. 
 Ex: x*=7; //multiplica 7 no conteúdo da 
 variável x ( x = x * 7;) 
 /= divide uma quantidade especificada no conteúdo de uma variável. 
 Ex: x/=4; //divide por 4 o conteúdo da 
 variável x ( x = x / 4;) 
 
Estruturas de Controle 
 
Fornecem uma estrutura à execução de um algoritmo, podendo ser combinadas. Tipos: Seqüencial, 
condicional e repetitiva. 
Estrutura Seqüencial: Expressa uma seqüência única de comandos de um algoritmo a serem 
executados na ordem em que aparecem. 
 
Exemplo de um algoritmo em C: 
 int X, Y, Total; //declara três variáveis inteiras 
 int main ( ) //inicia a função main 
 { X = 5; //armazena o valor 5 na variável X 
 Y = 8; //armazena o valor 8 na variável Y 
 Total = X + Y; //armazena o resultado da expressão na variável Total 
 } 
 
 
Operações de entrada e saída 
Em C, as operações de entrada e saída de dados estão contidas em funções prontas contidas em 
bibliotecas da linguagem. Para o uso dessas funções, deve-se incluir a biblioteca correspondente no 
programa por meio da cláusula #include. 
 
Saída de dados: 
Envia ou “escreve” uma informação numa saída específica. Ex: vídeo. 
Uma das funções para este fim é a função cout, que se encontra na biblioteca <iostream.h> 
Declaração: 
 cout << informação; 
 
onde, informação pode ser: 
 uma constante. Ex: 
 cout <<55; //envia o valor 55 
 cout <<“valor inválido”;//envia o texto 
 conteúdo de variáveis de memória. Ex: 
 cout << “A soma é “<< X; //envia texto e o conteúdo da variável X 
 resultados de expressões aritméticas. Ex: 
 cout <<“Resultado:“ << P*B/3; //envia texto e o resultado da expressão 
 
A saída de dados no vídeo permite que se possa controlar: 
 Salto de linhas: caracter \n. Este deve ser inserido no texto no local para o salto de linha. 
A quantidade de caracteres desse tipo indica a quantidade de saltos desejada. 
Ex: 
 cout << “\nA soma é “<< X; 
 Tabulamento: caracter \t. Este deve ser inserido no texto no local para o efeito de 
tabuçamento. A quantidade de caracteres desse tipo indica a quantidade de tabs desejada. 
Ex: 
 cout << “\nOs valores são: \t“<< X <<”\t”<< Y; 
 
Entrada de dados: 
Recebe ou “lê” um dado de entrada específica (ex: teclado) e o armazena numa variável de 
memória. Uma das funções para este fim é a função cin, que se encontra na biblioteca 
<iostream.h>. 
Declaração: 
 cin >> nomeVariável; 
Ex: 
 cout << “\nDigite uma letra”; //envia o texto 
 cin >> M; //recebe por digitação um caracter e o 
armazena na variável M 
 
Função system 
A partir dos próximos exemplos será incluída a biblioteca <stdlib.h>, para uso da função 
system contida nesta biblioteca. 
Para essa função será enviado como parâmetro a cláusula pause, que solicita uma pausa na 
execução do programa. Quando executada essa pausa no programa, a mensagem “Aperte uma tecla 
para continuar” aparece e a execução fica em suspenso até que uma tecla qualquer seja pressionada. 
Isso é necessário, pois o ambiente DEV C++ finaliza a janela de execução ao final do programa não 
permitindo a visualização dos resultados. 
 
Exemplo: 
1 –Receber dois números inteiros e informar a soma deles. 
 
 #include<iostream.h> //inclusão da biblioteca 
 #include<stdlib.h> //inclusão da biblioteca 
 int X, Y, Total; //declaração de variáveis inteiras 
 int main ( ) //inicia a função main 
 {cout <<“\nDigite um número ”; //envia o texto 
 cin >> X; //recebe por digitação um número e 
 o armazena na variável X 
 cout <<“\nDigite outro número ”; //envia outro texto 
 cin >> Y; //recebe por digitação um número e 
 o armazena na variável X 
 Total = X + Y; //armazena na variável Total o 
 resultado da expressão 
 cout <<“\nA soma é “ <<Total; //envia o texto e o conteúdo da variável 
 Total 
 cout << “\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
 
2 - Receber por digitação dois números e visualizar os resultados da soma e da subtração dos dois 
números. 
 #include<iostream.h> //inclusão da biblioteca 
 #include<stdlib.h> //inclusão da biblioteca 
 int n1, n2, soma, sub; //declaração de variáveis inteiras 
 int main ( ) //inicia a função main 
 {cout <<“\nDigite um número ”; //envia o texto 
 cin >> n1; //recebe por digitação um número e 
 o armazena na variável n1 
 cout <<“\nDigite outro número ”; //envia outro texto 
 cin >> n2; //recebe por digitação um número e 
 o armazena na variável n2 
 soma = n1 + n2; //armazena na variável soma o 
 resultado da soma 
 sub = n1 - n2; //armazena na variável sub o 
 resultado da subtração 
 cout <<“\nA soma é “ <<soma; //envia o texto e o conteúdo da variável 
 soma 
 cout <<“\nA subtração é “ <<sub; //envia o texto e o conteúdo da variável 
 sub 
 cout << “\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
3 - Receber por digitação dois números e visualizar os resultados da soma, da subtração, da 
multiplicação e da divisão, dos dois números. 
Obs: neste algoritmo as variáveis foram declaradas como tipo float (números reais), para permitir 
divisão fracionária. Foram utilizadas três versões diferentes para descrevê-lo. 
 
1ª versão (declaração de 4 variáveis para o armazenamento dos resultados das expressões) 
 #include<iostream.h> //inclusão da biblioteca 
 #include<stdlib.h> //inclusão da biblioteca 
 float n1, n2, soma, sub, mult ,divi; //declaração de variáveis fracionárias 
 int main ( ) //inicia a função main 
 {cout <<“\nDigite um número ”; //envia o texto 
 cin >> n1; //recebe por digitação um número e 
 o armazena na variável n1 
 cout <<“\nDigite outro número ”; //envia outro texto 
 cin >> n2; //recebe por digitação um número e 
 o armazena na variável n2 
 soma = n1 + n2; //armazena na variável soma o 
 resultado da soma 
 sub = n1 - n2; //armazena na variável sub o 
 resultado da subtração 
 mult = n1 * n2; //armazena na variável mult o 
 resultado da multiplicação 
 divi = n1 / n2; //armazena na variável divi o 
 resultado da divisão 
 cout <<“\nA soma é “<<soma; //envia o texto e o conteúdo da variável 
 soma 
 cout <<“\nA subtração é “<<sub; //envia o texto e o conteúdo da variável 
 sub 
 cout <<“\nA mltiplicação é “<<mult; //envia o texto e o conteúdo da variável 
 mult 
 cout <<“\nA divisão é “<<divi; //envia o texto e o conteúdo da variável 
 divi 
 cout << “\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
2ª versão (declaração de apenas uma variável para o armazenamento dos resultados das expressões) 
 #include<iostream.h> //inclusão da biblioteca 
 #include<stdlib.h> //inclusão da biblioteca 
 float n1, n2, result; //declaração de variáveis fracionárias 
 int main ( ) //inicia a função main 
 {cout <<“\nDigite um número ”; //envia o texto 
 cin >> n1; //recebe por digitação um número e 
 o armazena na variável n1 
 cout <<“\nDigite outro número ”; //envia outro texto 
 cin >> n2; //recebe por digitação um número e 
 o armazena na variável n2 
 result = n1 + n2; //armazena na variável result o 
 resultado da soma 
 cout <<“\nA soma é “ <<result; //envia o texto e o conteúdo da variável 
 result 
 result = n1 - n2; //armazena na variável result o 
 resultado da subtração 
 cout <<“\nA subtração é “ <<result; //envia o texto e o conteúdo da variável 
 result 
 result = n1 * n2; //armazena na variável result o 
 resultado da multiplicação 
 cout <<“\nA multiplicação é “ <<result; //envia o texto e o conteúdo 
 da variável result 
 result = n1 / n2; //armazena na variável result o 
 resultado da divisão 
 cout <<“\nA divisão é “ <<result; //envia o texto e o conteúdo da variável 
 result 
 cout << “\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
3ª versão (as expressões são calculadas dentro do cout) 
 #include<iostream.h> //inclusão da biblioteca 
 #include<stdlib.h> //inclusão da biblioteca 
 float n1, n2; //declaração de variáveis fracionárias 
 int main ( ) //inicia a função main 
 {cout <<“\nDigite um número ”; //envia o texto 
 cin >> n1; //recebe por digitação um número e 
 o armazena na variável n1 
 cout <<“\nDigite outro número ”; //envia outro texto 
 cin >> n2;//recebe por digitação um número e 
 o armazena na variável n2 
 cout <<“\nA soma é “ << n1+n2; //envia o texto e o conteúdo da variável 
 result 
 cout <<“\nA subtração é “ << n1-n2;//envia o texto e o conteúdo da variável 
 result 
 cout <<“\nA multiplicação é “ << n1*n2; //envia o texto e o conteúdo 
 da variável result 
 cout <<“\nA divisão é “ << n1/n2; //envia o texto e o conteúdo da variável 
 result 
 cout << “\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
 
Parte 2 
 
Estrutura Condicional ou de Seleção 
Avalia se uma condição associada a cláusula de condição if (se) é verdadeira ou falsa, para 
determinar quais comandos deverão ser executados. 
Na comparação de dois valores utilizam-se os operadores relacionais. 
 
Operadores Relacionais: 
Referem-se a maneira como valores se relacionam uns com outros. 
 == igual 
 != diferente 
 < menor 
 < = menor ou igual 
 > maior 
 > = maior ou igual 
 
Uma estrutura condicional em C pode ser simples ou composta: 
 Estrutura Simples: uma condição é avaliada e, se a condição for verdadeira, um conjunto 
ou bloco de um ou mais comandos são executados. Se a condição for falsa, nenhum bloco 
de comandos é indicado e a execução continua fora da estrutura 
 
Declaração da estrutura: 
 
 if (condição) 
 { Bloco com um ou mais comandos ou estruturas } 
 
O uso das chaves { } indicam o bloco de comandos. Não é necessário a cláusula END SE 
para indicar o fim da estrutura condicional. 
Quando no bloco de comandos houver apenas um comando não é obrigatório o uso das { }; 
 
Ex: 
 if ( A == B) 
 cout << “\nOs valores das duas variáveis são iguais”;} 
 
ou 
 
 if ( A == B) 
 cout << “\nOs valores das duas variáveis são iguais”; 
 
 
Obs: se o conteúdo das variáveis de memória A e B são iguais, a função cout é executada. 
Caso contrário, o programa segue normalmente fora da estrutura. 
 
 Estrutura Composta: uma condição é avaliada e, se a condição for verdadeira, um 
conjunto ou bloco de um ou mais comandos são executados. Se a condição for falsa, um 
conjunto ou bloco de comandos de um ou mais comandos são executados. Após o término 
da execução de um dos blocos, a execução continua fora da estrutura 
 
 
Declaração da estrutura: 
 
 if (condição) 
 { Bloco com um ou mais comandos ou estruturas } 
 else 
 { Bloco com um ou mais comandos ou estruturas } 
 
A cláusula else (senão) indica a negação da condição da cláusula if. O uso das chaves { } 
indicam o bloco de comandos. Não é necessário a cláusula END SE para indicar o fim da 
estrutura condicional. 
Quando no bloco de comandos houver apenas um comando não é obrigatório o uso das { }; 
 
Ex: 
if (A == B) 
 {cout <<“\nOs valores das duas variáveis são iguais”; } 
else 
 {cout <<“\nOs valores das duas variáveis são diferentes”; 
} 
 
ou 
 if (A == B) 
 cout <<“\nOs valores das duas variáveis são iguais”; 
else 
 cout <<“\nOs valores das duas variáveis são diferentes”; 
 
Obs: se o conteúdo das variáveis de memória A e B são iguais, a função cout do primeiro 
bloco é executado. Senão, a função cout do segundo bloco é executado. Nunca os dois 
blocos serão executados seqüencialmente. Após a execução de um deles, o programa segue 
normalmente fora da estrutura. 
 
 
Exercícios 
 
1 – Receber por digitação um número inteiro e informar se o mesmo é par ou impar. 
 
1ª versão ( foi criado a variável resto para armazenar o resto da divisão) 
 #include<iostream.h> //inclusão da biblioteca 
 #include<stdlib.h> //inclusão da biblioteca 
 int num, resto; //declaração de variável inteira 
 int main ( ) //inicia a função main 
 {cout <<“\nDigite um número ”; //envia o texto 
 cin >> num; //recebe por digitação um número e 
 o armazena na variável num 
 resto = num % 2; //armazena o resto da divisão do numero 
 por 2 na variável resto 
 if (resto == 0) //compara o conteúdo de resto 
com 0 
 {cout <<“\nO número é par“;} //informa que o numero é par 
 else 
 {cout <<“\nO número é impar“;} //informa que o numero é impar 
 
 cout << “\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
2ª versão (o cálculo do resto da divisão foi feito dentro da condição. O seu resultado será 
comparado 
 com o valor 0) 
 #include<iostream.h> //inclusão da biblioteca 
 #include<stdlib.h> //inclusão da biblioteca 
 int num; //declaração de variável inteira 
 int main ( ) //inicia a função main 
 {cout <<“\nDigite um número ”; //envia o texto 
 cin >> num; //recebe por digitação um número e 
 o armazena na variável num 
 if (num % 2 == 0) //compara resultado da expressão com 0 
 {cout <<“\nO número é par“;} //informa que o numero é par 
 else 
 {cout <<“\nO número é impar“;} //informa que o numero é impar 
 
 cout << “\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
Dentro de qualquer um dos blocos de comandos podem existir outras estruturas condicionais. 
Sempre que numa cláusula else for necessária uma condição a ser avaliada, deve existir um if 
associado à condição. 
Exemplo: 
if (condição) 
 { if (condição) 
 { Bloco com um ou mais comandos ou estruturas } 
 else 
 { Bloco com um ou mais comandos ou estruturas } 
 } 
else 
 { Bloco com um ou mais comandos ou estruturas } 
 
Exemplo: 
if (condição) 
 { Bloco com um ou mais comandos ou estruturas } 
else 
 { if (condição) 
 { Bloco com um ou mais comandos ou estruturas } 
 else 
 { Bloco com um ou mais comandos ou estruturas } 
 } 
 
Esta última forma também pode ser expressa na forma else if.. 
Exemplo: 
 
if (condição) 
 { Bloco com um ou mais comandos ou estruturas } 
else if (condição) 
 { Bloco com um ou mais comandos ou estruturas } 
else if (condição) 
 { Bloco com um ou mais comandos ou estruturas } 
 - - - - - - 
else 
 { Bloco com um ou mais comandos ou estruturas } 
 
Exemplo de algoritmo: 
Receber por digitação dois números inteiros e um operador aritmético (+ ou -). Realizar a operação 
desejada e visualizar o resultado. 
 
1ª versão (utiliza a variável result para armazenar o resultado e depois visualizá-lo) 
 #include<iostream.h> //inclusão da biblioteca 
 #include<stdlib.h> //inclusão da biblioteca 
 int N1, N2, result; //declaração de variáveis inteiras 
 char oper; //declaração de variável caracter 
 int main () 
 { cout << “\nDigite um número”; //envia o texto 
 cin >> N1; //recebe por digitação um número 
 e o armazena na variável N1
 cout << “\nDigite um número”; //envia o texto 
 cin >> N2; //recebe por digitação um número 
 e o armazena na variável N2
 
 cout << “\n Digite um operador aritmético (+ -)”; //envia o texto 
 cin >> oper; //recebe por digitação o operador 
 e o armazena na variável oper
 if (oper == '+') //compara conteúdo de oper com ‘+’ 
 { result = N1 + N2; //armazena o resultado da 
 expressão 
 na variável result 
 cout <<”\nResultado da soma: “ << result; //envia um texto e o 
conteúdo da variável 
result} 
 else if (oper == '-') //compara conteúdo de oper com ‘+’ 
 { result = N1 – N2; //armazena o resultado da expressão 
 na variável result 
 cout <<“\nResultado da subtração: “<<result; //envia um texto 
e o conteúdo da variável result 
 } 
 else 
 { cout <<“\nOperador aritmético inválido“;} //envia um texto 
 
 cout << “\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
2ª versão (a operação aritmética é feita no cout) 
 #include<iostream.h> //inclusão da biblioteca 
 #include<stdlib.h> //inclusão da biblioteca 
 int N1, N2; //declaração de variáveis inteiras 
 char oper; //declaração de variável caracter 
 int main () 
 { cout << “\nDigite um número”; //envia o texto 
 cin >> N1; //recebe por digitação um número 
 //e o armazena na variável N1
 
 cout << “\nDigite um número”; //envia o texto 
 cin >> N2; //recebe por digitação um número 
 e o armazena na variável N2
 
 cout << “\n Digite um operador aritmético (+ -)”; //envia o texto 
 cin >> oper; //recebe por digitação um número 
 e o armazena na variável oper
 if (oper == '+') 
 { cout <<”\nResultado da soma: “ << N1+N2;} //envia um texto e o 
 resultado da expressão 
 else if (oper == '-') 
 { cout <<“\nResultado da subtração: “<< N1–N2;} //envia um texto 
e o resultado da expressão 
 else 
 { cout <<“\nOperador aritmético inválido“;} //envia um texto 
 cout << “\n\n”; //salta duas linhas no vídeo 
 system(“pause”); //executa uma pausa na execução 
 } 
 
 
Expressões condicionais 
 
Uma estrutura condicional pode conter na sua parte condição uma expressão condicional composta 
por mais de uma condição. Nesse caso, utilizam-se os operadores lógicos entre elas, os quais 
definem como as relações entre as condições são conectadas. 
 
Operadores Lógicos: 
 ! not (NÃO) 
 && and (E) 
 || or (OU) 
 
Durante a execução do programa, o processador avalia cada condição da expressão condicional 
determinando se são verdadeiras ou falsas e, em seguida, utiliza os operadores lógicos aplicando a 
Tabela Verdade a seguir, para determinar o resultado final da expressão (V ou F). A Tabela Verdade 
é a mesma descrita nas aulas de algoritmos. 
 
Ex: 
 if (A == B && C > 4) 
 if (C < D || A >= B) 
 if (!( A == D / 3 || C < = 9)) 
 
Exemplo 
Receber por digitação 3 números inteiros diferentes. Em seguida informar no vídeo os números em ordem 
crescente. 
 
1ª versão: 
#include <stdlib.h> 
#include <iostream.h> 
int n1,n2,n3; 
int main () 
{ cout <<”\nDigite um numero”; 
 cin >> n1; 
 cout <<”\nDigite um segundo numero diferente do primeiro”; 
 cin >> n2; 
 cout <<”\nDigite um terceiro numero diferente dos outros”; 
 cin >> n3; 
 if (n1 == n2 || n1 == n3 || n2 == n3) 
 {cout <<”\nOs três numeros não são diferentes”;} 
 else 
 {if (n1 < n2 && n1 < n3 && n2 < n3) 
 cout <<”\nOrdem crescente: “<<n1<<”, “<<n2<<”, “<<n3; 
 else if (n1 < n2 && n1 < n3 && n3 < n2) 
 cout <<”\nOrdem crescente: “<<n1<<”, “<<n3<<”, “<<n2; 
 else if (n2 < n1 && n2 < n3 && n1 < n3) 
 cout <<”\nOrdem crescente: “<<n2<<”, “<<n1<<”, “<<n3; 
 else if (n2 < n1 && n2 < n3 && n3 < n1) 
 cout <<”\nOrdem crescente: “<<n2<<”, “<<n3<<”, “<<n1; 
 else if (n3 < n1 && n3 < n2 && n1 < n2) 
 cout <<”\nOrdem crescente: “<<n3<<”, “<<n1<<”, “<<n2; 
 else 
 cout <<”\nOrdem crescente: “<<n3<<”, “<<n2<<”, “<<n1; 
 } 
 cout <<”\n\n”; 
 system (“pause”); 
} 
 
2ª versão: 
 
#include <stdlib.h> 
#include <iostream.h> 
int n1,n2,n3; 
int main () 
{ cout <<”\nDigite um numero”; 
 cin >> n1; 
 cout <<”\nDigite um segundo numero diferente do primeiro”; 
 cin >> n2; 
 cout <<”\nDigite um terceiro numero diferente dos outros”; 
 cin >> n3; 
 if (n1 == n2 || n1 == n3 || n2 == n3) 
 {cout <<”\nOs três numeros não são diferentes”;} 
 else 
 {if (n1 < n2 && n1 < n3) 
 {cout <<”\nOrdem crescente : “<< n1 <<”, “; 
 if (n2 < n3) 
 {cout << n2 <<”, “<< n3;} 
 else 
 {cout << n3 <<”, “ << n2;} 
} 
 else if (n2 < n1 && n2 < n3) 
 {cout <<”\nOrdem crescente : “<< n2 <<”, “; 
 if (n1 < n3) 
 {cout << n1 <<”, “<< n3;} 
 else 
 {cout << n3 <<”, “<< n1;} 
} 
 else if (n3 < n1 && n3 < n2) 
 {cout <<”\nOrdem crescente : “<< n3 <<”, “; 
 if (n2 < n1) 
 {cout << n2 <<”, “<< n1;} 
 else 
 {cout << n1 <<”, “<< n2;} 
 } 
 } 
 cout <<”\n\n”; 
 system (“pause”); 
} 
 
 
 
 
 
3ª versão: 
 
#include <stdlib.h> 
#include <iostream.h> 
int n1,n2,n3,prim,meio,ult; 
int main () 
{ cout <<”\nDigite um numero”; 
 cin >> n1; 
 cout <<”\nDigite um segundo numero diferente do primeiro”; 
 cin >> n2; 
 cout <<”\nDigite um terceiro numero diferente dos outros”; 
 cin >> n3; 
 if (n1 == n2 || n1 == n3 || n2 == n3) 
 {cout <<”\nOs três numeros não são diferentes”;} 
 else 
 {if (n1 < n2 && n1 < n3) 
 {prim = n1;} 
 else if (n2 < n1 && n2 < n3) 
 {prim = n2;} 
 else 
 {prim = n3;} 
 if (n1 > n2 && n1 > n3) 
 {ult = n1;} 
 else if (n2 > n1 && n2 > n3) 
 {ult = n2;} 
 else 
 {ult = n3;} 
 } 
 meio = (n1 + n2 + n3) – (prim + ult); 
 cout <<”\nOrdem crescente: “<<prim<<”, “<<meio<<”, “<<ult; 
 cout <<”\n\n”; 
 system (“pause”); 
} 
 
Funções: printf e scanf 
 
São funções em C, para o tratamento da saída e entrada de dados, respectivamente. Estas duas 
funções utilizam formatadores para indicar o tipo de dado que está sendo recebido por digitação ou 
enviado para o vídeo. Os formatadores são: 
 
 %i - números inteiros (int) 
 %f - números reais (float) 
 %d - números reais com dupla precisão (double) 
 %c - caracter (char) 
 %s - vários caracteres (string) 
 
 printf: envia ou “escreve” uma informação no vídeo. Biblioteca <stdio.h> 
 Declaração: 
 printf (informação); 
 onde, informação pode ser: 
 uma constante. Ex: 
 printf(“\nAlgoritmos”); 
 conteúdo de variáveis de memória. Neste caso, na parte texto deve aparecer o 
formatador na posição em que se deseja inserir o conteúdo da variável. Ex: 
 printf(“\nA soma é: %i“,X); 
 resultados de expressões aritméticas. Ex: 
 printf(“\nResultado: %f“,P*B/3); 
 printf(“\nOdobro de %i é %i“, num, num*2); 
Obs: O formatador para tipo float (%f), permite a visualização de um número fixo de casas 
decimais, utilizando-se o ponto decimal e o número de casas decimais entre os dois 
caracteres. Ex: 
 printf(“\nValor da compra: %.2f“,vlCompra); 
 
 scanf: recebe por digitação um valor e o armazena na variável indicada no parâmetro. 
Utiliza o formatador para indicar o tipo do dado recebido. Biblioteca <stdio.h> 
 Declaração: 
 scanf (formatadorTipo,&variável); 
 Ex: 
 scanf (“%i”, &numero); //recebe por digitação um número inteiro e 
 o armazena na variável numero 
 Parte 3 
 
Estrutura Repetitiva 
 
Permite que um bloco ou conjunto de comandos ou estruturas sejam repetidas enquanto a condição 
indicada for verdadeira. Na linguagem C existem três tipos de uso de estruturas de repetição. 
 
1 – Estrutura WHILE (enquanto) 
 
Declaração: 
 while (condição) 
 { Bloco com um 
 ou mais comandos ou estruturas 
 } 
onde, 
condição é a comparação de dois valoresque podem ser constantes, conteúdos de variáveis de 
memória, resultado de expressões aritméticas ou retorno de funções, por meio do uso de 
operadores relacionais. Aqui pode ser utilizado uma expressão condicional com mais de uma 
condição relacionada com os operadores && (E) e ||(OU). 
 
Se a condição for verdadeira o bloco de comandos entre chaves { } será executado. Ao ser 
encontrado a chave de fim de bloco, a execução do algoritmo retorna ao início da estrutura para 
uma nova avaliação da condição. Quando a condição for falsa, o bloco não é executado e a 
execução do programa continua a partir do próximo comando após a estrutura. 
Não é obrigatório o uso de chaves para blocos com apenas um comando. 
 
Exemplos: 
1- Receber por digitação uma certa quantidade de números, enquanto o usuário desejar digitar 
números. Somá-los e visualizar o resultado da soma ao final. 
 #include <iostream.h> 
 #include <stdlib.h> 
 int num, soma; //declaração das variáveis inteiras 
 char continua; //declaração de variável tipo caracter 
 int main () //início da função main 
 {soma = 0; //inicializa soma com o valor 0 
 continua = ‘S’; //inicializa continua com ‘S’ 
 while ( continua ==‘S’) //se verdadeira executa o bloco 
 {cout <<“\nDigite um número”; //envia um texto 
 cin >> num; //armazena o valor digitado em num 
 soma = soma + num; //acumula o conteúdo de num em soma 
 cout <<“\nDeseja continuar S/N”; //envia um texto 
 cin >> continua; //armazena o valor digitado em continua
 } //retorna ao inicio da estrutura 
 cout <<“\nA soma dos números é “<<soma; //envia o texto e conteúdo 
 cout <<”\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
 
 
 
2- Receber por digitação 5 números, somá-los e visualizar o resultado da soma ao final. 
 #include <iostream.h> 
 #include <stdlib.h> 
 int num, soma, cont; //declaração das variáveis inteiras 
 int main () //início da função main 
 {soma = 0; //inicializa soma com o valor 0 
 cont = 0; //inicializa cont com 0 
 while (cont < 5) //se verdadeira executa o bloco 
{cout <<“\nDigite um número”; //envia um texto 
 cin >>num; //armazena o valor digitado em num 
 soma = soma + num; //acumula o conteúdo de num em soma 
 cont++; //acumula 1 em cont (cont = cont +1) 
 } //retorna ao inicio da estrutura 
 cout << “\nA soma dos números é “<<soma; //envia o texto e conteúdo 
 cout <<”\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
3 - Uma pesquisa de mercado entrevistou 100 pessoas para saber a preferência pelos produtos A, B 
e C. Receber por digitação as preferências dessas pessoas e visualizar ao final a quantidade de 
preferências de cada tipo de produto. 
 
 #include <iostream.h> 
 #include <stdlib.h> 
 int totA, totB, totC,cont; //declaração das variáveis inteiras 
 char prod; //declaração de variável tipo caracter 
 int main () //início da função main 
 {cont = 0; //inicializa cont com o valor 0 
 totA = 0; //inicializa totA com o valor 0 
 totB = 0; //inicializa totB com o valor 0 
 totC = 0; //inicializa totC com o valor 0 
 while (cont < 100) //se verdadeira executa o bloco 
 {cout<< “\nDigite o produto “; //envia o texto 
 cin >> prod; //armazena o produto digitado em prod 
 if (prod == 'A'|| prod == 'a') 
 totA++; //acumula 1 na variável totA (totA = totA +1) 
 else if (prod == 'B' || prod == 'b') 
 totB++; //acumula 1 na variável totB (totB = totB +1) 
 else if (prod == 'C' || prod == 'c') 
 totC++; //acumula1 na variável totC (totC = totC +1) 
 cont++; //acumula 1 em cont (cont = cont + 1) 
 } //retorna ao inicio da estrutura 
 cout <<“\nQtde de produtos A: “<<totA; //envia o texto e conteúdo de totA 
 cout <<“\nQtde de produtos B: “<<totB; //envia o texto e conteúdo de totB 
 cout <<“\nQtde de produtos C: “<<totC; //envia o texto e conteúdo de totC 
 cout <<”\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
2 – Estrutura DO ... WHILE (faça ... enquanto) 
 
Declaração: 
 do 
 { Bloco com um 
 ou mais comandos ou estruturas 
 }while (condição); 
 
onde, 
condição é a comparação de dois valores que podem ser constantes, conteúdos de variáveis de 
memória, resultado de expressões aritméticas ou retorno de funções, por meio do uso de 
operadores relacionais. Aqui pode ser utilizado uma expressão condicional com mais de uma 
condição relacionada com os operadores && (E) e ||(OU). 
 
Ao encontrar o comando do (faça) o bloco entre chaves { }é executado. Ao terminar o bloco, a 
condição é testada: se a condição for verdadeira a execução retorna ao comando do e o bloco de 
comandos será executado novamente. Quando a condição for falsa, o bloco não é executado e a 
execução do programa continua a partir do próximo comando após a estrutura. 
Não é obrigatório o uso de chaves para blocos com apenas um comando. 
 
Exemplo: 
 Receber por digitação 5 números, somá-los e visualizar o resultado da soma ao final. 
 #include <iostream.h> 
 #include <stdlib.h> 
 int num, soma, cont; //declaração das variáveis inteiras 
 int main () //início da função main 
 {soma = 0; //inicializa soma com o valor 0 
 cont = 0; //inicializa cont com 0 
 do //executa o bloco de comandos 
{cout <<“\nDigite um número”; //envia um texto 
 cin >>num; //armazena o valor digitado em num 
 soma = soma + num; //acumula o conteúdo de num em soma 
 cont++; //acumula 1 em cont (cont = cont +1) 
 } while (cont < 5); //se verdadeira executa o bloco novamente 
 cout << “\nA soma dos números é “<<soma; //envia o texto e conteúdo 
 cout <<”\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
 
3 – Estrutura FOR (para) 
 
Declaração: 
 for (inicializações ; condição ; incrementos ) 
 { Bloco com um 
 ou mais comandos ou estruturas 
 } 
onde, 
 inicializações: uma ou mais inicializações a serem feitas quando da primeira vez que a estrutura 
é executada. Separar com virgulas se existirem várias inicializações. 
 condição: é a comparação de dois valores que podem ser constantes, conteúdos de variáveis de 
memória, resultado de expressões aritméticas ou retorno de funções, por meio do uso de 
operadores relacionais. Aqui pode ser utilizado uma expressão condicional com mais de uma 
condição relacionada com os operadores && (E) e ||(OU). 
 incrementos: um ou mais incrementos ou decrementos a serem executados sempre que houver 
um retorno para o início da estrutura. Separar com virgulas se existirem vários incrementos. 
 
A estrutura do for possui três parâmetros separados por ponto-e-virgula (;). 
Da primeira vez que a estrutura é executada o parâmetro das inicializações é executado e em 
seguida o parâmetro com a condição é avaliado. Se a condição for verdadeira o bloco de comandos 
entre chaves { } será executado. Ao ser encontrado a chave de fim de bloco, a execução do 
algoritmo retorna ao início da estrutura. Sempre que houver retornos, primeiro é executado o 
parâmetro dos incrementos e em seguida, uma nova avaliação da condição. Quando a condição for 
falsa, o bloco não é executadoe a execução do programa continua a partir do próximo comando 
após a estrutura. 
Não é obrigatório o uso de chaves para blocos com apenas um comando. 
 
 
Exemplo: 
 Receber por digitação 5 números, somá-los e visualizar o resultado da soma ao final. 
 #include <iostream.h> 
 #include <stdlib.h> 
 int num, soma, cont; //declaração das variáveis inteiras 
 int main () //início da função main 
 { for (cont = 0,soma=0; cont < 5; cont++) 
 {cout <<“\nDigite um número”; //envia um texto 
 
 cin >>num; //armazena o valor digitado em num 
 soma = soma + num; //acumula o conteúdo de num em soma 
 } //retorna ao início da estrutura 
 cout << “\nA soma dos números é “<<soma; //envia o texto e conteúdo 
 cout <<”\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
Obs: as inicializações das variáveis cont e soma, que eram feitas antes de começar a estrutura de repetição, 
passaram a ser feitas no primeiro parâmetro do for e o incremento da variável cont, que era feito dentro do 
bloco de comandos da estrutura, passou a ser feito no terceiro parâmetro do for. 
 
Variações do for: 
 com várias inicializações: 
 Ex: for (x =0, y =1, z =0; x < 20; x++) 
 com vários incrementos ou decrementos: 
 Ex: for (a =20; a >= 1; a--, b++, c++) 
 sem inicializações: 
 Ex: for (; p <= 200; p++) 
 sem incrementos ou decrementos: 
 Ex: for (m =0, s =0; m <100;) 
 só com a condição: 
 Ex: for (; x >= 500;) 
 sem parâmetros: (for infinito) 
 Ex: for (;;) 
Obs: um loop infinito é utilizado quando não se sabe por exemplo, quando algum evento externo irá 
acontecer que possa interromper a estrutura de repetição. Neste caso pode-se utilizar o comando break.. 
 
 
Comando break: 
permite interromper uma estrutura de repetição de qualquer tipo, mesmo que a condição ainda seja 
verdadeira. 
Nesse caso, a execução continua a partir do próximo comando após a estrutura. 
 
Ex: 
 Receber por digitação 5 números ou até que o número recebido seja negativo, somá-los e visualizar o 
resultado da soma ao final. 
 #include <iostream.h> 
 #include <stdlib.h> 
 int num, soma, cont; //declaração das variáveis inteiras 
 int main () //início da função main 
 { for (cont = 0,soma=0; cont < 5; cont++) 
 {cout <<“\nDigite um número”; //envia um texto 
 cin >>num; //armazena o valor digitado em num 
 if (num < 0) 
 {cout <<”\nNúmero negativo”; //fim da digitação de numeros 
 break; //interrompe e continua após a estrutura 
 } 
 soma = soma + num; //acumula o conteúdo de num em soma 
 } 
 cout << “\nA soma dos números é “<<soma; //envia o texto e conteúdo de 
 soma 
 cout <<”\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
 
Exemplo: 
Uma pesquisa de mercado entrevistou 100 pessoas para saber a preferência pelos produtos A, B e 
C. Receber por digitação as preferências dessas pessoas e visualizar ao final a quantidade de 
preferências de cada tipo de produto. 
 
 #include <iostream.h> 
 #include <stdlib.h> 
 int totA, totB, totC,cont; //declaração das variáveis inteiras 
 char prod; //declaração de variável tipo caracter 
 int main () //início da função main 
 {for (cont =0,totA =0,totB = 0,totC = 0;cont < 100; cont++) 
 { cout<< “\nDigite o produto “; //envia o texto 
 cin >> prod; //armazena o produto digitado em prod 
 if (prod == 'A'|| prod == 'a') 
 totA++; //acumula 1 na variável totA (totA = totA +1) 
 else if (prod == 'B' || prod == 'b') 
 totB++; //acumula 1 na variável totB (totB = totB +1) 
 else if (prod == 'C' OU prod == 'c') 
 totC++; //acumula1 na variável totC (totC = totC +1) 
 } //retorna ao inicio da estrutura 
 cout <<“\nQtde de produtos A: “<<totA; //envia o texto e conteúdo de totA 
 cout <<“\nQtde de produtos B: “<<totB; //envia o texto e conteúdo de totB 
 cout <<“\nQtde de produtos C: “<<totC; //envia o texto e conteúdo de totC 
 cout <<”\n\n”; //salta duas linhas no vídeo 
 system (“pause”); //executa uma pausa na execução 
 } 
 
Exemplo de tradução para C, de um algoritmo de teste de mesa 
 
Algoritmo 
 var: x1, x2, y, k, m, b, c 
 escrever “Digite um numero” 
 ler x1 
 escrever “Digite outro numero” 
 ler x2 
 y = 7 
 k = 0 
 m = 0 
 c = 1 
 repita enquanto y >= x1 
 k = k + x1 + 1 
 se k > 7 
 c = c + 2 
 senão 
 c = c + 3 
 fim se 
 b = 1 
 repita enquanto b < x2 
 m = m + 2 
 b = b + 1 
 c = c + 1 
 fim repita 
 y = y – 1 
 fim repita 
 escrever c 
 escrever k 
 escrever m 
Fim 
 
 Traduzindo-se para C: 
 
#include <stdlib.h> 
#include <iostream.h> 
int x1, x2, y, k, m, b, c; 
int main() 
{cout << "\nDigite um numero "; 
 cin >> x1; 
 cout << "\nDigite outro numero "; 
 cin >> x2; 
 y = 7; 
 k = 0; 
 m = 0; 
 c = 1; 
 while (y >= x1) 
 { k = k + x1 + 1; 
 if (k > 7) 
 {c = c + 2;} 
 else 
 {c = c + 3;} 
 b = 1; 
 while (b < x2) 
 { m = m + 2; 
 b++; 
 c++; 
 } 
 y--; 
 } 
 cout <<"\nValor da variavel c: "<< c; 
 cout <<"\nValor da variavel k: "<< k; 
 cout <<"\nValor da variavel m: "<< m; 
 cout <<"\n\n"; 
 system ("pause"); 
}