APOSTILA COMPLETA ANITA

Prévia do material em texto

�
 
�Professora ANITA LOPES��
FUNDAMENTOS DA LINGUAGEM C
	
1 A linguagem C
1.1	Introdução
	
A linguagem C é uma linguagem de nível intermediário que utiliza recursos da linguagem de máquina de forma simples. É uma linguagem estruturada, com flexibilidade/portabilidade entre sistemas operacionais e tem sido usado para criação de vários tipos de programas tais como processadores de texto, sistemas operacionais, planilhas, outras linguagens de programação, etc.
A linguagem C é "Case Sensitive", isto é, maiúsculas e minúsculas fazem diferença.
	1.2	Estrutura de um programa em C
	
	Um programa em C é constituído de:
um cabeçalho que contem definições de pré-processamento tais como os arquivos de cabeçalho, as definições de constantes simbólicas, declaração de variáveis globais, declaração de rotinas, etc.
um bloco da função principal e outros blocos de de funções.
comentários. 
	[ <definições de pré-processamento> ]
	[ <declaração de variáveis globais> ]
	<tipo de retorno da função> main( <parâmetros>) >
	{
	 Bloco de comandos
	}
	<tipo de retorno da função> <nome_da_função1 >( <parâmetros>) >
	{
	 Bloco de comandos da função1
	}
	...
	<tipo de retorno da função> <nome_da_funçãon >( <parâmetros>) >
	{
	 Bloco de comandos da função2
	}
Exemplo de um programa em C
#include <stdio.h>
main()
{ 
printf("\nPRIMEIRO PROGRAMA EM C");
}
	Explicando:
	#include <stdio.h> instrui o compilador a usar a biblioteca padrão de entrada e
 saída
	main() main é o nome da função principal; a palavra 
 { inicia a função
	printf imprime na tela a msg após alimentar linha
	} finaliza a função
1.2.1 	Conjunto de caracteres
	Um programa fonte em C é um texto não formatado escrito em um editor de textos usando um o conjunto padrão de caracteres ASCII.	
	
Caracteres válidos:
	As letras minúsculas e maiúsculas não acentuadas
	Os algarismos de 0 - 9 
 	+ - * / \ = | & ! ? # % ( ) { } [ ] _ ‘ “ . , : < >
	
	Observação: Qualquer outro caracter é valido para as strings. 
	1.2.2	Comentários
	Os comentários em C podem aparecer em qualquer lugar do programa e têm como objetivo fazer um esclarecimento sobre uma linha ou trecho do programa.
	Os comentários terão um /* antes e um */ depois.
	Exemplo:
	/* programar em C eh facil */	
	1.2.3 	Diretivas de Compilação
	Na linguagem C, alguns comandos são processados durante a compilação. Estes comandos são chamados de diretivas de compilação e são eles que informam quais bibliotecas e constantes simbólicas deverão ser anexadas quando for gerado o programa executável.
A diretiva #include diz ao compilador para incluir na compilação do programa outros arquivos. Geralmente estes arquivos contem bibliotecas de funções ou rotinas do usuário. 
As bibliotecas agrupam funções de acordo com as finalidades. Se não fizéssemos uso delas, nossos programas seriam muito extensos e teríamos problemas na linkedição. 
Sintaxes: 
	#include <nome_da_biblioteca >
	#include “...nome_da_biblioteca ”
onde nome_da_biblioteca é o nome da biblioteca que se deseja incluir. Estando entre os sinais < e > significa que está no diretório padrão e ficando entre “, significa que precisamos fornecer o caminho onde se encontra a biblioteca.
	Exemplos de bibliotecas:
BIBLIOTECA ctype.h
	Converte para maiúscula ou para minúscula uma letra
	toupper(letra)
	tolower(letra)
BIBLIOTECA math.h
	Calcula o valor absoluto real d
	fabs(double d)
	Funções trigonométricas do ângulo arco, em radianos
	sin(double arco)
	cos(double arco)
	tan(double arco)
	asin(double arco)
	acos(double arco)
	atan(double arco)
	Funções de arredondamento para inteiro
	ceil(double num) Ex. ceil(3.2) => 4.0 arredonda pra cima
	floor(double num) Ex. floor(3.2) => 3.0 arredonda para baixo
	Funções logarítmicas: log() é logaritmo natural (base e), log10() é logaritmo decimal (base 10)
	log(double num)
	log10(double num)
	Funções: potência e raiz quadrada
	pow(double base, double exp); Potenciacao: pow(3.2,5.6) => 3.25.6
	sqrt(double num); Raiz quadrada: sqrt(9.0) = >3.0.
BIBLIOTECA stdio.h
		Esvazia o buffer, lê e imprime
	fgetc(stdin);
	fgets(lixo,100,stdin);
	scanf(…);
	gets(…);
	getchar(…);
	printf(…);
	putchar(…);
	puts(…);
BIBLIOTECA stdlib.h
		Calcula o valor absoluto do inteiro i e do real d, respectivamente
	abs(int /float)
	rand()
BIBLIOTECA string.h → ver anexo I
		Concatena duas strings
	strcat(str1, str2);
	Copia o conteúdo de uma variável em outra variável
	strcpy(str1, str2) /* não é permitido: str1 =str2;*/
	Fornece o número de caracteres de uma string
	strlen(str1) 
	Compara duas strings 
	 devolve número menor que 0 se str1 vier antes de str2 
strcmp(str1, str2) devolve número maior que 0 se str1 vier depois de str2
 devolve 0 se str1 for igual à str2 
2. Saída 
	Existem varias maneiras de se fazer uma escrita de informações na linguagem C. 
	Primeiramente, vamos aprender a usar função printf().
 Biblioteca: stdio.h 
	printf( "expressão de controle ", <lista_de_argumentos > );
	
A expressão de controle contém uma descrição de tudo que aparecerá na tela.
	Além das mensagens, estarão presentes também os códigos de controle para impressão dos conteúdos das variáveis, alimentação de linha, tabulação, etc.
	 Código 
	Significado
	%d 
	Inteiro
	%f 
	Float
	%c 
	Caractere
	%s 
	String
	%o
	Constante octal
	%x  ou %X 
	Constante hexadecimal
	%u 
	Inteiro sem sinal
	%ld 
	Longo inteiro
	%f
	float
	%e
	exponencial
	%g
	Usa-se %e ou %f
	%p 
	Ponteiro
	%+.. 
	Coloca sinal
	
%<n>d
	Formata Inteiro formata com n casas. Os operadores < e > não deverão ser colocados na expressão. Eles indicam que o conteúdo de n é variável. Exemplo: %4d
	%<0n>d
	Formata inteiro preenchendo com 0 as posições não usadas. Os operadores < e > não deverão ser colocados na expressão. Eles indicam que o conteúdo de 0n é variável . Exemplo: %04d
	%<n.f>f
	Formata real com determinado número de casas na parte inteira, inclui o ponto decimal e o número de casas na parte fracionária. Os operadores < e > não deverão ser colocados na expressão. Eles indicam que o conteúdo de n é variável. Exemplo: %8.2f 
	%% 
	Coloca na tela um % 
	 
		Controle/Caracter
	Seqüência de escape
	nulo (null) 
