Introdução À Linguagem C

Linguagem C
Caractersticas Bsicas de C
Linguagem de alto nvel com operaes de baixo nvel tambm (nvel mdio). Uso ostensivo de smbolos e identificadores abreviados. Permite uso combinado no usual entre operandos e operadores em comandos. Sensvel diferena entre letras maisculas e minsculas em comandos e identificadores (sensitive case). Altamente portvel em diversas plataformas.
Constantes em C
Em C, as constantes podem ser: Nmeros inteiros, Nmeros reais, Literais (apenas um carter) ou Textos, como cadeias de literais (strings).
Constantes em C
As constantes numricas inteiras podem ser representadas nas bases decimal, octal e hexadecimal. Nmeros inteiros na base decimal so compostos por dgitos de 0 a 9 e no devem comear por 0. Ex.: 1, 2, 34, 56, etc.
Constantes em C
Nmeros inteiros na base octal so compostos por dgitos de 0 a 7 e sempre comeam por 0. Ex.: 0, 02, 07, 010, etc. Nmeros inteiros na base hexadecimal so compostos por dgitos de 0 a 9 e por letras de A a F (maisculas ou minsculas) e sempre comeam por 0x (ou 0X). Ex.: 0x0, 0x02, 0x0a, 0xff, etc.
Constantes em C
Constantes de nmeros inteiros, representados em qualquer base, podem ser especificados como sem sinal (unsigned) ou como longos (long), acrescentando ao final o carter U, L (maisculos ou no) ou ambos. Exemplos: 123U; -010L; 0x10UL.
Constantes em C
As constantes numricas reais so sempre representadas na base decimal e podem ser descritas usando a notao cientfica (de engenharia) ou no. Exemplos:
123.23 -321.4 -1.0e10, mesmo que -10000000000.0 2.3e-5, mesmo que 0.000023
Constantes em C
As constantes literais representam sempre um nico carter e so sempre delimitadas por aspas simples ( e ). Carteres imprimveis da tabela ASCII so representados diretamente: Exemplos: a, b, c, A, B, C, 0, 1, 2, etc.
Constantes em C
Carteres no imprimveis podem ser representados como constantes simblicas ou atravs de seus cdigos numricos na tabela ASCII. Em ambas as formas, o carter de escape \ (barra invertida) deve aparecer no incio.
Constantes em C
Constantes simblicas imprimveis: \n: pulo de linha; para carteres no
\r: retorno de carro at o incio da linha; \b: retorno de um carter (backspace); \f: pulo de pgina (form feed); \t: tabulao horizontal; \v: tabulao vertical.
Constantes em C
Para representar um carter (imprimvel ou no) atravs de seu cdigo ASCII, este cdigo dever ser um nmero na base octal ou hexadecimal, da seguinte forma:
O dgito 0, que costuma aparecer no incio da constante numrica na base octal ou hexadecimal, removido; No seu lugar, o carter de escape \ introduzido e as aspas simples so usadas como delimitadoras.
Constantes em C
Exemplos:
Na base octal: \0: carter NULL da tabela ASCII; \101: a letra A maiscula (0101 em octal). Na base hexadecimal: \x1a: um espao em branco (0x1a em hexa); \x41: a letra A maiscula (0x41 em hexa).
Constantes em C
Carteres especiais, como aspa simples e dupla e o prprio carter de escape \ (barra invertida) devem ser representadas com um carter de escape frente. Exemplos: \: o carter aspa simples;
\: o carter aspa dupla; \\: o carter barra invertida.
Constantes em C
Constantes de texto (strings) so cadeias (ou arranjos) de 0 ou mais literais (carteres) que so sempre delimitados por aspas duplas ( e ).
Apesar de no aparecer nessas constantes, o carter NULL automaticamente acrescido ao final do texto ( \0 ) para marcar o seu final.
Constantes em C
Exemplos: A constante formada apenas por NULL \0; A constante A uma cadeia com os literais A e \0; A constante texto uma cadeia com os literais t, e, x, t, o e \0; A constante \x41gora\nsim uma cadeia com os literais \x41 (mesmo que A em ASCII), g, o, r, a, \n, s, i, m e \0.
Constantes em C
Constantes literais e constantes de texto so armazenadas de forma diferente e, portanto, NUNCA podem ser comparadas ou confundidas.
A A
Entrada e Sada em C
A linguagem C padro no introduz comandos nativos de entrada e sada para programas. Ao invs disso, C oferece uma biblioteca padro com funes que fazem esse trabalho (deve-se usar #include <stdio.h> no incio do programa). Dentre vrias dessas funes esto puts(), gets(), printf() e scanf().
Entrada e Sada em C
As funes puts() e gets() imprimem na tela e lem do teclado um texto, respectivamente. A sintaxe delas puts(expr_texto) e gets(var_texto), em que expr_texto pode ser uma constante ou uma varivel de tipo texto e var_texto apenas uma varivel de tipo texto.
Entrada e Sada em C
A funo puts(expr_texto) pega o contedo de expr_texto e imprime, carter a carter, todo o seu contedo at encontrar o carter NULL ( \0 ). A funo gets(var_texto) espera que o usurio entre com um texto no teclado e armazena essa entrada em var_texto.
Entrada e Sada em C
As funes printf() e scanf() fazem impresso na tela e leitura do teclado formatadas, respectivamente. Ambas funes exigem a especificao de pelo menos um parmetro no incio, conhecido como texto de formatao (format string).
Entrada e Sada em C
printf() e scanf() tm as seguintes sintaxes:
printf(texto_format, p1, p2, p3, ..., pN)
e scanf(texto_format, &p1, &p2, ..., &pN)
Entrada e Sada em C
Na funo printf(), o parmetro texto_format (texto de formatao) constitudo de texto que efetivamente ser impresso na tela e de cdigos de formatao que sero substitudos pelos parmetros p1, p2, p3, ... e pN. Para cada cdigo de formatao, dever haver um parmetro (constante ou varivel) correspondente para substitu-lo na sada de impresso.
Entrada e Sada em C
Cdigos de formatao para printf():
Tipo de sada
Literal Nmeros inteiros
Cdigo de formatao
%c %d %ld %u %o %x %f %lf %e %g %s %%
Descrio
Apenas um carter Nmero inteiro na base decimal Nmero inteiro longo na base decimal Nmero inteiro sem sinal na base decimal Nmero inteiro na base octal Nmero inteiro na base hexadecimal Nmero real Nmero real longo Nmero real em notao cientfica %f ou %e, o que for mais curto para imprimir Texto O prprio carter %
Nmeros reais Texto %
Entrada e Sada em C
Exemplos:
printf(texto simples); printf(A letra %c e maiscula, A); printf(%s\n, outro texto); printf(Nome=%s, Idade=%d\n, nome, idade);
Entrada e Sada em C
A funo scanf() usa praticamente os mesmos cdigos de formatao de printf(). Entretanto, ela os usa para extrair, do texto entrado pelo usurio, os valores preenchidos de acordo com o texto de formatao. Aps o texto de formatao, todos os parmetros seguintes de scanf() DEVEM ser variveis.
Entrada e Sada em C
Exemplo: suponha que o usurio tenha digitado o texto Eu tenho 20 anos pelo teclado. A seguinte chamada de scanf()
scanf(Eu tenho %d anos, &idade);
faz com que a varivel idade receba o valor 20. scanf() geralmente usado de forma mais simples, para ler variveis a partir da entrada. O operador & necessrio para que a varivel possa ser alterada pela funo. Quando o parmetro for uma varivel de tipo texto, & NO dever ser usado.
Entrada e Sada em C
Exemplos:
scanf(%d\n, &idade); scanf(%s %d\n, nome, &idade); scanf(%f\n, &graus_celsius);
Entrada e Sada em C
Para se ler um texto pelo teclado, a chamada de gets(texto) melhor que scanf(%s\n, texto), pois scanf() ignorar o resto do texto que comear com algum espao em branco. Ou seja, se o usurio entrar com o texto Amauri Jr., scanf() ler apenas Amauri, enquanto que gets() ler o texto todo.
Comentrios em C
Um comentrio um bloco de texto que no processado pelo compilador mas serve como nota para o programador. Em C, um comentrio iniciado com /* e finalizado com */. Exemplo: /* Isto um comentrio */ Comentrios em C, tradicionalmente, no podem ser aninhados. Exemplo: /* /*Isto no pode*/ */
Palavras Reservadas de C
A linguagem C possui um conjunto de palavras que no podem ser usadas como identificadores (nome) de variveis ou funes em programas.
Palavras Reservadas de C
auto break case char const continue default do double else enum extern float for goto if int long register return short signed sizeof static struct switch typedef union unsigned void volatile while
Tipos Primitivos de C
A linguagem C tambm prov um conjunto de tipos bsicos primitivos sobre os quais programas e novos tipos (definidos pelo usurio) podem ser criados. A notao [ smbolo ]opc (ou simplesmente smboloopc), usada na tabela a seguir e tambm no resto deste curso indica que o smbolo em questo opcional.
Tipo Genrico Tipo em C Tamanho Intervalo de Valores
-128...+127 0...+255 -2147483648...+2147483647 0...+4294967295 -32768...+32767 0...+65535 -2147483648...+2147483647 0...+4294967295 -2147483648...+2147483647 10.0-40...10.0+40 10.0-310...10.0+310 10.0-4934...10.0+4934 N/A [signed] opc char 8 bits (byte) unsigned char 8 bits (byte) int 32 bits (word) signed [int] opc unsigned [int] opc 32 bits (word) Tipos 16 bits inteiros [signed] opc short [int] opc unsigned short [int] opc 16 bits [signed] opc long [int] opc 32 bits unsigned long [int] opc 32 bits enum...{...} (enumerao) 32 bits (word) 32 bits Tipos reais float (ponto double 64 bits flutuante) long double 96 bits Tipo vazio void 8 bits (sem valor)
Os qualificadores signed e unsigned determinam se o tipo inteiro tem ou no sinal, respectivamente. Por default, TODOS os tipos inteiros so signed. Quando os qualificadores signed, unsigned, short ou long so usados, o tipo int pode omitido (int default).
Os valores de tipos literais char, signed char e unsigned char so considerados inteiros e ocupam um byte de memria. Os valores de tipos inteiros int, signed, unsigned, e enumerados (enum) costumam ocupar uma palavra (word) de memria por motivos de eficincia.
Os valores de tipos inteiros short, signed short e unsigned short, por conveno, ocupam 2 bytes (16 bits) de memria. Os valores de tipos inteiros long, signed long e unsigned long, por conveno, ocupam 4 bytes (32 bits) de memria.
Todos os valores de tipos reais podem ser positivos ou negativos. O tipo especial vazio void usado em duas circunstncias:
Em declarao de funes, para declarar uma funo que no retorna valor, ou Em declarao de ponteiros, para declarar um ponteiro que possa apontar para qualquer tipo de dado.
Estrutura de um Programa em C
Um programa em C composto por um ou mais arquivos-fonte. Um arquivo-fonte em C contm uma ou mais declaraes de variveis e funes. Deve haver apenas uma funo main() em todo o programa para que ele seja executvel.
Primeiro Programa em C
#include <stdio.h>
int main() { printf(Alo mundo\n); }
Declarao de Variveis em C
Forma Simples:
tipo var1, var2, ..., varn; int x, y, z; char letra, opcao_menu; float celsius, fahrenheit;
Forma com iniciao de valores:
tipo var1
= const
]opc,
...;
int x = 0, y, z = 1; char letra, opcao_menu = s; float celsius = 100.0;
Opcionalmente, uma ou mais palavras reservadas auto, const, extern, register, static ou typedef podem ser especificadas antes do tipo na declarao de variveis.
O especificador auto default e determina que as variveis sejam alocadas, quando comea a execuo do bloco onde foram declaradas, e desalocadas, quando termina a execuo do bloco, automaticamente.
O especificador const s permite que um valor seja atribudo varivel no momento de sua declarao. Outras formas de alterar o seu valor so proibidas (constantes). O especificador extern avisa ao compilador que a varivel est definida fora do arquivo-fonte (declarao externa).
O especificador register pede ao compilador que a varivel resida em algum registrador da CPU, ao invs de estar na RAM. Este especificador pode ou no ser acatado pelo compilador, dependendo da disponibilidade de registradores. Variveis register NO podem ter endereo de memria e DEVEM ser de tipo inteiro.
O especificador static faz com que a varivel no seja desalocada quando termina a execuo do bloco onde foi declarada. O escopo da varivel continua sendo local ao seu bloco. Quando uma declarao de varivel static feita fora das funes, o escopo da varivel o arquivo-fonte onde foi declarada (varivel com escopo de arquivo).
O especificador typedef transforma a declarao de variveis em declarao de tipos definidos pelo usurio (os nomes de variveis passam a ser nomes de novos tipos).
typedef tipo novo_tipo1, ...;
Exemplos: auto int x, y, z; auto register int x, y, z; extern int i; static float g = 9.8; const char opcao_sim = S; typedef int meu_tipo_int;
Declarao de Funes em C
tipoopc nome ( param_formaisopc ) { decl_variveis_locaisopc comandosopc }
Ou tipoopc nome ( param_formaisopc );
A funo uma expresso e retorna um valor com o mesmo tipo de sua declarao. A omisso do tipo da funo implica que ela retorna valores inteiros (tipo int default). O comando return faz a funo voltar ao lugar onde foi chamada, retornando o resultado da expresso especificada.
Funes de tipo void NO devem retornar valores. O comando return, caso seja necessrio em uma funo de tipo void, NO deve ter uma expresso especificada. A funo retorna automaticamente ao lugar onde foi chamada aps executar o seu ltimo comando.
Funes podem ter zero ou mais parmetros formais. Um parmetro formal uma varivel local que recebe a CPIA do valor do argumento passado no momento em que a funo chamada (passagem de parmetro por valor).
Somente para os argumentos de tipo vetor, a passagem de parmetro SEMPRE por referncia. Passagem de parmetros por referncia, para argumentos que no sejam de tipo vetor, pode ser emulada usando ponteiros explicitamente.
int soma(int n1, int n2) { return n1 + n2; } int multiplica(int n1, unsigned n2) { int result = 0; while (n2 > 0) { result = result + n1; n2 = n2 1; } return result; }
float pi() { return 3.1415926; } numero_magico() { return 123; } void conta_ate_10() { int i; for (i = 0; i < 10; i++) printf(%d\n, i+1); } void funcao_vazia() {}
Uma funo pode ser declarada sem ser definida:
A declarao insere na tabela de smbolos do compilador as informaes sobre a existncia da varivel ou da funo no programa. A definio uma declarao na qual a varivel ou funo efetivamente criada no programa. Toda definio uma declarao, nem toda declarao uma definio.
A declarao sem definio da funo conhecida como prottipo da funo. O prottipo informa somente o tipo, o nome e, opcionalmente, os parmetros formais da funo:
tipoopc nome ( param_formaisopc );
Uma mesma funo pode ser declarada vrias vezes num programa, mas s pode ser definida uma vez (redeclaraes so permitidas, redefinies no). Todas as redeclaraes (os prottipos e a definio) de uma funo devem ser compatveis entre si (mesmo tipo e mesmos parmetros formais, se declarados).
A redeclarao de funes til quando:
Se deseja chamar uma funo que ainda no foi definida (talvez definida noutro arquivo). Neste caso, DEVE haver um prottipo desta funo no arquivo-fonte onde ela chamada. Se usa recursividade indireta ou cclica, no qual uma funo a() chama b() e b(), por sua vez, chama a().
Exemplos:
/* A funo puts() externa */ int puts(char *s); int main() { puts(Alo); }
int fat(int n);

