Estrutura Seqüencial em C

Prévia do material em texto

1 
LINGUAGEM E TÉCNICA DE PROGRAMAÇÃO I 
 
Profa. Gisele Busichia Baioco 
gisele@ft.unicamp.br 
 
 
Algoritmos Estruturados e 
Linguagem de Programação Estruturada 
 
Estrutura Seqüencial em C 
1 Formato Geral da Estrutura Seqüencial em C 
#include <nome-da-biblioteca> 
 
main() 
{ 
 declaração-de-variáveis 
 comandos 
} 
 
Bibliotecas 
As bibliotecas (ou arquivos-cabeçalho) são arquivos contendo várias funções que 
podem ser incorporadas aos programas C. A diretiva #include faz com que o texto contido 
dentro da biblioteca especificada por nome-da-biblioteca seja inserido no programa. 
 
Sensibilidade ao Caso 
É importante salientar que a linguagem C é sensível ao caso, ou seja, em C letras 
maiúsculas e minúsculas são tratadas como caracteres diferentes (por exemplo, a é diferente 
de A). Sendo assim, todos os comandos devem, obrigatoriamente, ser escritos com letras 
minúsculas. 
 
Palavras Reservadas de C 
Uma palavra reservada é essencialmente um comando (instrução) ou um tipo de 
dado e, na maioria das vezes, são as palavras reservadas de uma linguagem que definem o que 
pode ser feito e como será feito. As palavras reservadas não podem ser utilizadas como 
identificadores. 
O conjunto de palavras reservadas (32) que o padrão ANSI C especifica são as 
seguintes: 
 
auto double int struct 
break else long switch 
case enum register typedef 
char extern return union 
const float short unsigned 
continue for signed void 
default goto sizeof volatile 
do if static while 
 2 
 
 Vale a pena observar que todas as palavras reservadas de C são minúsculas. Portanto, 
como C é sensível ao caso, deve-se tomar cuidado ao digitar uma palavra reservada. 
2 Declaração de Variáveis em C 
O nome da variável é um identificador que segue as regras válidas para a formação de 
identificadores (formado por letras, dígitos e sublinhados, começando obrigatoriamente por 
uma letra ou sublinhado). Deve-se observar que em C, somente os 32 primeiros caracteres de 
um identificador são significativos. Logo, se uma variável tiver mais de 32 caracteres, C não 
será capaz de identificar o trigésimo terceiro caractere. A sensibilidade ao caso também é 
válida para identificadores, por exemplo, os identificadores cont, Cont e CONT representam 
três identificadores diferentes em C. 
Formato geral de declaração de variáveis em C: 
 
 tipo-de-dado lista-de-identificadores; 
 
 onde: 
tipo-de-dado: é um dos tipos de dados válidos em C a ser associado às variáveis da 
lista-de-identificadores; 
 lista-de-identificadores: são os nomes (identificadores) escolhidos para as variáveis, 
que devem estar separados por vírgula. 
 
Em C existem cinco tipos de dados básicos: 
 
Tipo Descrição Bits Bytes Faixa de Valores 
char caracteres ASCII de 8 bits 8 1 -128 a 127 
int inteiros 16 2 -32768 a 32767 
float tipo ponto flutuante (real) 32 4 3.4E-38 a 3.4E+38 
double tipo ponto flutuante (real) de dupla precisão 64 8 1.7E-308 a 1.7E+308 
void sem valor 0 0 sem valor 
 
 A linguagem C não possui o tipo de dado lógico (dados que assumem valores 
verdadeiro ou falso), pois considera qualquer valor diferente de 0 (zero) verdadeiro e 0 (zero) 
falso. 
 Exemplos de declarações de variáveis em C: 
 
1) Declaração de uma variável cujo identificador é x, do tipo real: 
 
float x; 
 
2) Declaração de duas variáveis cujos identificadores são n1 e n2, do tipo inteiro: 
 
int n1, n2; 
 
3) Declaração de uma variável cujo identificador é resposta, que permite armazenar um 
único caractere: 
 
 char resposta; 
 
 3 
