Você está na página 1de 12

main ( ) { lista de declaraes seqncia de comandos }

1. Variveis:
tipo lista_de_variveis; tipo nome_da_varivel = constante; ->inicializao da varivel Tipo Tamanho aproximado em bits Faixa mnima Char 8 -127 a 127 int 16 -32.767 a 32.767 float 32 Seis dgitos de preciso double 64 Dez dgitos de preciso

2. Constantes:
Caracter: envolvidas por apostrofe a, % Inteiras: 10, -100 Ponto flutuante: 11,123, 0,12E3 String: entre aspas a Caracter de barra invertida: Cdigo Significado \n nova linha ( LF) \t tabulao horizontal \ \' ' \0 Nulo \\ barra invertida

3. Vetores:
tipo nome_da_matriz [ tamanho]; - primeiro elemento nome_da_matriz [0] String: vetor de caracteres terminada por \0. Na declarao sempre usar um caracter a mais p/ o \0.

4. Matrizes:
tipo nome_da_matriz [nro_linhas] [ nro_colunas]; Inicializao de vetores e matrizes: tipo nome_da_matriz [tamanho1]...[tamanhoN] = {lista_de_valores};

5. Ponteiros:
so variveis que contm endereos a) Declarao: tipo * nome_do_ponteiro; b)Operador &: nome_do_ponteiro = &valor; -> nome_do_ponteiro recebe o endereo da varivel valor; c)Contedo armazenado endereado por ponteiro: valor_aux = * nome_do_ponteiro; -> valor_aux recebe o valor apontado pelo ponteiro * nome_do_ponteiro.

d)Inicializao: ponteiros podem ser inicializado com a constante NULL. e)Para acessar o primeiro endereo de um vetor: elem=valores[0]; ou elem = * valores;

6. Estruturas:
uma coleo de variveis, que podem ter tipos diferentes e que so referenciadas por um nome comum, fornecendo uma maneira conveniente de se ter informaes relacionadas agrupadas. struct <nome> { <tipo> <nome_da_variavel_1>; <tipo> <nome_da_variavel_2>; <tipo> <nome_da_variavel_3>; ... } <variveis estrutura>; Referenciando elementos de estruturas: <nome_da_variavel_estrutura>.<nome_do_elemento> Pode-se utilizar estruturas em matrizes: struct funcionario funcis [ 50]; -> declara um estrutura de variaveis com 50 posies; Declarando um ponteiro para estrutura: declara-se ponteiros para estruturas colocando um * aps o nome da estrutura (que identifica a definio da estrutura). Por exemplo: struct funcionario * pt_funci; int * pt, x; Usando ponteiros para estruturas: para que o ponteiro declarado aponte para uma estrutura, utiliza-se o operador &: pt_funci = & funcis [ 0]; pt = & x; Para acessar os elementos de uma estrutura usando um ponteiro, deve-se usar o operador -> ( sinal de menos seguido pelo de maior que). Por exemplo: gets ( pt_funci->nome); pt_funci->idade = 21; printf ( "%d", pt_funci->idade); printf ( "%s", pt_funci->end); printf ( %d, * pt) ***

7. Operadores:
Atribuio: nome_da_varivel = expresso; Aritimticos: Operador Ao subtrao, tambm + adio * multiplicao / diviso % resto -decremento ++ incremento Precedncia: Mais alta ++ -*/% Mais baixa +Verdadeiro e falso: verdadeiro qualquer valor diferente de zero Operadores relacionais:

Operador > >= < <= == != Operadores lgicos: Operador && || ! Precedncia: maior

Ao Maior que Maior ou Menor que Menor ou Igual Diferente Ao AND OR NOT

! > >= < <= == != && menor ||

8. Condicionais:
IF:
a) b) if ( expressao) comando; if ( expressao) comando; else comando; if ( expressao) { comando; comando}; else { comando; comando};

c)

IF/ELSE:
if ( expressao) comando; else if ( expressao) comando; else if ( expressao) comando; ... else comando;

SWITCH:
switch ( expressao) { case constante1: seqncia de comandos break;

case constante2: seqncia de comandos break; .. . default: seqncia de comandos }

9. Comandos de interao:
For:
for ( inicializao; condio; incremento) comando;

While:
while ( condio) comando;

Do While:
do { comando; } while ( condio);

10. Comando de desvio:


