ApostilaC-Basico v2

Prévia do material em texto

#include<math.h>
#include<stdio.h>
#include<stdlib.h>
float max(float x, 
 float y){
 if (x > y)
 return x;
 return y;
}
float mediaHarmPond(float amostra1, 
	float peso1, 
	float amostra2, 
	float peso2, 
	float amostra3, 
	float peso3) {
 return (peso1 + peso2 +peso3)/(peso1/max(amostra1,0.0001)+peso2/max(amostra2,0.0001)+peso3/max(amostra3,0.0001));
}
void main(){
 unsigned long int cod;
 int i, n=0;
 float p1, p2, p3, mh[60], mh_media=0, somatorio=0, s;
 FILE *saida;
 
 if ((saida = fopen("l:medias.DAT", "w"))== NULL){ // Cria um arquivo para escrita
	 printf("Nao conseguiu criar arquivo de saida.\n");
 exit(0); // Aborta execucao
 }
 while(1){
	 printf("Forneca o codigo do aluno\n");
	 scanf("%ld",&cod);
 if (cod==0) break; // Sai do laco
	 printf("Forneca as notas das provas do aluno\n");
	 scanf("%f %f %f",&p1, &p2, &p3);
	 if (p1>=0 && p1<=10 && p2>=0 && p2<=10 && p3>=0 && p3<=10){
 mh[n] = mediaHarmPond(p1,1,p2,2,p3,3);
 mh_media += mh[n];
		fprintf(saida,"Codigo: %8ld Prova 1: %2.2f Prova 2: %2.2f Prova 3: %2.2f Media harmonica ponderada: %2.2f\n", cod, p1, p2, p3, mh[n]);
 n++;
 } else
 printf("Intervalo de notas invalido\n");
 }
 mh_media = mh_media/n;
 for(i=0;i<n;i++)
 somatorio+=(mh[i]-mh_media)*(mh[i]-mh_media);
 s = sqrt(somatorio/(n-1));
 printf("O desvio padrao eh %.4f\n",s);
}
Programação 
em C
Módulo básico
Sumário
1	Introdução	5
1.1	Visão geral de um programa C	5
2	Estrutura Básica de um Programa em C	6
2.1	Bibliotecas	7
2.2	As bibliotecas disponíveis e algumas funções interessantes	7
3	Comando de Escrita	9
3.1	Modificadores de Saída	11
3.2	Exercícios	11
4	Tipos de Dados	13
4.1	Constantes	15
4.2	Constantes pré-definidas	16
5	Variáveis	18
5.1	Nome de Variáveis	18
5.2	Declaração de Variáveis	18
5.2.1	Escopo de Variáveis	19
5.3	Palavras reservadas	21
6	Operadores	23
6.1	Atribuição	23
6.1.1	Conversão de Tipos em Atribuições	23
6.2	Operadores Aritméticos	24
6.2.1	Operadores Aritméticos de Atribuição	25
6.3	Operadores Relacionais e Lógicos	26
6.4	Precedência dos operadores aritmético, Relacionais e Lógicos	27
6.5	Operadores de Ponteiros & e *	27
6.6	Operador Vírgula	28
6.7	Expressões	28
6.7.1	Conversão de Tipos em Expressões	28
6.7.2	Casts	29
6.7.3	Espaçamento e Parênteses	30
7	Algumas funções de E/S	31
7.1	scanf()	31
7.2	Lendo e escrevendo caracteres	33
7.2.1	getche() e getch()	33
7.3	Exercícios	34
8	Comandos Condicionais	36
8.1	Comando if	36
8.2	Comando switch	37
8.3	Exercícios	38
9	Estrutura de Repetição (Laços)	43
9.1	Laço for	43
9.2	Laço while	44
9.3	Laço do-while	45
9.4	break	46
9.5	exit()	47
9.6	Exercícios	48
10	Funções	53
10.1	Localização das funções	54
10.1.1	Corpo da função antes do programa principal (no mesmo arquivo)	54
10.1.2	Corpo da função depois do programa principal (no mesmo arquivo)	54
10.1.3	Corpo da função escrito em arquivo separado	55
10.2	Protótipo de funções	56
10.3	Diretiva #define	56
10.4	Exercícios	57
11	Vetores e Matrizes	60
11.1	Inicialização de Vetores e Matrizes	60
11.2	Matrizes e Vetores como argumento de Funções	61
11.3	Limites	61
11.4	Exercícios	62
12	Strings (cadeia de caracteres)	68
12.1	Leitura de Strings	68
12.1.1	scanf()	68
12.1.2	gets()	70
12.2	Escrita de Strings	70
12.2.1	printf()	70
12.2.2	puts()	70
12.3	Funções de Manipulação de Strings	71
12.3.1	strlen()	71
12.3.2	strcat()	71
12.3.3	strcmp()	71
12.3.4	strcpy()	72
12.4	Exemplo Geral	72
12.5	Exercícios	72
13	E/S com Arquivo	80
13.1	Streams	80
13.2	Arquivos	80
13.3	Sistema de Arquivos	80
13.4	Estrutura FILE	81
13.5	Abertura de Arquivos	81
13.6	Fechamento de Arquivo	82
13.7	Verificando fim de arquivo	82
13.8	Comando de gravação em modo texto formatado	82
13.9	Streams Padrão	83
13.10	Exercícios	83
A.	Tabela Ascii	85
14	Bibliografia	86
Introdução
A linguagem C foi criada por Dennis M. Ritchie e Ken Thompson no Laboratório Bell em 1972, baseada na linguagem B de Thompson que era uma evolução da antiga BCPL. Ela foi implementada pela primeira vez num computador DEC PDP-11 que usava o sistema operacional UNIX.
A linguagem C tornou-se muito popular devido a características como:
· C é uma linguagem de alto nível com uma sintaxe bastante estruturada e flexível tornando sua programação bastante simplificada.
· Programas em C são compilados, gerando programas executáveis.
· C compartilha recursos tanto de alto quanto de baixo nível, pois permite acesso e programação direta do microprocessador. Com isto, rotinas cuja dependência do tempo é crítica, podem ser facilmente implementadas usando instruções em Assembly. Por esta razão, C é a linguagem preferida dos programadores de aplicativos.
· C é uma linguagem estruturalmente simples e de grande portabilidade. O compilador C gera códigos mais enxutos e velozes do que muitas outras linguagens. 
· Embora estruturalmente simples (poucas funções intrínsecas), C não perde funcionalidade pois permite a inclusão de uma farta quantidade de rotinas do usuário. Os fabricantes de compiladores fornecem uma ampla variedade de rotinas pré-compiladas em biblioteca.
Como uma ferramenta poderosa a linguagem C é usada na construção de vários aplicativos como sistemas operacionais, planilhas eletrônicas, processadores de texto, sistemas de transmissão de dados, entre outros. Um exemplo clássico é o sistema operacional UNIX, o qual foi implementado em C.
No início da década de 80, a linguagem C é padronizada pelo American National Standard Institute: surge o ANSI C. Atualmente, a linguagem C vem sendo usada para desenvolver novas linguagens, entre elas a linguagem C++ e Java.
Visão geral de um programa C
A geração do programa executável a partir do programa fonte obedece a uma seqüência de operações ante de tornar-se um executável. Depois de escrever o código-fonte (ou programa) em um editor de textos (ou um ambiente de programação integrado), o programador executa o compilador. Essa ação desencadeia uma seqüência de etapas, cada qual traduzindo a codificação do usuário para uma forma de linguagem de nível inferior, que termina com o executável criado pelo linkador.
Editor
(módulo fonte em C)
(módulo fonte em C)
Pré-processador
(novo fonte expandido)
Compilador
(arquivo objeto)
Linkador
(executável)
Figura 1.1 - Codificação de um programa C
Estrutura Básica de um Programa em C
Um programa C consiste em uma ou várias funções. A seguir é mostrada a estrutura global de um programa em C. Detalhes sobre cada parte do programa serão vistos ao longo do texto.
 Sintaxe:
<Bibliotecas>
<Declarações_globais>
<Tipo_de_dado> <nome_função1>( <lista_de_parâmetros>) {
 <Declarações_locais>
 <Seqüência de comandos>
}
<Tipo_de_dado> <nome_função2>( <lista_de_parâmetros>) {
 <Declarações_locais>
 <Seqüência de comandos>
}
<Tipo_de_dado> <nome_funçãoN>( <lista_de_parâmetros>) {
 <Declarações_locais>
 <Seqüência de comandos>
}
Como um programa pode ter mais de uma função, deve existir um mecanismo que garanta que todos os programas inicializem da mesma forma. Este mecanismo pode ser entendido como a padronização da função que será chamada primeiramente. Tal função chama-se main().
Sintaxe:
int main()		primeira função a ser executada
{			inicia o corpo da função
 return 0;
}			termina a função
	Conforme a sintaxe, int seria um tipo de dado do valor que é retornado para o sistema operacional (normalmente um inteiro, já que este valor é utilizado pelo sistema operacional para saber como o programa foi finalizado). A função main()não possui parâmetro neste caso (mas existe a possibilidade de receber dados na chamada do programa). O comando return devolve 0 (isto é, o código para dizer que o programa foi executado com sucesso) para quem chamou a função , neste caso o sistema operacional
Um programa em C deve possuir somente uma única função main()
A seguir, algumas regras para a programação em C:
	Toda função C deve ser iniciada e encerrada por um abre chaves e um fecha chaves respectivamente;
	O nome da função, os parênteses e as chaves são os únicos elementos obrigatórios de uma função;
Todas as instruções devem estar dentro das chaves;
	As instruções C são sempre encerradas por um ponto-e-vírgula;
Bibliotecas
A linguagem C organiza os diferentes conjuntos de funções comuns em bibliotecas padrões de funções. Então, para fazer uso de certa função de uma determinada biblioteca, o programador tem que informar que biblioteca está utilizando. Apesar de parecer complicado de ter que saber em qual biblioteca cada comando está definido, normalmente, um programa não utiliza muitas bibliotecas padrões definidas (cada biblioteca possui diversas funções). Além disso, a cada função nova, define-se da biblioteca onde a mesma está definida. 
Para fazer isto, usa-se uma diretiva de compilação a qual é colocada fora de qualquer função do programa. A diretiva é #include instrui o compilador a ler outro arquivo-fonte.
Sintaxe:
#include nome_arq
onde nome_arq tem que estar entre aspas ou símbolos de maior ou menor. Em algumas plataformas, somente uma forma (<>). Para outras, aspas significam para o compilador que a biblioteca em questão deve ser buscada primeiramente no diretório atual e depois no diretório padrão do compilador ou pelas variáveis de ambiente. Também, os caracteres “<>“ significam ao compilador que deve procurar somente no diretório padrão ou nos diretórios definidos pelas variáveis de ambiente.
Exemplo 2.1
	#include <stdio.h>