4) Declaração de uma variável cujo identificador é nome, que permite armazenar 40 
caracteres: 
 
 char nome[41]; 
 
OBS: É necessário declarar o tamanho de uma variável que armazena mais de um caractere 
com um caractere a mais do que realmente será utilizado, pois a linguagem C utiliza essa 
posição para o caractere de controle ‘\0’. No exemplo anterior, a variável nome irá armazenar 
no máximo 40 caracteres; a posição 41 será utilizada para armazenar o caractere de controle 
‘\0’. 
 
 Os tipos de dados básicos de C, exceto o tipo void, podem ser combinados a 
modificadores de tipos, resultando em novos tipos de dados. Os modificadores signed (com 
sinal), unsigned (sem sinal), long e short, podem ser aplicados aos tipos básicos char e int. 
Pode-se aplicar long ao tipo double. O uso de signed com inteiros é redundante, pois a 
declaração default dos inteiros assume um número com sinal. 
Na tabela seguinte estão todas as combinações possíveis dos tipos básicos com os 
modificadores: 
 
Tipo Bits Bytes Faixa de Valores 
char 8 1 -128 a 127 
unsigned char 8 1 0 a 255 
signed char 8 1 -128 a 127 
int 16 2 -32768 a 32767 
unsigned int 16 2 0 a 65535 
signed int 16 2 -32768 a 32767 
short int 16 2 -32768 a 32767 
unsigned short int 16 2 0 a 65535 
signed short int 16 2 -32768 a 32767 
long int 32 4 -2147483648 a 2147483647 
unsigned long int 32 4 0 a 4294967295 
signed long int 32 4 -2147483648 a 2147483647 
float 32 4 3.4E-38 a 3.4E+38 
double 64 8 1.7E-308 a 1.7E+308 
long double 80 10 3.4E-4932 a 1.1E+4932 
void 0 0 sem valor 
 
 É importante ressaltar que, de acordo com o compilador C que estiver sendo utilizado, 
o tamanho (número de bits e bytes) e a faixa de valores podem variar. A faixa de valores 
apresentada na tabela anterior está de acordo com o padrão ANSI C e é considerada como 
faixa mínima. 
 
Inicialização de variáveis 
Em C, pode-se dar valores à maioria das variáveis ao mesmo tempo em que são 
declaradas, colocando um sinal de igual e uma constante depois do nome da variável. 
 O formato geral da inicialização é: 
 
 tipo-de-dado identificador-da-variável = constante; 
 
 
 4 
Exemplos: 
 char resposta = 'S'; 
 int n1 = 0; 
 float x = 135.35; 
3 Comando de Atribuição em C 
O comando de atribuição é utilizado para atribuir valores a variáveis, sendo 
representado em C pelo sinal de =. 
 Formato geral de um comando de atribuição em C: 
 
identificador = expressão; 
 
onde: 
identificador: é o nome da variável à qual está sendo atribuído o valor; 
= é o operador de atribuição; 
expressão: pode ser expressão aritmética, expressão lógica ou relacional. 
 
Exemplos de atribuições válidas: 
 
 x = 4; 
x = x + 2; 
n1 = 2.5; 
n2 = n1; 
resposta = ‘S’; 
 
 Em C, as constantes de um único caractere devem ser escritas entre apóstrofos (‘ ‘). As 
cadeias de caracteres devem vir delimitadas por aspas (“ “). 
 O comando de atribuição não pode ser utilizado para atribuir uma cadeia de caracteres 
a uma variável. 
Caso seja necessário armazenar uma cadeia de caracteres em uma variável, deve-se 
utilizar uma função para manipulação de caracteres, conforme exemplificado a seguir: 
 
 strcpy(nome, “Gisele”); 
 
Para que seja possível a utilização da função strcpy() deve-se inserir ao programa, por 
meio da diretiva #include, a biblioteca string.h. 
Mais detalhes sobre a manipulação de cadeias de caracteres (strings), serão abordados 
posteriormente. 
 
Programa exemplo: 
 
O seguinte algoritmo: 
 
Algoritmo 
início 
 declare X,Y,Z: numérico inteiro; 
 nome: caractere; 
 X ← 10; 
 Y ← 20; 
 Z ← X + Y; 
 nome ← “Gisele”; 