int mult_fat(int n) { return n*fat(n-1); } int fat(int n) { if (n<=0) return 1; return mult_fat(n); }
Opcionalmente, antes da declarao de uma funo, pode-se acrescentar o especificador extern ou static. O especificador extern avisa ao compilador que a funo declarada (prottipo) est definida fora do arquivofonte (em padres mais recentes de C, isso no mais necessrio).
O especificador static faz com que o escopo da funo seja local ao arquivofonte onde foi definida, ao invs de ser global (escopo de arquivo, tal qual como na declarao de variveis).
Exemplos:
extern int puts(char *s); static void escreve_alo() { puts(Alo); }
Comandos de C
Um comando em C pode ser: Uma expresso (de chamada de funo, de incremento, de atribuio, etc.), De iterao (while, do...while e for), De deciso (if, if...else e switch), De desvio de fluxo (goto, break, continue e return) , Um comando rotulado, Um bloco de comandos, delimitados por { e } ou Vazio (comando ausente).
Comandos de C
Lembrete: Todos os comandos, com exceo do bloco de comandos, devem ser terminados com o smbolo ponto-e-vrgula ( ; ) . Todas as declaraes, com exceo da definio de funo, devem tambm ser terminadas com o smbolo ponto-e-vrgula.
Expresses e Operadores em C
Uma expresso em C pode ser: Uma constante, Uma varivel, Uma chamada de funo, Uma sub-expresso delimitada por ( e ) ou Uma combinao bem formada de operandos (sub-expresses) e operadores.
Em C, uma expresso que corresponde a um contedo de memria (ou de registrador), que possa ser modificado direta ou indiretamente como uma varivel, conhecida como lvalue. Um lvalue tem esse nome por ficar ao lado esquerdo de um operador de atribuio (left value).
Uma expresso em C pode ter operadores: Aritmticos. Relacionais e Lgicos. de Incremento / Decremento. Bit-a-Bit. de Atribuio.
Operadores Aritmticos
Operador + expr - expr expr1 * expr2 expr1 / expr2 expr1 % expr2 expr1 + expr2 expr1 - expr2 Tipos dos Operandos Sinal numri- Inteiros e co unrio reais Multiplicao Inteiros e reais Diviso Resto de Somente diviso inteira inteiros Soma Inteiros e reais Subtrao Descrio Associatividade Precedncia Da dir. para esq. 14
Da esq. para dir.
13
Da esq. para dir.
12
Exemplos: 2 + 5 * 2; 5 / 2; 5.0 / 2.0; 10 % 3; -14 % 3;
/* /* /* /* /* = = = = = 12 */ 2 */ 2.5 */ 1 */ -2 */
Em C no h um tipo lgico (boolean) especfico. Ao invs das constantes true (verdadeiro) e false (falso), C assume que o valor zero falso e qualquer outra coisa verdadeiro.
Operador ! expr expr1 > expr2 expr1 >= expr2 expr1 < expr2 expr1 <= expr2 expr1 == expr2 expr1 != expr2 Descrio No lgico unrio Maior que Maior ou igual a Menor que Menor ou igual a Igual a Diferente de Tipos dos Associatividade Precedncia Operandos Inteiros e Da dir. para esq. 14 ponteiros Inteiros, reais e ponteiros
Inteiros, reais e ponteiros
Da esq. para dir.
10
Da esq. para dir. Da esq. para dir. Da esq. para dir.
9 5 4
expr1 && expr2 E lgico expr1 || expr2 Ou lgico
Inteiros e ponteiros Inteiros e ponteiros
Exemplos: 1 == 2; 1 != 2; 10 == 9+1; 1 && 0; 1 || 0; 10==8+2 && !(2!=2);
/* /* /* /* /* /* = = = = = = 0 1 1 0 1 1 */ */ */ */ */ */
Os operadores de incremento/decremento ALTERAM o operando (lvalue) e retornam o seu valor alterado. Para que uma expresso possa ser incrementada ou decrementada, ela deve ser um lvalue.
C possui 2 operadores de incremento e 2 operadores de decremento. Os operadores de incremento/decremento podem ser pr-fixado (a operao realizada antes de todas as outras na expresso) ou de ps-fixado (a operao realizada aps todas as outras na expresso).
Operadores de Incremento/Decremento
Operador ++ lvalue -- lvalue lvalue ++ lvalue -Descrio Pr-incremento unrio Pr-decremen to unrio Ps-incremen to unrio Ps-decremen to unrio Tipos dos Associatividade Precedncia Operandos Inteiros e ponteiros Da dir. para esq. 14
Inteiros e ponteiros
Da esq. para dir.
Exemplos: a = 1; b = 4; /* inicia */ y = 2 * --a; /* y=0 */ y = 2 * b--; /* y=8 */ /* agora, a=0 e b=3 */ z = ++a + b++; /* z=4 */ /* agora, a=1 e b=4 */
Os operadores de manipulao de bits (operadores bit-a-bit) correspondem s instrues de baixo nvel de C. Implementam as operaes de deslocamento de bits e as operaes NOT (no bit-a-bit), AND (e bit-a-bit), XOR (ou bit-a-bit exclusivo) e OR (ou bit-a-bit inclusivo) em bits.
Operadores Bit-a-Bit
Operador ~ expr Descrio No bit-a-bit unrio Deslocamento expr1 << expr2 de bits esq. Somente Deslocamento inteiros expr1 >> expr2 de bits dir. Somente expr1 & expr2 E bit-a-bit inteiros Ou exclusivo Somente expr1 ^ expr2 bit-a-bit inteiros Ou inclusivo Somente expr1 | expr2 bit-a-bit inteiros Tipos dos Associatividade Precedncia Operandos Somente Da dir. para esq. 14 inteiros Da esq. para dir. 11
Da esq. para dir. Da esq. para dir. Da esq. para dir.
8 7 6
A expresso var << n retorna o valor de var com os seus bits deslocados n casas esquerda. Mesmo que var * 2n. A expresso var >> n retorna o valor de var com os seus bits deslocados n casas direita. Mesmo que var / 2n (div. inteira). Os deslocamentos no so cclicos: os bits mais significativos perdidos em deslocamentos esquerda no reaparecem direita e vice-versa.
A expresso ~var (no bit-a-bit) retorna o valor de var com todos os seus bits invertidos. A expresso var1 & var2 (e bit-a-bit) retorna um valor no qual cada bit 1, se os bits na mesma casa em var1 e var2 tambm forem 1, ou 0, caso contrrio.
A expresso var1 ^ var2 (ou exclusivo bit-abit) retorna um valor no qual cada bit 1, se os bits na mesma casa em var1 e var2 forem diferentes, ou 0, caso contrrio. A expresso var1 | var2 (ou inclusivo bit-abit) retorna um valor no qual cada bit 1, se pelo menos um dos bits na mesma casa em var1 e var2 for 1, ou 0, caso contrrio.
No confunda os operadores bit-a-bit ( ~, &, ^ e | ) com os operadores lgicos ( !, && e || ): os resultados podem no ser os mesmos!. Exemplo:
v1 = 2 && 5; /* v1 = 1 (VERDADEIRO) */ v2 = 2 & 5; /* v2 = 0 (FALSO) */
Exemplos: unsigned char m = 1, r = m << 2; /* r=4 r = m >> 1; /* r=0 r = ~m; /* r=254 r = m & n; /* r=2 r = m ^ n; /* r=1 r = m | n; /* r=3
n = 3, r; (00000100) (00000000) (11111110) (00000010) (00000001) (00000011)
*/ */ */ */ */ */
Operadores de Atribuio
Operador lvalue = expr lvalue += expr lvalue -= expr lvalue *= expr lvalue /= expr lvalue %= expr lvalue &= expr lvalue ^= expr lvalue |= expr lvalue <<= expr lvalue >>= expr Descrio Associatividade Precedncia Atribui o valor de expr a lvalue lvalue = lvalue + expr lvalue = lvalue - expr lvalue = lvalue * expr lvalue = lvalue / expr Da dir. para esq. 2 lvalue = lvalue % expr lvalue = lvalue & expr lvalue = lvalue ^ expr lvalue = lvalue | expr lvalue = lvalue << expr lvalue = lvalue >> expr
Uma expresso de atribuio, na forma lvalue = expr, copia o valor de expr para o contedo de lvalue e depois retorna o valor que ficou em lvalue. O tipo de expr pode ser inteiro, real ou ponteiro. Dado um operador q, as outras formas de atribuio funcionam como acumuladores:
lvalue q= expr lvalue = lvalue q expr
Exemplos:
unsigned inverte_num(unsigned num) { unsigned dg, num_inv = 0; while (num > 0) { dg = num % 10; num_inv *= 10; /* num_inv = num_inv*10 */ num_inv += dg; /* num_inv = num_inv+dg */ num /= 10; /* num = num/10 */ } return num_inv; }
Pelo fato da atribuio, em C, ser um operador (e no um comando, como em Pascal), pode-se associar vrias atribuies numa nica expresso: a = b = c = 0; No confunda o operador de atribuio = com o operador relacional de igualdade ==.
Exemplos:
#include <stdio.h> int main() { int n = 0; if (n = 0) puts(CORRETO); else puts(ERRADO); } #include <stdio.h> int main() { int n = 0; if (n == 0) puts(CORRETO); else puts(ERRADO); }
Imprimir ERRADO
Imprimir CORRETO
A linguagem C ainda introduz dois operadores bastante atpicos: o operador vrgula ( , ) e o operador ternrio ?: . O operador vrgula avalia TODAS as suas subexpresses da esquerda para a direita, mas o resultado de toda a expresso o resultado da subexpresso mais direita. Exemplos: v1 = 1, 2, 3, 4, 5; /* v1=5 */ v2 = ++v1, v1*v1; /* v2=36 */
A expresso com operador ternrio expr1? expr2:expr3 um if implcito, no sentido de que o seu resultado a avaliao de expr2, caso expr1 seja verdadeira, ou expr3 caso contrrio. Exemplos:
v3 = v2==36 ? v1 : v1+1;/* v3=6 */ v4 = v35 ? 1 : 0; /* v4=1 */
Comandos de Iterao em C
A linguagem C prov trs comandos de iterao: o comando while, o comando do...while e o comando for. A sintaxe do comando while :
while (expr) comando
O comando while primeiramente testa expr. Se expr for VERDADEIRA, comando executado e o controle volta para o incio da iterao, no qual expr novamente testada. O lao termina quando expr finalmente for 0 (FALSO).
Exemplo:
#include <stdio.h>
int main() { int i = 0; while (i < 10) { puts(Repetindo...); i++; } }
A sintaxe do comando do...while :
do comando while (expr)