Não se usa o ponto-e-vírgula após diretivas de compilação. Este tipo de declaração é muito usado nos programas profissionais. Cada comando pré-definido em C está prototipado em alguma biblioteca (isto é informado conjuntamente ao comando).
As bibliotecas disponíveis e algumas funções interessantes
A seguir segue uma lista de algumas as bibliotecas disponíveis no compilador Turbo C++ Borland: Ao longo do texto veremos o uso de muitas funções cobrindo uma boa parte destas bibliotecas, porém o leitor que desejar tornar-se "fluente" na linguagem C pode (e deve) estudá-las com profundidade.
alloc.h assert.h bcd.h bios.h complex.h
	conio.h ctype.h dir.h dirent.h dos.h
	errno.h fcntl.h float.h fstream.h generic.h
	graphics.h io.h iomanip.h iostream.h limits.h
	locale.h malloc.h math.h mem.h process.h
	setjmp.h share.h signal.h stdarg.h stddef.h
	stdio.h stdiostr.h stdlib.h stream.h string.h
	strstrea.h sys\stat.h sys\timeb.h sys\types.h time.h
	values.h
	A seguir, algumas funções disponíveis pelas bibliotecas da linguagem C: 
Biblioteca math.h	
int abs(int i);
double fabs(double d);
Calcula o valor absoluto do inteiro i e do real d, respectivamente.
	double sin(double arco);
double cos(double arco);
double tan(double arco);
double asin(double arco);
double acos(double arco);
double atan(double arco);
	Funções trigonométricas do ângulo arco, em radianos.
double ceil(double num);
double floor(double num);
	Funções de arredondamento para inteiro.
ceil() 
	Arredonda para cima. Ex. ceil(3.2) → 3.0;
floor() 
	Arredonda para baixo. Ex. floor(3.2) → 4.0;
double log(double num);
double log10(double num);
Funções logarítmicas: log() é logaritmo natural (base e), log10() é logaritmo decimal (base 10).
double pow(double base, double exp);
Potenciação: pow(3.2,5.6) = 3.25.6. 
double sqrt(double num);
Raiz quadrada: sqrt(9.0) = 3.0. 
Biblioteca stdlib.h
int random(int num);
Gera um número inteiro aleatório entre 0 e num - 1.
Comando de Escrita
	A função printf() é uma das funções de E/S (entrada e saída) que mostra na tela os parâmetros que são passados como argumento. Seu protótipo está na biblioteca stdio.h.
Sintaxe:
	printf(“<expressao_de_controle>”, lista_de_argumentos)
onde:
expressão_de_controle = contém caracteres que serão exibidos na tela e códigos de formatação que indicam o formato em que os argumentos (da lista_de_argumentos) devem ser impressos.
lista_de_argumentos = lista de argumentos que serão apresentadas na expressão_de_controle. Tal lista não tem tamanho máximo e cada argumento deve ser separado por uma vírgula.
	A Tabela 3.1 mostra os códigos na linguagem para caracteres que não podem ser inseridos diretamente do teclado.
Tabela 3.1 - Código para os caracteres especiais
	CÓDIGO
	SIGNIFICADO
	\n
	Nova Linha (LF)
	\t
	Tabulação (HT)
	\b
	Retrocesso (BS)
	\”
	”
	\\
	Barra invertida
	\f
	Salta Página de Formulário (FF)
	\r
	Retorno de Carro (CR)
	\’
	’
	\v
	Tabulação Vertical
	\a
	Alerta (beep)
	\N
	Constante octal (onde N é uma constante octal)
	\xN
	Constante Hexadecimal (onde N é uma constante hexadecimal) 
	\0
	Nulo
	Além destes, existem os códigos para formatação de impressão dos argumentos passados para a função, os quais estão relacionados na Tabela 3.2.
Tabela 3.2 - Códigos para formatação de impressão
	Código
	Significado
	%c
	Caractere Simples
	%d ou %i
	Inteiro decimal com sinal
	%e ou %E 
	Notação Científica (com e minúsculo ou maiúsculo, respectivamente)
	%f
	Ponto Flutuante
	%g ou %G 
	%e ou %f (o mais curto, respectivamente)
	%o
	Octal
	%s
	Cadeia de Caracteres
	%u
	Inteiro decimal sem Sinal
	%x ou %X
	Hexadecimal (caracteres em minúsculo e maiúsculo, respectivamente)
	%p
	Ponteiro (endereço)
	%n
	Ponteiro inteiro. 
	%%
	Escreve o símbolo %
O uso incorreto do código de formatação produz, em geral, uma saída incorreta. Por exemplo, o comando printf(“%f”,x), onde a variável x é declarada como int x=4, produz a saída 0 e não 4 como esperava-se, pois o printf procura por uma variável real e não inteira.
Exemplo 3.1
#include <stdio.h>
int main() {
 printf(“A %s C foi criada em %d \nOk?”, “Linguagem”, 1972);
 return 0;
}
Execução:
A Linguagem C foi criada em 1972
Ok?
No Exemplo 3.1 percebe-se o uso de dois tipos de códigos: primeiro de formatação com %s (para um literal - string) representando a constante “Linguagem” e %d (inteiro decimal) representando a constante ano 1972; segundo um código especial para representar caractere de nova linha \n.
Exemplo 3.2
#include <stdio.h>
int main() {
 printf(“A %s %c foi”, “Linguagem”, ‘C’);
 printf(“ criada em %d ”, 1972);
 return 0;
}
Execução:
	A Linguagem C foi criada em 1972
	No Exemplo 3.2, nota-se que ‘C’ é delimitado por aspas simples enquanto que “Linguagem” é delimitado por aspas duplas. Isto indica ao compilador como diferenciar um caractere de uma cadeia de caracteres.
	O especificador de formato %n faz com que o printf() armazene na variável apontada por seu argumento correspondente com um valor igual ao número de caracteres que já foram escritos. 
Exemplo 3.3
#include <stdio.h>
int main() {
 int cont;	
 printf(“caracteres%n escritos\n”, &cont);
 printf(“%d\n”, cont);
 return 0;
}
Execução:
	Caracteres escritos
	10
Este tipo de formato é comumente utilizado para formatação dinâmica de saída de dados.
	O especificador de formato %p é utilizado para mostrar um endereço de memória de acordo com o formato de endereçamento da máquina. 
Exemplo 3.4
#include <stdio.h>
int main() {
 int cont;	
 printf("A variável cont está armazenada no endereço: %p\n", &cont);
 return 0;
}
Execução:
A variável cont está armazenada no endereço: 0012FF5C 
Modificadores de Saída
	Para complementar os códigos de formatação a linguagem C oferece alguns códigos especiais para melhorar a apresentação dos dados. Para isto relacionam-se:
· ‘-’ : alinhamento pela esquerda.
· ‘+’: coloca o sinal de menos ou mais se o valor for numérico.
· n (número) : indica o tamanho mínimo do campo. O preenchimento é feito com espaços em branco. Se o tamanho iniciar com 0 (ex. 05), o preenchimento passa a ser feito com zeros.
· .m : tamanho máximo do campo, menos para os reais onde é usado para indicar o número de casas decimais.
· * : substitui um dos n, mas o seu valor é o próximo parâmetro.
· ‘l’ : indica que segue um dado longo.
Exemplo 3.3
COMANDO	TELA
printf(“%s %d”, “Numero”,10);	Numero 10
printf(“%8s %4d”, “Numero”,10);	##Numero ##10
printf(“%-8s %4d”, “Numero”,10);	Numero## ##10
printf(“%-3.5s %2.2f”,“Numero”,10.99);	Numer 10.99
printf(“Long%ld”, 57485784);	Long 57485784
onde: 
	# - representa 1 espaço em branco.
Exercícios 
1. Escreva os comandos de saída formatada que gerem as seguintes saídas:
 01234567890123456789012
a) Camisa estampada 40,00
 Camisa lisa 35,00
b) Camisa estampada 40,00
 Camisa lisa 35,00
c) Camisa estampada 00040,00
 Camisa lisa 00035,00
d) Camisa e 40
 Camisa l 35
2. Corrija o seguinte programa:
	#include <stdio.h>
	int main{ }(
		printf(A Linguagem C foi criada em %d\n, 1972)
		return1;
	)
Tipos de Dados
	Em C existem 5 tipos de variáveis básicas. Nos computadores da linha IBM-PC (plataforma 32 bits), a Tabela 4.1 é válida. Estes tipos de dados definem a quantidade de memória que ocupa e o intervalor de valores que consegue representar. 
Tabela 4.1 - Tipos de dados básicos para plataformas 32 bits
	Tipo
	Bits
	Faixa Mínima
	char
	8
	-128 a 127
	int
	32
	-2,147,483,648 a 2,147,483,647
	float
	32
	3.4E-38 a 3.4E+38
	double
	64
	1.7E-308 a 1.7E+308
	void
	0
	sem valor
Os tipos char e int armazenam números inteiros, enquanto que os tipos float e Double armazenam números de ponto flutuante (é um formato de representação digital de números reais).
Com exceção de void, os tipos de dados básicos podem estar acompanhados por modificadores na declaração de variáveis. Os modificadores de tipos da linguagem C são:
Linguagem de Programação C
2
· signed;
· long;
· unsigned;
· short.
Os modificadores signed, short, long e unsigned podem ser aplicados aos tipos básicos char e int. Contudo, long também pode ser aplicado a double. 
A função printf() possui especificadores de formato que permitem mostrar inteiros short e long. O %ld, %li, %lo, %lu, %lx especificam que o tipo de dado é long. O %hd, %hi, %ho, %hu, %hx especificam que o tipo de dado é short. 
O especificador de formato long pode ser ainda utilizado para tipo ponto flutuante (indicando que segue um double): %le, %l E, %lf, %lg, e %lG. Outro especificado de formato é o L, o qual é utilizado para associar um long double: %Le, %LE, %Lf, %Lg, e %LG.
A Tabela 4.2 mostra todas a combinações de tipos de dados e as informações sobre tamanho, formatação e intervalo.
Tabela 4.2 - Utilização dos tipos de dados (plataforma 32 bits)
	
	Tipo
	Bits
	Formatação printf()
	Intervalo
	
	
	
	
	Inicio
	Fim
	Inteiros 
	char
	8
	%c
	-128
	127
	
	unsigned char
	8
	%c
	0
	255
	
	signed char
	8
	%c
	-128
	127
	
	short int
	16
	%hi
	-32.768
	32.767
	
	signed short int
	16
	%hi
	-32.768
	32.767 
	
	unsigned short int
	16
	%hu
	0
	65.535
	
	int
	32
	%i
	-2.147.483.648
	2.147.483.647
	
	signed int
	32
	%i
	-2.147.483.648
	2.147.483.647
	
	unsigned int
	32
	%u
	0
	4.294.967.295
	
	long int
	32
	%li
	-2.147.483.648
	2.147.483.647
	
	signed long int
	32
	%li
	-2.147.483.648
	2.147.483.647
	
	unsigned long int
	32
	%lu
	0
	4.294.967.295
	Ponto Flutuante
	float
	32
	%f
	3,4E-38
	3.4E+38 
	
	double
	64
	%lf
	1,7E-308
	1,7E+308
	
	long double
	80
	%Lf
	3,4E-4932
	3,4E+4932