fim 
 
 5 
Em C fica: 
 
#include <string.h> 
 
main() 
{ 
 int X, Y, Z; 
 char nome[41]; 
 X = 10; 
 Y = 20; 
 Z = X + Y; 
 strcpy(nome, “Gisele”); 
} 
 
4 Comentários em C 
Os comentários podem aparecer em qualquer lugar em um programa C delimitados 
por /* */. Exemplo: 
/* isto é um comentário */ 
 
 Os comentários podem ser escritos em várias linhas. Exemplo: 
 
 /* isto é um exemplo 
 de comentário de 
 múltiplas linhas */ 
 
 Não são permitidos os símbolos de /* e */ dentro de um comentário. Exemplo: 
 
 /* estou escrevendo /* um comentário ilegal */ 
5 Operadores e Expressões em C 
5.1 Operadores aritméticos 
 A tabela seguinte lista os operadores aritméticos em C: 
 
Operadores aritméticos Ação 
- subtração e menos unário (para números negativos) 
+ adição* multiplicação 
/ divisão 
% resto da divisão de inteiros 
-- decremento 
++ incremento 
 
 Precedência dos operadores aritméticos: 
 
 Mais alta ++ -- 
 - unário 
 * / % 
 Mais baixa + - 
 
 6 
Incremento e decremento 
O operador de incremento (++) acrescenta uma unidade a seu operando, enquanto que 
o de decremento (--) subtrai uma unidade. Então: 
 
x++ equivale a x = x + 1 
x-- equivale a x = x - 1 
 
Tanto o operador de incremento quanto o de decremento podem iniciar ou vir após o 
operando (++x ou x++ equivalem a x = x + 1). Porém, quando usados em uma expressão 
existe diferença: quando o operador de incremento ou de decremento precede o operando 
(++x ou --x), a operação de incremento ou decremento é feita antes de usar o valor do 
operando; quando o operador de incremento ou de decremento é colocado depois do operando 
(x++ ou x--), o valor do operando é usado antes de ser incrementado ou decrementado. Por 
exemplo: 
 x = 10; 
 y = ++x; 
 
O valor de y será 11, pois x é incrementado e depois seu valor é atribuído a y. 
 
 x = 10; 
 y = x++; 
 
 O valor de y será 10, pois o valor de x é atribuído a y e depois x é incrementado. 
 
Funções aritméticas 
 
 A biblioteca math.h contém as funções aritméticas de C. A tabela seguinte lista as 
principais funções aritméticas, sendo que outras podem ser encontradas na documentação da 
biblioteca math.h. 
 
Função Operação 
double ceil (double x) Arredonda x para cima. Ex.: ceil(3.2) é 4 
double cos(double x) Calcula o cosseno de x expresso em radianos 
double exp(double x) Calcula logaritmo natural e elevado à potência x 
double fabs(double x) Calcula o valor absoluto de x 
double floor(double x) Arredonda x para baixo. Ex.: floor(3.2) é 3 
double log(double x) Calcula o logaritmo natural de x (positivo) 
double log10(double x) Calcula o logaritmo na base 10 de x (positivo) 
double modf(double x, double *y) Retorna a parte fracionária de x e coloca a parte inteira de x em y 
double pow(double x, double y) Retorna x elevado à potência y 
double sin(double x) Calcula o seno de x expresso em radianos 
double sqrt(double x) Calcula a raiz quadrada de x 
double tan(double x) Calcula a tangente de x expresso em radianos 
 
 7 
5.2 Operadores relacionais e lógicos 
 A tabela seguinte lista os operadores relacionais em C: 
 
Operadores relacionais Ação 
> maior que 
>= maior ou igual a 
< menor que 
<= menor ou igual a 
== igual a 
!= não igual a (diferente de) 
 
A tabela seguinte lista os operadores lógicos: 
 
Operadores lógicos Ação 
&& AND 
|| OR 
! NOT 
 
 Precedência dos operadores relacionais e lógicos: 
 
 Mais alta ! 
 > >= < <= 
 == != 
 && 
 Mais baixa || 
 
 Tanto os operadores relacionais como os operadores lógicos têm precedência menor 