Break:
fora a terminao imediata do lao. O programa retorna ao comando seguinte ao lao. Se houver laos aninhados, um comando break provoca a sada apenas do lao mais interno.

Continue:
Trabalha semelhante ao break, s que, ao invs de forar a terminao, provoca a prxima iterao do lao, pulando qualquer cdigo intermedirio. No for, continue faz com que o teste condicional e o incremento do lao sejam executados. No while e do-while, o controle do programa passa para o teste condicional.

11. Funes:
so os blocos construcionais de C e o local onde toda a atividade do programa ocorre. [<tipo>] <nome_da_funcao> ( [<lista de parametros>]) { [< declaracao de variaveis locais; >] [< comandos; >] [< return ( valor); >] } Passagem de argumentos por valor e por referncia:

a) Por valor - esse mtodo copia o valor de um argumento no parmetro formal . Assim, alteraes feitas nos parmetros no tm efeito nas variveis usadas para cham-la. b) Por referncia - nesse, o endereo de um argumento copiado no parmetro. Dentro da funo, o endereo usado para acessar o argumento real. Assim, alteraes no parmetro afetam a varivel usada para chamar a rotina. Deve-se passar para a funo o endereo da varivel ( operador &) e esta deve receber o argumento num ponteiro do tipo apropriado. c) Chamando funes com matrizes: para passar matrizes para funes, deve-se usar, como argumento, o ponteiro para a matriz, ou seja, o seu identificador ( nome da matriz). A funo deve receber o argumento num ponteiro do tipo apropriado. d) Comando return: O comando return no obrigatrio. Se ele no aparecer na funo, ela retornar aps a execuo do seu ltimo comando. Da mesma forma, uma funo pode conter vrios comandos return. Obviamente, apenas um deles ser executado. e) Funes do tipo void: so funoes que no retornam valores. Apenas as funes que no so declaradas como void podem ser usadas como operando em qualquer expresso vlida de C. f) Funes que no devolvem valores inteiros: quando o tipo da funo no explicitamente declarado, o compilador C atribui automaticamente a ela o tipo padro, que int. No entanto, quando necessrio um tipo de dado diferente, o processo envolve dois passos: primeiro, deve ser dada funo um especificador de tipo explcito; segundo, o tipo da funo deve ser identificado antes da primeira chamada feita a ela. g) Prottipos de funes: uma declarao expandida da funo que abrange a quantidade e os tipos de argumentos que esta vai receber. Prottipos permitem que C fornea uma verificao mais forte de tipos. h) Funes que retornam ponteiros: so manipuladas da mesma forma que qualquer outro tipo de funo.

Exemplo de instrues:

1. Entrada de dados:
char aux [ 100]; ... printf ( "Entre com um numero: "); gets ( aux); -> entrada como string data = atoi ( aux); -> converso de string para int data = aux [ 0]; -> data recebe apenas um caracter data = atof ( aux); -> converso de string para float ou double vet [ i] = atoi ( aux); ->armazena o valor em um vetor gets ( func.nome); -> entrada de dados numa variavel estrutura char gets ( aux); func.idade = atoi ( aux); -> entrada de dados numa varivel estrutura int

2. Sada de dados na tela:


printf ( "\n"); -> linha em branco printf ( "O valor da variavel caracter e: %c\n", ch); printf ( "O valor da variavel inteira e: %d\n", i); printf ( "O valor da variavel float e: %f\n", real1); printf ( "O valor da variavel double e: %e\n", real2); printf ( "Divisao: %d\n", a / b); printf ( "Resto: %d\n", a % b); printf ( "\nO numero de negativos e: %d\n",cont_negativos); printf("\nDentro do intervalo [10,20]: %d, fora: %d\n",dentro, fora); printf("A media aritmetica e: %f\n", acumulador /nro_valores); -> ponto flutuante printf( Valor armazenado: %d \n, *ponteiro_valor); -> imprime o valor apontado por um ponteiro printf ( "%d", func_002.idade); -> imprime um valor de uma varivel estrutura printf ( "%s", func_003.end); -> imprime um string de uma varivel estrutura printf ( "%d", funcis [ 2].idade); ->imprime a posio 3 da variavel estrutura printf ( "\n %s %s %d \n", func_002.nome, func_002.end, func_002.idade); -> imprime variavel estrut. printf ( " %c ", func_001.nome [ i]); -> imprime variveis estrutura com indice printf ( "O numero de pessoas eh: %d, e o percentual eh: %f\n", cont_t, ( ( float) cont_t / cont_ind)); -> o detalhe deste comando que cont_t e cont_ind foram declaradas int e no float