O uso de signed com inteiros é redundante. No entanto, ele é permitido porque a declaração default de inteiros assume um número com sinal. O uso mais importante de signed é modificar char em implementações em que esse tipo, por padrão, não tem sinal. Algumas implementações podem permitir que unsigned seja aplicado aos tipos de ponto flutuante (como em unsigned double). Porém, isso reduz a portabilidade de seu código e geralmente não é recomendado. O modificador unsigned altera o valor da faixa mínima do tipo através do uso do bit mais significativo (indicador de sinal). 
O tamanho, e consequentemente o intervalo de valores, pode variar de plataforma para plataforma. Por exemplo, o long double em algumas plataformas possui 10 bytes de tamanho. O char já é um tipo que não varia de plataforma.
Exemplo 4.1
#include <stdio.h>
int main() {
 int qtde;
 char tam;
 float total;
 qtde = 2; tam = ‘G’;
 total = 20.70;
 printf(“Comprei %d camisas de tamanho %c.”, qtde, tam);
 printf(“\nNo total, paguei R$ %f.”, custo);
 return 0;
}
Execução:
	Comprei 2 camisas de tamanho G.
	No total, paguei R$ 20.70.
	As variáveis podem ser inicializadas no momento em que se faz a declaração das mesmas. Pode-se ver isto usando o programa anterior, que a execução será a mesma da versão anterior.
Exemplo 4.2
#include <stdio.h>
int main() {
 int qtde=2;
 char tam=‘G’;
 float total=20.70;
 printf(“Comprei %d camisas de tamanho %c.”, qtde, tam);
 printf(“\nNo total, paguei R$ %f.”, custo);
 return 0;
}
Devido às diferenças de tipos em diferentes máquinas e plataformas, pode-se utilizar a função sizeof() para descobrir o tamanho real da variável ou tipo.
Exemplo 4.3
#include <stdio.h>
int main() {
 printf("Tipo\t\tTamanho\n");
 printf("char\t\t%d\n",sizeof(char));
 printf("int\t\t%d\n",sizeof(int));
 printf("float\t\t%d\n",sizeof(float));
 printf("double\t\t%d\n",sizeof(double));
 printf("long int\t%d\n",sizeof(long int));
 return 0;
}
Execução:
Tipo Tamanho
char 1
int 4
float 4
double 8
long int 4
Constantes
	Uma constante tem valor fixo e inalterável durante a execução do programa. Isto pode ser exemplificado pelo Exemplo 3.1 e Exemplo 3.2 da função printf() e pelo Exemplo 4.4.
Exemplo 4.4
	‘C’
	“programa”
	8
	465.67
	Uma constante caractere é escrita entre aspas simples (‘’) enquanto que uma constante literal entre aspas duplas (“”) e constantes numéricas como o número propriamente dito. 
As constantes ‘A’ e “A” são diferentes pois a primeira é um caractere e a segunda é um literal. Apesar do conteúdo ser o mesmo a linguagem C representa as duas constantes de maneira diferente.
	Constantes em C podem ser de qualquer um dos cinco tipos de dados básicos. A maneira como cada constante é representada depende do seu tipo. Pode-se especificar precisamente o tipo da constante numérica através da utilização de um sufixo. Para tipos em ponto flutuante coloca-se um F após o número, ele será tratado como float. Se for colocado um L, ele tornar-se-á um long double. Para tipos inteiros, o sufixo U representa unsigned e o L representa long. A tabela 5.3 mostra alguns exemplos de constantes.
Tabela 4.3 - Exemplo de constantes
	Tipo de Dado
	Exemplo de Constantes
	int
	1 123 21000 -234
	long int
	35000L -34L
	short int
	10 -12 90
	unsigned int
	10000U 987U 40000“
	float 
	123.23F 2.34e-3F
	double
	123.23 12312333 -0.9876324
	long double
	1001.2L
	Além destas existem as constantes Hexadecimais e Octais. Usam-se tais sistemas numéricos para facilitar a programação. Uma constante hexadecimal deve consistir em um 0x seguido por uma constante na forma hexadecimal. Uma constante octal começa com 0.
Exemplo 4.5
	int hex = 0x80;		/* 128 em decimal */
	int oct = 012;		/* 10 em decimal */
Constantes pré-definidas
Em alguns compiladores C, algumas constantes simbólicas já estão pré-definidas. Estas constantes em geral definam alguns valores matemáticos (, /2, e, etc.), limites de tipos etc. A seguir segue uma tabela contendo algumas (existem muitas outras) constantes simbólicas pré-definidas no compilador Turbo C++ da Borland.
Biblioteca Constante Valor Significado
math.h M_PI 3.14159... 
math.h M_PI_2 1.57079... /2
math.h M_PI_4 0,78539... /4
math.h M_1_PI 0,31830... 1/
math.h M_SQRT2 1,41421... 2
conio.h BLACK 0 valor da cor (preto)
conio.h BLUE 1 valor da cor (azul)
conio.h GREEN 2 valor da cor (verde)
conio.h CYAN 3 valor da cor (cyan)
conio.h RED 4 valor da cor (vermelho)
conio.h MAGENTA 5 valor da cor (magenta)
limits.h INT_MAX 2.147.483.647 limite superior do tipo int
limits.h INT_MIN -2.147.483.648 limite inferior do tipo int
Variáveis
	Variável em C é um espaço de memória reservado para armazenar um certo tipo de dado e tendo um nome para referenciaro seu conteúdo. O conteúdo da mesma pode variar segundo os comandos de alteração do programa.
Exemplo 5.1
#include <stdio.h>
int main() {
 int ano;
 ano = 1972;
 printf(“A Linguagem C foi criada em %d ”, ano);
 return 0;
}
	A primeira instrução,
	int ano;
é um exemplo de declaração de variável, isto é, apresenta um tipo, int, e um nome, ano.
	A segunda instrução,
	ano = 1972;
atribui um valor à variável e este valor será acessado através de seu nome. Para realizar isto foi usado o operador de atribuição (=).
Nome de Variáveis
A seguir listamos algumas regras para nomes de variáveis:
· Uma variável não pode ter o mesmo nome de uma palavra-chave de C.
· Letras maiúsculas diferem das letras minúsculas. 
· O número de caracteres válidos é definido de ambiente para ambiente.
Todo identificador deve iniciar com letra (maiúscula ou minúscula) e ser composto exclusivamente por letras, dígitos e underscore (isto é, _).
Exemplo 5.2
char x;			/* Válida */
int x2r;			/* Válida */
float #ertt;			/* Inválida */
float main;			/* Inválida */
float total da venda;	/* Inválida */
float total_da_venda;	/* Válida */
Declaração de Variáveis
	A declaração de variáveis serve para reservar uma quantidade de memória apropriada para armazenar o tipo especificado. Tal declaração consiste no nome de um tipo, seguido do nome da variável. Em C todas as variáveis devem ser declaradas. 
	Se existir mais de uma variável do mesmo tipo, pode-se declará-la de uma vez separando seus nomes por vírgulas.
	int ano, mes, dia;
Escopo de Variáveis
	O escopo de uma variável define onde a mesma pode ser referenciada. O escopo de uma variável está relacionado à posição onde ela é declarada. Existem três lugares básicos: dentro de funções, na definição dos parâmetros das funções e fora de todas as funções. Estas são variáveis locais, parâmetros formais e variáveis globais, respectivamente.
Variáveis Globais
	Variáveis que são declaradas fora de qualquer função. Tais variáveis são reconhecidas (isto é, podem ser alteradas ou referenciadas) pelo programa inteiro e podem ser usadas por qualquer pedaço de código. 
Exemplo 5.3
#include <stdio.h>
int num=10;
int main() {
	 printf(“%d”, num * num);
 return 0;
	}
	O Exemplo 5.4 mostra que qualquer função do programa pode manipular uma variável global. 
Exemplo 5.4
#include <stdio.h>
int num=2;
	int media(int y, int x) {
	 return ((x+z)/num);
	}
int main() {
	 int x1 = 15;
 int x2 = 4;
	 printf(“%d %d ”, num * num, media(x1,x2));
 return 0;
	}
	Deve-se ressalvar que um mesmo programa em C pode conter n variáveis com o mesmo identificador, desde que apenas uma delas seja global e as demais n-1 sejam declaradas localmente em n-1 funções. Se houver duas variáveis com o mesmo identificador x, uma global e outra local à função X, as referências à variável x dentro de X correspondem a referências à variável local e as referências fora de X correspondem à variável global.
	Em algumas situações, variáveis globais são úteis para passar informações entre funções ou entre o algoritmo principal e as funções, mas sua utilização deve ser feita com parcimônia, pois seu uso indiscriminado pode ser fonte de erros difíceis de serem identificados. O Exemplo 5.5 ilustra um erro típico decorrente do uso incorreto de variáveis globais.
Exemplo 5.5
#include<stdio.h>
int i;
// Função que escreve seqüências decrescentes de números:
void escNa1(int n) {
 for (i=n; i>0; i--)
 printf("%i ",i);
}
int main() {
 for (i=1; i<=5; i++) {
 escNa1(i);
 printf("\n");
 }
}
	Nesse exemplo, a função escNa1() recebe um valor n e escreve os números de n a 1. A função main(), por sua vez, utiliza escNa1() para escrever, em ordem decrescente, o número 1, seguido das seqüências de 2 a 1, 3 a 1, 4 a 1 e, finalmente, 5 a 1. A função está aparentemente correta. A variável i é uma variável global modificada tanto no laço da função escNa1() quanto da função main(). Esperar-se-ia que a execução do programa gerasse as seguintes seqüências: 
1
2 1
3 2 1
4 3 2 1
5 4 3 2 1
	Ao executar-se o programa, entretanto, é obtido o seguinte resultado: 
1
1
1
1
1
1
1
1
...
	A explicação para esse comportamento é que a variável i recebe 1 na função main() e substitui o argumento n da chamada escNa1(). Em escNa1(), ela é decrementada, passando a ser 0. Na próxima iteração do for de main(), ela é incrementada (voltando a ser 1) e substitui o argumento n da chamada escNa1(). Esse processo repete-se indefinidamente.
	Na medida do possível, deve-se evitar o uso de variáveis globais, priorizando o uso de argumentos quando for necessário passar ou receber valores de funções. Outra razão para o não uso de variáveis globais é facilitar a reutilização de funções entre diferentes programas. Se uma função utiliza uma variável global, ao portar essa função para outro programa será necessário portar, também, as variáveis globais que ela referencia, tornando mais difícil a reutilização dessa função em outros algoritmos.
Variáveis locais
	Variáveis que são declaradas dentro de uma função. Tais variáveis só podem ser referenciadas por comandos que estão dentro do bloco no qual as variáveis foram declaradas, isto é, não são reconhecidas fora de seu próprio bloco de código (nem mesmo na função main()). 
Exemplo 5.6
#include <stdio.h>
int main() {
	 int num;
	 num = 10;
 return 0;
	}
	Como a linguagem C permite somente a declaração de variáveis logo após a abertura de abre-chaves, alguns programadores abrem chaves no meio do programa apenas para declara uma nova variável.