que os operadores aritméticos. Lembrando que os parênteses ( ) podem ser utilizados para 
alterar a precedência. 
5.3 Expressões 
As expressões são compostas de constantes, variáveis e operadores. Uma expressão 
em C é qualquer combinação válida desses componentes. Por exemplo: 
Considerando a seguinte declaração de variáveis: 
float a, b; 
int num, valor; 
Pode-se ter as seguintes expressões: 
 
Expressão Tipo de Resultado 
num int 
2.5 float 
a/num float 
num + valor int 
(b*a)/num float 
(a == b) && (valor < 10) valor diferente de 0 (verdadeiro) ou 0 (falso) 
 
 8 
Conversão de tipos em expressões 
 A linguagem C aceita expressões com variáveis e constantes de tipos diferentes. 
Quando isso ocorre uma conversão implícita de tipos é realizada, de acordo com a seguinte 
regra geral: todos os operandos são convertidos para o tipo do operando cuja faixa de valores 
permitida seja maior. 
As operações são analisadas individualmente para que a conversão de tipos dos 
operandos seja realizada. Por exemplo, seja a seguinte declaração de variáveis: 
 char c; 
 int i; 
 float f; 
 double d; 
 A expressão seguinte terá as seguintes conversões de tipo: 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
Casts 
 Cast é utilizado para forçar uma expressão a ser de um determinado tipo. Seu formato 
geral é: 
 (tipo-de-dado) expressão 
 
 onde: 
tipo-de-dado: é um dos tipos de dado padrão de C; 
expressão: é uma expressão válida em C. 
 
 Exemplo: 
 int x; 
 ... 
 (float)x/2; 
 
 Essa construção garante que o computador avaliará a expressão x/2 como float. 
Nesse caso, o cast (float) será associado a x, fazendo com que o computador converta 2 para o 
tipo float, efetue a divisão de dois operandos do tipo float e o resultado será float. No 
entanto, se fosse: 
 
 (float)(x/2); 
 
 Nesse caso, o computador efetua uma divisão de inteiros (não considera a parte 
fracionária do resultado) e converte o resultado para float. 
resultado = ( c / i ) + ( f * d ) - ( f + i ); 
int double float 
int double float 
double 
double 
 9 
Espaçamento e parênteses 
 Pode-se colocar espaços à vontade em uma expressão para auxiliar a legibilidade. Por 
exemplo, as expressões seguintes são iguais: 
 x=20/y*(226/x); 
 x = 20 / y * (226 / x); 
 O uso de parênteses redundantes ou adicionais não afetará o cálculo de uma expressão. 
Pode-se usar parênteses para deixar a ordem de avaliação da expressão mais clara. Por 
exemplo, as expressões abaixo são iguais: 
 x=y/4-15*z-220; 
 x = (y / 4) - (15 * z) - 220; 
6 Comandos de Entrada e Saída em C 
A tabela seguinte lista as funções básicas de entrada e saída em C: 
 
Função Operação 
getchar() Lê um caractere do teclado e espera por um <enter> 
getche() Lê um caractere do teclado, imprime na tela e não espera por <enter> 
getch() Lê um caractere do teclado, não imprime na tela e não espera por <enter> 
putchar() Escreve um caractere na tela 
gets() Lê uma string do teclado 
puts() Escreve uma string na tela 
printf() Função geral de saída 
scanf() Função geral de entrada 
 
A maioria das funções de entrada e saída exige a inclusão da biblioteca stdio.h por 
meio da diretiva #include. Apenas as funções getche() e getch() exigem a inclusão da 
biblioteca conio.h. 
Exemplo: 
Algoritmo 
Início 
declare X,Y: numérico inteiro; 
escreva(“Digite um número: ”); 
leia(X); 
 escreva(“Digite outro número: ”); 
leia(Y); 
 escreva(“O primeiro número digitado foi:”, X); 
 escreva(“O segundo número digitado foi:”, Y); 
fim 
Em C fica: 
#include <stdio.h> 
 