campainha (bell) 
retrocesso (backspace) 
tabulacao horizontal 
nova linha (new line) 
tabulacao vertical 
alimentacao de folha (form feed) 
retorno de carro (carriage return)
aspas (") 
apostrofo (') 
interrogacao (?) 
barra invertida (\) 
	\0
\a
\b
\t
\n
\v
\f
\r
\"
\'
\?
\\
	Exemplos:
	printf("\nProfessora Anita Lopes\n"); /*sem lista de argumentos */ 
	printf("\nO numero eh: %d", num); /* imprime mensagem e conteúdo de uma
 variável inteira*/
	#include <stdio.h>
main()
{
 printf("\nletra %c - numero %d ",'A','A');
 printf("\n%06d",123);
 printf("\n%d",-15);
 printf("\n%+d",123);
 printf("\n%8.5f", 12.3456);
 printf("\n%8.0f", 12.3456);
}
	
3. Constantes e variáveis
	
3.1 Constantes
	O C possui quatro tipos básicos de constantes: inteiras, de ponto flutuante,caracteres e strings. Constantes inteiras e de ponto flutuante representam números de um modo geral.
	3.1.1	Constantes inteiras
	As constantes inteiras na linguagem C podem ser escritas no formato decimal (base 10), hexadecimal (base 16) ou octal (base 8). 
	Exemplos:
 	Decimal: 12 
	Octal : 033 ( em decimal vale 27. O zero antes do número caracteriza a constante octal)
	Hexadecimal: 0xff ( em decimal vale 255. O zero e o x antes do número caracterizam a constante hexadecimal)
	
	#include <stdio.h>
main()
{ 
 printf("\ndecimal= %d octal= %o hexadecimal= %X",27,27,27);
 printf("\ndecimal= %d octal= %o hexadecimal= %X",27,27,27);
}
	
	3.1.2	Constantes de ponto flutuante
	
	São números reais com um ponto decimal e (opcionalmente) um expoente.	
	Exemplos: 
	1.876 476.65 1.23e-9 -1.e2 10.6e18 -.853E+67
	3.1.3	Constantes caracteres
	Uma constante caracter é uma letra ou símbolo colocado entre plicas.
	Exemplo:
	’A’	’N’	’I’	’T’ ’A’	
	As constantes caracter são armazenadas como números inteiros. Estes números correspondem aos valores de cada caracter dentro do código ASCII.
	
	3.1.4	Constantes strings
	Uma constante string consiste de um conjunto de caracteres do código ASCII padrão ou estendido, colocados entre aspas duplas.
	Exemplo: 
	”UAL!”
	”Matemática”
	”APRENDENDO A PROGRAMAR EM C ”
Na linguagem, C uma string é um vetor de caracteres terminado com um caracter nulo. O caracter nulo é um caracter com valor inteiro igual a zero (código ASCII igual a 0). O terminador nulo também pode ser escrito usando a convenção de barra invertida do C como sendo '\0'.
	char nome_da_string[tamanho];
Como precisamos reservar uma posição para o terminador, sempre iremos declarar o tamanho necessário mais um.
Vamos supor que declaremos uma variável de nome palavra de 11 posições(char palavra[11]; ) e armazenemos a palavra PROGRAMAS nela. 
É bom ressaltar que a linguagem C não inicializa as variáveis e toda célula não usada têm valor indeterminado. 
Não se esqueça de inicializar as variáveis de seus programas, pois coisas incríveis podem acontecer!
As strings são consideradas vetores de caracteres( matriz linha). Como na Matemática, para se acessar um determinado caracter de uma string, basta "indexarmos". 
	
	str[1] = 'o'
str[2] = 'a'
	No exemplo acima, percebemos que o primeiro caracter se encontra na posição 0( em algumas linguagens, seria a posição 1). Desta forma, se indexarmos com 1, na verdade estaremos nos referindo ao segundo caracter da string; se indexarmos com 2, na verdade estaremos nos referindo ao terceiro caracter da string e assim sucessivamente. 
3.1.5 Constantes Simbólicas
	A Matemática define pi como tendo o valor 3,14159265. Muitas vezes precisaremos definir algumas constantes em nossos programas.
3.1.5.1 Constantes definidas pelo programador 
	
	O programador pode definir constantes simbólicas em qualquer programa.
	Sintaxe: 
	#define <nome> < valor >
	Onde #define é uma diretiva de compilação que diz ao compilador para trocar as ocorrências do texto nome por valor. Observe que não há ; no final da instrução pois trata-se de um comando para o compilador e não para o processador. A instrução #define deve ser escrita antes da instrução de declaração da rotina principal. 
	
	Exemplo: 
	
	#include <stdio.h>
#include <math.h>
#define quadrado(x) (x*x)
#define pi 3.14159265
#define conv(x) (x*pi/180)
main()
{ 
 printf("\nnumero: 12" );
 printf("\n\nquadrado= %d", quadrado(12));
 printf("\n\nangulo: 30" );
 printf("\n\nseno de %.2f eh %4.2f",30.,sin(conv(30)));
}
	
	O uso da diretiva #define não se restringe apenas para declarar constante(#define pi 3.14159265 ) mas também podemos usá-la para definir macro instruções(#define conv(x) (x*pi/180) ou #define quadrado(x) (x*x) ). 
3.2 Variáveis
A variável é um lugar(endereço) na memória principal que armazena um dado e tem um nome associado para facilitar a programação .
	Em C, as variáveis podem ser declaradas no inicio do programa, mas poderemos também declarar dentro de algumas estruturas, diferentemente de outras linguagens. Estas variáveis podem ser de vários tipos: int (inteiro), float (real de simples precisão) , char (caracter único), double (real de dupla precisão).
	Tipo
	Tamanho
	Intervalo
	Uso
	char
int 
float 
double
	1 byte 
4 bytes 
4 bytes 
8 bytes 
	-128 a 127
-2147483648 a 2147483647
3.4e-38 a 3.4e38 
1.7e-308 a 1.7e308 
	número muito pequeno e caracter ASCII
contador, controle de laço
real (precisão de 6dígitos)
científico (precisão de 10 dígitos)
	Quando se define um tipo de variável, informamos ao computador quanto de memória será necessária para armazenar este dado e que tipos de operações poderão ser realizadas com este dado.
	Para se declarar uma variável, usamos a seguinte sintaxe:
	< tipo> nome_da_variável ;
	
	O nome de uma variável deve obedecer algumas regras:
O primeiro caracter pode ser uma letra ( maiúscula ou minúscula) ou o caracter sublinha. Aconselha-se a não usar o caracter sublinha no inicio para não confundir com algumas funções. 
Os demais caracteres, letras algarismos ou o caracter sublinha.
Exemplos:
	int a; float peso; char sexo; int idade1, idade2;
3.2.1	Palavras reservadas
	Existem certos nomes que não poderão ser usados como identificadores. São chamadas as palavras reservadas e são de uso restrito da linguagem C. O conjunto de palavras reservadas usadas em C é o seguinte:
	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
 
3.2.2	Tipos modificados
	Além dos tipos de dados mencionados, existem os modificadores: long, short, signed e unsigned. Tipicamente o modificador long aumenta o número de bytes usados para o registro do número. O modificador unsigned, usado somente em inteiros, permite que um bit usado para guardar o sinal do número seja usado para guardar o valor do número. 
	Tipo
	Tamanho (bytes)
	Intervalo
	unsigned char 
	1
	0 a 255 
	unsigned int 
	2
	0 a 65 535
	unsigned long int 
	4
	0 a 4 294 967 295
	long int 
	4
	-2 147 483 648 a 2 147 483 647
	short int
	2
	-32768 a 32767
	long double 
	10
	3.4e-4932 a 1.1e4932
3.2.3 Conversão de tipo (Casting)
	Algumas vezes queremos, momentaneamente, modificar o tipo de dado representado por uma variável, isto é, queremos que o dado seja apresentado em um tipo diferente do qual a variável foi inicialmente declarada. Por exemplo: ao fazermos uma divisão entre dois inteiros, a linguagem C trunca a parte fracionária e podemos desejar que isto não aconteça. Este procedimento é chamado de conversão de tipo ou casting . 
Sintaxe: 
	(tipo) variável
onde tipo é o nome do tipo ao qual queremos converter o dado armazenado em variável. 
Exemplo: 
	#include <stdio.h>
main()
{ 
 printf("\nnumero: 7" );
 printf("\n\nDIVIDINDO POR 3\nsem conversao= %dcom conversao= %f",7/3, (float)7/3);
}
	
3.2.4 Variável ponteiro
Nós já sabemos que uma variável é um endereço na MP que armazena um dado. É bom deixar claro que não é um único endereço, pois, dependendo do tipo, poderemos estar alocando 1, 2, 4, 8 ou mais posições para cada variável como vimos na última tabela. 
Uma variável ponteiro armazena o endereço de outra variável. Mais adiante estudaremos este tipo de variável uma vez que se não trabalharmos bem com este tipo de variável, não conseguiremos programar bem na linguagem C.
Mas, par começarmos logo nos acostumando, vamos observar o programa abaixo:
	#include <stdio.h>
main()
{ int num, *p; /*observe o asterisco antes de p indicando que é uma variável ponteiro*/
 printf("\nDigite numero: ");
 scanf("%d",&num);
 p=&num; /*p recebe o enderereco de num, isto é, p aponta para num*/
 printf("\n\nEndereco da variavel mostrado pela variavel ponteiro: %u\n\nValor da variavel mostrado pela variavel ponteiro: %d", p, *p);
 printf("\n\nEndereco da variavel mostrado pela propria variavel: %u\n\nValor da variavel mostrado pela propria variavel: %d", &num, num);
} 
	
	LEIA VÁRIAS VEZES ESTE TRECHO
	Você observou que, ao mandarmos mostrar na tela a variável p, foi mostrado seu conteúdo que na verdade era o endereço da variável num que foi exatamente o mesmo valor mostrado na tela quando mandamos mostrar na tela &num, significando ao colocarmos o operador de endereço & antes do nome da variável num, que desejamos o endereço e não o conteúdo.
 Quando mandamos mostrar na tela o conteúdo da variável ponteiro que representamos com o *, foi mostrado o conteúdo da posição de memória que a variável ponteiro aponta, mostrando o mesmo conteúdo da variável num.
4. Atribuição
Consiste em atribuir um valor a uma variável. Em C, o comando de atribuição tem a seguinte sintaxe:
	< nome_da_variável > = <conteúdo> ;
	
Exemplos:
a = 12 ; peso = 65.2; sexo ='f'; idade1 = 21; idade2 = 34;
Observação 1: Em C, é possível declarar e inicializar uma variável: int a = 12; 
Observação 2: Em C, é possível inicializar várias variáveis: x =t =s = 0;
Na atribuição múltipla as operações ocorrem da direita para a esquerda, isto é, inicialmente o valor 0 é atribuído a s, depois o valor de s é atribuído a t e, por último, o valor de t é atribuído a x.
4.1 Atribuição múltipla.
	A linguagem C permite que se atribua um valor a muitas variáveis. em uma única instrução. 
Sintaxe: 
	var_1 = [var_2 = ... ] valor;
Exemplo:
a = b = 0;
5. Entrada de dados 
	scanf
5.1 Formatada - scanf
Biblioteca: stdio.h
Sintaxe:
	scanf( "expressão de controle ", <lista_de_argumentos > );
  	 A função scanf() permite que o usuário digite dados através do dispositivo padrão de entrada: teclado. 
	A expressão de controle contém os códigos de formatação para o tipo de dado que será lido.
	A lista de argumentos corresponde aos endereços das variáveis. O nome de cada variável deverá ser precedido pelo caracter &.
	 Código 
	Significado
	%d 
	Lê um número inteiro
	%f 
	Lê um número em ponto flutuante
	%e 
	Lê um número em ponto flutuante
	%g 
	Lê um número em ponto flutuante
	%c 
	Lê um caracter
	%s 
	Lê uma string
	%o
	Lê um número octal
	%x  ou %X 
	Lê um número hexadecimal
	%u 
	Lê um inteiro sem sinal
	%ld 
	Lê um longo inteiro
	%lf 
	Lê um longo real(double)
	%p 
	Lê um ponteiro
Exemplos:
	scanf("%d", &num); /* lê para uma variável inteira*/ 
	 scanf("%d %d", &num1, &num2 ); /* lê para duas variáveis inteiras separadas por um espaço*/ 
scanf("%d,%d", &num1, &num2 ); /* lê para duas variáveis inteiras separadas por uma vírgula*/ 
	#include <stdio.h>
main()
{ 
 int n;
 char resp;
 printf("\nnumero:" );scanf("%d",&n);
 printf("\ndecimal= %d octal= %o hexadecimal= %X hexadecimal= %x",n,n,n,n);
 fgetc(stdin);
 scanf("%c",&resp);
}
	
Observe a função fgetc(stdin); usada para esvaziar o buffer antes de ser lido o dado para variável caracter, pois o buffer do teclado demora para esvaziar.
5.2 gets
	Função usada com vetores de caracter.
Biblioteca: stdio.h
Sintaxe:
	gets( <nome do vetor de caracteres> );
 
Observações:
A função scanf abandona o armazenamento assim que um espaço for encontrado.
Como não existe para a função gets um controle para a quantidade de caracteres digitados, os caracteres poderão ser armazenados em áreas importantes do sistema, seu programa, etc.
Conselho: evite usá-la.
 5.3 fgets - teclado
	Função usada com vetores de caracter.
Biblioteca: stdio.h
Sintaxe:
	fgets(<nome do vetor de caracteres>,<tamanho máximo>, stdin);
	Esta função é similar a gets na leitura de uma linha de caarcteres, sendo mais flexível porque o programador especifica o máximo de caracteres que podem ser armazenados. Para usá-lo para entrada via teclado, é preciso usar o parâmetro stdin.
	Esta função lê caracteres do teclado até que o enter seja pressionado ou n-1 caracteres tenham sido lidos.
	Observações
 1: Lembre-se de que dos n caracteres declarados com a variável vetor de caracteres, o último caracter é reservado para finalizar o vetor('/0').
 2: Se o conteúdo não ultrapassar a n-1 caracteres, então uma nova linha é adicionada ao vetor.
	Observe os exemplos e abaixo e as linhas que foram colocadas para que você possa contar com mais facilidade o número de caracteres armazenados nas variáveis:
	#include <stdio.h>
#include <string.h>
main()
{int i;char nome[25],c;
 printf("\nNome: ");
 fgets(nome,25,stdin);
 printf("\n\n1234567890123456789012345678901234567890\n%s",nome);
 printf("\n\nNome: ");
 gets(nome);
 printf("\n\n1234567890123456789012345678901234567890\n%s",nome);
 scanf("%c",&c);
}
	
Como a entrada de dados estava limitada em 24 caracteres(lembre-se de que um caracter é sempre reservado para o finalizador do vetor), os caracteres restantes ficaram armazenados no buffer do teclado e a próxima função de entrada(gets(nome) ) foi "bypassada" e o que estava no buffer foi armazenado na variável. Tentamos então "recolher o lixo".
O QUE FIZEMOS PARA RETIRAR ESTE PROBLEMA?
	#include <stdio.h>
#include <string.h>
main()
{int i;char nome[25],c,lixo[100];
 printf("\nNome: ");
 fgets(nome,25,stdin);
 printf("\n\n1234567890123456789012345678901234567890\n%s",nome);
 fgets(lixo,100,stdin);/*ATENCAO PARA ESTA LINHA*/
 printf("\n\nNome: ");
 gets(nome);
 printf("\n\n1234567890123456789012345678901234567890\n%s",nome);
 scanf("%c",&c);
 }
	
Incluímos a linha: fgets(s,100,stdin); ,mas quando executamos novamente e digitamos um nome com menos de 24 caracteres, outro problema: a função fgets(s,100,stdin); ficou esperando a entrada de dados. Observou?
A saída foi fazer uma proteção com if, fazendo com que esta função só funcionasse se o tamanho do vetor tivesse atingido o máximo que, neste exemplo era 24. Veja como ficou o programa:
	#include <stdio.h>
#include <string.h>
main()
{int i;char nome[25],c,s[100];
 printf("\nNome: ");
 fgets(nome,25,stdin);
 printf("\n\n1234567890123456789012345678901234567890\n%s",nome);
 if(strlen(nome)==24 && nome[23]!='\n')fgets(s,100,stdin);/*ATENCAO PARA ESTA LINHA*/
 printf("\n\nNome: ");
 gets(nome);
 printf("\n\n1234567890123456789012345678901234567890\n%s",nome);
 scanf("%c",&c);
}
	
Pudemos observar que o problema foi quase totalmente resolvido exceto pelo uso da função gets(...); que armazenou tudo que foi digitado e que poderá trazer SÉRIOS PROBLEMAS.
	CONCLUSÕES;
Sempre incluir a linha: if(strlen(nome)==<tamanho –1>)fgets(s,100,stdin); 
Nunca usar gets,pois esta função armazena os caracteres digitados sem se preocupar com o limite.
6. Operadores Aritméticos
	
Existem cinco operadores aritméticos em C. Cada operador aritmético está relacionado a uma operação aritmética elementar: adição, subtração, multiplicação e divisão. Existe ainda um operador (%) chamado operador de módulo cujo significado é o resto da divisão inteira. 
	
	Operador
	Operação
	+
-
*
/
%
	adição
subtração
multiplicação
divisão
módulo (resto da divisão inteira)
	
	Sintaxe: 
	operando1 operador operando2
	onde operador é um dos símbolos mostrados acima e operando é uma constante ou um identificador de variável. 
	Exemplos:
	12 + 5 -> 17
	12 * 5 -> 60
	12 / 5 -> 2 quando se divide dois inteiros, o resultado é um inteiro
	12 % 5 -> 2 resto da divisão inteira	
	Observação: Se você precisar dividir dois números inteiros e quiser a resposta em real, existe duas saídas:
Coloque um ponto em um dos operandos caso, pelo menos um, seja uma constante: 12 / 5. .
Caso os dois operandos sejam variáveis, faça: (float) a/b . 
		Não existe em C, como existe em outras linguagens, um operador específico para a operação de potenciação (ab). Existe, porém, uma função de biblioteca (pow()) que realiza esta operação, ou você poderá criar quando aprender a usar as funções log e exp.. 
			
	#include <stdio.h>
main()
{ int n;
 char resp;
 printf("\nnumero:" );scanf("%d",&n);
 printf("\n\nTUDO POR 5 \n\nsoma= %d subtracao= %d multiplicacao= %d divisao inteira= %d resto= %d",n+5,n-5,n*5,n/5,n%5);
 fgetc(stdin); /* esvazia o buffer de entrada */
 scanf("%c",&resp);
}
	
	
6.1	Hierarquia das operações
	
	Categoria
	Operadores
	Prioridade
	parênteses
	( ) 
	interno ( externo
	função
	nome() 
	E ( D
	incremental, lógico
	++ -- ! 
	E ( D
	aritmético
	* / %
	E ( D
	aritmético
	+ -
	E ( D
	relacional
	< > <= >=
	 E ( D
	relacional
	== !=
	E ( D
	lógico
	&&
	E ( D
	lógico
	||
	E ( D
	condicional
	?:
	E ( D
	atribuição
	= += -= *= /= %= 
	E ( D
6.2 	Operadores de Atribuição Aritmética
	Muitas vezes queremos alterar o valor de uma variável realizando alguma operação aritmética com ela.
A linguagem C apresenta instruções otimizadas com o uso de operadores ditos operadores de atribuição aritmética. Os símbolos usado são (+=, -=, *=, /= , %=). 
Sintaxes: 
	var += exp;
var -= exp; 
var *= exp; 
var /= exp; 
var %= exp;
	var = var + exp;
var = var - exp; 
var = var * exp; 
var = var / exp; 
var = var % exp;
onde var é o identificador da variável e exp é uma expressão válida. Estas instruções são equivalentes as seguintes:
Exemplos: 
	Atribuição Aritmética
	Instrução Equivalente
	cont += 1; 
j -= i ; 
num *= 1 + k;
divide /= 5; 
resto %= 2; 
	cont = cont + 1;
j = j – i ;
num = num * (1 + k);
divide = divide / 5;
resto = resto % 2;
O operador de atribuição aritmética tem precedência menor que os outros operadores até aqui discutidos.
6.3 	Operadores Incrementais
	Em programação existem instruções muito comuns chamadas de incremento e decremento. Uma instrução de incremento adiciona uma unidade ao conteúdo de uma variável. Uma instrução de decremento subtrai uma unidade do conteúdo de uma variável. 
Existem, em C, operadores específicos para realizar as operações de incremento (++) e decremento (--). Eles são genericamente chamados de operadores incrementais.
Sintaxe: 
	
	Instrução Equivalente
	++ var;
var ++ ; 
-- var ; 
var -- ; 
	var = var + 1;	
var = var + 1;
var = var – 1;
var = var – 1;
onde var é o nome da variável da qual se quer incrementar ou decrementar um unidade. 
Observe que existe duas sintaxes possíveis para os operadores: pode-se colocar o operador como prefixo ou como sufixo. Nos dois casos o valor da variável será incrementado (ou decrementado) de uma unidade. Porém se o operador for colocado como sufixo, o valor da variável será incrementado (ou decrementado) antes que a variável seja usada em alguma outra operação. Caso o operador seja colocado como sufixo, o valor da variável será incrementado (ou decrementado) depois que a variável for usada em alguma outra operação. 
	#include <stdio.h>
main()
{ int n,n1,n2;
 char resp;
 printf("\033[2J");
 printf("\033[30;47m");
 printf("\nnumero:" );scanf("%d",&n);
 printf("\n\nprefixo++ n1= %d sufixo++ n2= %d",n1=++n, n2=n++);
 fgetc(stdin);
 scanf("%c",&resp);
}
	
Observação: Não se preocupe com os avisos, pois o objetivo foi mostrar os incrementos pré e pós fixados. Como visto na tabela de hierarquia das operações, o operador ++ tem hierarquia da direita para esquerda. Desta forma, ele atribui 13 à variável n2 e depois incrementa n. Como a atribuição à variável n1 é com prefixo, ele incrementa n outra vez e depois atribui o valor 15 à variável n1.
	Os operadores incrementais tem a mais alta precedência entre todos, sendo superados apenas pelos parênteses que tem precedência ainda maior. 
6.4 	Operadores Relacionais e Lógicos
	
	As expressões lógicas usadas nas estruturas de teste são formadas pelos operadores relacionais e lógicos. 
6.4.1	Operadores relacionais
Operadores relacionais verificam a relação de magnitude e igualdade entre dois valores. São seis os operadores relacionais em C:
	Operador
	Significado
	>
<
>=
<=
==
!=
	maior que
 menor que
maior ou igual a 
menor ou igual a 
igual a
diferente de
Sintaxe: 
	expressão_1 operador expressão_2
onde expressão_1 e expressão_2 são duas expressões numéricas quaisquer, e operador é um dos operadores relacionais.
	Ao contrário de outras linguagens, em C não existem tipos lógicos, portanto o resultado de uma expressão lógica é um valor numérico: uma expressão avaliada verdadeira recebe o valor 1, uma expressão lógica avaliada falsa recebe o valor 0.
Os operadores relacionais de igualdade (== e !=) tem precedência menor que os de magnitude (>, <, >= e <=). Estes, por sua vez, tem precedência menor que os operadores aritméticos. 
6.4.2	Operadores lógicos
São três os operadores lógicos de C: &&, || e !. Estes operadores têm os mesmos significados dos operadores lógicos Booleanos AND, OR e NOT. 
Sintaxes: 
	expr_1 && expr_2
expr_1 || expr_2
!expr
onde expr_1 , expr_2 e expr são expressões quaisquer. 
Observe que os operadores lógicos atuam sobre expressões de quaisquer valores. Para estes operadores todo valor numérico diferente de 0 é considerado 1.
	Operador
	Matemática
	C
	conjunção
disjunção
negação
	 e ^
 ou v 
 não |
	&& 
|| 
!
TABELA VERDADE DO OPERADOR &&
Suponha duas perguntas feitas a quatro pessoas. Se a resposta do candidato for negativa, deverá falar 0, caso contrário, falará 1.
Suponha também que só será chamado para entrevista o candidato que dominar as duas linguagens.
	 Você conhece C?
	Você conhece PASCAL?
	SAÍDA
	0
	0
	0
	0
	1
	0
	1
	0
	0
	1
	1
	1
Neste exemplo, somente o quarto candidato seria chamado para a entrevista, pois o operador && (e), só considera a expressão como verdadeira se todas as expressões testadas forem verdadeiras.
 
TABELA VERDADE DO OPERADOR ||
Suponha duas perguntas feitas a quatro pessoas. Se a resposta do candidato for negativa, deverá falar 0, caso contrário, falará 1.
Suponha também que será chamado para entrevista o candidato que dominar pelo menos uma linguagem.
	 Você conhece C++?
	Você conhece JAVA?
	SAÍDA
	0
	0
	0
	0
	1
	1
	1
	0
	1
	1
	1
	1
Neste exemplo, somente o primeiro candidato não seria chamado para a entrevista , pois o operador || (ou),considera a expressão como verdadeira se, pelo menos uma expressão testada for verdadeira.
Observação:
O Operador && tem precedência sobre o operador ||. Estes dois têm precedência menor que os operadores relacionais. 
TABELA VERDADE DO OPERADOR !
Suponha uma pergunta feita a duas pessoas. Se a resposta do candidato for negativa, deverá falar 0, caso contrário, falará 1.
	Você Não conhece C++?
	SAÍDA
	1
	0
	0
	1
Observação:
O operador ! tem a mesma precedência que os operadores incrementais. 
6.5 	Operador Condicional
	
	O operador ternário (?) é usado em expressões condicionais. Este operador necessita de três operandos. Seu uso poderá simplificar a instrução if expressão1; else expressão2;.
Sintaxe: 
	condição ? expressão_1 : expressão_2
	
Exemplo:
	...
	a=24;
	b=38;
	c= (a >b) ?a: b; /* o valor de c seria 38, pois b é maior do que a.
O operador condicional tem baixa precedência, precedendo apenas aos operadores de atribuição. 
Lembra do algoritmo para descobrir o maior entre 3 números? Você podia fazer de várias maneiras, mas, com certeza, nunca seria menor da que vai ser mostrada abaixo:
	#include <stdio.h>
 main()
 {int a,b,c,maior;
 printf("\ndigite 3 numeros: ");
 scanf("%d,%d,%d",&a,&b,&c);
 maior=(a>b && a>c)?a:(b>c)?b:c;
 printf("\nmaior:%d \n",maior);
 }
	
Observação:
O operador condicional tem baixa precedência, precedendo apenas aos operadores de atribuição. 
6.6 	Operadores bit-a-bit
	
	A linguagem C , por ser uma linguagem de nível intermediário, isto é, apresenta características de linguagens de alto nível, mas também suporta operações que podem ser feitas em linguagem de baixo nível.
	Os operadores bit-a-bit só podem ser usados com variáveis dos tipos char e int. As operações realizadas são de deslocamento, atribuição e teste e são feitas em cada bit dos operandos, pois eles são representados em suas formas binárias.
	Os operadores bit-a-bit encontram aplicações onde o controle dos bits é muito importante tal como na transmissão de dados via modem, multiplicações e divisões por potências de dois, troca de valores de variáveis, etc. 
	Operador
	Ação
	&
	AND
	|
	OR
	^
	XOR (OR exclusivo)
	~
	NOT
	>>
	Deslocamento de bits a direita
	<<
	Deslocamento de bits a esquerda
	Existem dois operadores AND e dois operadores OR na linguagem C: um AND(&&) e um OR(||) ,operadores lógicos, que só retornam 1 ou 0 e um AND(&) e um OR(|) que podem retornar valores diferentes:
	Seja, para entendimento a representação do 5 em binário: 00000101.
	Operador and bit-a-bit
	 00000101
& 00000101
	 00000101
	
A resposta seria 5, pois a operação bit-a-bit trabalha da seguinte maneira: será 1 se os dois bits, em posições idênticas nos dois operandos forem 1.
O operador & geralmente é usado para mascarar um conjunto de bits, enquanto o operador | geralmente é usado para ativar bits.
	Veja o exemplo:
	#include <stdio.h>
main()
{int x,y;
 printf("\nDigite 1 numero inteiro: ");
 scanf("%d",&x);
 printf("\nDigite 2 numero inteiro: ");
 scanf("%d",&y);
 printf("\nValor de x= %d\tValor de b: %d", x,y);
 /*trocando valores das variaveis usando o operador XOR (^)*/
 x^=y; y^=x; x^=y;
 printf("\n\ntrocando valores das variaveis usando o operador XOR (^)*\nValor de x= %d\tValor de y: %d\n\n", x,y);
 /*multiplicando por potencias de 2 usando o operador << */
 printf("\n\nmultiplicando %d por potencia de 2(8) usando o operador << =%d\n\n",y,y<<3);
 /*dividindo por potencias de 2 usando o operador >> */
 printf("\ndividindo %d por potencia de 2(4), usando o operador >> =%d\n\n",y,y>>2);
 /*simulando modulo de potencias de 2 usando o operador & */
 printf("\nmodulo da divisao de %d por potencia de 2(4), usando o operador & =%d\n\n",y,y&3);
 /*complemento de um numero ~ */
 printf("\ncomplemento do letra A(criptografando, por exemplo) , usando o operador ~ =%c\n\n",~65);
}
	
Quando o operador de deslocamento de bit << for usado,significa que você irá multiplicar o número por uma potência de 2.  Por exemplo: se você desejar e multiplicar por 8( 23 ), deverá fazer três deslocamentos: i << 3; 
 INCLUDEPICTURE "C:\\LINGUAGE\\tc\\cursos\\cursoc\\aulas\\line.gif" \* MERGEFORMATINET 
7. Estruturas de seleção - if / switch
Nossos programas até agora seguiram um mesmo padrão: entrava-se com dados, estes eram processados e alguma informação era mostrada na tela.
Agindo desta forma, o computador mais parecia uma máquina de calcular. O aprendizado de novos conceitos como a da estrutura de seleção nos dará uma visão maior da complexidade de tarefas que ele poderá executar. 
7.1	Estrutura de decisão - if...else
	
A estrutura if...else é uma estrutura de controle do C muito fácil de ser usada Após o teste, o fluxo poderá seguir dois caminhos, isto é, se o teste resultar em uma verdade, será executado o comando ou bloco de comandos que se encontra após o fecha parênteses do teste, caso contrário, se existir, será executado o comando ou bloco de comandos que se encontra após o comando else. 
7.1.1 	Estrutura de decisão com um bloco
Sintaxe: 
	 if(condição)
 {
 bloco
 }
onde:	condição é uma expressão lógica ou relacional.
	bloco é um conjunto de instruções, separadas por ponto-e-vírgula. 
 { e } só serão obrigatórias se tiver mais de uma ação para ser executada.
Se a condição for verdadeira, o bloco é executado. Caso contrário, o bloco não é executado.
Exemplo: 
	#include <stdio.h>
main()
{ int idade;
 printf("\nQuantos anos voce tem? " );
 scanf("%d",&idade);
 if(idade>=18)
 printf("\nMAIOR DE IDADE" );
}
	
7.1.2 	Estrutura de decisão com dois blocos
Sintaxe:
	 if(condição)
 {
 bloco
 }
 else
 {
 bloco
 }
onde:	condição é uma expressão lógica ou relacional.
bloco 1 e bloco 2 são conjuntos de instruções.
Se a condição for verdadeira o bloco 1 é executado. Caso contrário, o bloco 2 é executado.
Exemplo
	#include <stdio.h>
main()
{ int num;
 printf("\nDigite numero inteiro: " );
 scanf("%d",&num);
 if(num%2==0)
 printf("\nPAR" );
 else
 printf("\nIMPAR");
}
	
	
7.1.3	Decisão de múltiplos blocos (if...else if...)
Muitas vezes, nossos programas poderão envolver várias condições excludentes. Programas que envolvem faixas salariais ou faixas de idades são exemplos clássicos do uso da instrução if ... else if ... .
Sintaxe: Decisão de múltiplos blocos:
	if(condição 1)
{
 bloco 1
}
...
else if(condição N)
{
 bloco N
}
else
{
 bloco P
 }
onde:	condição 1, condição 2, ... são expressões lógicas ou relacionais.
bloco 1 , bloco 2,... são conjuntos de instruções.
Se a condição 1 for verdadeira o bloco 1 é executado. Caso contrario, as condições serão avaliadas, sucessivamente até que seja verdadeira ou chegue ao último else, onde o bloco P seria executado. Observe que apenas um dos blocos é executado.
Exemplo
	#include <stdio.h>
main()
{ int a;
 printf("\nDigite numero: " );
 scanf("%d",&a);
 if(a<200)
 printf("\nNUMERO MENOR QUE 200");
 else if(a >500)
 printf("\nNUMERO MAIOR DO QUE 500");
 else
	printf("\nNUMERO NO INTERVALO 200-500");
}
	
	
	
7.2 	Estrutura switch...case
A estrutura switch...case, também conhecida como alternativa de múltiplas escolhas, é uma estrutura que simplifica nossos programas no uso de decisão de múltiplos blocos quando a expressão de controle( a condição) envolver tipos int ou char(de um caracter que também é considerada inteira). O resultado desta expressão é comparado ao valor de cada um dos rótulos, e os comandos são executadas a partir desderótulo. 
Sintaxe
	switch(expressão)
{
 case rótulo_1:
 bloco1;
 break;
 case rótulo_2:
 bloco2 
 break;
 ...
 case rótulo_n:
 bloco n
 break;
<default:
 bloco d>
 }
onde:
expressão é uma expressão inteira ou char de um caracter.
rótulo_1,rótulo_2,...rótulo_n e rótulo_d são constantes inteiras ou char de 
 um caracter.
	bloco 1, bloco 2, ..., bloco n e bloco d são conjuntos de instruções.
Execução:
A expressão é avaliada e o fluxo desviado para o conjunto cujo rótulo é igual ao resultado da expressão. O bloco abaixo do rótulo é executado. Se o valor da expressão não for igual a nenhum rótulo, o bloco do defualt é executado. Você não é obrigado a colocar o rótulo do default e por esta razão ele se encontra entre os sinais de menor e maior. 
Por que usar break?
Normalmente, em outras linguagens de programação, após a avaliação da expressão e a execução do bloco correspondente, o fluxo do programa passa para a pro'xima instrução, ignorando todos os outros rótulos. Na linguagem C isto não acontece e poderá trazer sérias conseqüências em seus programas. O uso do break forçará a saída do comando switch e a execução do próximo comando. 
Exemplo:
	#include <stdio.h>
#include <math.h>
main()
{ int op;
 float a;
 printf("\033[2J\033[30;47m");
 printf("\nDigite numero: " );
 scanf("%f",&a);
 printf("\nDigite Opcao: 1 dobro 2 metade 3 raiz cubica: " );
 scanf("%d",&op);
 switch(op)
 { case 1: printf("\nDOBRO: %f", a*2);
	 break;
 case 2: printf("\nMETADE: %f", a/2);
	 break;
 case 3: printf("\nRAIZ CUBICA: %f", pow(a,(1/3.0)));
	 break;
 default: printf("\nNAO PEDIU NADA");
 }
}
	
	
	
	
Existirá alguma situação que não será necessário usar break?
Sim.
	#include <stdio.h>
main()
{
 int t;
 for (t = 0; t < 10; t ++)
 switch (t)
 {
 case 1: printf("Preciso ");
 break;
 case 2: printf("estudar ");
 case 3:
 case 4: printf("muito ");
 printf("para poder passar\n");
 break;
 case 5:
 case 6:
 printf(" em Programcao II");
 break;
 case 7:
 case 8:
 case 9: printf("-");
 }
}
	
8. Estruturas de repetição 
Três são as estruturas de repetição disponíveis na linguagem C: for, while e do ... while. Em todas as estruturas estará presente pelo menos uma expressão para controlar a repetição.
8.1 Estrutura de repetição: for
A estrutura do for é a mais simples estrutura de repetição e é usada para repetir um ou vários comandos tantas vezes quanto desejarmos. É a estrutura mais indicada quando o número de repetições for conhecido embora, as outras duas estruturas também possam ser usadas. O controle do número de repetições, na maioria das vezes, é feito por uma variável chamada de variável contadora.
A estrutura do for na linguagem C é um pouco diferente das demais linguagens, pois a condição pode não se prender somente a uma variável contadora.
	Sintaxes
	for (inicialização;condição;incremento) declaração;
	for (inicialização ;condição ;incremento)
{
 bloco de comandos
}
onde:	inicialização é uma expressão de inicialização da variável contadora e só é 
 executada uma vez..
condição é uma expressão lógica de controle de repetição.
	incremento é uma expressão de incremento da variável contadora.
bloco de comandos é um conjunto de instruções a ser executado.
 
	Exemplos
	#include <stdio.h>
main()
{ int cont; for(cont=1;cont<=10;cont++)
 printf("%d ",cont);
}
	
	#include <stdio.h>
main()
{ int cont;
 for(cont=0;cont<50;cont+=2)
 printf("%d ",cont);
}
	
	#include <stdio.h>
#include <math.h>
main()
{ int cont;
 float num;
 for(cont=1;cont<=5;cont++)
 { printf("\nDigite numero: ");
 scanf("%f",&num);
 printf("Raiz quadrada: %.4f",sqrt(num));
 }
}
	
	#include <stdio.h>
main() 
 {
 int n=1;
 for(;n<10;printf("\nUNESA!"),n++ )
 printf("Informatica-Praca XI\n");
}
	
8.2 Estrutura de repetição: while
A estrutura while é uma estrutura "poderosa" da programação. Muitos programadores fazem uso somente desta estrutura. Ela testa primeiro a condição e poderá nem executar o bloco caso a condição seja falsa. Logo, a estrutura do while repete enquanto a condição for verdadeira.
Ë importante que a variável presente na condição tenha seu valor alterado dentro da repetição, pois, caso contrário, entrará em loop.
Normalmente, todos os autores mostram simplesmente a sintaxe da estrutura, mas esquecem de informar como na prática ela deverá ser escrita.
Abaixo, apresentarei a sintaxe geral e a sintaxe usada na prática:
	Sintaxe 
	
	Sintaxe na prática
	while(condição)
{
 bloco de comandos
}
	
	atribuição ou leitura da variável presente na condição
while(condição)
{
 bloco de comandos
 atribuição ou leitura da variável presente na condição
}
onde:	condição é uma expressão lógica ou numérica.
bloco de comandos é um conjunto de instruções.
	Exemplo
	#include <stdio.h>
main()
{ int num;
 printf("\nDigite numero positivo: ");
 scanf("%d",&num);
 while(num>0)
 { if(num%2==0)
 printf("\nPAR");
 else
 printf("\nIMPAR");
 printf("\nDigite numero positivo: ");
 scanf("%d",&num);
 }
}
	
 8.3	Estrutura de repetição: do...while
Esta estrutura é parecida com while. Sua diferença é que o bloco é executado pelo menos uma vez, pois testa ao final. Esta estrutura repete enquanto a condição for verdadeira.
Sintaxe
	do
{
 bloco de comandos
}
while(condição);
onde:	condição é uma expressão lógica ou numérica.
bloco de comandos é um conjunto de instruções.
Exemplo
	#include <stdio.h>
#include <ctype.h>
main()
{ float n1,n2,n3;
 char op;
 do
 { printf("\nMENU\n\nS somar dois numeros\nQ quadrado de um numero");
 printf("\nM multiplicar tres numeros\nF finalizar\nOPCAO: ");
 scanf("%c",&op);
 op=toupper(op);
 switch(op)
 {
	case 'S':
		 printf("\nDois numeros separados por virgulas: ");
		 scanf("%f %f",&n1,&n2);
		 printf("\nSoma: %f",n1+n2);
 break;
	case 'Q':
 printf("\nDigite numero: ");
		 scanf("%f",&n1);
		 printf("\nQuadrado: %f",n1*n1);
 break;
	case 'M':
 printf("\nDigite tres numeros separados por espacos: ");
		 scanf("%f %f %f",&n1,&n2,&n3);
		 printf("\nProduto: %f",n1*n2*n3);
 break;
 case 'F': 
 printf("\nSAINDO");
 break;
	default:printf("\nOPCAO INEXISTENTE");
 }
 fgetc(stdin);
 }
 while(op!='F');
}
	
   8.4 Comandos associados
As estruturas de repetição podem, mas não devem, sofrer desvios e interrupções em sua seqüência normal.
8.4.1 break
Assim como o foi usado para interromper o comando switch, poderá ser usado com qualquer um dos três comandos de repetição.
continue
O comando continue pode ser visto como sendo o oposto do break. Ele só funciona dentro de um loop. Quando o comando continue é encontrado, o loop pula para a próxima iteração, sem o abandono do loop, ao contrário do que acontece no comando break.
O exemplo abaixo mostra a eficiência deste comando, pois, logo depois que o teste for executado e se não for encontrado o espaço, a variável a é incrementada e testada.
	#include <stdio.h>
#include <string.h>
main()
{ int a,cont=0;
 char nome[30];
 printf("\nNome:");
 fgets(nome,30,stdin);
 for(a=0;a<strlen(nome)-1;a++)
 { if(nome[a]!=' ')continue;
 cont++;}
 printf("\nTotal de partes do nome: %d\n",cont+1);
}
	
9 Estruturas
As estruturas em C podem ser homogêneas e heterogêneas. Inicialmente, vamos abordar as homogêneas, pois são mais familiares uma vez que conhecemos seu conceito da matemática quando estudamos matrizes.
9.1 Estruturas homogêneas
Em C, o uso de matrizes é de fundamental importância e existe uma relacionamento estreito entre matrizes e ponteiros que estudaremos mais adiante.
A grande novidade que estudaremos será o uso de matrizes com estruturas heterogêneas.
As matrizes são tabelas na MP e podem ter uma ou mais dimensão. Quando tem somente uma dimensão, também chamamos de vetor.
Na linguagem C, como já vimos, uma variável char ,que precisa armazenar mais de um caracter, faz uso de matriz, pois podemos acessar cada um de seus caracteres em separado, usando o nome da variável e sua posição entre colchetes.
O exemplo abaixo que converte cada um dos caracteres para maiúscula exemplifica bem o que queremos demonstrar:
	#include <stdio.h>
#include <ctype.h>
main()
{ int a;
 char nome[30];
 printf("\nNome: "); fgets(nome,30,stdin);
 for(a=0;a<strlen(nome)-1;a++)
 nome[a]=toupper(nome[a]);
 printf("\nNome em maiusculas: %s\n",nome);
}
	
 Neste exemplo, você observou a função toupper que faz parte da biblioteca ctype.h. Esta função converte um caracter, desde que seja uma letra minúscula, para maiúscula.
Como a variável nome, chamada em outras linguagens de variável "string", é declarada na linguagem C como um vetor de variáveis do tipo char, pudemos acessar cada caracter do conjunto e convertê-lo, quando possível.
Você já imaginou se esta função não existisse? Observe a linha abaixo e verifique se obteríamos o mesmo resultado:
	if(nome[a] >= 'a' && nome[a] <= 'z') nome[a] = nome[a] - 32;
 
	
Por que será que na linguagem C a posição do primeiro caracter é 0 ?
O endereço guardado é o do primeiro caracter que chamamos de base, logo qualquer outro caracter será acessado pelo endereço base mais sua posição. Se o endereço é o da primeira posição, somente o 0 poderia ser acrescido para permanecer na mesma posição.
Se declararmos pal com tamanho 5, lembre-se de que só podemos usar 4 posições, pois uma reservada para o finalizador \0 que indica o fim do vetor.
É bom você já ir se acostumando com este conceito de apontamento, pois para se programar bem em C, precisaremos dominar o conceito de ponteiros.
9.1.1 Declarando uma matriz:
 tipo nome do conjunto [ ... ] [ ...] ... ; 
Exemplos:
/* declara uma matriz unidimensional de 5 elementos inteiros */
 int num[ 5 ]; 
/* declara uma matriz bidimensional com 100 linhas e 4 colunas do tipo float */
 float notas [ 100 ][ 4 ]; 
/* declara uma matriz bidimensional com 100 linhas e 30 colunas do tipo char */
 char nomes [ 100 ][ 30 ]; 
 Toda matriz para guardar nomes, na linguagem C, é bidimensional, pois o primeiro índice indica a quantidade de nomes e o segundo o número de caracteres –1 que serão armazenados em cada nome.
9.1.2 Armazenamento
O armazenamento na matriz poderá ser feito através de um comando de leitura ou de atribuição.
9.1.2.1 Leitura
	#include <stdio.h>
main()
{ int num[5],a;
 for(a=0;a<5;a++)
 { printf("\nNumero %d: ",a+1); scanf("%d",&num[a]);}
 printf("\n\n\nNumeros armazenados\n\n");
 for(a=0;a<5;a++)
 printf("\n%d",num[a]);
 printf("\n");
}
	
	#include <stdio.h>
main()
{ int num[3][3],L,c;
 for(L=0;L<3;L++)
 for(c=0;c<3;c++)
 { printf("Numero da linha %d coluna %d: ",L+1,c+1);
 scanf("%d",&num[L][c]);
 }
 printf("\n\n\nNumeros armazenados\n\n");
 for(L=0;L<3;L++)
 { for(c=0;c<3;c++)
 printf("%d\t",num[L][c]);
 printf("\n");
 }
 printf("\n");
}
	
 
9.1.2.2 Atribuição
Podemos também inicializar as matrizes através de atribuições:
Exemplos:
int vet[4]={6,7,8,9};
float nota[3]={8.5,6.2,9.8};
char nome[12]="João Renato";
char nomes[4][30]={"JOÃO", "MARIA", "PEDRO","FILIPE"};
int mat[][3]={1,2,3,4,5,6,7,8,9};
/* na declaração/atribuição acima, é assumido 3 como número de linhas */
	#include <stdio.h>
main()
{ int L,c;
 int dias_meses[][13]={0,31,28,31,30,31,30,31,31,30,31,30,31, 0,31,
 29,31,30,31,30,31,31,30,31,30,31};
 printf("\n\nPara anos nao bissextos, primeira linha e para bissextos, segunda linha\n\n");
 for(L=0;L<2;L++)
 { for(c=1;c<13;c++)
 printf("%6d", dias_meses[L][c]);
 printf("\n");
 }
 printf("\n");
}
	
9.1.3 Operações
Em relação às matrizes numéricas, podemos realizar todas as operações que já conhecemos com matrizes: produto escalar, soma, subtração, multiplicação por escalar, multiplicação de matrizes, cálculo do determinante, etc.
 9.1.4 Ordenação 
Vários são os métodos de ordenação. Alguns são mais eficientes e mais complicados e outros menos eficientes para um grande conjunto de dados, porém mais simples.
Para que possamos ordenar nomes, precisaremos conhecer duas funções que fazem parte da biblioteca string.h:
Função strcmp
Esta função tem dois argumentos do tipo vetor de char(ou cadeia de caracteres).
Os argumentos são comparados e é devolvido um dos resultados:
… strcmp(arg1,arg2)…
0 – se os dois argumentos forem iguais.
número > 0 - se o primeiro argumento vier na ordem alfabética depois do segundo.
número < 0 - se o primeiro argumento vier na ordem alfabética antes do segundo.
Observação: Você deve estar estranhando a necessidade desta função, mas na linguagem C, como já falamos a variável vetor de char é um endereço, e não tem sentido comparamos endereços. É, portanto, expressamente proibido usar operadores relacionais para comparar este tipo de variável.
Função strcpy
Esta função tem dois argumentos: o primeiro é o destino e o segundo, a origem. Copia a origem no destino.
strcpy(arg1,arg2);
Observação: É, portanto, expressamente proibido usar comando de atribuição este tipo de variável.
Exemplo 1: Ordenação por Seleção 
	#include <stdio.h>
#include <string.h>
#include <ctype.h>
main()
{ char nome[5][30], aux[30];
 int l,c,min;
 for(l=0;l<5;l++)
 { printf("digite nome %d: ",l+1);
 fgets(nome[l],30,stdin);
 for(c=0;c<strlen(nome[l]);c++ )
 nome[l][c]=toupper(nome[l][c]);
 }
 for(l=0;l<4;l++)
 { min=l;
 for(c=l+1;c<5;c++)
	if(strcmp(nome[c],nome[min])<0)
	 min=c;
strcpy(aux,nome[l]);
strcpy(nome[l],nome[min]);
strcpy(nome[min],aux);
 }
 printf("\n\nRelacao dos nomes ordenados\n\n");
	for(l=0;l<5;l++)
	printf("%2d-%s",l+1,nome[l]);
 printf("\n");
}
	
Exemplo 2: Ordenação por Inserção
	#include <stdio.h>
 main()
{ int num[5],l,c,d,n;
 for( l = 0 ; l < 5; l++)
 { printf("\nnumero %d: ",l + 1);
 scanf("%d",&n);
 c=0;
 while( n >= num[c] && c<l)
 c ++;
 if(l!=0)
 for (d= l; d >= c+1; d--)
 num[d] = num[d-1] ;
 num[c] = n ;
 }
 printf("\n\nVetor Ordenado\n");
 for(l=0;l<5;l++)
 { printf("\n%d",num[l]);}
 printf("\n");
}
	
9.1.4 Pesquisa
9.1.4.1 Seqüencial
Este método é o mais simples, pois começa no primeiro elemento só para quando encontra ou chega ao final.
	#include <stdio.h>
 main()
{ int mat[5],l,n_mat,pos,achou;
 for( l = 0 ; l < 5; l++)
 { printf("\nEntre com a %d matricula: ",l + 1);
 scanf("%d",&mat[l]);
 }
 printf("\nQual a matricula a ser procurada? ");
 scanf("%d",&n_mat);
 achou=0;
 for(l=0;l<5 && achou==0;l++)
 { if(n_mat!=mat[l])continue;
 achou=1; pos=l;
 }
 if(achou==1)
 printf("\nMatricula achada na posicao: %d",pos+1);else
 printf("\nMatricula nao achada");
 printf("\n");
}
	
 
9.1.4.2 Binária
Este método será mais eficiente se o conjunto estiver ordenado.
Baseia-se em reduzir o espaço a ser pesquisado.
1. Inicialmente, aponta-se para o centro da tabela. Como se faz isto?
 Suponha um vetor de 8 elementos:
 centro = (0 + 7) /2; /* valor 3 */ 
2. Depois, perguntamos se o elemento pesquisado é igual ao que está sendo apontado. Se não for, continua-se com a pesquisa.
3. Se continuarmos com a pesquisa, verificamos se o elemento pesquisado é maior(menor) do o que está sendo apontado.
4. Se for, calculamos o novo centro:
 
 centro = (posição do apontador +1 +7) /2; 
 Se não for:
 centro = (0 + posição do apontador -1) /2; 
5. E assim, sucessivamente até acharmos, ou não.
	#include <stdio.h>
#include <string.h>
#include <ctype.h>
#define N 5
main()
{ int L,c,inicio,fim,meio; char vet[N][30],auxs[30],lixo[100];
 for(L=0;L<N;L++)
 { printf("\nDigite elemento %d : ",L+1);
 fgets(auxs,30,stdin);
 if(strlen(auxs)==29)
 { fgets(lixo,100,stdin);auxs[28]='\n';}
 strcpy(vet[L],auxs); 
 for(c=0;c<strlen(vet[L]);c++)
 vet[L][c]=toupper(vet[L][c]);
 }
 /*ORDENA*/
 for(L=0;L<N-1;L++)
 { char aux[30];int pos;
 for(pos=L,c=L+1;c<N;c++)
 if(strcmp(vet[pos],vet[c])>0)
 pos=c;
 strcpy(aux,vet[L]);
 strcpy(vet[L],vet[pos]);
 strcpy(vet[pos],aux);
 } 
 printf("\n\n\nVETOR CARACTER ORDENADO\n\n");
 for(L=0;L<N;L++)
 printf("%s",vet[L]);
 /*PESQUISA BINARIA*/
 do
 { 
 printf("\nDigite nome de procura ou FIM para terminar: ");
 fgets(auxs,30,stdin);
 for(c=0;c<strlen(auxs);c++)
 auxs[c]=toupper(auxs[c]);
 inicio=0;fim=N-1;
 do 
 { meio=(inicio+fim)/2; 
 if(strcmp(vet[meio],auxs)<0)
 inicio=meio+1;
 else 
 fim=meio-1; 
 }
 while((inicio<=fim) && (strcmp(vet[meio],auxs)!=0));
 if(strcmp(vet[meio],auxs)==0)
 printf("\nNome encontrado na posicao: %d\n",meio+1);
 else if(strcmp(auxs,"FIM\n")!=0) 
 printf("\nNome nao encontrado\n");
 }
 while(strcmp(auxs,"FIM\n")!=0);
 printf("\n\n");
} 
 
	
 
9.2 Estrutura heterogênea (struct)
Uma estrutura(struct) é, na verdade, um conjunto de variáveis que podem ter tipos diferentes.
Suponha que você deseje armazenar nome, e duas notas de um aluno. Se você usar variáveis simples, precisará declarar três variáveis simples e, para que fiquem claras que existe uma relação entre elas, precisamos nomeá-las de uma forma que nos faça entender que elas se relacionam. Usando struct fica mais claro o relacionamento entre elas.
Suponha também que você deseje armazenar nome, e duas notas de três alunos. Se você usar matrizes, precisará declarar uma matriz para guardar os nomes e uma matriz bidimensional para guardar as notas(pode ser também duas matrizes unidmensionais). Se você usar uma matriz de struct, será necessária somente uma matriz.
As variáveis de um struct são chamadas de campos ou membros.
Normalmente, costumamos associar um nome à estrutura para que possamos definir novos tipos.
 9.2.1 Declarando um struct 
 sintaxe 1
	struct 
{ tipo da variável 1 nome da variável 1;
 tipo da variável 2 nome da variável 2;
 tipo da variável n nome da variável n;
}nome do struct1, nome do struct2;
 
 sintaxe 2
	struct nome da estrutura
{ tipo da variável 1 nome da variável 1;
 tipo da variável 2 nome da variável 2;
 tipo da variável n nome da variável n;
};
struct nome da estrutura nome do struct1, nome do struct2;
/* ao fazermos esta declaração, dizemos que os dois structs são do tipo nome da estrutura*/
9.2.2 fazendo referência a um membro um struct
	nome do struct. nome do membro -> struct simples
Exemplos:
scanf("%d",&dados.idade);
printf("\n%d", dados.idade);
	nome do struct[posição]. nome do membro -> matriz de struct
Exemplos:
scanf("%d",&cad[3].idade);
printf("\n%d", cad[3].idade);
Exemplo 1:
Guardar nome e duas notas de um aluno e imprimir a média e o nome.
	#include <stdio.h>
main()
{
 struct 
 { char nome[30];
 float nota1,nota2;
 }aluno;
 char c;
 printf("\nNome : "); fgets(aluno.nome,30,stdin);
 printf("\nNota 1: "); scanf("%f",&aluno.nota1);
 printf("\nNota 2: "); scanf("%f",&aluno.nota2); 
 printf("\nMedia: %.1f",(aluno.nota1+aluno.nota2)/2);
 printf("\t%s",aluno.nome);
}
	
Exemplo 2:
Guardar nome e duas notas de três alunos e imprimir a média e o nome.
	#include <stdio.h>
main()
{ char c;int a;
 struct Cadastro
 { char nome[30];
 float nota1,nota2;
 };
 struct Cadastro aluno[3];
 for(a=0;a<3;a++)
 { printf("\nNome : ");fgets(aluno[a].nome,30,stdin);
 printf("\nNota 1: "); scanf("%f",&aluno[a].nota1);
 printf("\nNota 2: "); scanf("%f",&aluno[a].nota2); fgetc(stdin);
 }
 printf("\n\nMedia\tNome\n\n");
 for(a=0;a<3;a++)
 {printf("\n%.1f",(aluno[a].nota1+aluno[a].nota2)/2);
 printf("\t%s",aluno[a].nome);
 } 
 fgetc(stdin);scanf("%c",&c);
 }
	
Observação: Nos exemplos abaixo, você verá uma das maiores vantagens de se usar uma matriz de struct, pois quando precisarmos ordenar, não teremos que fazer muitos trechos de troca. A grande vantagem é que podemos trocar de lugar todo o struct. Observe que foi criada uma estrutura de nome aux para poder fazer a troca.
Exemplo 3: Faça um programa usando matriz de estruturas para armazenar matricula e idade de 5 alunos. Ordene pela matrícula e liste.
	#include <stdio.h>
 main()
{ struct CAD
 { int mat, idade;}aluno[5],aux;
 int l,c;
 for(c=0;c<5;c++)
 {printf("\nMatricula %d: ", c+1);scanf(%d",&aluno[c].mat);
 printf("Idade: "); scanf(%d",&aluno[c].idade);
 }
 /* ORDENACAO */
 for(l=0;l<4;l++)
 for(c=l+1;c<5;c++)
 if(aluno[l].mat>aluno[c].mat)
 {aux=aluno[l]; aluno[l]=aluno[c];aluno[c]=aux;}
 printf("\n\n\n\nMatr.\tIdade\n\n");
 for(c=0;c<5;c++)
 printf("\n%4d\t%2d",aluno[c].mat,aluno[c].idade);
 printf("\n\n\n");
}
	
Exemplo 4: A federação de vôlei do Rio de Janeiro gostaria de fazer um programa que pudesse armazenar: nome dos 10 times que participaram do campeonato, número de vitórias, número de derrotas e nome do técnico. Faça um programa usando matriz heterogênea que possa entrar com todos os dados citados, ordene pelo número de vitórias e imprima a listagem ordenada, contendo a classificação final, isto é, 1o lugar, 2o lugar, ..., 10o lugar. 
	#include <stdio.h>
main()
{ struct FVRJ 
 { char nomeTime[40],nomeTecnico[40];
 int vitorias,derrotas;
 }times[10],aux; 
 int l,c; 
 for(c=0;c<10;c++) 
 {printf("\nNome do time %d: ", c+1); 
 fgets(times[c].nomeTime,40,stdin);
 printf("\nNome do tecnico %d: ", c+1); 
 fgets(times[c].nomeTecnico,40,stdin);
 printf("\nTotal de vitorias: ");
 scanf("%d",&times[c].vitorias); 
 printf("\nTotal de derrotas: ");
 scanf("%d",&times[c].derrotas); 
 fgetc(stdin);
 } 
 /* ORDENACAO */ 
 for(l=0;l <9;l++) 
 for(c=l+1;c<10;c++) 
 if(times[l].vitorias<times[c].vitorias) 
 {aux=times[l]; times[l]=times[c];times[c]=aux;} 
 printf("\n\n\n\nClassificao\tTime\n\n"); 
 for(c=0;c<10;c++) 
 printf("\n%2do lugar \t%s",c+1,times[c].nomeTime); 
 printf("\n\n\n");
}
9.2.3 Declarando ou definindo
A principal diferença é que quando se declara, não se aloca espaçona MP e quando se define, sim. 
9.2.4 Embutindo a definição na declaração
Veja exemplo abaixo:
	struct Notas
{float n1,n2,media;}
struct 
{ char nome[3];
 struct notas notasAluno;
}Auno;
Observação: No primeiro, estamos associando uma etiqueta(nome) ao struct: Notas. Estamos definindo um novo tipo de dado.
No segundo, estamos declarando um struct de nome Aluno que tem embutindo uma definição na declaração.
Quando precisarmos nos referenciar à variável n1, por exemplo:
	 .... Aluno.notasAluno.n1
Exemplo 5:
#include <stdio.h>
main()
{ struct Notas
 {float n1,n2,media;};
 struct 
 { char nome[30];
 struct Notas notasAluno;
 }Aluno;
 char c;
 printf("\nNome : "); fgets(Aluno.nome,30,stdin);
 printf("\nNota 1: "); scanf("%f",&Aluno.notasAluno.n1);
 printf("\nNota 2: "); scanf("%f",&Aluno.notasAluno.n2); 
 Aluno.notasAluno.media=(Aluno.notasAluno.n1+Aluno.notasAluno.n2)/2;
 printf("\nMedia: %.1f",Aluno.notasAluno.media);
 printf("\t%s",Aluno.nome);
}
10 Funções
 
 10.1 Conceito
Função é um trecho de programa com atribuições específicas, simplificando o entendimento do programa, proporcionando ao programa menores chances de erro e de complexidade. 
A linguagem C é formada de várias funções.
10.2 Vantagens
As funções através da passagem de parâmetros e através do seu nome permitem que sejam retornados valores à rotina chamadora e desta forma, esses valores poderão ser impressos, atribuídos a uma variável ou podem servir em operações aritméticas entre outras. 
 Os principais objetivos de uma função são:	
Dividir e estruturar um algoritmo em partes logicamente coerentes;
Facilidade em testar os trechos em separados;
O programador poderá criar sua própria biblioteca de funções, tornando sua programação mais eficiente uma vez que poderá fazer uso de funções por ele escritas em vários outros programas com a vantagem de já terem sido testadas;
Maior aumentar a legibilidade de um programa;
Evitar que uma certa seqüência de comandos necessária em vários locais de um programa tenha que ser escrita repetidamente nestes locais, diminuindo também, o código fonte, ;
Tudo isto justifica o uso de funções em nossos programas
10.3. Funções Pré-definidas
O conjunto de funções pré-definidas é muito extenso e aqui vamos estudar algumas funções das bibliotecas: math.h, ctype.h, string.h e stdlib.h.
Quando estudamos uma função, temos vários parâmetros a observar. Veja, por exemplo a seguinte função pré-definida da biblioteca math.h:
double sqrt(double x)
Este é o protótipo da função, isto é, informações sobre o tipo de retorno da função e tipos dos parâmetros.
Esta função retorna um valor double, seu nome é sqrt e o tipo da variável que recebe o valor passado é double.
Quando você criar suas funções, elas precisarão ter uma declaração semelhante a esta.
As funções poderão ser localizadas antes da função principal(main) ou depois. Se uma função for declarada antes, o protótipo da função não precisará ser declarado na função main, mas se declarada depois, o protótipo precisará ser declarado na função main. 
Declaração de uma função:
	tipo
	identificador
	(lista de parâmetros)
	int, float, char, void
	Nome da função 
	( tipo1 nome1, tipo2 nome2 )
Exemplos:
int quadrado(int l)
char maiuscula(char n[] )
10.3.1 Funções Numéricas 
Biblioteca: math.h
	#include <stdio.h>
#include <math.h>
#define PI (3.14159265)
main()
{ float f;
 printf("\nFUNCOES NUMERICAS\n");
 printf("\nDigite numero real: ");
 scanf("%f",&f);
 printf("\nNumero: %f",f);
 printf("\nABSOLUTO: %f",fabs(f));
 printf("\nCEIL: %f",ceil(f));
 printf("\nFLOOR: %f",floor(f));
 printf("\nTRUNC: %f",trunc(f));
 printf("\nROUND: %ld",lround(f));
 printf("\nFMOD: %.f",fmod(f,3));
 printf("\nSQRT: %.f",sqrt(f+0.5));
 printf("\nSeno de 30: %.2f",sin(30*PI/180));
 printf("\nCo-seno de 30: %.2f",cos(30*PI/180));
 printf("\nTangente de 30: %.2f",tan(30*PI/180));
 printf("\nPotencia de 2 elevado a 3: %f",pow(2,3));
 printf("\nLogaritmo de 8 na base neperiana: %.3f",log(8));
 printf("\nLogaritmo de 8 na base 10: %.3f",log10(8));
 printf("\nLogaritmo 8 na base 2: %.3f",log(8)/log(2));
 printf("\nRaiz cubica de 8: %.3f",exp(1./3*log(8)));
 printf("\n\n");
}
	
10.3.2 Funções que Convertem strings em números 
Biblioteca: stdlib.h
	#include <stdio.h>
#include <stdlib.h>
main()
{ char s[30];
 printf("\nFUNCOES CHAR-NUMER0\n");
 printf("\nDigite numero real: ");
 scanf("%s",&s);
 printf("\nNumero: %f",atof(s));
 printf("\nDigite numero inteiro: ");
 scanf("%s",&s);
 printf("\nNumero: %d",atoi(s));
 printf("\nABSOLUTO: %d",abs(atoi(s)));
 printf("\n\n");
}
	
	
10.3.3 Funções Strings 
Biblioteca: string.h/ctype.h
	#include <stdio.h>
#include <string.h>
#include <ctype.h>
main()
{char c,s1[40],s2[30];
 printf("\nBIBLIOTECA ctype.h\n");
 printf("\nLetra: ");
 scanf("%c",&c);fgetc(stdin);
 if(islower(c))
 printf("\nConvertida para maiuscula: %c",toupper(c));
 else
 printf("\nConvertida para minuscula: %c",tolower(c));
 printf("\n\nBIBLIOTECA string.h\n");
 printf("\nPalavra 1: "); fgets(s1,30,stdin);s1[strlen(s1)-1]='\0';
 printf("\nPalavra 2: "); fgets(s2,30,stdin);s2[strlen(s2)-1]='\0';
 strcat(s1,"FIM");
 printf("\n\nConcatenacao: %s",s1);
 strcpy(s1,s2);
 printf("\n\nApos copia de toda palavra2: %s",s1);
 printf("\n\nTamanho de s2: %d",strlen(s2));
 printf("\n\nComparando strings\n");
 printf("\nDigite PAZ: "); fgets(s1,30,stdin);
 printf("\nDigite PAZ: "); fgets(s2,30,stdin);
 if(strcmp(s1,s2)==0)
 printf("\nIGUAIS");
 else
 printf("\nDiferentes"); 
 printf("\nDigite PAZ: "); fgets(s1,30,stdin);
 printf("\nDigite AMOR: "); fgets(s2,30,stdin);
 if(strcmp(s1,s2))/*equivale a strcmp(s1,s2)!=0 */
 printf("\nDIFERENTES");
 else
 printf("\nIguais");
 printf("\n");system("PAUSE");
}
	
10.4. Diretiva #define
Define um identificador e um conteúdo que irá ser substituído toda vez que o identificador aparecer em um programa.
Esta diretiva pode ser associada a uma string ou a uma macro semelhante a uma função.
Se o tamanho da macro for pequena, substitui com vantagens o uso de funções.
Exemplo 1:
	#include <stdio.h>
#include <math.h>
#define quadrado(x) ((x)*(x))
#define pi (3.14159265)
#define NP (2.71828182846)
#define conv(x) ((x)*(pi)/(180))
main()
{ 
 printf("\nnumero: 12" );
 printf("\n\nquadrado= %d", quadrado(12));
 printf("\n\nangulo: 30" );
 printf("\n\nseno de %.2f eh %4.2f",30.,sin(conv(30)));
 printf("\n\nneperiano %.11f",NP);
}
Exemplo 2:
	#include <stdio.h>
#define AREA(b,h) (b*h)
main()
{ float base,alt;
 printf("\nBASE: ");
 scanf("%f",&base);
 printf("\nALTURA: ");
 scanf("%f",&alt);
 printf("\nAREA: %.2f",AREA(base,alt));
 printf("\n");
}
Exemplo 3:
	#include <stdio.h>
#include <math.h>
#define HIPO(c1,c2) (sqrt(c1*c1+c2*c2))
main()
{ float cat1,cat2;
 printf("\nCATETO 1: ");
 scanf("%f",&cat1);
 printf("\nCATETO 2: ");
 scanf("%f",&cat2);
 printf("\nHIPOTENUSA: %.2f",HIPO(cat1,cat2));
 printf("\n");
}
Exemplo 4:
	#include <stdio.h>
#include <math.h>
#define POT(b,e) (exp(e*log(b)))
main()
{ int base, expoente;
 printf("\nBase: ");
 scanf("%d",&base);
 printf("\nexpoente: ");
 scanf("%d",&expoente);
 printf("\nPotencia: %.2f",POT(base,expoente));
 printf("\n");
}
10.5 Chamada da função
	
Não devemos ficar preocupados como isso irá acontecer, pois já fizemos uso de vários funções internas(funções do tradutor) e, da mesma forma, chamaremosas funções feitas por nós.
Quando uma função é chamada, o fluxo de controle é desviado para a função, no momento em que ela é ativada no algoritmo principal. Ao terminar a execução dos comandos da função, o fluxo de controle retorna ao comando seguinte àquele onde ela foi ativada, exatamente como na figura abaixo:
	main()
	
	funcao1( ...)
{ ...
 retorna(...);
}
	{...
	
	
	...
	
	
	< chamada da função 1 >
	
	...
	...
	}
10.6 Estrutura de uma função
Uma função é um bloco contendo início e fim, sendo identificada por um nome , pelo qual será referenciada em qualquer parte e em qualquer momento do programa. A função serve para executar tarefas menores como ler, calcular, determinar o maior/menor valor entre uma lista de valores, ordenar, converter para maiúsculas, entre outras.
Após executar estas tarefas menores, a função retorna, ou não, um determinado valor para a função chamadora.
Quando a função não retornar nada(nulo) usaremos o tipo void, pois é sugerido pelo comitê de padronização ANSI. 
Dentro da função, podem ser declaradas variáveis que chamamos de variáveis locais, pois só são visíveis dentro da função.
Sintaxe da função:
	<tipo de função> nome_da_função (declarações dos parâmetros) 
	{
	 ( declaração das variáveis locais(
	
	comandos que formam o corpo da funcao 
	
	 return(( valor () ; /* ou return; ou nada */
	}
	tipo de função 
	: 
	tipo de dado que a função dará retorno. Pode ser int, float, charou void
	nome da função 
	:
	segue as mesmas regras de declaração de variáveis 
	parâmetros 
	: 
	nomes das variáveis, seguem as mesmas regras de declaração de variáveis
	declarações dos parâmetros
	:
	declarações de variáveis da função(tipo e nome)
	{
	:
	início da função 
	variáveis locais 
	:
	declarações de variáveis que serão utilizadas dentro da função( tipo e nome)
	corpo da função 
	:
	seqüência de comandos 
	return( .. ) 
	:
	o que vai ser retornado para o algoritmo ou não existe
	} 
	:
	fim da função
10.7. Localização das funções
Nós adotaremos após a função principal, mas elas poderão ser colocadas antes da função principal(main).
	main()
{ protótipo da funcao1; protótipo da funcao2; protótipo da funcao3;
...
}
	funcao1(...)
{...
}
	funcao2(...)
{...
}
	funcao3(...)
{...
}
10.8. Dividindo o programa em funções
Nós podemos modularizar nossos programas para que possamos deixá-lo mais claro. Se as funções manipulam as mesmas variáveis, deveremos declará-las com variáveis globais, isto é, fora de todas as funções.
10.9 Tipos de Funções
10.9.1 Funções void ( não retornam nada)
Este tipo de função não tem nenhum dado de retorno para a função principal. Ela executa o trecho e retorna para a função seguinte da sua chamada. A função pode não ter parâmetros e ser do tipo void, também.
Exemplo:
	#include <stdio.h>
main()
{void linha();/*prototipo da função(tipo de retorno, nome e (argumentos) */
 printf("\nUNESA\n");
 linha();
 printf("\nINFORMATICA - 2 PERIODO\n");
 linha();
 printf("\nPROGRAMACAO II\n");
 linha();
 printf("\nPROF. ANITA LOPES\n");
 linha();
 printf("\n");
}
void linha()
{int a;
 for(a=1;a<=50;a++)
 printf("*");
}
10.9.2 Funções com passagem de valor 
A linguagem C passa os valores para funções através de argumentos das chamadas das funções para os parâmetros das funções, na verdade variáveis que receberão cópias dos dados. Desta maneira, os dados de origem não são alterados.
Uma boa dica: Suponha que você comprou um livro e descobriu alguns erros. Você corrige no seu livro, mas não altera o original que, enquanto o autor não corrigir, os erros permanecerão.
A única exceção é para as matrizes, uma vez que já falamos que matrizes são ponteiros para o primeiro elemento da matriz.
Exemplo 1: Função linha com asteriscos
	#include <stdio.h>
#include <stdlib.h>/*soh no Windows*/
main()
{void linha(int x);
/*prototipo da função(tipo de retorno, nome e (argumentos) */ 
 printf("\nUNESA\n"); 
 linha(5); 
 printf("\nINFORMATICA - 2 PERIODO\n"); 
 linha(23); 
 printf("\nPROGRAMACAO II\n"); 
 linha(14); 
 printf("\nPROF. ANITA LOPES\n"); 
 linha(17); 
 printf("\n");
 system("pause");/*soh no Windows*/
}
void linha(int x)
{int a; 
for(a=1;a<=x;a++) 
printf("*");
}
Exemplo 2: Função linha com número variado de asteriscos
	#include <stdio.h>
#include <stdlib.h>/*soh no Windows*/
main()
{void linha(int x, char c);
/*prototipo da função(tipo de retorno, nome e (argumentos) */ 
 printf("\nUNESA\n"); 
 linha(5); 
 printf("\nINFORMATICA - 2 PERIODO\n"); 
 linha(23); 
 printf("\nPROGRAMACAO II\n"); 
 linha(14); 
 printf("\nPROF. ANITA LOPES\n"); 
 linha(17); 
 printf("\n");
 system("pause");/*soh no Windows*/
}
void linha(int x)
{int a; 
for(a=1;a<=x;a++) 
printf("*");
}
Exemplo 3: Função linha com número variado de qualquer caracter
	#include <stdio.h>
#include <stdlib.h>/*soh no Windows*/
main()
{void linha(int x,char c);
/*prototipo da função(tipo de retorno, nome e (argumentos) */ 
 printf("\nUNESA\n"); 
 linha(5,'#'); 
 printf("\nINFORMATICA - 2 PERIODO\n"); 
 linha(23,'*'); 
 printf("\nPROGRAMACAO II\n"); 
 linha(14,'@'); 
 printf("\nPROF. ANITA LOPES\n"); 
 linha(17,'='); 
 printf("\n");
 system("pause");/*soh no Windows*/
}
void linha(int x,char c)
{int a; 
for(a=1;a<=x;a++) 
printf("%c",c);
}
Exemplo 4: função PA.
	#include <stdio.h>
main()
{int PA(int x,int y,int z); /* prototipo da funcao */
 int a1,n,r;char c;
 printf("\nDigite primeiro termo, razao, numero de termos: ");
 scanf("%d%d%d",&a1,&r,&n);
 PA(a1,r,n);fgetc(stdin);
 scanf("%c",&c);
}
int PA(int x,int y,int z)
{int c;
 for(c=1;c<=z;c++)
 {printf("%d ",x);x+=y;} 
 return;
}
Exemplo 5: Função RAIZ.
	#include <stdio.h>
#include <math.h>
main()
{float RAIZ(float rad,int ind); /* prototipo da funcao */
 int I;float r;char c;
 printf("\nDigite radicando e �ndice ");
 scanf("%f%d",&r,&i);
 if(r>=0 && I>1)
 printf("\nRAIZ: %.3f",RAIZ(r,i));
 else if(I%2==1 && r<0)
 printf("\nRAIZ: -%.3f",RAIZ(fabs®,i)); 
 else printf("\nNAO POSSO FAZER\n");
 fgetc(stdin);
 scanf("%c",&c);
}
float RAIZ(float rad,int ind)
{ return(exp(1./ind*log(rad)));}
Exemplo 6: Função maiuscula
	#include <stdio.h>
#include <ctype.h>
#include <string.h>
main()
{char s[30],maiuscula(char n[]),c;
 printf("\nNOME: ");
 fgets(s,30,stdin);
maiuscula(s); printf("\nConvertida para MAIUSCULA: %s",s);
 scanf("%c",&c);
}
char maiuscula(char n[])
{int c;
 for(c=0;c<strlen(n);c++)
 n[c]=toupper(n[c]);
}
Exemplo 7: Função maiuscula/Troca/retira\n
	#include <stdio.h>
#include <string.h>
#include <ctype.h>
main()
{
 char n1[30], n2[30], n3[30],c;
 char troca1(char x[], char y[]), maiuscula(char n[]),verifica(char n[]);
 printf("\nDigite nome 1: ");
 fgets(n1,30,stdin); verifica(n1); maiuscula(n1);
 printf("\nDigite nome 2: ");
 fgets(n2,30,stdin); verifica(n2); maiuscula(n2);
 printf("\nDigite nome 3: ");
 fgets(n3,30,stdin); verifica(n3); maiuscula(n3);
 printf("\n\n\nANTES DA TROCA\n%s\n%s\n%s", n1,n2,n3);
 if(strcmp(n1,n2)>0)troca1(n1,n2);
 if(strcmp(n1,n3)>0)troca1(n1,n3);
 if( strcmp(n2,n3)>0 )troca1(n2,n3);
 printf("\n\n\nDEPOIS DA TROCA\n%s\n%s\n%s", n1,n2,n3);
 scanf("%c",&c);
 }
char troca1(char x[], char y[])
{ char aux[30];
 strcpy(aux,x);
 strcpy(x,y);
 strcpy(y,aux);
}
char verifica(char n[])