Exemplo 5.7
#include <stdio.h>
int main() {
	 int num;
	 num = 10; /* Até este ponto somente a variável num existe */
	 { 
	 int x= 10; /* A partir deste ponto as variáveis x e num existem */
	 num = x + 2;
	 } /* A partir deste ponto somente a variável num existe */
 return 0;
	}
Parâmetros Formais
	Variáveis que são declaradas para passagem de parâmetros em funções. 
Exemplo 5.8
	int soma(int x, int y) {
	 return (x+y);
	}
Palavras reservadas
Existem certos nomes que não podem ser usados como identificadores. São chamadas as palavras reservadas e são de uso restrito da linguagem C (comandos, estruturas, declarações, etc.). Algumas palavras reservadas em C são:
 asm auto break case cdecl char
 class const continue _cs default delete
 do double _ds else enum _es
 extern _export far _fastcall float for
 friend goto huge if inline int
 interrupt _loadds long near new operator
 pascal private protected public register return
 _saveregs _seg short signed sizeof _ss
 static struct switch template this typedef
 union unsigned virtual void volatile while
Operadores
	A linguagem C é muito rica em operadores internos. C define quatro classes de operadores: aritméticos, relacionais, lógicos e bit a bit. Além disso, C tem alguns operadores especiais para tarefas particulares.
Atribuição
	Para o operador de atribuição é utilizado o símbolo =. Lembre-se que as atribuições são executadas da direita para esquerda. 
Exemplo 6.1
	x = 10;
	y = x;
Além disto, a linguagem oferece um tipo de atribuição múltipla, isto é, em um comando só pode-se atribuir o mesmo valor a muitas variáveis.
Exemplo 6.2
	a = b = c = 10;	/* a, b, c terão o valor 10
Conversão de Tipos em Atribuições
	A linguagem C permite a conversão automática de tipos, o que não acontece em Pascal, por exemplo. Conversão de tipos refere-se à situação em que variáveis de um tipo são misturadas com varáveis de outro tipo. Em um comando de atribuição, a regra de conversão de tipos é muito simples: o valor do lado direito (lado da expressão) de uma atribuição é convertido no tipo do lado esquerdo (variável destino), como no Exemplo 6.3:
Exemplo 6.3
#include <stdio.h>
int main() { 
	 int x;
	 char ch;
	 float f;
	 ch = x;	// Linha1
	 x = f;	// Linha 2
	 f = ch;	// Linha 3
	 f = x;	// Linha 4
 return 0;
	}
	Na linha 1, os bits mais significativos da variável inteira x são ignorados, deixando ch com os 8 bits menos significativos. Se x está entre 255 e 0, então ch e x têm valores idênticos. De outra forma, o valor de ch reflete apenas os bits menos significativos de x. Na linha 2, x recebe a parte inteira de f. Na linha 3, f converte o valor inteiro de 8 bits armazenado em ch no mesmo valor em formato de ponto flutuante. Isso também acontece na linha 4, exceto por f converter um valor inteiro de 16 bits no formato de ponto flutuante.
	A Tabela 6.1 mostra algumas conversões de tipos e seus efeitos. Para essas conversões foi assumido uma palavra de 32 bits.
Tabela 6.1 - Conversões de tipos e seus efeitos
	Tipo Destino
	Tipo da Expressão
	Possível Informação Perdida
	signed char
	char
	Se valor > 127, o destino é negativo
	char
	short int
	Os 8 bits mais significativos
	char
	int 
	Os 24 bits mais significativos
	char
	long int
	Os 24 bits mais significativos
	int
	float 
	A parte fracionária e possivelmente mais
	float
	double
	Precisão, o resultado é arredondado
	Para utilizar a Tabela 6.1 a fim de fazer uma conversão não mostrada, simplesmente converta um tipo por vez até acabar. Por exemplo, para converter double em int, primeiro converta double em float e, então, float em int.
Operadores Aritméticos
	A Tabela 6.2 mostra os operadores aritméticos suportados pela linguagem.
Tabela 6.2 - Operadores aritméticos
	Operador
	Ação
	
	-
	Subtração, também menos unário
	
	+
	Adição
	
	*
	Multiplicação
	
	/
	Divisão
	
	%
	Módulo da Divisão (resto)
	
	--
	Decremento 
	
	++
	Incremento
	
	O menos unário multiplica seu único operando por -1. Isso é, qualquer número precedido por um sinal 
	O operador / executa uma divisão inteira quando ambos os operandos são do tipo inteiro. 
Exemplo 6.4
	int op1=20, op2=3;
	float op3=20, op4=3;
	printf("%i\n",op1/op2);	/* Imprime 6 */
	printf("%f\n",op1/op4);	/* Imprime 6.666667 */
	printf("%f\n",op3/op2); 	/* Imprime 6.666667 */
	printf("%f\n",op3/op4); 	/* Imprime 6.666667 */
	O operador % devolve o resto de uma divisão inteira. Por isso, os dois operandos envolvidos devem ser do tipo inteiro e o segundo operando não pode ser 0 (zero).
Exemplo 6.5
	int op1=20, op2=3;
	float op3=20, op4=3;
	printf("%i\n",op1%op2);	/* Imprime 2 */
	printf("%i\n",op2%op1); 	/* Imprime 3 */		
	printf("%i\n",op1%op4);	/* Erro de compilação */
	printf("%i\n",op2%0); 	/* Erro de execução: divisão por zero */
	printf("%i\n",op3%0); 	/* Erro de compilação */
	A linguagem C inclui dois operadores que geralmente não encontramos em outras linguagens. São os operadores de incremento (++) e decremento (--), os quais somam 1 ao seu operando, e subtraem 1 de seu operando, respectivamente.
x++; ou ++x; ou x = x + 1;
x--; ou --x; ou x = x - 1;
	Quando usados em uma expressão tem seus efeitos alterados pela posição do sinal de decremento e incremento. Se o operador de incremento ou decremento preceder seu operando, C executa a operação de incremento ou decremento antes de usar o valor do operando. Se o operador estiver após seu operando, C usa o valor do operando antes de incrementá-lo ou decrementá-lo.
Exemplo 6.6
	x = 10;
	y = ++x; /*y recebe 11*/
x = 10; 
y = x++; 	/* y recebe 10 */
	A precedência dos operadores aritméticos (qual operador deverá ser executado primeiro) é a seguinte:
++	--			Mais alta
- (menos unário)
*	/	%
+	-			Mais baixa
Os operadores do mesmo nível de precedência são avaliados pelo compilador da esquerda para a direita.
Operadores Aritméticos de Atribuição
	A Tabela 6.3 mostra os operadores aritméticos de atribuição suportados pela linguagem.
Tabela 6.3 - Operadores aritméticos de atribuição
	Operador
	Ação
	
	x -= y
	x = x - y
	
	x += y
	x = x + y
	
	x *= y
	x = x * y
	
	x /= y
	x = x / y
	
	x %= y
	x = x % y
	
	As expressões com este operadores são mais compactas e normalmente produzem um código de máquina mais eficiente. 
A execução da operação aritmética ocorre por último após a avaliação da expressão à direita do sinal igual. 
Exemplo 6.7
	x *= 2			equivale a x = x * 2
	x /= y + 5		equivale a x = x / (y + 5)
	x %= 2	 + y		equivale a x = x % (2 + y)
	x -= y			equivale a x = x - y
Operadores Relacionais e Lógicos
	A Tabela 6.4 mostra os operadores relacionais e lógicos suportados pela linguagem C.
Tabela 6.4 - Operadores relacionais e lógicos
	Operador
	Ação
	Operador
	Ação
	>
	Maior que
	&&
	E (AND)
	>=
	Maior ou igual que
	||
	OU (OR)
	<
	Menor que
	!
	NÃO (NOT)
	<=
	Menor ou igual que
	
	
	==
	Igual
	
	
	!=
	Diferente
	
	
	Em C, verdadeiro é qualquer valor diferente de zero, e falso é zero. As expressões que usam operadores relacionais ou lógicos devolvem zero para falso e 1 para verdadeiro. 
Toda expressão relacional e lógica produz como resultado 0 ou 1.
Exemplo 6.8
#include <stdio.h>
int main() {
	 char varLogica;
	 varLogica = 10 == 20;
	 printf("A expressão anterior é %i\n",varLogica);
	 varLogica = 10 < 20;
	 printf("A expressão anterior é %i\n",varLogica);
	 varLogica = 10 != 20;
	 printf("A expressão anterior é %i\n",varLogica);
	 varLogica = 10 != 20 && 3 == 3;
	 printf("A expressão anterior é %i\n",varLogica);
	 varLogica = 10 == 20 || 3 == 3;
	 printf("A expressão anterior é %i\n",varLogica);
	 varLogica = 10 == 20 && 3 == 3;
	 printf("A expressão anterior é %i\n",varLogica);
	 varLogica = !(10 == 20) && 3 == 3;
	 printf("A expressão anterior é %i\n",varLogica);
 return 0;
	}
Execução:
A expressão anterior é 0
A expressão anterior é 1
A expressão anterior é 1
A expressão anterior é 1
A expressão anterior é 1
A expressão anterior é 0
A expressão anterior é 1
	A precedência dos operadores relacionais e lógicos é a seguinte:
!				Mais alta
>	>=	<	<=
==	!=
&&
||				Mais baixa
Precedência dos operadores aritmético, Relacionais e Lógicos
	A Tabela 6.5 mostra a precedência dos operadores aritméticos, relacionais e lógicos da linguagem C.
Tabela 6.5: Precedência dos operadores aritméticos, relacionais e lógicos
	Precedência
	Operador
	1º
	()
	2º
	- (menos unário) ++ -- ! (NÃO) 
	3º
	* / %
	4º
	+ -
	5º
	< <= > >=
	6º
	== != 
	7º
	&&
	8º
	||
	9º 
	= *= /= %= += -=
Todo operador aritmético com operandos numéricos produz um resultado numérico. 
Todo operador relacional com operandos numéricos produz um resultado lógico. 
Todo operador lógico com operandos lógico produz um resultado lógico. 
Operadores de Ponteiros & e *
	Um ponteiro é um endereço na memória de uma variável. Uma variável de ponteiro é uma variável especialmente declarada para guardar um ponteiro para seu tipo especificado. 
	O primeiro operador de ponteiro é &. Ele é um operador unário que devolve o endereço na memória de seu operando. Por exemplo,
m = &cont;
atribui o endereço de memória da variável cont em m. Este operador é muito utilizado na leitura de variáveis. 
	Este tipo de operando não pode ser utilizado em três casos:
1. &(cont + 4) - sempre associa-se a uma variável e não expressão;
2. &3 - constantes não são válidas;
3. variáveis declaradas com classe de armazenamento register (não existe endereço para registrador).
	O segundo operador é *. Ele é um operador unário que devolve o valor da variável localizada no endereço que o segue. Por exemplo, se m contém o endereço da variável cont,