main() 
{ 
 int X, Y; 
 printf(“Digite um numero: ”); 
 scanf(“%d”, &X); 
 printf(“Digite outro numero: ”); 
 scanf(“%d”, &Y); 
 printf(“O primeiro numero digitado foi: %d”, X); 
 printf(“O segundo numero digitado foi: %d”, Y); 
} 
 
 10 
Outros exemplos de utilização das funções de entrada e saída de C: 
 
1) O programa seguinte lê um caractere e o imprime na tela: 
#include <stdio.h> 
#include <conio.h> 
 
 main() 
 { 
 char c; 
 c = getch(); /* lê um caractere */ 
 putchar(c); /* escreve o caractere na tela */ 
 } 
 
2) O programa seguinte lê uma cadeia de caracteres (string) e a imprime na tela: 
#include <stdio.h> 
 
main() 
{ 
 char nome[41]; 
 gets(nome); /* lê uma string */ 
 puts(nome); /* imprime a string na tela */ 
 } 
 
A função printf() 
 
Formato geral: 
 
printf(“string-de-controle”, lista-de-argumentos); 
 
onde: 
 lista-de-argumentos é formada por variáveis e/ou constantes; 
 string-de-controle contém três tipos de itens: 
• caracteres que a função imprimirá na tela; 
• códigos de formatação que definem a maneira como os argumentos serão exibidos; 
• constantes de barras invertidas que controlam mudança de linha, tabulação, etc. 
 
Os códigos de formatação são formados pelo sinal de % (porcentagem) seguido do 
código correspondente. São eles: 
 
Código Formato a ser impresso na tela 
%c caractere 
%d inteiro decimal 
%i inteiro decimal 
%e notação científica 
%f ponto flutuante (real) 
%g exibe %e ou %f – o que for mais curto 
%o octal 
%s string (cadeia de caracteres) 
%u inteiro decimal sem sinal 
%x hexadecimal 
 
 11 
Logicamente,deve-se ter exatamente tantos argumentos quantos forem os códigos de 
formatação. Ainda, devem coincidir na ordem em que são apresentados. Por exemplo: 
 
 #include <stdio.h> 
 
 main() 
 { 
 char c; 
 c = getchar(); 
 printf(“Bom %c %d %s”, c, 10, “dia!”); 
} 
 
 O exemplo anterior exibe: Bom seguido do caractere lido e das constantes 10 e dia!. 
Vale observar que quando se deseja imprimir constantes, não há a necessidade de utilizar 
códigos de formatação, pois as constantes podem ser escritas diretamente na string de 
controle. O programa do exemplo anterior poderia ser escrito da seguinte maneira: 
 
#include <stdio.h> 
 
 main() 
 { 
 char c; 
 c = getchar(); 
 printf(“Bom %c 10 dia”, c); 
} 
 
Existem dois modificadores de tipos dos códigos de formatação que permitem que 
printf() exiba dados long e short. Pode-se aplicar esses modificadores aos códigos d, i, o, u, 
e x. O modificador l diz a printf() que se segue um tipo de dado long. Por exemplo: 
 
%ld diz a printf() que deve ser exibido um long int. 
 
O modificador l pode também ser prefixo dos códigos de ponto flutuante e, f e g, e 
indica que se segue um double. 
O modificador h instrui printf() para exibir um short int. Por exemplo: 
 
%hu diz a printf() que deve ser exibido um short unsigned int. 
 
Para uma melhor saída dos dados, deve-se usar e abusar dos códigos de formatação, 
pois esses podem ter modificadores que alteram o formato de saída dos dados. Alguns 
exemplos: 
 
a) Modificadores que especificam a largura do campo: 
 
%4d - o computador imprimirá um número inteiro decimal com no mínimo quatro 
dígitos. Se o número tiver menos que quatro dígitos o computador preencherá com espaços à 
esquerda até completar quatro; se tiver mais, o computador imprimirá o número 
completamente. 
 
 %04d - o computador preencherá com zeros à esquerda um número com menos de 
quatro dígitos para que o comprimento total do número seja quatro. 
 
 12 