O comando do...while, ao contrrio do comando while, primeiramente executa comando para depois testar expr. A iterao continua at que expr seja 0 (FALSO).
Exemplo:
#include <stdio.h>
int main() { int i = 0; do { puts(Repetindo...); i++; } while (i < 10); }
A sintaxe do comando for :
for (expr1 opc; expr2 opc; expr3 opc) comando
Primeiramente, expr1 (expresso de iniciao) executada uma nica vez, depois expr2 testada (expresso de condio), em seguida, comando e expr3 (expresso de incremento/decremento) so executados. O ciclo se repete partir de um novo teste de expr2 at que o valor 0 (FALSO) seja encontrado.
O comando for um comando while com uma sintaxe diferente:
for (expr1; expr2; expr3) comando;
, na verdade, a mesma coisa que:

expr1; while (expr2) { comando; expr3; }
Exemplo:
#include <stdio.h> int main() { int i; for (i = 0; i < 10; i++) puts(Repetindo...); }
As expresses expr1, expr2 e expr3 so opcionais no comando for:
#include <stdio.h> int main() { int i = 0; for ( ; i < 10 ; ) { puts(Repetindo...); i++; } }
Quando todas as expresses so omitidas do comando for, ele se comporta como um lao eterno:
#include <stdio.h> int main() { for ( ; ; ) puts(Repetindo pra sempre...); }
Comandos de Deciso em C
A linguagem C prov trs comandos de deciso: o comando if, o comando if...else e o comando switch. A sintaxe do comando if :
if (expr) comando
O comando if primeiramente testa expr. Se expr for VERDADEIRA ( 0 ), comando executado. Exemplo:
#include <stdio.h> int main() { int i; for (i = 0; i < 10; i++) { printf(%d, i); if (i % 2 == 0) puts( par); } }
O comando if...else acrescenta ao comando if a possibilidade de executar um outro comando quando a condio FALSA. A sintaxe do comando if...else :
if (expr) cmd1 else cmd2
O comando if...else primeiramente testa expr. Se expr for VERDADEIRA ( 0 ), cmd1 executado, caso contrrio ( expr = 0 ), cmd2 que executado. Exemplo:
#include <stdio.h> int main() { int i; for (i = 0; i < 10; i++) { printf(%d, i); if (i % 2 == 0) puts( par); else puts( impar); } }
O comando switch um comando de deciso com mltiplos casos. A sintaxe do comando switch :
switch (expr) { case const1: cmd1; ...; cmdN; breakopc; case const2: cmdN+1; ...; cmdM; breakopc; ... ... ... ... ... ... ... ... ... ... ... ... ... ...
[
}
default: cmdO; ...; cmdP;
]opc
O comando switch primeiro avalia expr e encontra o seu valor. Depois, ele encontra o caso ( case ) cuja constante consti seja igual ao valor encontrado e executa, a partir da, os seus comandos at o comando break. O caso especial default, se houver, executado quando nenhuma das constantes coincidem com o valor de expr.
Tanto expr como as constantes consti do switch devem ser de tipo inteiro (literal inclusive). As constantes dos casos de um comando switch devem ser diferentes entre si, ou seja, a especificao de dois ou mais casos com a mesma constante provocar um erro de compilao.
A ausncia do comando break no fim de um caso faz a execuo continuar nos prximos casos at encontrar o primeiro break ou o fim do bloco do switch. O ltimo caso ( default inclusive ) no precisa ser terminado com o comando break.
Exemplo:
#include <stdio.h> int main() { int i; for (i = 0; i < 10; i++) { printf(%d, i); switch (i % 2) { case 0: puts( par); break; case 1: puts( impar); } } }
Outro exemplo de switch:
#include <stdio.h> int main() { char opcao; scanf(%c\n, &opcao); switch (opcao) { case s: case S: puts(Voc digitou Sim); break; case n: case N: puts(Voc digitou No); break: default: puts(Voc deve digitar \s\, \S\, \n\ ou \N\); } }
Comandos de Desvio em C
A linguagem C tem 4 comandos de desvio: goto, break, continue e return. O comando goto rtulo desvia para o comando rotulado com rtulo ( usando a sintaxe rtulo: comando ):
#include <stdio.h> int main() { int i = 0; inicio: if (i == 10) goto fim; printf(%d\n, i++); goto inicio; fim: puts(FIM); }
O comando break desvia sempre para fora do bloco corrente:
#include <stdio.h>
int main() { int i = 0; for (;;) { /* lao eterno */ i++; if (i > 10) break; /* sai quando i > 10 */ printf(%d\n, i); } }
O comando break pode ser usado nos comandos de repetio (while, do...while ou for) e, comumente, no comando switch. O comando continue, dentro do bloco de um comando de repetio, faz com que o fluxo de execuo do programa seja desviado para o incio do comando de repetio, desconsiderando o resto dos comandos do bloco. O lao do comando de repetio NO terminado pelo continue:
#include <stdio.h>
int main() { int i = 0; while (i < 10) { i++; if (i % 2 == 1) continue; /* volta se impar */ printf(O nmero %d par\n); } }
O comando return fora uma sada da funo em execuo f e desvia o fluxo de execuo do programa para a funo que chamou f, precisamente logo aps chamada de f. Se a funo no for de tipo void, o comando return deve vir acompanhado de uma expresso, cujo valor retornado para a funo que a chamou.
#include <stdio.h> int num_eh_primo(unsigned num) { unsigned i = 2; while (i < num) { if (num % i == 0) return 0; /* volta para main() com FALSO */ i++; } return 1; /* volta para main() com VERDADEIRO */ } int main() { int n; scanf(%d\n, &n); if (num_eh_primo(n)) printf(%d primo\n, n); else printf(%d no primo\n, n); }
Comandos Rotulados em C
Um comando rotulado um comando precedido por um identificador conhecido como rtulo. O rtulo usado como referncia para onde um desvio ocorrer com o comando goto:
goto rotulo; /* desvia para rotulo */ puts(esta linha no ser executada!); rotulo: puts(vim de um goto!);
Blocos de Comandos em C
Um bloco de comandos um comando com suas prprias declaraes de variveis locais e comandos em seqncia, delimitados por chaves ( { e } ):
#include <stdio.h> int main() { int x = 10; { /* Este o incio do bloco de comandos */ int x = 20; /* x local a este bloco */ printf(x = %d\n, x); /* imprimir 20 */ } /* fim do bloco de comandos */ printf(x = %d\n, x); } /* imprimir 10 */
Um bloco de comandos comumente usado quando se deseja usar mais de um comando quando uma regra sinttica exige apenas um. Exemplo:
for (i = 0; i < 10; i++) printf(%d\n, i);
Necessitaria de um bloco de comandos se o incremento da varivel i no fosse feito dentro do comando for (veja a sintaxe de for):
for (i = 0; i < 10; ) { printf(%d\n, i); i++; }
Um bloco de comandos uma estrutura sinttica de C (e de outras linguagens afins) e pode ser usada tambm com apenas um comando, sem problemas:
for (i = 0; i < 10; i++) { printf(%d\n, i); }
Tipos Estruturados em C
Um Tipo Estruturado, numa linguagem de programao como C, um tipo de dados construdo a partir de ou composto por outros tipos de dados (primitivos ou no). Estes tipos podem ser homogneos ou heterogneos.
Um Tipo Estruturado Homogneo um tipo composto por vrios elementos de mesmo tipo bsico.
Os Vetores ou Arranjos estruturados homogneos. so tipos
Em C, se constri um vetor uni-dimensional a partir de um tipo bsico tipo com a seguinte declarao:
tipo var_vetor[num_elementos];
Um vetor pode ser multi-dimensional (matriz), bastando apenas acrescentar mais dimenses declarao:
tipo var_matriz[n_elemdim1]...[n_elemdimN];
Exemplos: int vetor1[300], vetor2[100]; float matriz[10][20]; char nome[61]; char texto[101]; char linhas_texto[10][101];
O nmero de elementos de cada dimenso de um vetor DEVE ser uma expresso constante de tipo inteiro. Cada elemento de um vetor de N elementos obtido especificando, numa expresso, o nome do vetor e uma expresso inteira (ndice do vetor) entre 0 e N-1 inclusive, situado entre colchetes ( [ e ] ). Exemplo:
#include <stdio.h>
int main() { /* declarando um vetor e seu ndice */ int vetor[10], i; /* lendo o vetor */ for (i = 0; i <= 9; i++) { printf(entre um valor para vetor[%d]: , i); scanf(%d\n, &vetor[i]); } /* escrevendo o vetor */ for (i = 0; i <= 9; i++) printf(vetor[%d] = %d\n, i, vetor[i]); }
Deve-se observar atentamente que o tipo da varivel vetor um vetor uni-dimensional com 10 elementos de tipo int e que o tipo de vetor[i] (i-simo elemento da varivel vetor) simplesmente int.
Vetores multi-dimensionais normalmente precisam de um ndice especfico para cada dimenso:
#include <stdio.h>
int main() { float m[2][2], det; /* declara matriz m e det */ int i, j; /* declara ndices para m */ for (i = 0; i < 2; i++) { for (j = 0; j < 2; j++) { printf(Entre valor de m[%d][%d] , i, j); scanf(%f\n, &m[i][j]); } } det = m[0][0] * m[1][1] m[0][1] * m[1][0]; printf(A determinante de m %f\n, det); }
Em C, operadores de atribuio ( = ) e funes de entrada e sada (como puts() e gets()) no so aplicveis vetores. Para se atribuir o contedo de um vetor a para o vetor b, por exemplo, deve-se fazer um lao for (ou while) e atribuir elemento a elemento:
for (i=0; i<10; i++) b[i] = a[i];
A Linguagem C prov tambm, em sua biblioteca padro, funes especiais para manipulao de vetores (na verdade, manipulao de memria). Para isso, devese acrescentar a linha #include <memory.h> no incio do arquivo-fonte.
A funo memmove(dest, orig, tam) copia a quantidade (especificada em tam) de bytes do contedo de orig para dest. memmove(b, a, sizeof(a)) ento copiar todo o contedo do vetor a para o vetor b. sizeof(x) definido em C e sempre retorna o tamanho em bytes ocupado por uma varivel ou tipo x.
A funo memset(var, valor, tam) atribui um valor a cada byte de var. O parmetro tam especifica a quantidade de bytes. memset(a, 0, sizeof(a)) ento atribuir o valor 0 a todos os elementos do vetor a.
Um Tipo Estruturado Heterogneo um tipo composto por vrios elementos de diferentes tipos. Em C, um tipo estruturado heterogneo definido como um struct ou como um union.
O tipo estruturado struct uma COMPOSIO INCLUSIVA de vrios elementos de tipos possivelmente diferentes, denominados membros. Cada membro identificado por um nome (identificador), como acontece nas variveis.
A construo de um tipo struct segue a seguinte sintaxe em C:
struct nome_structopc { tipo1 membro1, membro2, ..., membroN; tipo2 membroN+1, membroN+2, ..., membroM; ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... tipoT membroY, membroY+1, ..., membroZ; }
var_struct1, var_struct2, ..., var_structK
]opc
Exemplos:
struct ponto { float x, y; } p1, p2, p3; struct pessoa { char nome[61]; struct { int dia, ms, ano; } data_nascto; float altura; };
A definio de um struct introduz um novo tipo em C. Opcionalmente, pode-se declarar as variveis logo aps, como p1, p2 e p3 do struct ponto;
Pode-se tambm declarar as variveis aps a definio do struct: struct pessoa eu, tu, ele;
A identificao do tipo deve vir com a palavra reservada struct seguido do nome do struct. Quando no h necessidade de uma referncia posterior a esse tipo, o nome do struct pode ser omitido em sua declarao (struct annimo).
Para se acessar um membro de um struct, usase o operador ponto ( . ) para se denotar de qual varivel struct se est acessando o membro:
int main() { struct pessoa scanf(%s\n, scanf(%d\n, scanf(%d\n, scanf(%d\n, scanf(%f\n, scanf(%s\n, scanf(%f\n, }
eu, ele; eu.nome); eu.data_nascto.dia); eu.data_nascto.mes); eu.data_nascto.ano); eu.altura); ele.nome); ele.altura); /* /* /* /* /* /* /* meu nome */ dia que nasci */ ms que nasci */ ano que nasci */ minha altura */ nome dele */ altura dele */
Ao contrrio de vetores, pode-se atribuir um struct a outro com o operador =, desde que sejam do mesmo tipo. Mesmo assim, no existem funes de entrada e sada para structs, como em vetores.
O tipo estruturado union uma COMPOSIO EXCLUSIVA de vrios elementos de tipos possivelmente diferentes, denominados membros. Isto significa que um union armazena apenas um dos seus membros por vez, requerendo apenas o tamanho do maior deles para a sua ocupao em memria.
A sintaxe da construo de um union semelhante ao do struct:
union nome_unionopc { tipo1 membro1, membro2, ..., membroN; tipo2 membroN+1, membroN+2, ..., membroM; ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... ... tipoT membroY, membroY+1, ..., membroZ; }
var_union1, var_union2, ..., var_unionK
]opc
Exemplo:
struct pessoa2 { unsigned tipo_id; /* 0-CNPF, 1-CNPJ */ union { char CNPF[11]; /* ou Pessoa Fsica */ char CNPJ[14]; /* ou Pessoa Jurdica */ } id; char nome[61]; char endereco[201]; };
A nica diferena entre o struct e o union que o struct mantm todos os seus membros em memria (o tamanho de um struct a soma dos tamanhos de todos os seu membros!) e o union mantm apenas um de seus membros por vez (o tamanho de um union o tamanho de seu maior membro!).
Variveis de Tipo Texto em C