q = *m;
coloca o valor de cont em q. Este operador é muito utilizado em manipulação de posições de memória e durante a passagem de parâmetros em funções.
	Os seguintes operadores * e & colocam o valor 10 na variável chamada target. O resultado (o valor 10) deste programa é mostrado na tela.
Exemplo 6.9
#include <stdio.h>
int main() {
 int target, source;
 int *m;
 source = 10;
 m = &source;
 target = *m;
 printf(“%d”,target);
 return 0;
}
Operador Vírgula
	O operador vírgula é usado para encadear diversas expressões. O lado esquerdo de um operador vírgula é sempre avaliado como void. Isso significa que a expressão do lado direito se torna o valor de toda a expressãoseparada por vírgulas. 
Exemplo 6.10
	x = (y = 3, y + 1);
	No Exemplo 6.10, primeiro y recebe 3 e, em seguida, atribui o valor 4 a x.
Expressões
	Operadores, constantes e variáveis são os elementos que constituem as expressões. Uma expressão em é qualquer combinação válida desses elementos.
Conversão de Tipos em Expressões
	Quando constantes e variáveis de tipos diferentes são misturadas em uma expressão, elas são convertidas a um mesmo tipo. O compilador C converte todos os operandos no tipo do maior operando, o que é denominado promoção de tipo. Isso é feito operação por operação, como descrito nas regras de conversão de tipos abaixo.
SE um operando é long double
ENTÃO o segundo é convertido para long double.
SENÃO, SE um operando é double
ENTÃO o segundo é convertido para double. 
SENÃO, SE um operando é float
ENTÃO o segundo é convertido para float. 
SENÃO, SE um operando é unsigned long
ENTÃO o segundo é convertido para unsigned long.
SENÃO, SE um operando é long
ENTÃO o segundo é convertido para long. 
SENÃO, SE um operando é unsigned
ENTÃO o segundo é convertido para unsigned.
	Há ainda um caso adicional especial: se um operando é long e o outro é unsigned, e se o valor do unsigned não pode ser representado por um long, os dois operandos são convertidos para unsigned long.
	Considere as conversões de tipo que ocorrem no Exemplo 6.11. 
Exemplo 6.11
char ch;
int i;
float f;
double d;
result= ( ch / i ) + ( f * d ) - ( f + i );
 	 int	 double float
	 		double
		 		 double
Primeiro, o caractere ch é convertido para um inteiro e float f é convertido para double. Em seguida, o resultado de ch/i é convertido para double porque f*d é double. O resultado final é double porque, nesse momento, os dois operandos são double.
Casts
	A linguagem permite que uma expressão pode ser forçada a ser de um tipo especificado usando uma construção chamada cast. A forma geral de um cast é
	(tipo) expressão
onde um tipo é um tipo de dado padrão de C. Por exemplo, para ter certeza de que a expressão x /2 será do tipo float, escreve-se
	(float) x/2;
	Neste caso se a variável x fosse um inteiro ímpar sem o cast seu valor reria um inteiro (o que não seria verdadeiro). Entretanto, com o uso do Cast oa variável x é definida como um float o que tornará o seu resultado um float. 
Exemplo 6.12
	int op1=20, op2=3;
	float op3=20;
	printf("%f\n",(float)op1/op2);			/* Imprime 6.666667 */
	printf("%i\n",(int)op3/op2); 			/* Imprime 6 */
	printf("%i\n",(int)op3%op2); 			/* Imprime 2 */
	printf("%f=%f\n",20.0/3, (float)20/3);		/* Imprime 6.666667 */
	Como um operador, um cast é unário e tem a mesma precedência de qualquer outro operador unário.
	
Espaçamento e Parênteses
	A linguagem C não limita o espaçamento ou tabulações em uma expressão. Ajudam a aumentar a legibilidade do programa. O excesso de parênteses não causa erros, isto é, colocar parênteses onde não necessita, não provoca erros, mas dificulta a leitura do programa.
Algumas funções de E/S 
	Neste capítulo será visto algumas funções como scanf (), getchar() e putchar(). Tais funções encontram-se no arquivo stdio.h.
scanf()
	Esta função serve para ler dados formatados da entrada padrão (teclado). Sua sintaxe é similar à de printf(), isto é, uma expressão de controles seguida por uma lista de argumentos separados por vírgulas. A principal diferença é que os argumentos de scanf() devem ser endereços de variáveis. Para enviar o endereço de cada argumento utiliza-se o operador &.
Sintaxe:
	scanf(“expressão_de_controle”, lista_de_argumentos)
	A expressão de controle pode conter códigos de formatação (mostrados na Tabela 7.1), precedidos por um sinal %, caracteres de espaço em branco e caracteres de espaço não branco. 
Tabela 7.1 - Códigos de formatação do comando scanf()
	Código
	Significado
	%c
	Lê um único caractere simples
	%d ou %i
	Lê um inteiro decimal
	%e
	Lê um número em notação científica
	%f
	Lê um número em ponto flutuante
	%g
	Lê um número em ponto flutuante
	%o
	Lê um número em octal
	%s
	Lê um a cadeia de caracteres
	%u
	Lê um inteiro decimal sem sinal
	%x
	Lê um hexadecimal
	%ld
	Lê um inteiro longo
	%lf
	Lê um ponto flutuante longo
	%Lf
	Lê um ponto flutuante longo (Double)
	%%
	Busca por um conjunto de caracteres
Exemplo 7.1
#include <stdio.h>
int main() {
 char a;
 printf(“Digite um caractere e veja-o em decimal, ”);
 printf (“ octal e hexadecimal. \n”);
 scanf(“%c”,&a);
 printf(“\n%c=%d dec., %o oct. e %x hex. \n”,a,a,a,a);
 return 0;
}
Execução (faça você mesmo):
Quando a função scanf() for utilizada para ler caracteres (isto é, utilizar o %c), deve-se adicionar a linha de comando “flush(stdin);” após a linha da função scanf(). Esta funçÃo limpa o bufer do teclado já que o %c considera o ENTER como um novo caracter.
	O caractere * colocado após o % avisa à função que deve ser lido um valor do tipo indicado pela especificação, mas não deve ser atribuído a nenhuma variável (não deve ter parâmetros na lista de argumentos para estas especificações).
Exemplo 7.2
#include <stdio.h>
int main() {
 char hora, minuto, segundo;	
 printf("Digite a hora no formato hh:mm:ss: ");
 scanf("%i%*c%i%*c%i",&hora,&minuto,&segundo);
 printf("Você digitou %02i:%02i:%02i\n",hora,minuto,segundo);
 return 0;
}
Note que o caractere ‘:’ foi ignorado pela função scanf() no Exemplo 7.2, como definido pelo formato %*c (ignorar um caracter).
Execução:
Digite a hora no formato hh:mm:ss: 12:34:4
Você digitou 12:34:04
	Um caractere de espaço branco (isto é, um espaço, uma tabulação ou uma nova linha - enter) na expressão de controle faz com que a função scanf() ignore um ou mais caracteres de espaço em branco durante a leitura. 	Um caractere de espaço não branco na expressão de controle faz com que a função scanf() leia e ignore caracteres iguais durante a leitura. O Exemplo 7.3 mostra um programa que exemplifica o uso de caracteres de espaço em branco e não branco. 
Exemplo 7.3
#include <stdio.h>
int main() {
 int x,y;	
 scanf("%d%d",&x,&y);
 printf("x=%d y=%d\n",x,y);
 scanf("%d,%d",&x,&y);
 printf("x=%d y=%d\n",x,y);
 scanf("%dt%d",&x,&y);
 printf("x=%d y=%d\n",x,y);
 return 0;
}
Execução:
1 2
x=1 y=2
3,4
x=3 y=4
5t6
x=5 y=6
No primeiro scanf(), as variáveis estão separadas por um espaço em branco, o que permite que o usuário utilize uma tabulação, um enter ou espaço em branco (escolhido durante a execução) para separar os dois valores a serem lidos. No segundo scanf(), uma vírgula é colocada entre os dois especificadores fazendo com que a função leia um inteiro, uma vírgula e descarte a mesma, e leia outro inteiro. Note que a leitura foi realizada com sucesso de acordo com o resultado da função printf() que segue a leitura. No terceiro scanf(), um caractere ‘t’ é colocado entre os dois especificadores fazendo com que a função leia um inteiro, um caractere ‘t’ e descarte o mesmo, e leia outro inteiro, como o caso do segundo scanf(). Por isso, tem que ter muito cuidado para não confundir o scanf() com o printf() e colocar texto na expressão de controle.
	O Exemplo 7.2 pode ser reescrito da seguinte forma utilizando um espaço de caractere não branco. A diferença entre o Exemplo 7.4 e o Exemplo 7.2 é que o primeiro obriga o usuário a digitar o caractere ‘:’ entre os números, enquanto que o segundo aceita qualquer tipo de caractere.
Exemplo 7.4
#include <stdio.h>
int main() {
 char hora, minuto, segundo;	
 printf("Digite a hora no formato hh:mm:ss: ");
 scanf("%i:%i:%i",&hora,&minuto,&segundo);
 printf("Você digitou %02i:%02i:%02i\n",hora,minuto,segundo);
 return 0;
}
Lendo e escrevendo caracteres
	A função getchar() lê um caractere do teclado (este comando necessita o pressionamento da tecla <ENTER> após o caractere), e putchar() escreve um caractere na tela. A função getchar() espera até que uma tecla seja pressionada (a qual é mostrada na tela) e devolve o seu valor. A função putchar() escreve seu argumento caractere na tela a partir da posição atual do cursor. Os protótipos para getchar() e putchar()são mostrados aqui:
int getchar(void);
int putchar(int c);
	A função getchar() devolve um inteiro, mas o byte de baixa ordem contém o caractere. Além disso, pode-se chamar putchar() com um argumento caractere. A função putchar() devolve o caractere escrito, ou EOF (definida em stdio.h e geralmente é igual a -1), se ocorreu algum erro. A função putchar() não acrescenta um ‘\n’ a saída.
Exemplo 7.5
#include <stdio.h>
int main() {
 char ch;
 printf(“Digite algum caractere:”); ch=getchar();
 printf(“\n A tecla pressionada eh ”);
 putchar(ch);
 return 0;
}
getche() e getch()
	A função getche() lê um caractere do teclado sem pressionar <ENTER> e mostra o que foi digitado. Esta função não aceita argumentos e devolve o caractere lido para a função que a chamou.
Exemplo 7.6
#include <stdio.h>
int main() {
 char ch;
 printf(“Digite algum caractere:”);
 ch=getche();
 printf(“\n A tecla pressionada eh %c.”, ch);
 return 0;
}
Execução:
Digite algum caractere: a
A tecla pressionada eh a.
	A função getch() lê um caractere do teclado sem pressionar <ENTER> e não mostra o que foi digitado. Esta função não aceita argumentos e devolve o caractere lido para a função que a chamou.