#include <stdio.h> 
 
 main() 
 { 
 int num; 
 printf(“Entre com um número inteiro: ”); 
 scanf(“%d”, &num); 
 printf(“%4d\n%04d”, num, num); 
} 
 
 b) Modificadores que especificam o número de casas decimais ou tamanho 
mínimo e máximo: 
 
%10.4f - imprimirá um número ponto flutuante de pelo menos 10 caracteres com 
quatro casas decimais. Se o número tiver menos que 10 caracteres o computador preencherá 
com espaços à esquerda até completar 10; se tiver mais, o computador imprimirá o número 
completamente, fazendo alguns arredondamentos. Se o número tiver menos que 4 casas 
decimais o computador completará com zeros à direita; se tiver mais, o computador 
arredondará o número. 
 
%010.4f – tem as mesmas características do formato %10.4f, com a diferença que se 
o número tiver menos que 10 caracteres o computador preencherá com zeros à esquerda até 
completar 10. 
 
Quando esse formato é usado para strings, o número que vem depois do ponto 
especifica o comprimento máximo do campo. Por exemplo: 
 %5.7s - exibir uma string com pelo menos cinco e não mais que sete caracteres de 
comprimento. Se a string for maior que a largura máxima, o computador truncará os 
caracteres que estiverem além do limite especificado. 
 
 #include <stdio.h> 
 
 main() 
 { 
 float num; 
 char str[30]; 
 printf("Entre com um número ponto flutuante: "); 
 scanf("%f", &num); 
 printf("Entre com uma string: "); 
 scanf("%s", str); 
 printf("%10.4f\n%5.7s", num, str); 
 } 
 
 c) Sinalizador de justificação pela esquerda: 
 
Por default, todo resultado é justificado pela direita. Para justificar pela esquerda 
coloca-se um sinal de menos diretamente depois de %. Por exemplo: 
 
#include <stdio.h> 
 
main() 
{ 
 printf("%-10.2f", 123.12); /* justificação pela esquerda */ 
 printf("\n%10.2f", 123.12); /* justificação pela direita */ 
} 
 13 
 
O programa exibe, respectivamente: 
 
123.12 
 123.12 
 
Alguns caracteres, como mudança de linha, não podem ser inseridos pelo teclado. Por 
esse motivo, C fornece as constantes com barras invertidas. A tabela seguinte apresenta as 
mais usadas: 
 
Código Significado 
\n mudança de linha 
\r retorna o cursor para o início da linha 
\b retorna o cursor um caractere 
\t tabulação 
\” aspas duplas 
\’ aspas simples 
\0 nulo (finalizador de strings) 
\\ barra invertida 
 
A função scanf() 
 
Formato geral: 
 
 scanf(“string-de-controle”, lista-de-argumentos); 
 
 onde: 
lista-de-argumentos é composta por variáveis; 
string-de-controle consiste em três classificações de caracteres: 
• códigos de formatação; 
• caracteres brancos; 
• caracteres não-brancos. 
 
Os códigos de formatação são representados pelo sinal % seguido do código 
correspondente. São eles: 
 
Código Formato a ser lido do teclado 
%c lê um único caractere 
%d lê um inteiro decimal 
%i lê um inteiro decimal 
%e lê um número em notação científica 
%f lê um número ponto flutuante 
%o lê um octal 
%s lê uma string (cadeia de caracteres) 
%u lê um inteiro decimal sem sinal 
%x lê um hexadecimal 
 
 Os modificadores de tipos dos códigos de formatação para leitura de long e short, 
respectivamente l e h, seguem a mesma regra de printf(). 
Os códigos de formatação devem coincidir com as variáveis da lista de argumentos. 
 14 
 
Caracteres brancos: um caractere branco é um espaço, um tab ou um \n. Um 
caractere branco na string de controle faz com que scanf() passe por cima de um ou mais 
caracteres brancos na entrada. 
 
Caracteres não-brancos: um caractere não-branco na string de controle faz com que 
scanf() leia e desconsidere um caractere coincidente. Por exemplo, a string de controle 
"%d,%d" faz com que scanf() primeiro leia um inteiro, depois leia e desconsidere uma 
vírgula e, finalmente, leia um outro inteiro. Se o computador não encontrar o caractere 
especificado, scanf() terminará. 
 