A linguagem C no introduz um tipo para variveis que armazenem textos. O tipo primitivo char armazena apenas um carter. Para se armazenar textos, deve-se usar vetores de carteres, com o cuidado de se reservar um elemento a mais para o carter nulo \0 ao final.

Como acontece com vetores, h que se recorrer biblioteca padro para executar operaes como cpia e comparao entre textos. Deve-se incluir a linha #include <string.h> no incio do arquivo-fonte para se ter as declaraes das funes necessrias.

A funo strcpy(texto_dest, texto_orig) copia todo o texto_orig para texto_dest, inclusive o carter marcador de fim \0. A funo strcmp (texto1, texto2) compara texto1 contra texto2. Se ambos forem iguais, retorna 0. Se texto1 for menor que texto2, retorna um valor negativo. Se texto1 for maior que texto2, retorna um valor positivo.

A funo strlen(texto) retorna o numero de carteres (com exceo do carter nulo \0) que texto contm. A funo strcat(texto1, texto2) concatena (acrescenta ao final) texto2 ao texto1 e o finaliza com \0. As funes strcpy() e strcat() tambm retornam o texto resultante de suas operaes.

#include <stdio.h> #include <string.h>
int main() { char texto_a[101], texto_b[101]; puts(Entre com um texto); gets(texto_a); /* l texto_a */ strcpy(texto_b, texto_a); /* texto_b = texto_a */ printf(texto_a = \%s\\n, texto_a); printf(texto_b = \%s\\n, texto_b); }