As funções getch() e getche() não são implementadas em todos os compiladores. Por isso, verifique se o seu compilador oferece tais funções antes de usá-las.
Exercícios
1. 
Faça um programa que leia 3 variáveis a, b e c, coeficientes de uma equação do 2º grau e escreva as duas raízes da equação.
2. Um representante comercial realizará uma viagem de vários dias de automóvel, e, após, quer saber a quilometragem média por litro de gasolina. Para isto, ele anotará a quilometragem no velocímetro ao sair de viagem, e depois, a quilometragem na chegada; ele também vai somar toda a gasolina (em litros) usada para abastecer o carro durante a viagem. Escreva um programa em C que, a partir desses dados, informe a quilometragem média por litro de gasolina.
3. Escreva um programa em C que leia a distância percorrida em km e o tempo que um piloto levou para percorrê-la (em minutos). O programa deve calcular a velocidade média em km/h, e exibir a seguinte frase: 
A velocidade média foi <velocidade media calculada> km/h.
4. Escreva um programa em C que calcule e escreva a soma Sn dos n primeiros termos de uma série:
onde a1 é o primeiro termo da série, an é o último e n é o número de termos. Os valores de a1, an e n serão fornecidos pelo usuário.
5. Escreva um programa em C que calcule e escreva o valor de um termo an qualquer de uma progressão geométrica dada por:
onde a1 é o primeiro termo da série, an é o último e n é o número de termos. Os valores de a1, an e n serão fornecidos pelo usuário.
6. Em uma pizzaria, cada tulipa de chope custa R$ 2,80 e uma pizza mista grande custa R$20,00 mais R$1,50 por tipo de cobertura pedida (queijo, presunto, banana, etc.). Uma turma vai à pizzaria e pede uma determinada quantidade de chopes e uma pizza grande com uma determinada quantidade de coberturas. Escreva um programa em C que calcule e conta e, sabendo quantas pessoas estão à mesa, quanto que cada um deve pagar (não esqueça os 10% do garçom).
7. Escreva um programa em C que leia, com a função getch(), seis caracteres numéricos representando os dígitos de um número. O primeiro caractere lido representa o dígito mais à esquerda do número; o último caractere lido representa o dígito mais à direita do número. O programa deve armazenar em uma variável int o número correspondente à seqüência de caracteres. O valor correspondente é obtido através do somatório do valor dos dígitos multiplicados por 10 elevado ao seu peso, onde o dígito mais à direita tem peso 0, o seguinte tem peso 1, o terceiro peso 2 e assim por diante. Por exemplo, se a seqüência de caracteres lida foi
'0' '2' '5' '3' '7' '3'
o valor colocado na variável será
105x0 + 104x2 + 103x5 + 102x3 + 101x7 +100x3 = 25373
Dica: para a conversão de um caractere numérico no número correspondente, basta subtrair o código ASCII do caractere zero do próprio caracter. assim, '0' - '0' = 0; '1' - '0' = 1; '2' - '0' = 2; ...; '9' - '0' = 9. 
8. Escreva um programa em C que leia o valor total, em termos de preço, de uma compra e o valor pago. O programa deve calcular e escrever o troco, em termos da quantidade de cédulas de R$ 100,00, 50,00, 10,00, 5,00 e 1,00 e de moedas de 50, 25, 10, 5 e 1 centavos. 
9. Faça um programa em C que calcule a quantidade de latas de tinta necessária e o custo para pintar tanques cilíndricos de combustível, onde são fornecidos (o programa lê) a altura (h) e o raio (r) desse cilindro. A área (a) de um cilindro é dada pela seguinte fórmula:
Sabe-se que a lata de tinta anti-corrosiva custa R$ 40,00, cada lata contém 5 litros e cada litro de tinta pinta 3 metros quadrados em média. Para que fique bem coberto de tinta, há necessidade de duas mãos.
Comandos Condicionais
	Os comandos condicionais determinam se um pedaço de código deve ser executado de acordo com o resultado de uma expressão lógica. Três comandos são disponibilizados pela linguagem C:
· if
· if-else
· switch
Comando if
Sintaxe:
	if (<expressão>)
	 <comando>;
	else
	 <comando>;
onde comando pode ser um único comando, um bloco de comandos ou nada (no caso de comandos vazios). A cláusula else é opcional. Utilizando o português estruturado, este comando seria definido da seguinte maneira:
se expressão então
 comando
senao
 comando
fimse
	No Exemplo 8.1, o comando de atribuição é executado se e somente se x for diferente de 0. Note que não existe um símbolo ou palavra para definir o começo do bloco então.
Exemplo 8.1
	if (x != 0)
	 y = 0;
Caso haja um else ele pertence ao if mais próximo.
Exemplo 8.2
	if (a > 5) {
	 if (a < 10)
	 b = 3;
 } else
	 b = 7;
	No Exemplo 8.2, o comando de atribuição “b = 3;” somente é executado se o valor da variável a é maior que 5 e menor do que 10. O comando de atribuição “b = 3;” somente é executado se o valor da variável a é menor que 5. Se não fosse separado por chaves o comando if mais interno o else pertenceria ao mesmo e não ao mais externo.
Exemplo 8.3
	/* Programa para adivinhar um numero */
	#include “stdio.h”
	#include “stdlib.h”
	int main() {
	 int num, tentativa;
	 num = rand(); /*gera numero aleatorio entre 0 e 32767*/
	 scanf(“%d”, &tentativa);
	 if (tentativa == num)
	 printf(“* * * CERTO * * *”);
 return 0;
	}
	Para montar um bloco de comando é somente necessário usar o abre e fecha chaves para marcar início e fim de bloco de comandos respectivamente.
Comando switch
	C tem um comando interno de seleção múltipla, switch, que testa sucessivamente o valor de uma expressão contra uma lista de constantes inteiras ou de caractere.
Sintaxe:
	switch (<expressão>) {
		case <valor1> : <seqüência de comandos>
				break;
		case <valor2> : <seqüência de comandos>
				break;
		…
		default:
			 <seqüência de comandos>
	}
	O valor da expressão é testado, na ordem, contra os valores das constantes especificadas nos comandos case. Quando uma igualdade for encontrada, a seqüência de comandos associada àquele case será executada até que o comando break ou o fim do comando switch seja alcançado. O comando default (opcional) é executado no momento em que não coincidir nenhum valor. 
Exemplo 8.4
	#include <stdio.h>
	int main() {
	 char opcao;
	 printf(“1. Opcao 1 \n”);
	 printf(“2. Opcao 2 \n”);
	 printf(“3. Opcao 3 \n”);
	 printf(“Opcao:”);
	 opcao=getchar();
	 switch(opcao) {
		case ‘1’: printf (“\nVocê escolheu a opcao 1”);
			break;
		case ‘2’: printf (“\n Você escolheu a opcao 2”);
			break;
		case ‘3’: printf (“\n Você escolheu a opcao 3”);
			break;
		default: printf (“\n Nenhuma opcao selecionada”);
			break;
		}
 return 0;
	}
O caso default é opcional e, embora seja geralmente posicionado no final do bloco switch, ele pode aparecer em qualquer posição entre os case´s especificados.
	Caso um break é esquecido, o programa continua a executar as próximas instruções até achar outro break ou o símbolo fecha chaves.
Exemplo 8.5
#include<stdio.h>
int main() {
 int n;
 for (n = 1; n<=5; n++) {
 printf(“%d\t”,n);
 switch( n ) {
 case 1: printf(“A“); break;
 case 3: printf(“B“);
 case 4: printf(“C“); break;
 default: printf(“*“);
 case 5: printf(“D“);
 }
 printf(“.\n”); 
 }
} 
	O resultado para o Exemplo 8.5 é mostrado a seguir:
1 A.
2 *D.
3 BC.
4 C.
5 D.
	Note que quando n é igual a 2, a opção default é executada e como não há um break que finaliza o caso default, o comando para o caso 5 também é executado. O mesmo ocorre quando n é igual a 3. Como este caso não foi finalizado pelo break, o próximo comando (caso 4) também é executado até achar um break.