Todas as variáveis usadas para receber valores usando scanf() devem ser passadas por 
seus endereços, o que significa que todos os argumentos devem ser ponteiros para as variáveis 
usadas como argumentos. Por exemplo, para ler um inteiro para a variável cont, scanf() deve 
ser escrita da forma: 
 
 scanf("%d", &cont); 
 
 Quando o argumento já é um ponteiro, não precisa ser precedido pelo operador &. 
Esse é caso da leitura de strings. Por exemplo: 
 
 #include <stdio.h> 
 
 main() 
 { 
 char str[30]; 
 scanf(“%s”, str); 
 printf(“%s”, str); 
 } 
 
 A seguir tem-se algumas variações de scanf(): 
 
 scanf(“%d%d”, &x, &y); /* aceita uma entrada do tipo 10 20, mas não 
 tem sucesso com a entrada 10,10 */ 
 
 scanf(“%d%*c%d”, &x, &y); /* dada a entrada 10/20, coloca o valor 10 
 em x, desconsidera o sinal de divisão e 
 coloca o valor 10 em y */ 
OBS: um * colocado depois de % e antes de um código de formatação lerá dados do tipo 
especificado, mas suprirá suas atribuições. 
 
 scanf(“%dt%d”, &x, &y); /* dada a entrada 10t20, coloca 10 em x e 
 20 em y, descartando o caractere t */ 
 
scanf(“%20s”, str); /* lê não mais que 20 caracteres e coloca em str. 
 Se a string de entrada for maior que 20 
 caracteres, então uma leitura subseqüente 
 começa com os caracteres excedentes */ 
 
 scanf(“%s ”, str); /* não retornará até ser digitado um caractere 
 depois de digitar um caractere branco. Isso 
 ocorre devido ao espaço depois de %s, o que 
 instrui scanf() a ler e desconsiderar 
 espaços, tabs e \n */ 
 
 15 
7 Exemplos de Programas C 
1) Faça um algoritmo e programa C que leia quatro números inteiros, calcule e mostre a 
soma desses números. 
Solução: 
 
Algoritmo 
início 
 /* Declaração de variáveis*/ 
 declare n1, n2, n3, n4, soma: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(“Digite quatro números inteiros: “); 
 leia(n1); 
leia(n2); 
leia(n3); 
leia(n4); 
/* Processo – cálculo da soma */ 
soma ← n1 + n2 + n3 + n4; 
/* Saída de dados */ 
escreva(“Soma = “, soma); 
fim 
 
#include <stdio.h> 
 
main() 
{ 
 /* Declaração de variáveis */ 
 int n1, n2, n3, n4, soma; 
 /* Entrada de dados */ 
 printf(“Digite quatro números inteiros: “); 
 scanf(“%d”, &n1); 
scanf(“%d”, &n2); 
scanf(“%d”, &n3); 
scanf(“%d”, &n4); 
/* Processo – cálculo da soma */ 
soma = n1 + n2 + n3 + n4; 
/* Saída de dados */ 
printf(“Soma = %d“, soma); 
} 
 
 16 
2) Escreva um algoritmo e programa C que receba três notas e seus respectivos pesos, 
calcule e mostre a média ponderada dessas notas. 
Solução: 
 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare nota1, nota2, nota3, /* notas */ 
 media: numérico real; 
 peso1, peso2, peso3 /* pesos */: numérico inteiro; 
 /* Entrada de dados */ 
 escreva(“Entre com a primeira nota e seu peso: “); 
 leia(nota1); 
 leia(peso1); 
escreva(“Entre com a segunda nota e seu peso: “); 
 leia(nota2); 
 leia(peso2); 
escreva(“Entre com a terceira nota e seu peso: “); 
 leia(nota3); 
 leia(peso3); 
 /* Processo – cálculo da média ponderada */ 
 media ← (nota1*peso1+nota2*peso2+nota3*peso3)/(peso1+peso2+peso3); 
 /* Saída de dados */ 
 escreva(“Média ponderada = “, media); 