3. Loop:
1) for ( x = 1; x <= 100; x ++) printf ( "%d ", x); for ( x = 1, y = 101; x != y; x ++); for ( x = 1; x <= 100; x ++) { y = x * x; printf ( "%d = %d / ", x, y); } x = 1; y = x * x;

2)

for ( ; x < 100 && y < 1000;) { printf ( " x = %d e y = %d | ", x, y); x ++; y = x * x; } 3) int n = 0; for ( ; ;) { if ( ++ n > 100) break; printf ( "%d ", n); }

4)

int n; for ( n = 1; n <= 100; n ++) { if ( n % 2) continue; printf ( "%d ", n); } 5) Faz uma pesquisa num vetor variaveis estrutura for ( i = 0; i < cont_ind; i ++) { if ( ( indvs [ i].sexo == 'm' || indvs [ i].sexo == 'M') && ( indvs [ i].idade >= 18 && indvs [ i].idade <= 30)) cont_m1830++; } 6) for ( i = 0; i < strlen ( func_001.nome); i ++) printf ( "%c", func_001.nome [ i]); -> imprime uma varivel estrutura caracter a caracter

4. Testes condicionais:
if ( media >= 7.5 && media < 9.0) conceito = 'B'; int cont_negativos = 0; if ( a < 0) cont_negativos ++;

for ( i = 0; i < 10; i ++) { printf ( "Entre com um numero: "); gets ( aux); a = atoi ( aux); if ( a >= 10 && a <= 20) dentro ++; else fora ++; }

While: 1) char ch; ch = 'a'; while ( ch != 'a') ch = getch ( ); char ch; ch = 'a'; while ( ch != 'a') { ch = getch ( ); printf ( "Foi teclado %c\n", ch); }

2)

3)

char ch; ch = 'a'; do { ch = getch ( ); printf ( "Foi teclado %c\n", ch); } while ( ch != 'a');

4) while com ponteiros char frase [ 255], * aux; printf ( "Entre com uma frase qualquer: "); gets ( frase); aux = frase; -> aux recebe o endereo inicial do vetor while ( * aux) printf ( "%c", * aux ++); -> imprime at que o valor do vetor for diferente de \0

5)

do { printf ( "Entre com o codigo........: "); gets ( aux); codigo_informado = atoi ( aux); if ( codigo_informado < 1 || codigo_informado > 3) break; printf ( "Entre com a quantidade....: "); gets ( aux); quantidade = atoi ( aux); switch ( codigo_informado) { case 1: prod [ 0].qtde = prod [ 0].qtde + quantidade; break; case 2: prod [ 1].qtde = prod [ 1].qtde + quantidade; break; case 3: prod [ 2].qtde = prod [ 2].qtde + quantidade; break; } } while ( 1);

5. Ponteiros:
... int valor, *ponteiro_valor, *ponteiro_novo; valor = 10; ponteiro_valor = &valor; -> ponteiro_valor recebe o endereo da varivel valor ponteiro_novo = ponteiro_valor; -> copia o valor de um ponteiro p/ outro; printf(Valor armazenado: %d \n, *ponteiro_novo); ... int *ponteiro, vetor_inteiros[4] = {0, 10, 20, 30}; ponteiro = &vetor_inteiros[0]; ->ponteiro recebe o endereo inicial do vetor ponteiro+= 2; /* igual a: ponteiro = &vetor_inteiros[2]; */ printf(Valor apontado: %d \n, *ponteiro); Alocao dinmica de elementos de um vetor: int tam, * pt_aux, * vet; int i; char aux [ 10]; printf ( "Entre com o numero de elementos do vetor: "); gets ( aux);

tam = atoi ( aux); vet = ( int *) malloc ( tam * sizeof ( int)); -> alocao dinmica de vetores ... free ( vet); ->liberar a memria no final da execuo Imprime a frase um caracter por vez at que aux seja igual a \0 char frase [ 255], * aux; printf ( "Entre com uma frase qualquer: "); gets ( frase); aux = frase; while ( * aux) printf ( "%c", * aux ++); Grava a frase no vetor str e imprime caracter a caracter do primeiro ao ultimo e invertido: int i, tam; char str [ 15]; strcpy ( str, "Este e o texto"); tam = strlen ( str); for ( i = 0; i < tam; i ++) { printf ( "%c", str [ i]); } for ( i = tam - 1; i >= 0; i --) { printf ( "%c", str [ i]); }