Como toda a estrutura switch é envolvida por chaves, não é necessário usar bloco quando há mais que uma instrução associada a um determinado case.
Exercícios
1. Escrever um programa que leia 3 pares de coordenadas (x,y), que definam 3 pontos e:
· Verificar se eles formam um triângulo (a < b + c): não podem estar alinhados e não podem haver pontos sobrepostos.
· calcular os lados do triângulo.
· classificar o tipo do triângulo:
· eqüilátero, isósceles ou escaleno.
· acutângulo, obtusângulo ou retângulo
2. Avalie (forneça o resultado) das seguintes expressões lógicas e aritméticas, mostrando todos os passos utilizados para a obtenção da solução:
a) (((4>=3) && (3!=3.1)) || (5>=4)) && (!(5==5.0))
b) (20%6) + 7 - 3.0 + 7/2.0 + (19/5) +(20+4)/4*3
3. Escreva um programa em C que leia dois números e escreva o maior deles
4. Escreva um programa que leia 3 números e os escreve em ordem crescente.
5. Faça um programa que leia um número inteiro, verifique se é positivo ou negativo e escreva uma mensagem apropriada.
6. Escreva um programa em C que leia um número n (declarado como float). Se o n for positivo, escreva uma mensagem indicando se ele é par ou ímpar. 
7. Escreva um programa em C que leia dois números inteiros e escreva o módulo da diferença entre os dois (o módulo é o valor absoluto, sempre positivo).
8. Escreva um programa em C que leia três valores e escreva a média ponderada deles. No cálculo da média ponderada, é atribuído peso 5 para o maior dos 3 valores e peso 2.5 para os outros dois. 
9. Um sistema de equações lineares do tipo: 
a.x + b.y = c 
d.x + e.y = f 
pode ser resolvido da seguinte forma: 
Escrever um programa em C que lê os coeficientes a, b, c, d, e e f e calcula e escreve os valores de x e y. Lembre-se que os denominadores das equações não podem ser zero. 
10. Escreva um programa em C que leia quatro valores correspondentes aos lados de um polígono. O programa deve informar se o polígono formado por esses valores é um retângulo, um quadrado ou um trapézio. 
11. Escreva um programa em C que recebe a hora de início de um jogo na forma <hora, minutos> e a hora de seu término. O programa deve escrever a duração do jogo em minutos.
12. Escreva um programa em C que leia três valores numéricos representando os lados de um triângulo. O programa deve verificar e informar se o triângulo formado é eqüilátero, isósceles ou escaleno.
13. Escreva programa em C que leia o preço do selo necessário para enviar uma carta simples, o preço do envelope e certa quantia de dinheiro. O programa deve calcular e escrever o número de cartas possíveis de serem enviadas com tal quantia, supondo um selo por carta.
14. Uma loja fornece 5% de desconto para funcionários e 10% de desconto para clientes especiais. Escreva um programa em C que calcule o valor total a ser pago por uma pessoa. O programa deverá ler o valor total da compra efetuada e um código que identifique se o comprador é um cliente comum (código 'c') , um funcionário ('f') ou um cliente especial ('e').
15. Escreva um programa em C que leia os códigos de 5 clientes de uma loja e o valor (em reais) que cada um destes clientes pagou por sua compra. O programa deverá escrever:
· valor total pago pelos 5 clientes; 
· valor da compra média efetuada; 
· códigos dos clientes que efetuaram compras superiores a 20 reais; e
· códigos dos clientes que efetuaram compras inferiores a 50 reais. 
16. Escreva um programa em C que lê código de um funcionário, o número de horas por ele trabalhadas e o valor que ele recebe por hora. O programa deve calcular o imposto de renda como segue:
· sobre o valor do salário bruto igual ou acima de R$ 2000,00, incide uma alíquota de 25%;
· sobre o valor do salário bruto acima de R$ 1500,00 e abaixo de 2000.00 incide uma alíquota de 15%; e
· sobre o valor do salário bruto acima de R$ 1000,00 e abaixo de 1500.00, incide uma alíquota de 10%.
O programa deve imprimir o código do funcionário, seu salário bruto e seu salário líquido.
17. Seja o seguinte programa
#include <stdio.h>
#include <stdlib.h>
#include <math.h> 
void main(){
float cod, sal_bruto, aumento, adicional;
int n_filhos;
printf("entre com o código do empregado:\n");
scanf("%f", &cod);
printf("entre com o salário bruto:\n");
scanf("%f", &sal_bruto);
printf("entre com o número de filhos:\n");
scanf("%d", &n_filhos);
/* bloco 1 */
if (sal_bruto >= 3000){
aumento = sal_bruto*0.10;
}
if ((sal_bruto <3000)&& (sal_bruto >=2000)){
aumento = sal_bruto*0.15;
}
if ((sal_bruto <2000)&& (sal_bruto >=1000)){
aumento = sal_bruto*0.20;
}
if (sal_bruto <1000){
aumento = sal_bruto*0.25;
}
/* bloco 2 */
if (n_filhos == 0){
adicional = 0;
}
if (n_filhos == 1){
adicional = 100;
}
if (n_filhos == 2){
adicional = 150;
}
if (n_filhos == 3){
adicional = 200;
}
else {
adicional = 300;
}
sal_bruto = sal_bruto + aumento + adicional;
printf("código = %f sal_bruto = %.2f\n", cod, sal_bruto);
}
Escreva as seguintes alterações no programa, sem alterar sua funcionalidade:
· todas as modificações necessárias para que a variável cod seja do tipo int;
· remova as bibliotecas que não estão sendo utilizadas;
· altere o bloco 1, de modo a simplificar as condições dos comados if. 
· remova os abre ({) e fecha-chaves (}) desnecessários;
· substitua o bloco 2 por um comando switch.
18. Seja o seguinte programa em C:
#include <conio.h>
#include <stdio.h>
void main(){
 int n1, n2, n3;
 clrscr();
 scanf("%d %d %d",&n1, &n2, &n3);
 if ((n1>=n2)&&(n1>=n3))
 if (n2>=n3) printf("%d %d %d\n", n1, n2, n3);
 else printf("%d %d %d\n", n1, n3, n2);
 else
 if ((n2>=n1)&&(n2>=n3))
 if (n1>=n3) printf("%d %d %d\n", n2, n1, n3);
 else printf("%d %d %d\n", n2, n3, n1);
 else
 if (n1>=n2) printf("%d %d %d\n", n3, n1, n2);
 else printf("%d %d %d\n", n3, n2, n1);
}
O que será escrito na tela, supondo que os valores lidos foram 2, 4 e 1?
19. Implemente em C uma calculadora simples de quatro operações. O usuário deve fornecer o valor do primeiro operando (float), a operação (um char: '+', '-', '*', '/') e o segundo operando (float). A calculadora mostra, então, o resultado da operação. Para teste do operador, use o comando switch.
Estrutura de Repetição (Laços)
	A ordem de execução dos programas em C até agora é de cima para baixo. Entretanto, esta ordem pode ser alterada através do uso de comandos que permitem alterar o controle do fluxo de programa fazendo com que o programa execute certo código diversas vezes. Estes comandos chamam-se de laços e a linguagem C possui três comandos: for, while e do-while. 
	Não existe restrição de número de comandos que podem ser executados repetidamente num laço e nem a utilização de um comando dentro de outro.
Laço for
	O laço for é uma estrutura de controle de repetição condicional com inicialização e incremento. Um contador normalmente é utilizado para contar o número de vezes que o laço deve ser executado.
Sintaxe:
	for(inicialização; condição; incremento) 
		comando;
onde comando é um comando vazio, um comando simples, ou um bloco de comandos. Como ilustrado na Figura 9.1, primeiro é executado a inicialização que consiste em atribuições iniciais (pode ser mais de uma, utilizando a vírgula entre atribuições). Depois é testada a condição (expressão relacional) de controle do laço. O incremento (ou decremento) é executado após a execução do comando ou bloco de comandos. O fim do laço é determinadopelo valor falso que a condição se apresenta.
Figura 9.1: Fluxograma do laço for.
A inicialização, condição, incremento, e até as instruções do laço for são opcionais. Além do comando, os parênteses e os dois “;” são obrigatórios.
Exemplo 9.1
	#include “stdio.h”
	int main() {
 int x;
	 for (x=1; x<=100; x++)
	 printf(“%d”,x);
 return 0;
	}
	No programa acima x é inicializado com 1. Uma vez que x é menor que 100, printf() é executado e x é incrementado em 1 e testado para ver se ainda é menor ou igual a 100. Esse processo se repete até que x fique maior que 100; nesse ponto, o laço termina. Então este programa imprime na tela os números de 1 a 100.
	O Exemplo 9.2 mostra o uso de um for aninhado dentro de outro. O programa exibe um quadro feito do caractere ASCII ‘░’ (código 176). O laço mais externo controla o número de linhas enquanto que o interno controla as colunas.
Exemplo 9.2
#include <stdio.h>
int main() {
 int i,j;
 printf(" 0123456789\n");
 for (i = 0; i< 5; i++) {
 printf("%d",i);
 for (j = 0; j< 10; j++) 
	printf("%c",176);
 printf("\n");
 }	 
 return 0;
}
Execução:
 0123456789
0░░░░░░░░░░
1░░░░░░░░░░
2░░░░░░░░░░
3░░░░░░░░░░
4░░░░░░░░░░
Laço while
	O laço while é uma estrutura de controle de repetição condicional no qual a condição é avaliada por primeiro
Sintaxe:
	while(condição) 
comando;
onde comando é um comando vazio, um comando simples, ou um bloco de comandos. Como ilustrado na Figura 9.2, primeiro é testada a condição (expressão relacional) de controle do laço. E a cada execução de comando é repetido o teste de condição. O laço pára de executar quando a condição for falsa.
Figura 9.2: Fluxograma do laço while.
Exemplo 9.3
#include <stdio.h>
int main() {
	 int cont=0;
	 char ch;
	 while((c=getchar()) != ‘0’)
	 cont++;
	 printf(“Foram lidos %d caracteres”,cont);
 return 0;
	}
Laço do-while
	Ao contrário dos comandos for e while, que testam a condição do laço no começo, o laço do-while verifica a condição ao final do laço.
Sintaxe:
	do {
		<comando> 
	} while(condição);
Este laço é utilizado em casos onde o comando ou bloco de comandos deve ser executado pelo menos uma vez (por exemplo, leitura de menus - Exemplo 9.4, validação de dados na leitura - 	No Erro! Auto-referência de indicador não válida., o programa fica lendo um valor inteiro enquanto o usuário digitar números menor que 1 ou maior que 3. Note que a própria condição de saída serve para verificar se o valor digitado está conforme o desejado. 
Exemplo 9.5). A Figura 9.3 mostra o fluxograma do laço do-while.
Figura 9.3: Fluxograma do laço do-while.
	No Exemplo 9.4, o programa mostra mensagens conforme a entrada do usuário. O programa fica lendo dígitos enquanto o usuário digitar dígitos diferentes de ‘1’ , ‘2’, ou ‘3’ (a qual é a condição de saída do laço). 
Exemplo 9.4
	#include <stdio.h>
	int main() {
	 char opcao;
	 printf(“1. Opcao 1 \n”);
	 printf(“2. Opcao 2 \n”);
	 printf(“3. Opcao 3 \n”);
	 printf(“Opcao:”);
	 do {
	 opcao=getchar();
	 switch(opcao) {
		case ‘1’: printf (“\nVocê escolheu a opcao 1”);
			 break;
		case ‘2’: printf (“\n Você escolheu a opcao 2”);
			 break;
		case ‘3’: printf (“\n Você escolheu a opcao 3”);
			 break;
		default: printf (“\n Nenhuma opcao selecionada”);
			 break;
	 }
	 } while (opcao != ‘1’ && opcao != ‘2’ && opcao != ‘3’);
 return 0;
	}
	No Erro! Auto-referência de indicador não válida., o programa fica lendo um valor inteiro enquanto o usuário digitar números menor que 1 ou maior que 3. Note que a própria condição de saída serve para verificar se o valor digitado está conforme o desejado. 
Exemplo 9.5
	#include <stdio.h>
	int main() {
	 char opcao;
	 do {
 		printf(“Digite um valor entre 1 e 3”);
		scanf(“%i”,&opcao);
	 } while (opção < 1 || opção > 3);
	 printf(“Opcao:”, opcao);
 return 0;
	}
Não é preciso usar chaves quando há um único comando a ser repetido, entretanto, elas são geralmente incluídas para evitar confusão entre while e do-while.
break
	Além de sua utilização no comando switch, o comando break pode ser usado no corpo de qualquer estrutura de repetição C. Causa a saída imediata do laço e o controle passa para o próximo comando do programa.
Sintaxe:
	break;
	A inserção de um break em um laço pode ser resultado de uma escolha errada do tipo de laço ou sequência de comandos do laço.
Exemplo 9.6
#include <stdio.h>
int main() {
 int n, k;
 printf(“\nDigite um número natural: ”);
 scanf(“%u”, &n);
 for(k=2; k<=n-1; k++) 
 if( n%k == 0 ) break;
 if (k==n) 
 printf(“\nO número é primo”);
 else 
 printf(“\nO número não é primo”);
 return 0;
}
Observe que o for pode ser interrompido tanto pela condição k  n1 quanto pela condição nk  0. O teste k  n, fora da repetição, é necessário para se determinar como a repetição foi interrompida. Claramente, se k chega a assumir o valor n é porque a repetição for não foi interrompida pelo break e, conseqüentemente, o número só pode ser primo. 
exit()
	Pode-se finalizar um programa usando a função exit() da biblioteca padrão. Essa função provoca uma terminação imediata do programa inteiro, forçando um retorno ao sistema operacional.
Sintaxe:
	void exit(int código_de_retorno);