fim 
 
#include <stdio.h> 
 
main() 
{ 
 /* Declaração de variáveis */ 
 float nota1, nota2, nota3; /* notas */ 
 float media; 
 int peso1, peso2, peso3; /* pesos */ 
 /* Entrada de dados */ 
 printf(“Entre com a primeira nota e seu peso: “); 
 scanf(“%f”, &nota1); 
 scanf(“%d”, &peso1); 
printf(“Entre com a segunda nota e seu peso: “); 
 scanf(“%f”, &nota2); 
 scanf(“%d”, &peso2); 
printf(“Entre com a terceira nota e seu peso: “); 
 scanf(“%f”, &nota3); 
 scanf(“%d”, &peso3); 
 /* Processo – cálculo da média ponderada */ 
 media = (nota1*peso1+nota2*peso2+nota3*peso3)/(peso1+peso2+peso3); 
 /* Saída de dados */ 
 printf(“Média ponderada = %f“, media); 
} 
 
 17 
3) Faça um algoritmo e programa C que receba o salário de um funcionário e o 
percentual de aumento, calcule e mostre o valor do aumento e o novo salário. 
Solução: 
 
Algoritmo 
início 
 /* Declaração de variáveis */ 
 declare sal, /* salário */ 
 perc_aumento, /* percentual de aumento */ 
 aumento, /* valor do aumento */ 
 novo_sal /* novo salário */: numérico real; 
 /* Entrada de dados */ 
 escreva(“Entre com o salário: “); 
 leia(sal); 
 escreva(“Entre com o percentual de aumento: “); 
 leia(perc_aumento); 
 /* Processo – cálculo do valor do aumento e do novo salário */ 
 aumento ← sal * perc_aumento/100; 
 novo_sal ← sal + aumento; 
 /* Saída de dados */ 
 escreva(“O aumento é de: “, aumento); 
 escreva(“O salário com aumento é de: “, novo_sal); 
fim 
 
#include <stdio.h> 
 
main() 
{ 
 /* Declaração de variáveis */ 
 float sal; /* salário */ 
 float perc_aumento; /* percentual de aumento */ 
float aumento; /* valor do aumento */ 
 float novo_sal; /* novo salário */ 
 /* Entrada de dados */ 
 printf(“Entre com o salário: “); 
 scanf(“%f”, &sal); 
 printf(“Entre com o percentual de aumento: “); 
 scanf(“%f”, &perc_aumento); 
 /* Processo – cálculo do valor do aumento e do novo salário */ 
 aumento = sal * perc_aumento/100; 
 novo_sal = sal + aumento; 
 /* Saída de dados */ 
 printf(“O aumento é de: %f“, aumento); 
 printf(“\nO salário com aumento é de: %f“, novo_sal); 
} 
 18 
8 Exercícios de Fixação 
1) Faça um algoritmo e programa C que leia três notas, calcule e mostra a média 
aritmética entre elas. 
2) Escreva um algoritmo e programa C que receba o salário de um funcionário, calcule e 
mostre o novo salário, sabendo-se que o salário teve um aumento de 25%. 
3) Escreva um algoritmo e programa C que receba um número positivo e maior que zero, 
calcule e mostre: 
a) o número ao quadrado; 
b) o número ao cubo; 
c) a raiz quadrada do número; 
d) a raiz cúbica do número. 
4) Sabe-se que: 
1 pé = 12 polegadas 
1 jarda = 3 pés 
1 milha = 1760 jardas 
Faça um algoritmo e programa C que receba uma medida em pés, faça as conversões 
necessárias e mostre os resultados em polegadas, jardas e milhas. 
5) O custo ao consumidor de um carro novo é a soma do preço de fábrica com o 
percentual de lucro do distribuidor e dos impostos aplicados ao preço de fábrica. Faça 
um algoritmo e programa C que leia o preço de fábrica de um veículo, o percentual de 
lucro do distribuidor e o percentual de impostos, calcule e mostre: 
a) o valor correspondente ao lucro do distribuidor; 
b) o valor correspondente aos impostos; 
c) o preço final do veículo.