int main() { char texto[101]; puts(Entre com um texto); gets(texto); /* l texto */ if (strcmp(texto, SIM) == 0) /* texto==SIM ? */ puts(Voc digitou \SIM\); else puts(Voc NO digitou \SIM\); }

int main() { char texto[101]; int tam_texto; puts(Entre com um texto); gets(texto); /* l texto */ tam_texto = strlen(texto); printf(O texto que voc entrou tem %d letras\n, tam_texto); }

int main() { char nome[101], sobrenome[101], nomecompleto[101]; puts(Entre com nome); scanf(%s\n, nome); /* l nome */ puts(Entre com sobrenome); scanf(%s\n, sobrenome); /* l sobrenome */ strcpy(nomecompleto, nome); /* nomecompleto=nome */ strcat(nomecompleto, ); /* + espao */ strcat(nomecompleto, sobrenome); /* + sobrenome */ printf(O nome completo %s\n, nomecompleto); }
O Pr-Processador C
O pr-processador da linguagem C um programa (rotina) que executado ANTES do processo de compilao do programa. Os comandos do pr-processador se destacam dos comandos de C pela presena do carter # sempre no incio de sua linha.
O Pr-Processador C
Ao contrrio dos comandos de C, os comandos do pr-processador so orientados a linha (o comando comea e termina sempre na mesma linha) e no terminam com ponto-e-vrgula. Pode-se fazer com que um comando do prprocessador seja descrito em mais de uma linha. Para isso, deve-se colocar o smbolo barra invertida ( \ ) ao final da linha que requer continuao.
O Pr-Processador C
O pr-processador C possui vrios comandos, dentre eles: #include, #define, #undef, #if, #ifdef, #ifndef, #else e #endif. O comando #include inclui todas as linha de um arquivo no arquivo-fonte onde ele aparece.
O Pr-Processador C
Existem 2 formas #include: para o comando
#include <arquivo>: O arquivo a ser includo reside numa pasta (ou pastas) especfica padro, geralmente dentro de onde o compilador est instalado (biblioteca padro). #include arquivo: O arquivo a ser includo reside na mesma pasta onde esto todos os arquivos-fontes do programa.
O Pr-Processador C
Em ambas as formas de #include, podese acrescentar um caminho relativo s suas origens especficas (pasta padro do compilador ou pasta do programa):
#include #include #include #include <sys\\time.h> /* no Windows */ <sys/time.h> /* no Unix e no Linux */ inc\\utilitarios.h /* no Windows */ inc/utilitarios.h /* no Unix e no Linux */
O Pr-Processador C
O comando #define cria um smbolo (conhecido tambm como MACRO) e, opcionalmente, o associa a uma cadeia de outros smbolos. O smbolo criado por #define pode ser usado dentro do programa em C.
O Pr-Processador C
Quando um smbolo #define usado no programa, o pr-processador o substitui pela cadeia associada ao smbolo (macrosubstituio). O smbolo ou macro do #define pode ser parametrizado. Neste caso, a macrosubstituio lembra uma chamada de funo (mas no a mesma coisa!).
O Pr-Processador C
#include <stdio.h>
#define NVEZES 10 /* Apenas uma macro */ #define IMPAR(n) ((n) % 2) /* uma macro parametrizada */ int main() { int num; for (num = 0; num < NVEZES; num++) { printf(O nmero %d , num); if (IMPAR(num)) puts( IMPAR); else puts( PAR); } }
O Pr-Processador C
Uma macro tambm pode substituir comandos, declaraes ou parte deles:
#include <stdio.h> #define PRASEMPRE for( ; ; ) int main() { int i = 0; PRASEMPRE { printf(%d\n, i); if (i == 100) break; i++; } }
O Pr-Processador C
#include <stdio.h> #define LISTA(TIPO, MAX_ELEM) struct { \ int qtd_elem; \ TIPO vet[MAX_ELEM]; \ } int le_elemento() { int elem; printf(Entre com um elemento (zero termina o programa) ); scanf(%d\n, &elem); return elem; } int main() { LISTA(int, 10) lista_int; int elem, i; lista_int.qtd_elem = 0; while (elem = le_elemento()) lista_int.vet[lista_int.qtd_elem++] = elem; for (i = 0; i < lista_int.qtd_elem; i++) printf(%d\n, lista_int.vet[i]); }
O Pr-Processador C
O comando #undef remove a definio de um smbolo, caso ele exista:
#include <stdio.h> #define DEZ 10 int main() { printf(%d\n, DEZ); /* OK */ #undef DEZ printf(%d\n, DEZ); /* PROBLEMA!! */ }
O Pr-Processador C
O comando #if testa uma expresso de condio. Se a condio for verdadeira ( 0 ), o trecho de programa (declaraes ou comandos) ser compilado at o comando #endif. Caso contrrio, o mesmo trecho de cdigo ser ignorado (como um comentrio).
O Pr-Processador C
Opcionalmente, pode-se usar o comando #else para especificar a compilao de outro cdigo quando a condio de #if for falsa ( = 0 ). Usa-se os comandos #if, #else e #endif quando se deseja ligar ou desligar modo de depurao, gerar cdigo com peculiaridades de plataforma (hardware ou software), etc.
O Pr-Processador C
#define WINDOWS
#include <stdio.h> #if defined(WINDOWS) # include <sys\\time.h> #else # include <sys/time.h> #endif
O Pr-Processador C
#include <stdio.h> #define EM_DEPURACAO
unsigned fat(unsigned n) { #if defined(EM_DEPURACAO) /* S ser compilado no modo EM_DEPURAO */ printf(%d\n, n); #endif if (n <= 1) return 1; else return n * fat(n 1); }
O Pr-Processador C
Os comandos #ifdef e #ifndef so formas abreviadas:
#ifdef Smbolo #if defined(Smbolo) #ifndef Smbolo #if !defined(Smbolo)
#ifdef EM_DEPURACAO /* S ser compilado no modo EM_DEPURAO */ printf(%d\n, n); #endif

Introdução À Linguagem C

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Introdução À Linguagem C

Caricato da

Copyright:

Formati disponibili

Linguagem C

\: o carter aspa dupla; \\: o carter barra invertida.

e scanf(texto_format, &p1, &p2, ..., &pN)

Nmeros reais Texto %

int x = 0, y, z = 1; char letra, opcao_menu = s; float celsius = 100.0;

int fat(int n);

Da esq. para dir.

Da esq. para dir.

Da esq. para dir.

Da esq. para dir. Da esq. para dir. Da esq. para dir.

expr1 && expr2 E lgico expr1 || expr2 Ou lgico

Inteiros e ponteiros Inteiros e ponteiros

Da esq. para dir.

Da esq. para dir. Da esq. para dir. Da esq. para dir.

while (expr) comando

int main() { int i = 0; while (i < 10) { puts(Repetindo...); i++; } }

do comando while (expr)

int main() { int i = 0; do { puts(Repetindo...); i++; } while (i < 10); }

, na verdade, a mesma coisa que:

if (expr) cmd1 else cmd2

default: cmdO; ...; cmdP;

var_struct1, var_struct2, ..., var_structK

var_union1, var_union2, ..., var_unionK

Variveis de Tipo Texto em C

Variveis de Tipo Texto em C

Variveis de Tipo Texto em C

Variveis de Tipo Texto em C

Variveis de Tipo Texto em C

Variveis de Tipo Texto em C

Variveis de Tipo Texto em C

Variveis de Tipo Texto em C

Potrebbero piacerti anche