O valor de código_de_retorno é retornado ao processo chamador (sistema operacional). O zero é geralmente usado como um código de retorno que indica uma terminação normal do programa. No Exemplo 9.7 o programa é finalizado quando o usuário digitar a opção 4. 
Exemplo 9.7
	#include <stdio.h>
	int main() {
	 char opcao;
	 printf(“1. Opcao 1 \n”);
	 printf(“2. Opcao 2 \n”);
	 printf(“3. Opcao 3 \n”);
	 printf(“4. Abandonar \n”);
	 printf(“Opcao:”);
	 do {
	 opcao=getchar();
	 switch(opcao) {
		case ‘1’: printf (“\nVocê escolheu a opcao 1”);
		 break;
		case ‘2’: printf (“\n Você escolheu a opcao 2”);
			 break;
		case ‘3’: printf (“\n Você escolheu a opcao 3”);
			 break;
		case ‘4’: exit(0);		/* retorna ao SO */
	 }
	 } while (opcao != ‘1’ && opcao != ‘2’ && opcao != ‘3’);
 return 0;
	}
Exercícios
1. Escreva um programa para calcular o fatorial de um número lido.
2. Escreva um programa para ler um caractere de comparação e vários caracteres de entrada finalizados por ‘0’ e contar o número de vezes que o caractere de comparação apareceu.
3. Escrever um programa que mostre os números primos entre 1 e 100.
4. Escreva um programa que leia um número não determinado de valores positivos, e mostre a soma e média dos respectivos números ao ser lido um valor negativo.
5. Faça um programa que leia um número (inteiro) e escreva todos os seus divisores.
6. Faça um programa que receba como entrada uma quantia em dinheiro e mostre na tela a quantidade de notas de 5, 10, 50 e 100 são necessárias para representar o valor. O programa deve contabilizar a partir das notas de 100.
7. Suponha um número N qualquer: se N é par então N agora é N / 2; se N é ímpar N agora é 3*N + 1. Assim para N = 3 calculamos a seguinte tabela :
		3 10 4 2 
		10 5 2 1
		5 16 1 4
		16 8 4 2
		8 4 2 1
Observe que a partir de sete iterações a seqüência 4 2 1 começa a se repetir . Faça um programa que calcule para um dado N o número de iterações até se chegar ao primeiro 1 .
8. Faça um programa que imprima os elementos de uma PA e o somatório da mesma dados : primeiro termo , número de termos e razão 
9. Faça um programa que imprima um elemento da seqüência de Fibonacci, dado o numero do elemento. 
10. Faça um programa onde o usuário entra com um número decimal e o mesmo calcula e imprime o número no sistema binário .
11. Faça um programa onde o usuário entra com dois números A e B o programa devolve como resultado A elevado a B .
12. Escreva um programa que solicite ao usuário três números inteiros a,b,c onde a é maior que 1 . Seu programa deve somar todos os inteiros entre b e c divisíveis por a.
13. Escrever um programa que leia os códigos e taxas de consumo, em Kw, dos consumidoresde uma cidade. O programa pára de ler quando o código fornecido for zero. O programa deve escrever a média de consumo e os valores da maior e menor taxa de consumo. 
14. Seja o seguinte programa:
#include <stdio.h>
void main(){
 int t_ant = 1, t_atu = 1, aux, i = 2, n;
 scanf("%d", &n);
 printf("1 ");
 if (n>1)
 while (i<=n){
 printf("%d ", t_atu);
 aux = t_atu;
 t_atu = t_atu+t_ant;
 t_ant = aux;
 i++; 
 }
}
O que será escrito na tela, supondo que o valor fornecido para n seja 6? Mostre o teste de mesa completo utilizado para determinar a saída. 
15. Existe um algoritmo interessante para se obter a raiz quadrada de um número quando ela é exata. Para isso, basta subtrair números ímpares consecutivos do número do qual se deseja retirar a raiz quadrada. O número de vezes será a raiz do número. Por exemplo: 
No exemplo, subtraíram-se de 25 os 5 primeiros números ímpares consecutivos até que se chegasse 0. Assim, a raiz quadrada de 25 é 5. Faça um programa que leia um inteiro n e escreva a raiz quadrada de n. Por exemplo, se o número lido foi 49, ele escreverá 7. O calculo da raiz quadrada deverá ser feito usando o algoritmo acima, sem usar qualquer função pré-existente em alguma biblioteca C. 
16. Escreva um programa que lê um número não determinado de conjuntos de valores, cada um formado pelo número de um aluno e suas 3 notas. O programa calcula, para cada aluno, a média ponderada com pesos respectivos de 4 para a maior nota e 3 para as outras duas. Ele também escreve o número do aluno, suas 3 notas, a média calculada e uma mensagem "Aprovado" se sua nota for maior ou igual a 6 ou "Exame" se sua nota menor do que 6. O programa pára de ler dados quando o número fornecido for 0.
17. O valor de PI/2 pode ser calculado pela seguinte série de produtos: 
Faça um programa que calcule e escreva este produto com 10000 termos. 
18. Um aço é classificado de acordo com o resultado de três testes, que devem verificar se ele satisfaz às seguintes especificações: 
· Teste 1: conteúdo de carbono abaixo de 7%;
· Teste 2: dureza Rokwell maior que 50;
· Teste 3: resistência à tração maior do que 80.000 psi.
O aço recebe grau 10 se passa pelos três testes; 9, se passa apenas nos testes 1 e 2; 8, se passa no teste 1; e 7, se não passou nos três testes. Faça um programa em C que leia números de amostras e, para cada amostra, leia o conteúdo de carbono (em %), a dureza Rokwell e a resistência à tração (em psi), e escreva o número da amostra e grau obtido. O programa pára de ler amostras quando o número de amostra fornecido seja negativo. 
19. Faça um programa em C que gere todos os números que são múltiplos de 2, 3, 5 e 7 simultaneamente, de 1 a 1000000.
20. Faça um programa em C que gere uma tabela com os números de 1 a 100 com seus divisores. A saída deve ser na forma:
Número 	Divisores
1 		1 
2 		1, 2 
3 		1, 3 
4 		1, 2, 4 
...
21. Escreva um programa em C que leia dois valores numéricos: n e teto. O programa deve ler, então, n valores numéricos e escrever o percentual de valores lidos maiores do que teto.
22. Escreva um programa em C que leia três valores numéricos: n, valor1 e valor2. O programa deve ler, então, n valores numéricos e escrever o percentual de valores lidos menores do que valor1 e o percentual de valores lidos maiores do que valor2. 
23. Altere programa abaixo para que ele repita a pergunta ate que o caractere lido seja valido (independentemente de ser em maiúscula ou minúscula).
#include <stdio.h>
void main(){
 char ch;
 printf(“Deseja continuar? (s/n)\n”);
 ch = getche();
 if (ch == 's') printf("Continua...")
 else if (ch == 'n') printf("Nao continua...")
}
24. Faça um programa em C que leia um número n (inteiro positivo menor que 10000) e escreva todos os números de 0 a n cuja soma dos dígitos formantes é 10. Por exemplo, se n = 160, o programa escreverá
19 28 37 46 55 64 73 82 91 109 118 127 136 145 154
25. Foram entrevistados 500 alunos de uma universidade. Para cada alunos entrevistado foi registrado o código do curso que ele freqüenta (1: engenharia; 2: computação; 3: administração) e sua idade. Faça um programa em C que processe tais dados fornecendo as seguintes informações:
· número de alunos por curso;
· número de alunos com idade entre 20 e 25 anos, por curso; e
· cursos com a menor média de idade.
26. Faça um programa em C que, para cada vendedor de uma revenda de automóveis, leia seu código, seu salário fixo e o número de carros do tipo 1, do tipo 2 e do tipo 3 por ele vendido no mês. O código 0 (zero) indica que não há mais vendedores. O programa deve calcular e escrever o salário de cada vendedor. Para cada carro vendido, o vendedor recebe uma comissão de 5%. O valor de venda de um carro do tipo 1 é R$ 15.000,00; do tipo 2, R$ 20.000,00; do tipo 3 R$ 30.000,00. Além da comissão, o vendedor recebe um bônus de acordo com o total de vendas (independentemente do tipo de carro vendido) conforme segue:
· se ele vendeu mais de 5 carros, o bônus é de R$ 300,00;
· se ele vendeu mais de 8 carros, o bônus é de R$ 500,00; e
· se ele vendeu mais de 10 carros, o bônus é de R$ 1000,00.
27. 18) Escreva um programa em C que leia um número e escreva seu fatorial. O fatorial de n é representado por n! sendo que
0! = 1
1! = 1
2! = 1.2 = 2
3! = 1.2.3 = 6
4! = 1.2.3.4 = 24
5! = 1.2.3.4.5 = 120
28. Faça um programa em C leia os resultados da eleição de 300 candidatos às cinco vagas de deputado estadual. Os dados são: número do candidato e número de votos obtidos. O programa deve escrever os números dos 5 candidatos eleitos.
29. Faça um programa em C que leia a área de uma floresta e a taxa anual de desmatamento. O programa deve informar em quantos anos a floresta estará completamente desmatada. 
30. Escrever um programa em C que lê 100 conjuntos de 2 valores, representando o número de um aluno (num) e sua altura (Ai) em centímetros. O programa deve escrever a média aritmética das alturas e os números dos alunos mais alto e mais baixo. 
31. Faça um programa em C que calcule o resultado final da eleição para presidência da república. Existem 4 (quatro) partidos disputando a eleição, cujos códigos são 12, 13, 14 e 15; para computar os votos, o programa lê o código do partido votado. O código 0 (zero) indica voto em branco, código 1 (um) indica voto nulo. O programa pára de ler códigos quando o código fornecido for -1. O programa deverá apurar e escrever o total de votos recebidos por cada partido, o total de votos brancos e o total de votos nulos. Ele também deverá informar se há necessidade de um segundo turno, i.e., O partido mais votado não obteve 50% + 1 dos votos válidos (não-brancos, não-nulos). No caso de não haver segundo turno, o programa deve escrever o partido vencedor; no caso de haver o segundo turno, o programa deve escrever quais partidos o disputarão.
32. Decidiu-se, em uma linha de produção, fazer uma verificação da taxa de uso diária dos equipamentos. Faça um programa em C que leia o código do equipamento e sua taxa de uso diária (número horas/dia). O programa deve escrever: 
· o código do equipamento mais usado;
· o número de equipamentos cuja taxa de uso é igual ou superior a 15 horas/dia; e
· o número de equipamentos cuja taxa de uso é igual ou inferior a 5 horas/dia.
A entrada de dados deve ser finalizada quando o código de equipamento informado for zero.
33. Um determinado tipo de aplicação financeira rende uma taxa fixa por mês. Faça um programa em C que leia o saldo da aplicação, a taxa (percentual), um determinado número de meses e informe o saldo, passado esse número de meses. 
34. Para o programa em C abaixo, diga o que será escrito na tela, supondo que o valor fornecido para N foi 6? Mostre o teste de mesa completo utilizado para determinar a saída.
#include<stdio.h>
void main(){
 int N, i=0, divs=1;
 printf("Forneça um número inteiro\n");
 scanf("%d",&N);
 do{
 if (N%i == 0) divs+= i;
 i++;
 } while(i <= N/2);
 if (divs == N) printf("%d é perfeito",N);
 else printf("%d não é perfeito",N);
}
35. Uma loja cobra, por produtos vendidos