Aula08_Manipulacao de string

Prévia do material em texto

Universidade Federal da Grande Dourados
Faculdade de Ciências Exatas e de Tecnologias
Curso de Bacharelado em Sistemas de Informação
Algoritmos e Programação
Constantes, strings, tipos de dados
Profª Janne Oeiras Lachi
1
Tipos básicos
` Vimos: 
` int, char, float
` Exemplo:
/* Mostra o uso de const para declarar constantes */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
const char Bip = ‘\a’; /* declaração de constante */
const double Pi = 3.141592; /* declaração de constante */
double raio, area;
printf(″Digite o raio da esfera:);
scanf(“%ld”, &raio);
area = 4.0 * Pi * raio * raio;
printf(″%c%c″, Bip, Bip);
printf(″\nArea da esfera = %.2lf\n″, area);
system(″PAUSE″);
return 0;
}
2
O tipo double
` Serve para armazenar números com ponto flutuante de dupla 
precisão
` Normalmente tem o dobro do tamanho do float e, portanto, 
o dobro da capacidade
` Números em ponto flutuante correspondem ao que os 
matemáticos chamam de números reais
` Em C temos três tipos de variáveis para armazenar um 
número em ponto flutuante:
` float, double e long double
3
Tipos de dados definidos pelo padrão ANSI
Tipo Bit* Bytes Faixa de Valores
char 8 1 -128 a 127
unsigned char 8 1 0 a 255
int 32 4 -2.147.483.648 a 2.147.483.647
unsigned int 32 4 0 a 4.294.967.295
short int 16 2 -32.768 a 32.767
long 32 4 -2.147.483.648 a 2.147.483.647
unsigned long 32 4 0 a 4.294.967.295
float 32 4 3.4x10-38 a 3.4x1038
double 64 8 1.7x10-308 a 1.7x10308
long double 80 10 3.4x10-4932 a 1.1x104932
*O tamanho e a faixa de valores podem variar de acordo com o processador ou compilador.
Modificadores de tipos
` Todos os tipos básicos podem ser acompanhados por um 
modificador. Em C temos 3 modificadores:
` short, long e unsigned
` long e short têm influência no tamanho usado para 
representar um valor
` unsigned indica se o tipo será usado para representar 
valores apenas positivos
` Observação: em alguns livros é citado o modificador signed, 
mas na declaração de variáveis ele pode ser omitido, o que 
significa que podem ser aceitos valores positivos e negativos.
5
Modificadores de tipos
` Um modificador pode ser usado sem que o tipo seja 
especificado. Nesse caso o compilador assume que o tipo 
é int
unsigned int
ou
unsigned
32 4 0 a 4.294.967.295
short int
ou
short
16 2 -32.768 a 32.767
long int
ou 
long
32 4 -2.147.483.648 a 2.147.483.647
6
Conversões de tipos
` Pode ser feita de duas maneiras:
` Automaticamente 
` Explicitamente
7
Conversão automática
` Quando dois ou mais operandos de diferentes tipos se 
encontram em uma mesma expressão, o conteúdo da 
variável de menor tamanho é convertido ao tipo da 
variável de maior tamanho.
` Essa conversão é feita em uma área temporária de 
memória, antes de a expressão ser executada e o 
resultado desta é novamente convertido para o tipo da 
variável à esquerda do operador de atribuição.
8
Conversão automática: exemplo
/* Conversão automática de tipo */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int A = 10;
char B = ‘X’;
float C = 2.30;
printf(″\nO valor inicial de A é %d\n″, A); 
printf(″\nO valor inicial de B é %c\n″, B); 
printf(″\nO valor inicial de C é %.2f\n″, C); 
A=C; /* A recebe a parte inteira de C, ou seja, 2*/
printf(″\nA=C, o valor de A é %d\n″, A); 
C=A; /* A variável A (int) é convertida em um float C, ou 
seja, 2*/
printf(″\nC=A, o valor de C é %f\n″, C); 
9
Conversão automática: exemplo (cont.)
B=A; /* B (char) recebe os bits de A (int) */
printf(″\nB=A, o valor de B é %d\n″, B); 
C=B; /* A variável C (float) recebe os bits de B (char) */
printf(″\nC=B, o valor de C é %.2\n″, C); 
system(″PAUSE″);
return 0;
}
10
Conversão automática
` Pode não resultar no esperado...
/* Conversão automática de tipo */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int VarInt=2000000000; /* 2.000.000.000 */
int Dez=10;
VarInt=(VarInt*Dez)/Dez; /* Valor muito grande */
printf(″\nVarInt= %d\n″, VarInt); /*resposta errada */
system(″PAUSE″);
return 0;
}
A saída é:
VarInt = -147483648
11
Conversão automática
` Onde está o problema?
/* Conversão automática de tipo */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int VarInt=2000000000; /* 2.000.000.000 */
int Dez=10;
VarInt=(VarInt*Dez)/Dez; 
/* O máximo que pode ser representado é 2.147.483.647 e essa 
conta dá 20.000.000.000, um valor muito grande */
printf(″\nVarInt= %d\n″, VarInt); /*resposta errada */
system(″PAUSE″);
return 0;
}
100 10101000 00010111 11001000 00000000
É o número - 1474836648012
Conversão explícita
` O operador de molde consiste em escrever o nome do 
tipo desejado entre parênteses e, em seguida, o valor ou 
a expressão a ser avaliada. O resultado é a expressão 
convertida para o tipo especificado
` Tem a seguinte sintaxe:
(tipo desejado)variável ou (tipo desejado)(expressão)
Conversão explícita: exemplo 1
/* Conversão explícita de tipo */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int VarInt=2000000000; /* 2.000.000.000 */
int Dez=10;
VarInt=((double)VarInt*Dez)/Dez; /* Converte para double */
printf(″\nVarInt= %d\n″, VarInt);
system(″PAUSE″);
return 0;
}
Conversão explícita: exemplo 2
/* Conversão automática de tipo */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int A = 10;
float B = 200.210;
printf(″\n--- Valores iniciais ---\n\n″); 
printf(″\nO valor inicial de A é %d\n″, A); 
printf(″\nO valor inicial de B é %.2f\n″, B); 
printf(″\n--- Conversão dos valores ---\n\n″); 
printf(″\nA=B, o valor de A é %d\n″, A= (int)B); 
A = 30;
B = 0.0;
printf(″\n--- Novos valores iniciais ---\n\n″); 
printf(″\nO valor inicial de A é %d\n″, A); 
printf(″\nO valor inicial de B é %.2f\n″, B); 
Conversão explícita: exemplo 2 (cont.)
printf(″\n--- Conversão dos valores ---\n\n″); 
printf(″\nB=A, o valor de B é %.2f\n″, B = (float) A); 
system(″PAUSE″);
return 0;
}
O módulo <math.h>: funções matemáticas
` Para usar as funções abaixo, as suas variáveis devem ser do 
tipo double
Função Exemplo Comentário
ceil ceil(x) Arredonda um número real para cima. Por 
exemplo, ceil(3.2) é 4.
floor floor(x) Arredonda o número para baixo. Por exemplo, 
floor(3.2) é 3.
abs abs(x) Obtém o valor absoluto de x.
sqrt sqrt(x) Calcula a raiz quadrada de x.
pow pow(x,y) Calcula a potência de x elevado a y.
modf z = modf(x, &y) Decompõe o número real armazenado em x em 
duas partes: y recebe a parte inteira e z, a parte 
fracionária do número.
17
Funções getche() e getch()
` Podem ser usadas como uma alternativa a função scanf()
` Podem ser usadas quando não queremos teclar ENTER 
para terminar a leitura
` Lêem um caractere no instante em que é digita, sem 
esperar pela tecla ENTER
` A diferença entre as duas é que a função getche() mostra 
na tela o caractere lido
` Precisam do módulo conio.h (não faz parte do C padrão, 
mas geralmente está presente junto com os compiladores 
por serem muito utilizadas)
18
Funções getche(): exemplo
/* Mostra a função getche() */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main ()
{
char ch;
printf(″\nPressione uma tecla: ”); 
ch = getche(); /* aguarda uma tecla no teclado */
printf(″\nA tecla sucessora ASCII é %c.\n”, ch+1); 
system(″PAUSE″);
return 0;
}
19
Funções getch(): exemplo
/* Mostra a função getch() */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main ()
{
char ch;
printf(″\nPressione uma tecla: ”); 
ch = getch(); /* aguarda uma tecla no teclado */
printf(″\nA tecla sucessora ASCII é %c.\n”, ch+1); 
system(″PAUSE″);
return 0;
}20
Funções getchar() e putchar()
` Fazem parte do módulo stdio.h (portanto, fazem parte do 
C padrão e estão presentes em qualquer compilador)
` A função getchar() aguarda o próximo caractere da 
entrada padrão (teclado) e retorna seu caractere lido. Só
termina a leitura quando o ENTER é pressionado.
` A função putchar() imprime um caractere na saída 
padrão (vídeo)
21
Funções getchar() e putchar(): exemplo
/* Mostra as funções getchar() e putchar() */
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>
int main ()
{
char ch;
printf(″\nPressione uma tecla: ”); 
ch = getchar(); /* aguarda uma tecla no teclado */
printf(″\nA tecla sucessora ASCII é ”);
putchar(ch+1); 
putchar(‘\n’); 
system(″PAUSE″);
return 0;
}
22
Um pouco mais sobre strings
` Como visto anteriormente, em C não existe um tipo 
string, isto é, não há um tipo definido para declararmos 
uma variável que aceite uma cadeia de caracteres.
` Precisamos criar uma estrutura chamada vetor do tipo 
char para armazenar, por exemplo, o nome de uma 
pessoa.
` O último caractere de uma string é um terminador, isto 
é, um caractere nulo representado por \0
23
Strings: exemplos
` “Jose da Silva”
` “?interrogação?”
` “1.234”
` “0”
` Exemplo com vetor:
Sempre precisa declarar
com um valor a mais do que
precisamos
char letra, palavra[21];
letra=‘a’;
palavra[0]=‘e’;
palavra[1]=‘x’;
palavra[2]=‘e’;
palavra[3]=‘m’;
palavra[4]=‘p’;
palavra[5]=‘l’;
palavra[6]=‘o’;
palavra[7]=‘\0’; /* fim da string */
palavra[8]=‘z’; /* será ignorado */ 
Posições de 8 a 20 serão
ignoradas porque o terminador
está na posição 7
24
Strings: atribuição
` Caractere a caractere em cada posição do vetor 
(exemplo anterior) ou das seguintes formas:
char nome[5]= {‘J’, ‘o’, ‘a’, ‘o’, ‘\0’};
ou
char nome[5]= {“Joao”};
25
Strings: operações inválidas
` Existem operações que não são possíveis de serem 
executadas utilizando uma string
char str[10]; /* correto */
char str2[10]={“Palavra 2”}; /* correto */
str = “abacaxi”; /* ERRO! Não é possível atribuir assim */
str1 = str2; /* ERRO! Não é possível copiar str2 para str */
if (str == str2) /* ERRO! Não é possível comparar str2 com str */
26
Lista 2: exercício 15
` Preparar um programa em C para ler um nome de pessoa na forma “nome 
de batismo” seguido por “sobrenome” e imprimir na forma “sobrenome”
seguido pelo “nome de batismo”.
` Exemplo:
Entrada: MONALISA, ALMEIDA PRADO
Saída: ALMEIDA PRADO, MONALISA
#include <stdio.h>
int main()
{
char nome_de_batismo[31], sobrenome[101];
printf("Informe o nome e o sobrenome separados por virgula:");
scanf("%[a-zA-Z ]%*[,]%[a-zA-Z ]", nome_de_batismo, sobrenome);
printf("\nO sobrenome e nome sao: %s,%s\n", sobrenome, nome_de_batismo);
return 0;
}
27
Lista 2: exercício 11
` %[...] lê uma seqüência de caracteres, sem ignorar espaços, especificando 
entre colchetes quais caracteres devem ser aceitos, ou, se o primeiro 
caractere dentro dos colchetes for um acento circunflexo (^), quais não 
devem ser aceitos. Além disso, se colocarmos um traço entre dois 
caracteres, todos os caracteres entre os dois serão incluídos no padrão.
` Por exemplo, se quisermos incluir qualquer letra minúscula, poderíamos 
escrever %[a-z]; se quiséssemos também incluir as maiúsculas, 
colocaríamos %[a-zA-Z]. A leitura pára quando for encontrado um 
caractere que não coincide com o padrão especificado.
printf("Informe o nome e o sobrenome separados por virgula:");
scanf("%[a-zA-Z ]%*[,]%[a-zA-Z ]", nome_de_batismo, sobrenome);
http://pt.wikibooks.org/wiki/Programar_em_C/Entrada_e_sa%C3%ADda_simples
28
Lista 2: exercício 11
` O modificador * (asterisco) especifica que o valor atual deve ser lido da 
maneira especificada, mas não será guardado em nenhuma variável, e 
portanto não deve haver um ponteiro correspondente a esse valor.
` Por exemplo, poderíamos ter um programa que espera ler uma palavra e 
depois um número, mas não importa qual palavra é.
` Nesse caso usaríamos o modificador *: scanf ("%*s %d", &numero). O 
programa leria a palavra e guardaria o número na variável numero.
printf("Informe o nome e o sobrenome separados por virgula:");
scanf("%[a-zA-Z ]%*[,]%[a-zA-Z ]", nome_de_batismo, sobrenome);
http://pt.wikibooks.org/wiki/Programar_em_C/Entrada_e_sa%C3%ADda_simples
29
Lista 2: exercício 11
` Outra solução....
#include <stdio.h>
#include <stdlib.h>
int main()
{
char nome_de_batismo[31], sobrenome[101];
printf("Informe o nome:");
scanf("%[a-zA-Z ]", nome_de_batismo);
printf("Informe o sobrenome:");
scanf(“%*[\n]%[a-zA-Z ]", sobrenome);
printf("\nO sobrenome e nome sao: %s,%s\n", sobrenome, nome_de_batismo);
system("pause");
return 0;
}
30
Problema sem o uso de %*[\n]
` Escrevemos o nome e teclamos ENTER
` Depois não conseguimos inserir o sobrenome por 
causa do ENTER entrado que não corresponde a 
nenhum caractere especificado dentro do []
` O programa então “pula” para a linha de impressão no 
formato “sobrenome”, “nome”
31
Usando o módulo <string.h>
Nome Sintaxe Função
strcpy strcpy (destino, origem) Copia ou atribui o conteúdo da string 
origem para destino.
strcat strcat(destino, origem) Concatena o conteúdo da string origem ao 
final do conteúdo de destino.
strcmp strcmp(string1, string2) Compara o conteúdo da string1 com a 
string2.
strlen strlen(string1) Retorna o tamanho da string1.
strupr strupr(string1) Converte o conteúdo da string1 em 
maiúsculas.
strlwr strlwr(string1) Converte o conteúdo da string1 em 
minúsculas.
Função strcpy(): exemplos
char linguagem[20];
linguagem = “Pascal”; /*ERRADO!!! */
strcpy(linguagem,“Pascal”); /*CERTO!!! */
char linguagem1[20]={“Linguagem Java”}, linguagem2[20]={“Pascal”};
linguagem1 = linguagem2; /*ERRADO!!! */
strcpy(linguagem2,linguagem1); /*CERTO!!! */
33
Função strcat(): exemplo
/* Mostra a função strcat() */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
char string1[51], string2[101];
printf(″\nEntre com uma string (até 50 caracteres): ”); 
scanf(“%s”, string1);
strcpy(string2,”Voce digitou a string ”);
strcat(string2, string1);
printf(″\n%s”,string2);
system(″PAUSE″);
return 0;
}
34
Função strcmp(): exemplo
35
/* Mostra a função strcmp() */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
char string1[21], string2[21];
int retorno;
printf(″\nEntre a primeira string (até 20 caracteres): ”); 
scanf(“%s”, string1);
printf(″\nEntre a segunda string (até 20 caracteres): ”); 
scanf(“%s”, string2);
retorno = strcmp(string2,string1);
if (retorno==0)
printf(“\nAs strings são iguais”);
else
printf(“\nAs strings são diferentes”);
system(″PAUSE″);
return 0;
}
if (strcmp(string2,string1))
printf(“\nAs strings são diferentes”)
else
printf(“\nAs strings são iguais”);
Se for 1, é pq são diferentes
Função strlen(): exemplo
/* Mostra a função strlen() */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
char string1[100];
int tamanho;
printf(″\nEntre a string (até 99 caracteres): ”); 
scanf(“%s”, string1);
tamanho = strlen(string1);
printf(“\nA sua string tem tamanho %d”, tamanho);
system(″PAUSE″);
return 0;
}
36
Função strupr(): exemplo
/* Mostra a função strcat() */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
int main ()
{
char string1[100];
int tamanho;
printf(″\nEntre a string (até 99 caracteres): ”); 
scanf(“%s”, string1);
printf(“\nVersão em letras maiúsculas: %s”, strupr(string1));
system(″PAUSE″);
return 0;
}
Poderia ter sido usado:
strupr(string1);
printf(“\nVersão em letras maiúsculas: %s”,string1);37
Umproblema exemplo
38
` 20. Uma empresa irá dar um aumento de salário aos 
seus funcionários de acordo com a categoria de cada 
empregado. O aumento seguirá a seguinte regra:
a) Funcionários das categorias A, C, F e H ganharão 10% de aumento sobre o 
salário
b) Funcionários das categorias B, D, E, I, J e T ganharão 15% de aumento 
sobre o salário ;
c) Funcionários das categorias K e G ganharão 25% de aumento sobre o 
salário;
d) Funcionários das categorias L, M, N, O, P, Q, R e S ganharão 35% de 
aumento sobre o salário;
e) Funcionários das categorias U, V, X, Y, W e Z ganharão 50% de aumento 
sobre o salário;
` Faça um Programa em C que escreva o nome, categoria e 
salário reajustado de um Empregado. 
39
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
int main()
{
float salario;
char categoria, nome[101];
printf("Informe o nome do funcionario:");
scanf("%s", nome);
fflush(stdin);
printf("\nInforme a categoria do funcionario:");
scanf("%c", &categoria);
printf("\nInforme o salario atual do funcionario");
scanf("%f", &salario);
categoria = toupper(categoria);
if (categoria == 'A' || categoria == 'C' || categoria == 'F' || categoria == 'H')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera de %.2f", nome, categoria, salario * 1.10);
else
{
if (categoria == 'B' || categoria == 'D' || categoria == 'I' || categoria == 'J' || categoria == 'T')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera de %.2f", nome, categoria, salario * 1.15);
else
{
if (categoria == 'K' || categoria == 'G')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera de %.2f", nome, categoria, salario * 1.25); 
else
{
if (categoria == 'L' || categoria == 'M' || categoria == 'N' || categoria == 'O' || categoria == 'P' || categoria 
== 'Q' || categoria == 'R' || categoria == 'S')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera de %.2f", nome, categoria, salario * 
1.35);
else
{
if (categoria == 'U' || categoria == 'V' || categoria == 'X' || categoria == 'Y' || categoria == 'W' || 
categoria == 'Z')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera de %.2f", nome, categoria, salario
* 1.50);
else
printf("\nCategoria invalida!!!");
}
}
}
} 
system("pause");
return 0;
}
Resolução com if...else
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
int main()
{
float salario;
char categoria, nome[101];
printf("Informe o nome do funcionario:");
scanf("%s", nome);
fflush(stdin);
printf("\nInforme a categoria do funcionario (A a Z):");
scanf("%c", &categoria);
printf("\nInforme o salario atual do funcionario");
scanf("%f", &salario);
categoria = toupper(categoria);
.
.
.
Entrada de dados
40
41
if (categoria == 'A' || categoria == 'C' || categoria == 'F' || categoria == 'H')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera de 
%.2f", nome, categoria, salario * 1.10);
else
{
if (categoria == 'B' || categoria == 'D' || categoria == 'I' || categoria == 
'J' || categoria == 'T')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera
de %.2f", nome, categoria, salario * 1.15);
else
{
if (categoria == 'K' || categoria == 'G')
printf("\nO salario reajustado do funcionario %s, da categoria %c, 
sera de %.2f", nome, categoria, salario * 1.25); 
else
{
if (categoria == 'L' || categoria == 'M' || categoria == 'N' || 
categoria == 'O' || categoria == 'P' || categoria == 'Q' || 
categoria == 'R' || categoria == 'S')
printf("\nO salario reajustado do funcionario %s, da categoria 
%c, sera de %.2f", nome, categoria, salario * 1.35);
else
{
if (categoria == 'U' || categoria == 'V' || categoria == 'X' || 
categoria == 'Y' || categoria == 'W' || categoria == 'Z')
printf("\nO salario reajustado do funcionario %s, da 
categoria %c, sera de %.2f", nome, categoria, salario*1.50);
else
printf("\nCategoria invalida!!!");
}
}
}
} 
continuação
Atenção
if (categoria == 'A' || categoria == 'C' || categoria == 'F' || categoria == 'H')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera de 
%.2f", nome, categoria, salario * 1.10);
if (categoria == 'A' || categoria == 'C' || categoria == 'F' || categoria == 'H')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera de 
%.2f", nome, categoria, salario * 1.10);
if (categoria == 'A' || 'C' || 'F' || 'H')
printf("\nO salario reajustado do funcionario %s, da categoria %c, sera de 
%.2f", nome, categoria, salario * 1.10);
Não pode construir a expressão sem comparar um a um 
porque a expressão sempre vai ser verdadeira.
42
Exemplo: usando o switch em C
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
int main()
{
char nome[31], categoria;
float salario;
printf("\nInforme o nome do funcionário:");
scanf("%s", nome);
fflush(stdin);
printf("\nInforme a categoria do funcionário (A a Z):");
scanf("%c", &categoria);
printf("\nInforme o salário do funcionário:");
scanf("%f", &salario);
categoria = toupper(categoria);
Entrada de dados
43
Exemplo: usando o switch em C
switch(categoria)
{
/* a) Funcionários das categorias A, C, F e H ganharão 
10% de aumento sobre o salário */
case 'A':
case 'C':
case 'F':
case 'H':
printf("\nO funcionário %s, da categoria %c deve ter 
novo salário de R$%.2f.\n\n", nome, opcao, 
salario*1.1);
break;
/* b) Funcionários das categorias B, D, E, I, J e T 
ganharão 15% de aumento sobre o salário ; */
case 'B':
case 'E':
case 'I':
case 'J':
case 'T':
printf("\nO funcionário %s, da categoria %c deve ter 
novo salário de R$%.2f.\n\n", nome, opcao, 
salario*1.15);
break;
44
Exemplo: usando o switch em C
/* b) Funcionários das categorias B, D, E, I, J e T ganharão 15% de aumento sobre o salário ; 
*/
case 'B':
case 'E':
case 'I':
case 'J':
case 'T':
printf("\nO funcionário %s, da categoria %c deve ter novo salário de R$%.2f.\n\n", nome, 
opcao, salario*1.15);
break;
/* c) Funcionários das categorias K e G ganharão 25% de aumento sobre o salário; */
case 'K':
case 'G':
printf("\nO funcionário %s, da categoria %c deve ter novo salário de R$%.2f.\n\n", nome, 
opcao, salario*1.25);
break;
/* d) Funcionários das categorias L, M, N, O, P, Q, R e S ganharão 35% de aumento sobre o 
salário; */
case 'L':
case 'M':
case 'N':
case 'O':
case 'P':
case 'Q':
case 'R':
case 'S':
printf("\nO funcionário %s, da categoria %c deve ter novo salário de R$%.2f.\n\n", nome, 
opcao, salario*1.35);
break;
45
Exemplo: usando o switch em C
46
/* e) Funcionários das categorias U, V, X, Y, W e Z ganharão 50% 
de aumento sobre o salário; */
case 'U':
case 'V':
case 'X':
case 'Y':
case 'W':
case 'Z':
printf("\nO funcionário %s, da categoria %c deve ter 
novo salário de R$%.2f.\n\n", nome, opcao, 
salario*1.5);
break;
default:
printf("\nCategoria inválida!\n");
break;
}
system ("pause");
return 0;
}
Exemplo: usando o switch em C
switch(opcao)
{
/* a) Funcionários das categorias A, C, F e H ganharão 
10% de aumento sobre o salário */
case 'A':
case 'C':
case 'F':
case 'H':
printf("\nO funcionário %s, da categoria %c deve ter 
novo salário de R$%.2f.\n\n", nome, opcao, 
salario*1.1);
break;
Não dá para fazer algo do tipo abaixo, usando o OU lógico:
case (‘A' || ‘C' || ‘F' || ‘H’):
printf("\nO funcionário %s, da categoria %c deve ter 
novo salário de R$%.2f.\n\n", nome, opcao, 
salario*1.1);
break; errado
47
Alguns detalhes de implementação...
48
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
int main()
{
char nome[31], categoria, opcao;
float salario;
printf("\nInforme o nome do funcionário:");scanf("%s", nome);
fflush(stdin);
printf("\nInforme a categoria do funcionário (A a Z):");
scanf("%c", &categoria);
printf("\nInforme o salário do funcionário:");
scanf("%f", &salario);
opcao = toupper(categoria);
Função toupper()
` Pertence ao módulo ctype.h
` Dada uma letra, ela a transforma para a sua versão 
maiúscula;
` Exemplo: 
` letra= ‘a’
` letra = toupper(letra);
` Agora o conteúdo de letra é ‘A’
` A função tolower() faz o contrário, isto é, converte uma 
letra maiúscula em minúscula
49
Função toupper()
` É usada porque o usuário pode digitar uma letra 
correspondente a uma categoria no formato minúsculo 
ou maiúsculo;
` Como dentro do nosso case usamos tudo maiúsculo, se 
não tratarmos essa possibilidade de letra minúscula, o 
case não reconhecerá quando o usuário digitar, por 
exemplo, a categoria ‘b’. Será dada a mensagem 
“Categoria inválida”.
50
Alguns detalhes de implementação...
51
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
int main()
{
char nome[31], categoria;
float salario;
printf("\nInforme o nome do funcionário:");
scanf("%s", nome);
fflush(stdin);
printf("\nInforme a categoria do funcionário (A a Z):");
scanf("%c", &categoria);
printf("\nInforme o salário do funcionário:");
scanf("%f", &salario);
categoria = toupper(categoria);
Problema sem o uso de fflush()
Escrevemos o nome da funcionária e teclamos ENTER
Depois não conseguimos inserir a categoria, pois o cursor já está pedindo o
valor do salário.
O que ocorre é que a categoria é do tipo char (1 caractere) e quando 
teclamos ENTER, esse ENTER é capturado e é atribuído à variável categoria
52
Função fflush()
` Pertence à biblioteca stdio.h
` Sintaxe: 
` fflush(stdin);
` Onde, fflush é o comando de limpeza do buffer e stdin é
o buffer de teclado
53
Usando o fflush (stdin)
54
Outra opção: fgets()
` Pertence à biblioteca stdio.h
` Sintaxe: 
` fgets(<nome da variável>, <tamanho>, stdin);
` O código ficaria então:
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
int main()
{
char nome[31], categoria, opcao;
float salario;
printf("\nInforme o nome do funcionário:");
fgets(nome,31,stdin);
55
Vantagem em relação ao scanf()
` Usando o scanf() não conseguimos pegar facilmente uma 
string com mais de uma palavra (ex.: José da Silva) porque 
o scanf() vai cortar a string no primeiro espaço em 
branco (ficaria somente José)
` O fgets() também ajuda a limitar o tamanho máximo da 
string que queremos pegar
56
Ainda não é suficiente...
O fgets() pega o ENTER que nós damos ao terminar de escrever o nome.
Veja na figura que há uma quebra de linha após o nome.
57
Ajeitando o código...
` Podemos incluir mais uma linha de código após o fgets()
` nome[strlen(nome)-1]='\0‘;
#include <stdio.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
int main()
{
char nome[31], categoria, opcao;
float salario;
system("chcp 1252 > nul");
printf("\nInforme o nome do funcionário:");
fgets(nome,31,stdin);
nome[strlen(nome)-1]='\0';
58
Ajeitando o código...
` A função strlen() pertence à biblioteca string.h e retorna 
o tamanho da string nome
` nome[strlen(nome)-1]='\0';
` Digitamos “Janne Lachi<enter>” que tem, portanto, 
tamanho 12, mas que está organizado da seguinte forma:
` Então, estamos pedindo para incluir o símbolo de final de 
string '\0' na posição strlen(nome)-1= 11, ou seja, 
estamos substituindo o ENTER por '\0'
59
Agora sim...
60
Explorando printf( )
` Códigos especiais são usados dentro da expressão de controle 
de printf( ) com o símbolo %
` Exemplos: %d, %s, %c, %f
` Se quisermos imprimir a frase “O desconto dado foi de 10%”, como 
faremos?
` Dentro do printf( ) devemos usar dois símbolos de %
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int desconto = 10;
printf(″O desconto dado foi de %d%%.\n″, desconto);
system(″PAUSE″);
return 0;
}
61
Tamanhos de campo na impressão
` A função printf( ) permite estabelecer o tamanho mínimo de 
um campo para impressão.
` Podemos definir o número de colunas que serão ocupadas por 
um valor ou texto a ser impresso.
` Essa definição é usada para alinhamento e estética
#include <stdio.h>
#include <stdlib.h>
int main ()
{
printf(″Os alunos são %2d.\n″, 350);
printf(″Os alunos são %4d.\n″, 350);
printf(″Os alunos são %5d.\n″, 350);
system(″PAUSE″);
return 0;
}
SAÍDA:
Os alunos são 350.
Os alunos são 350.
Os alunos são 350.
62
Observação
` Se o tamanho do campo especificado for menor que o 
tamanho mínimo necessário para imprimir o valor associado, a 
impressão utilizará o número necessário de colunas, 
ignorando o tamanho especificado para o campo.
#include <stdio.h>
#include <stdlib.h>
int main ()
{
printf(″Os alunos são %2d.\n″, 350);
printf(″Os alunos são %4d.\n″, 350);
printf(″Os alunos são %5d.\n″, 350);
system(″PAUSE″);
return 0;
}
SAÍDA:
Os alunos são 350.
Os alunos são 350.
Os alunos são 350.
63
Imprimindo uma tabela
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int lapis=45, borrachas=2345, canetas=420, cadernos=8, fitas=13050;
printf(″\nLapis %12d″, lapis);
printf(″\nBorrachas %12d″, borrachas);
printf(″\nCanetas %12d″, canetas);
printf(″\nCadernos %12d″, cadernos);
printf(″\nFitas %12d″, fitas);
system(″PAUSE″);
return 0;
} SAÍDA:
Lapis 45
Borrachas 2345
Canetas 420
Cadernos 8
Fitas 13050
64
Imprimindo uma tabela
` Pode-se usar tamanho de campos com números em ponto 
flutuante e, ao mesmo tempo, obter precisão e 
arredondamento.
#include <stdio.h>
#include <stdlib.h>
int main ()
{
float cidade1=4.875, cidade2=234.542, cidade3=42.036, cidade4=8.0;
printf(″\nCidade 1 %12.2f″, cidade1);
printf(″\nCidade 2 %12.2f″, cidade2);
printf(″\nCidade 3 %12.2f″, cidade3);
printf(″\nCidade 4 %12.2f″, cidade4);
system(″PAUSE″);
return 0;
}
65
Imprimindo uma tabela
` Pode-se usar tamanho de campos com números em ponto 
flutuante e, ao mesmo tempo, obter precisão e 
arredondamento.
/* Tamanho de campo com ponto flutuante */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
printf(″%4.2f\n”, 3456.78);
printf(″%3.2f\n”, 3456.78);
printf(″%3.1f\n”, 3456.78);
printf(″%10.3f\n”, 3456.78);
system(″PAUSE″);
return 0;
}
SAÍDA:
3456.78
3456.78
3456.8
3456.78
66
Alinhamento à direita ou à esquerda
/* Sem tamanho de campo */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
printf(″%.2f %.2f %.2f\n″, 8.0, 15.3, 584.13);
printf(″%.2f %.2f %.2f\n″, 834.0, 1500.55, 4890.21);
system(″PAUSE″);
return 0;
}
SAÍDA:
8.00 15.30 584.13
834.00 1500.55 4890.21
67
Alinhamento à direita ou à esquerda
/* Com tamanho de campo */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
printf(″%10.2f %10.2f %10.2f\n″, 8.0, 15.3, 584.13);
printf(″%10.2f %10.2f %10.2f\n″, 834.0, 1500.55, 4890.21);
system(″PAUSE″);
return 0;
}
68
Alinhamento à direita ou à esquerda
` O sinal de menos (-) precedendo a especificação do tamanho 
do campo justifica os campos à esquerda
/* Com tamanho de campo e alinhado à esquerda */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
printf(″%-10.2f %-10.2f %-10.2f\n″, 8.0, 15.3, 584.13);
printf(″%-10.2f %-10.2f %-10.2f\n″, 834.0, 1500.55, 4890.21);
system(″PAUSE″);
return 0;
}
69
Tamanho de campo com cadeias de 
caracteres
70
/* Com tamanho de campo com cadeias de caracteres */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
printf("\nOBJETO %12s", "CODIGO");
printf("\nLapis %12s", "WQR");
printf("\nBorrachas %12s", "ASO");
printf("\nCanetas %12s", "KPX");
printf("\nCadernos%12s", "FJI");
printf("\nFitas %12s\n", "TYE");
system("PAUSE");
return 0;
}
Complementando com zeros à esquerda
/* Com tamanho de campo e complementando com zeros*/
#include <stdio.h>
#include <stdlib.h>
int main ()
{
printf("\n%04d", 21);
printf("\n%06d", 21);
printf("\n%6.4d", 21);
printf("\n%6.0d", 21);
system("PAUSE");
return 0;
}
71
Função scanf( )
` Sintaxe:
scanf(“string de formatação”, endereço da variável 1,..., endereço da variável n);
` Alguns erros...
` Passar mais de uma variável como argumento:
` scanf(“%f%d”, &salario, &idade, &ano);
` Passar mais códigos do que variáveis:
` scanf(“%f%d%d”, &salario, &idade);
` Informar os nomes das variáveis sem o &:
` scanf(“%f%d”, salario, idade);
` A exceção é para variáveis do tipo string que não precisam do & por serem 
um vetor
72
scanf( )
` Espera que o usuário digite cada caractere exatamente como 
ela aparece na string de formatação
scanf(“string de formatação”, endereço da variável 1,..., endereço da variável n);
scanf(“Digite um numero inteiro: %d”, &meuInteiro);
` A função scanf() vai esperar que o usuário digite 
EXATAMENTE a frase Digite um numero inteiro: antes de 
introduzir o número inteiro esperado
` Para informar ao usuário o que deve ser dado como entrada, 
use a função printf()
73
Entrada formatada com scanf( )
` No exemplo abaixo queremos receber do usuário uma data 
com o formato dd/mm/aaaa
` Com o uso de %*c vamos ignorar o caractere /
/* Mostra o uso do caractere * com scanf() */
#include <stdio.h>
#include <stdlib.h>
int main ()
{
int dia, mes, ano;
printf("Digite uma data no formato dd/mm/aaaa: ");
scanf("%d%*c%d%*c%d", &dia, &mes, &ano);
printf("A data que voce digitou foi: %02d/%02d/%d\n", dia, mes, ano);
system("PAUSE");
return 0;
}
74
Operador condicional ternário
` É o único operador em C que opera sobre 3 expressões
` Sintaxe:
expressão 1 ? expressão 2 : expressão 3
` A expressão 1 é avaliada primeiro
` Se seu valor for diferente de 0 (verdadeira), a expressão 2 será
avaliada e o seu resultado será o valor da expressão condicional 
como um todo.
` Se seu valor for 0, a expressão 3 será avaliada e será o valor da 
expressão condicional como um todo.
75
Operador condicional ternário: 
exemplos
/* a variável que conter o maior valor numérico 
entre a e b será atribuída a max */
max = (a > b)? a: b;
/* Variável absol recebe o valor absoluto de x */
absol = (x > 0)? x : -x ;
/* Imprime “Ímpar” se x for um número ímpar ou “Par”
se x for par */
printf(“%s”, (x%2)? ”Impar” : “Par”);
76
Referências
` Ulysses de Oliveira. Programando em C. D. Rio de Janeiro; 
Editora Ciência Moderna, 2008 
` Victorine Viviane Mizrahi. Treinamento em linguagem C. 
São Paulo: Pearson Prentice Hall, 2008. 
` Ricardo Sonaglio Albano e Silvie Guedes Albano. Programação 
em Linguagem C. Rio de Janeiro; Editora Ciência Moderna, 
2010.
77
	Algoritmos e Programação
	Tipos básicos
	O tipo double
	Tipos de dados definidos pelo padrão ANSI
	Modificadores de tipos
	Modificadores de tipos
	Conversões de tipos
	Conversão automática
	Conversão automática: exemplo
	Conversão automática: exemplo (cont.)
	Conversão automática
	Conversão automática
	Conversão explícita
	Conversão explícita: exemplo 1
	Conversão explícita: exemplo 2
	Conversão explícita: exemplo 2 (cont.)
	O módulo <math.h>: funções matemáticas
	Funções getche() e getch()
	Funções getche(): exemplo
	Funções getch(): exemplo
	Funções getchar() e putchar()
	Funções getchar() e putchar(): exemplo
	Um pouco mais sobre strings
	Strings: exemplos
	Strings: atribuição
	Strings: operações inválidas
	Lista 2: exercício 15
	Lista 2: exercício 11
	Lista 2: exercício 11
	Lista 2: exercício 11
	Problema sem o uso de %*[\n]
	Usando o módulo <string.h>
	Função strcpy(): exemplos
	Função strcat(): exemplo
	Função strcmp(): exemplo
	Função strlen(): exemplo
	Função strupr(): exemplo
	Um problema exemplo
	Exemplo: usando o switch em C
	Exemplo: usando o switch em C
	Exemplo: usando o switch em C
	Exemplo: usando o switch em C
	Exemplo: usando o switch em C
	Alguns detalhes de implementação...
	Função toupper()
	Função toupper()
	Alguns detalhes de implementação...
	Problema sem o uso de fflush()
	Função fflush()
	Usando o fflush (stdin)
	Outra opção: fgets()
	Vantagem em relação ao scanf()
	Ainda não é suficiente...
	Ajeitando o código...
	Ajeitando o código...
	Agora sim...
	Explorando printf( )
	Tamanhos de campo na impressão
	Observação
	Imprimindo uma tabela
	Imprimindo uma tabela
	Imprimindo uma tabela
	Alinhamento à direita ou à esquerda
	Alinhamento à direita ou à esquerda
	Alinhamento à direita ou à esquerda
	Tamanho de campo com cadeias de caracteres
	Complementando com zeros à esquerda
	Função scanf( )
	scanf( )
	Entrada formatada com scanf( )
	Operador condicional ternário
	Operador condicional ternário: exemplos
	Referências