6. Estruturas:
1) struct funcionario { char nome [ 50]; char end [ 50]; int idade; } func_001; struct funcionario { char nome [ 50]; char end [ 50]; int idade; }; struct funcionario func;

2)

Estruturas com ponteiro: #define NRO_FUNCIS 3 int main(int argc, char **argv) { struct funcionario { char nome [ 50]; char end [ 50]; int idade; }; struct funcionario funcis [ NRO_FUNCIS]; struct funcionario * pt_funci; int i; char aux [ 10]; for ( i = 0; i < NRO_FUNCIS; i ++) {

printf ( "Nome, %d : ", i); gets ( funcis [ i].nome); printf ( "End, %d : ", i); gets ( funcis [ i].end); printf ( "Idade, %d : ", i); gets ( aux); funcis [ i].idade = atoi ( aux); } for ( i = 0; i < NRO_FUNCIS; i ++) { printf ( "%s\t", funcis [ i].nome); printf ( "%s\t", funcis [ i].end); printf ( "%d\n", funcis [ i].idade); } pt_funci = & funcis [ 1]; printf ( "%s\t", pt_funci->nome); printf ( "%s\t", pt_funci->end); printf ( "%d\n", pt_funci->idade); }

7. Funes:
1) Passagem de parametros atravs de variaveis int mul ( int, int); int -> declarao da variavel return mul ( int a, int b) { int res; res = a * b; return ( res); } int main( ) { int x = 10, y = 10; printf ( "O resultado eh: %d\n", mul ( x, y)); getch ( ); } float mul ( float, float); float mul ( float a, float b) { float res; res = a * b; return ( res); } int main( ) { float x = 10.0, y = 10.0; printf ( "O resultado eh: %f\n", mul ( x, y)); getch ( ); }

2) Passagem de parmetros atravs de ponteiros: int quadrado ( int *); int quadrado ( int * x) { * x = * x * * x; return ( * x); } int main( ) { int num = 5; printf ( "%d \n", quadrado ( & num)); printf ( "%d \n", num); -> o valor de num ser substituido pelo quadrado getch ( );

} Usando vetores e ponteiros para achar o maior valor: int maior ( int * vet, int pos); - > declarao da funo na rotina principal int main( ) { int vetor [ ] = { 112, 15, 25, 10, 9}; int pos = 5; printf ( "O maior valor do vetor eh: %d\n", maior ( vetor, pos)); -> chamada da funo getch ( ); } int -> tipo da funo maior (int vet [ ], int pos) -> tambm pode ser int * vet -> nome da funo e os parmetros { int maior, i; -> declarao de variveis internas da funo maior = vet [ 0]; for ( i = 1; i < pos; i ++) if ( vet [ i] > maior) maior = vet [ i]; return ( maior); } Usando strings: int tam_str ( char * str); int tam_str ( /* char * str */ char str [ ]) { int i; for ( i = 0; str [ i]; i ++); return ( i); } int main( ) { char string [ ] = "Testando"; printf ( "O tamanho da string eh: %d\n", tam_str ( string)); getch ( ); } Funo sem varivel de retorno: int eh_positivo ( int); int main( ) { int num = 10; if ( eh_positivo ( num)) printf ( "%d eh positivo\n", num); else printf ( "%d eh negativo\n", num); getch ( ); } int eh_positivo ( int x) { if ( x >= 0) return ( 1); else return ( 0); }

Retorno de uma funo usado numa expresso: int quadrado ( int); int quadrado ( int x) { x = x * x; return ( x); } int main( ) { int numa = 5, numb; numb = quadrado ( numa) + 1; printf ( "%d \n", numb); getch ( ); } Funo que retorna NULL: char * comeca_em ( char *, char); char * comeca_em ( char str [ ] /* char * str */, char c) { char * pt = str; for ( ; * pt; pt ++) if ( * pt == c) return ( pt); return ( NULL); } int main( ) { printf ( "Comecando pelo caracter %s\n", comeca_em ( "testando", 's')); getch ( ); }

Você também pode gostar