UNIVERSIDADE DE CAXIAS DO SUL CENTRO DE CINCIAS EXATAS E TECNOLGICAS DEPARTAMENTO DE INFORMTICA

LINGUAGEM C

Professor Andr Gustavo Adami

LINGUAGEM C

Sumrio
1. INTRODUO .............................................................................................................................. 4 1.1 VISO GERAL DE UM PROGRAMA C ........................................................................................... 4 2. ESTRUTURA BSICA DE UM PROGRAMA EM C............................................................... 5 2.1 BIBLIOTECAS ............................................................................................................................. 5 3. TIPOS DE DADOS ........................................................................................................................ 6 3.1 SIZEOF() .................................................................................................................................... 7 3.2 CONSTANTES ............................................................................................................................. 7 3.3 CONSTANTES PR-DEFINIDAS .................................................................................................... 8 3.4 AS BIBLIOTECAS DISPONVEIS E ALGUMAS FUNES INTERESSANTES ....................................... 8 4. COMANDO DE ESCRITA ......................................................................................................... 10 4.1 MODIFICADORES DE SADA ..................................................................................................... 11 4.2 EXERCCIOS ............................................................................................................................. 12 5. VARIVEIS ................................................................................................................................. 13 5.1 NOME DE VARIVEIS............................................................................................................... 13 5.2 DECLARAO DE VARIVEIS .................................................................................................. 13 5.2.1 Tipos de Declaraes de Variveis .................................................................................... 13
5.2.1.1 5.2.1.2 5.2.1.3 Variveis locais ............................................................................................................................. 14 Parmetros Formais ....................................................................................................................... 14 Variveis Globais .......................................................................................................................... 14

5.3

PALAVRAS RESERVADAS ......................................................................................................... 14

6. OPERADORES ............................................................................................................................ 16 6.1 ATRIBUIO ............................................................................................................................ 16 6.1.1 Converso de Tipos em Atribuies ................................................................................... 16 6.2 OPERADORES ARITMTICOS .................................................................................................... 17 6.2.1 Incremento e Decremento................................................................................................... 17 6.2.2 Operadores Aritmticos de Atribuio............................................................................... 17 6.3 OPERADORES RELACIONAIS E LGICOS .................................................................................. 18 6.4 OPERADORES DE PONTEIROS & E * ......................................................................................... 18 6.5 OPERADOR VRGULA............................................................................................................... 19 6.6 EXPRESSES ............................................................................................................................ 19 6.6.1 Converso de Tipos em Expresses ................................................................................... 19 6.6.2 Casts ................................................................................................................................... 20 6.6.3 Espaamento e Parnteses ................................................................................................. 21 7. ALGUMAS FUNES DE E/S .................................................................................................. 22 7.1 FUNO SCANF()..................................................................................................................... 22 7.2 LENDO E ESCREVENDO CARACTERES ....................................................................................... 23 7.3 EXERCCIOS ............................................................................................................................. 23 8. COMANDOS CONDICIONAIS................................................................................................. 24 8.1 COMANDO IF ........................................................................................................................... 24 8.2 COMANDO SWITCH .................................................................................................................. 24 8.3 EXERCCIOS ............................................................................................................................. 25 9. ESTRUTURA DE REPETIO (LAOS)............................................................................... 26

LINGUAGEM C

9.1 9.2 9.3 9.4 9.5

LAO FOR ................................................................................................................................ 26 LAO WHILE ............................................................................................................................ 26 LAO DO-WHILE ...................................................................................................................... 26 COMANDOS BREAK E EXIT() .................................................................................................... 27 EXERCCIOS ............................................................................................................................. 28

10. FUNES..................................................................................................................................... 29 10.1 LOCALIZAO DAS FUNES................................................................................................... 30 10.1.1 Corpo da funo antes do programa principal (no mesmo arquivo)................................. 30 10.1.2 Corpo da funo depois do programa principal (no mesmo arquivo)............................... 30 10.1.3 Corpo da funo escrito em arquivo separado .................................................................. 31 10.2 PROTTIPO DE FUNES .......................................................................................................... 32 10.3 DIRETIVA #DEFINE .................................................................................................................. 32 10.4 EXERCCIOS ............................................................................................................................. 32 11. VETORES E MATRIZES ........................................................................................................... 33 11.1 INICIALIZAO DE VETORES E MATRIZES ............................................................................... 33 11.2 MATRIZES E VETORES COMO ARGUMENTO DE FUNES ......................................................... 34 11.3 LIMITES ................................................................................................................................... 34 11.4 STRINGS .................................................................................................................................. 34 11.4.1 Leitura de Strings ............................................................................................................... 35
11.4.1.1 11.4.1.2 Funo scanf()........................................................................................................................... 35 Funo gets()............................................................................................................................. 35

11.4.2
11.4.2.1 11.4.2.2

Escrita de Strings ............................................................................................................... 36

Funo printf() .......................................................................................................................... 36 Funo puts()............................................................................................................................. 36

11.4.3
11.4.3.1 11.4.3.2 11.4.3.3 11.4.3.4

Funes de Manipulao de Strings .................................................................................. 37

Funo strlen() .......................................................................................................................... 37 Funo strcat()........................................................................................................................... 37 Funo strcmp() ........................................................................................................................ 37 Funo strcpy().......................................................................................................................... 37

11.4.4 Exemplo Geral.................................................................................................................... 38 11.5 EXERCCIOS ............................................................................................................................. 38 12. E/S COM ARQUIVO................................................................................................................... 40 12.1 STREAMS ................................................................................................................................. 40 12.2 ARQUIVOS ............................................................................................................................... 40 12.3 SISTEMA DE ARQUIVOS ........................................................................................................... 40 12.4 ESTRUTURA FILE.................................................................................................................... 41 12.5 ABERTURA DE ARQUIVOS ....................................................................................................... 41 12.6 FECHAMENTO DE ARQUIVO ..................................................................................................... 42 12.7 VERIFICANDO FIM DE ARQUIVO ............................................................................................... 42 12.8 COMANDO DE GRAVAO EM MODO TEXTO FORMATADO ....................................................... 42 12.9 STREAMS PADRO................................................................................................................... 43 12.10 EXERCCIOS ............................................................................................................................. 43 13. BIBLIOGRAFIA .......................................................................................................................... 44

LINGUAGEM C

1. Introduo
A linguagem C foi criada por Dennis M. Ritchie e Ken Thompson no Laboratrio Bell em 1972, baseada na linguagem B de Thompson que era uma evoluo da antiga BCPL. A linguagem C tornou-se muito popular devido a caractersticas como: O C uma linguagem de alto nvel com uma sintaxe bastante estruturada e flexvel tornando sua programao bastante simplificada. Programas em C so compilados, gerando programas executveis. O C compartilha recursos tanto de alto quanto de baixo nvel, pois permite acesso e programao direta do microprocessador. Com isto, rotinas cuja dependncia do tempo crtica, podem ser facilmente implementadas usando instrues em Assembly. Por esta razo o C a linguagem preferida dos programadores de aplicativos. O C uma linguagem estruturalmente simples e de grande portabilidade. O compilador C gera cdigos mais enxutos e velozes do que muitas outras linguagens. Embora estruturalmente simples (poucas funes intrnsecas) o C no perde funcionalidade pois permite a incluso de uma farta quantidade de rotinas do usurio. Os fabricantes de compiladores fornecem uma ampla variedade de rotinas pr-compiladas em biblioteca Como uma ferramenta poderosa a linguagem C usada na construo de vrios aplicativos como sistemas operacionais, planilhas eletrnicas, processadores de texto, sistemas de transmisso de dados, entre outros. Um exemplo clssico o sistema operacional UNIX, o qual foi implementado em C. No incio da dcada de 80 a linguagem C padronizada pelo American National Standard Institute: surge o ANSI C. Atualmente, a linguagem C vem sendo usada para desenvolver novas linguagens, entre elas a linguagem C++ e Java.

1.1 Viso geral de um programa C

A gerao do programa executvel a partir do programa fonte obedece a uma seqncia de operaes ante de tornar-se um executvel. Depois de escrever o mdulo fonte em um editor de textos, o programador aciona o compilador. Essa ao desencadeia uma seqncia de etapas, cada qual traduzindo a codificao do usurio para uma forma de linguagem de nvel inferior, que termina com o executvel criado pelo linkador. Editor (mdulo fonte em C) Pr-processador (novo fonte expandido)

Compilador (arquivo objeto) FIGURA 1.1 - Codificao de um programa C

Linkador (executvel)

LINGUAGEM C

2. Estrutura Bsica de um Programa em C

Um programa C consiste em uma ou vrias funes. Baseado nesta afirmao, deve existir um mecanismo que garanta que todos os programas inicializem da mesma forma. Este mecanismo pode ser entendido como a padronizao da funo que ser chamada primeiramente. Tal funo chama-se main(). Sintaxe: main() { } primeira funo a ser executada inicia o corpo da funo termina a funo

Abaixo relacionam-se algumas regras para a programao em C: Toda funo C deve ser iniciada e encerrada por um abre chaves e um fecha chaves respectivamente; O nome da funo, os parnteses e as chaves so os nicos elementos obrigatrios de uma funo; Todas as instrues devem estar dentro das chaves; As instrues C so sempre encerradas por um ponto-e-vrgula;

2.1 Bibliotecas
Para no ter que criar programas grandes devido a linkedio de um arquivo objeto a linguagem inclui as bibliotecas para que no momento da compilao seja gerado um programa com as funes utilizadas. Para fazer isto, usa-se uma diretiva de compilao a qual colocada fora de qualquer funo do programa. A diretiva #include instrui o compilador a ler outro arquivo-fonte. Sintaxe: #include nome_arq onde: nome_arq tem que estar entre aspas ou smbolos de maior ou menor Em algumas plataformas existe somente uma das duas formas. No caso da plataforma DOS/Windows 95, aspas significa para o compilador que a biblioteca em questo deve ser buscada primeiramente no diretrio atual e depois no diretrio padro do turbo ou pelas variveis de ambiente. Tambm, os caracteres <> significam ao compilador que deve procurar somente no diretrio padro ou nos diretrios definidos pelas variveis de ambiente. Exemplo 2.1 #include <stdio.h> No se usa o ponto-e-vrgula aps diretivas de compilao. Este tipo de declarao muito usado nos programas profissionais. Cada comando pr-definido em C est prototipado em alguma biblioteca (isto informado conjuntamente ao comando).

LINGUAGEM C

3. Tipos de Dados
Em C existem 5 tipos de variveis bsicas. Nos computadores da linha IBM-PC (sistema operacional 32 bits) a tabela 3.1 vlida. Tabela 3.1 - Tipos de dados bsicos para sistemas 32 bits (Windows, Linux) TIPO char int float double void BIT 8 32 32 64 0 FAIXA MNIMA -128 a 127 -2,147,483,648 a 2,147,483,647 3.4E-38 a 3.4E+38 1.7E-308 a 1.7E+308 sem valor

Com exceo de void, os tipos de dados bsicos podem estar acompanhados por modificadores na declarao de variveis. Os modificadores de tipos da linguagem C so: signed; unsigned; long; short.

Os modificadores signed, short, long e unsigned podem ser aplicados aos tipos bsicos caractere e inteiro. Contudo, long tambm pode ser aplicado a double. A tabela 3.2 mostra todas a combinaes de tipos de dados. Tabela 3.2 - Utilizao dos tipos de dados (plataforma 32 bits) Intervalo Tipo Bits Formato no scanf() Inicio Fim char 8 %c -128 127 unsigned char 8 %c 0 255 signed char 8 %c -128 127 int 32 %i -2.147.483.648 2.147.483.647 unsigned int 32 %u 0 4.294.967.295 signed int 32 %i -2.147.483.648 2.147.483.647 short int 16 %hi -32.768 32.767 unsigned short int 16 %hu 0 65.535 signed short int 16 %hi -32.768 32.767 long int 32 %li -18446744073709551616 18446744073709551615 signed long int 32 %li -18446744073709551616 18446744073709551615 unsigned long int 32 %lu 0 36893488147419103230 float 32 %f 3,4E-38 3.4E+38 double 64 %lf 1,7E-308 1,7E+308 long double 80 %Lf 3,4E-4932 3,4E+4932 O uso de signed com inteiros redundante. No entanto, ele permitido porque a declarao default de inteiros assume um nmero com sinal. O uso mais importante de signed modificar char em implementaes em que esse tipo, por padro, no tem sinal. Algumas implementaes podem permitir que unsigned seja aplicado aos tipos de ponto flutuante (como em unsigned double). Porm, isso reduz a portabilidade de seu cdigo e geralmente no recomendado. O modificador unsigned altera o valor da faixa mnima do tipo atravs do uso do bit mais significativo (indicador de sinal). Exemplo 3.1 #include <stdio.h> void main() { int qtde; char tam; float total; qtde = 2; tam = G; total = 20.70; printf(Comprei %d camisas de tamanho %c., qtde, tam);

LINGUAGEM C printf(\nNo total, paguei R$ %f., custo); } Execuo: Comprei 2 camisas de tamanho G. No total, paguei R$ 20.70. As variveis podem ser inicializadas no momento em que se faz a declarao das mesmas. Pode-se ver isto usando o programa anterior, que a execuo ser a mesma da verso anterior. #include <stdio.h> void main() { int qtde=2; char tam=G; float total=20.70; printf(Comprei %d camisas de tamanho %c., qtde, tam); printf(\nNo total, paguei R$ %f., custo); }

3.1 Sizeof()
O tamanho real de variveis pode mudar de mquina para mquina. A funoo sizeof() calcula o tamanho de qualquer varivel ou tipo e pode ajudar a eliminar cdigos dependentes da mquina de seus programas.

3.2 Constantes
Uma constante tem valor fixo e inaltervel durante a execuo do programa. Isto pode ser exemplificado pelos exemplos 3.1 e 3.2 da funo printf(). Em uma constante caractere escrita entre aspas simples (), uma constante cadeia de caracteres entre aspas duplas () e constantes numricas como o nmero propriamente dito. Exemplo 3.5 C programa 8 465.67 Constantes em C podem ser de qualquer um dos cinco tipos de dados bsicos. A maneira como cada constante representada depende do seu tipo. Pode-se especificar precisamente o tipo da constante numrica atravs da utilizao de um sufixo. Para tipos em ponto flutuante coloca-se um F aps o nmero, ele ser tratado como float. Se for colocado um L, ele tornar-se- um long double. Para tipos inteiros, o sufixo U representa unsigned e o L representa long. A tabela 5.3 mostra alguns exemplos de constantes. Tabela 3.3 - Exemplo de constantes Tipo de Dado int long int short int unsigned int float Double long double Exemplo de Constantes 1 123 21000 -234 35000L -34L 10 -12 90 10000U 987U 40000 123.23F 2.34e-3F 123.23 12312333 -0.9876324 1001.2L

Alm deste tem-se as constantes Hexadecimais e Octais. Usam-se tais sistemas numricos para facilitar a programao. Uma constante hexadecimal deve consistir em um 0x seguido por uma constante na forma hexadecimal. Uma constante octal comea com 0.

LINGUAGEM C

Exemplo 3.6 int hex = 0x80; int oct = 012; /* 128 em decimal */ /* 10 em decimal */

3.3 Constantes pr-definidas

Em alguns compiladores C, algumas constantes simblicas j esto pr-definidas. Estas constantes em geral definam alguns valores matemticos (, /2, e, etc.), limites de tipos etc. A seguir segue uma tabela contendo algumas (existem muitas outras) constantes simblicas pr-definidas no compilador Turbo C++ da Borland. Biblioteca math.h math.h math.h math.h math.h conio.h conio.h conio.h conio.h conio.h conio.h limits.h limits.h Constante M_PI M_PI_2 M_PI_4 M_1_PI M_SQRT2 BLACK BLUE GREEN CYAN RED MAGENTA INT_MAX INT_MIN Valor 3.14159... 1.57079... 0,78539... 0,31830... 1,41421... 0 1 2 3 4 5 32767 -32768 Significado /2 /4 1/ 2 valor da cor (preto) valor da cor (azul) valor da cor (verde) valor da cor (cyan) valor da cor (vermelho) valor da cor (magenta) limite superior do tipo int limite inferior do tipo int

3.4 As bibliotecas disponveis e algumas funes interessantes

A seguir segue uma lista de algumas as bibliotecas disponveis no compilador Turbo C++ Borland: Ao longo do texto veremos o uso de muitas funes cobrindo uma boa parte destas bibliotecas, porm o leitor que desejar tornar-se "fluente" na linguagem C pode (e deve) estud-las com profundidade. alloc.h conio.h errno.h graphics.h locale.h setjmp.h stdio.h strstrea.h values.h assert.h ctype.h fcntl.h io.h malloc.h share.h stdiostr.h sys\stat.h bcd.h dir.h float.h iomanip.h math.h signal.h stdlib.h sys\timeb.h bios.h dirent.h fstream.h iostream.h mem.h stdarg.h stream.h sys\types.h complex.h dos.h generic.h limits.h process.h stddef.h string.h time.h

A seguir, algumas funes disponveis pelas bibliotecas da linguagem C: Biblioteca math.h

LINGUAGEM C

int abs(int i); double fabs(double d); Calcula o valor absoluto do inteiro i e do real d, respectivamente. double sin(double arco); double cos(double arco); double tan(double arco); double asin(double arco); double acos(double arco); double atan(double arco); Funes trigonomtricas do ngulo arco, em radianos. double ceil(double num); double floor(double num); Funes de arredondamento para inteiro. ceil() arredonda para cima. Ex. ceil(3.2) == 3.0; floor() arredonda para baixo. Ex. floor(3.2) == 4.0; double log(double num); double log10(double num); Funes logartmicas: log() logaritmo natural (base e), log10() logaritmo decimal (base 10). double pow(double base, double exp); Potenciao: pow(3.2,5.6) = 3.25.6. double sqrt(double num); Raiz quadrada: sqrt(9.0) = 3.0.

Biblioteca stdlib.h int random(int num); Gera um nmero inteiro aleatrio entre 0 e num - 1.

LINGUAGEM C

4. Comando de Escrita
A funo printf() uma das funes de E/S (entrada e sada) que mostra na tela os parmetros que so passados como argumento. Seu prottipo est na biblioteca stdio.h. Sintaxe: printf(<expressao_de_controle>, lista_de_argumentos) onde: expresso_de_controle = contm caracteres que sero exibidos na tela e cdigos de formatao que indicam o formato em que os argumentos (da lista_de_argumentos) devem ser impressos. lista_de_argumentos = lista de argumentos que sero apresentadas na expresso_de_controle. Tal lista no tem tamanho mximo e cada argumento deve ser separado por uma vrgula. A tabela 4.1 mostra os cdigos na linguagem para caracteres que no podem ser inseridos diretamente do teclado. Tabela 4.1 - Cdigo para os caracteres especiais CDIGO \n \t \b \ \\ \f \r \ \v \a \N \xN \0 SIGNIFICADO Nova Linha (LF) Tab (HT) Retrocesso (BS) Barra invertida Salta Pgina de Formulrio (FF) Retorno de Carro (CR) Tabulao Vertical Alerta (beep) Constante octal (onde N uma constante octal) Constante Hexadecimal (onde N uma constante hexadecimal) Nulo

Alm destes, existem os cdigos para formatao de impresso dos argumentos passados para a funo, os quais est relacionados na tabela 4.2. Tabela 4.2 - Cdigos para formatao de impresso CDIGO printf() %c %d ou %i %e ou %E (minsculo ou maisculo) %f %g ou %G (minsculo ou maisculo) %o %s %u %x ou %X (minsculo ou maisculo) %% FORMATO Caractere Simples Decimal Notao Cientfica Ponto Flutuante %e ou %f (o mais curto) Octal Cadeia de Caracteres Decimal sem Sinal Hexadecimal Escreve o smbolo %

LINGUAGEM C

Exemplo 4.1 #include <stdio.h> void main() { printf(A %s C foi criada em %d \nOk?, Linguagem, 1972); } Execuo:: A Linguagem C foi criada em 1972 Ok? No exemplo 3.1 percebe-se o uso de dois tipos de cdigos: primeiro de formatao com %s (para strings) representando a constante string Linguagem e %d (decimais) representando a constante ano 1972; segundo um cdigo especial para representar caracter de nova linha \n. Exemplo 4.2 #include <stdio.h> void main() { printf(A %s %c foi , Linguagem, C); printf( criada em %d , 1972); } Execuo: A Linguagem C foi criada em 1972 No exemplo 3.2, nota-se que C delimitado por aspas simples enquanto que Linguagem delimitado por aspas duplas. Isto indica ao compilador como diferenciar um caractere de uma cadeia de caracteres.

4.1 Modificadores de Sada

Para complementar os cdigos de formatao a linguagem C oferece alguns cdigos especiais para melhorar a apresentao dos dados. Para isto relacionam-se: - : alinhamento pela esquerda. +: coloca o sinal de menos ou mais se o valor for numrico. n (nmero) : indica o tamanho mnimo do campo. O preenchimento feito com espaos em branco. Se o tamanho iniciar com 0 (ex. 05), o preenchimento passa a ser feito com zeros. .m : tamanho mximo do campo, menos para os reais onde usado para indicar o nmero de casas decimais. * : substitui um dos n, mas o seu valor o prximo parmetro. l : indica que segue um dado longo. Exemplo 4.3 COMANDO printf(%s %d, Numero,10); printf(%8s %4d, Numero,10); printf(%-8s %4d, Numero,10); printf(%-3.5s %2.2f,Numero,10.99); printf(Long %ld, 57485784); onde: # - representa 1 espao em branco. TELA Numero 10 ##Numero ##10 Numero## ##10 Numer 10.99 Long 57485784

LINGUAGEM C

4.2 Exerccios
1. Escreva os comandos de sada formatada que gerem as seguintes sadas: 01234567890123456789012 a) Camisa estampada 40,00 Camisa lisa 35,00 b) Camisa estampada Camisa lisa c) Camisa estampada Camisa lisa d) Camisa e Camisa l 40 35 40,00 35,00 00040,00 00035,00

LINGUAGEM C

5. Variveis
Varivel em C um espao de memria reservado para armazenar um certo tipo de dado e tendo um nome para referenciar o seu contedo. O contedo da mesma pode variar segundo os comandos de alterao do programa. Exemplo 5.1 #include <stdio.h> void main() { int ano; ano = 1972; printf(A Linguagem C foi criada em %d , ano); } A primeira instruo, int ano; um exemplo de declarao de varivel, isto , apresenta um tipo, int, e um nome, ano. A segunda instruo, ano = 1972; atribui um valor varivel e este valor ser acessado atravs de seu nome. Para realizar isto foi usado o operador de atribuio (=).

5.1 Nome de Variveis

Regras: Uma varivel no pode ter o mesmo nome de uma palavra-chave de C. Em C, letras maisculas diferem das letras minsculas. O nmero de caracteres vlidos definido de ambiente para ambiente.

5.2 Declarao de Variveis

A declarao de variveis serve para reservar uma quantidade de memria apropriada para armazenar o tipo especificado. Tal declarao consiste no nome de um tipo, seguido do nome da varivel. Em C todas as variveis devem ser declaradas. Se existir mais de uma varivel do mesmo tipo, pode-se declar-la de uma vez separando seus nomes por vrgulas. int ano, mes, dia;

5.2.1 Tipos de Declaraes de Variveis

O tipo de declarao de varivel definido pela localizao onde a mesma declarada. Existem trs lugares bsicos: dentro de funes, na definio dos parmetros das funes e fora de todas as funes. Estas so variveis locais, parmetros formais e variveis globais, respectivamente.

LINGUAGEM C

5.2.1.1 Variveis locais

Variveis que so declaradas dentro de uma funo. Tais variveis s podem ser referenciadas por comandos que esto dentro do bloco no qual as variveis foram declaradas, isto , no so reconhecidas fora de seu prprio bloco de cdigo. Exemplo 5.2 #include <stdio.h> void main() { int num; num = 10; }

5.2.1.2 Parmetros Formais

Variveis que so declaradas para passagem de parmetros em funes. Exemplo 5.3 int soma(int x, int y) { return (x+y); }

5.2.1.3 Variveis Globais

Variveis que so declaradas fora de qualquer funo. Tais variveis so reconhecidas pelo programa inteiro e podem ser usadas por qualquer pedao de cdigo. Exemplo 5.4 int num=10; #include <stdio.h> void main() { printf(%d, num * num); } Exemplo 5.5 int num=2; int media(int y, int x) { return ((x+z)/num); } #include <stdio.h> void main() { int x1 = 15; int x2 = 4; printf(%d } %d , num * num, media(x1,x2));

5.3 Palavras reservadas

Existem certos nomes que no podem ser usados como identificadores. So chamadas as palavras reservadas e so de uso restrito da linguagem C (comandos, estruturas, declaraes, etc.). O conjunto de palavras reservadas usadas em C o seguinte: asm auto break case cdecl char

LINGUAGEM C class do extern friend interrupt pascal _saveregs static union const double _export goto _loadds private _seg struct unsigned continue _ds far huge long protected short switch virtual _cs else _fastcall if near public signed template void default enum float inline new register sizeof this volatile delete _es for int operator return _ss typedef while

LINGUAGEM C

6. Operadores
A linguagem C muito rica em operadores internos. C define quatro classes de operadores: aritmticos, relacionais, lgicos e bit a bit. Alm disso, C tem alguns operadores especiais para tarefas particulares.

6.1 Atribuio
Para o operador de atribuio utilizado o smbolo =. Alm disto, a linguagem oferece um tipo de atribuio mltipla, isto , em um comando s pode-se atribuir o mesmo valor a muitas variveis. Exemplo 6.1 x = 10; a = b = c = 10;

6.1.1 Converso de Tipos em Atribuies

A linguagem C permite a converso automtica de tipos, o que no acontece em Pascal, por exemplo. Converso de tipos refere-se situao em que variveis de um tipo so misturadas com varveis de outro tipo. Em um comando de atribuio, a regra de converso de tipos muito simples: o valor do lado direito (lado da expresso) de uma atribuio convertido no tipo do lado esquerdo (varivel destino), como no exemplo 6.2: Exemplo 6.2 #include <stdio.h> void main() { int x; char ch; float f; ch = x; x = f; f = ch; f = x; } Na linha 1, os bits mais significativos da varivel inteira x so ignorados, deixando ch com os 8 bits menos significativos. Se x est entre 255 e 0, ento ch e x tm valores idnticos. De outra forma, o valor de ch reflete apenas os bits menos significativos de x. Na linha 2, x recebe a parte inteira de f. Na linha 3, f converte o valor inteiro de 8 bits armazenado em ch no mesmo valor em formato de ponto flutuante. Isso tambm acontece na linha 4, exceto por f converter um valor inteiro de 16 bits no formato de ponto flutuante. Na tabela 6.1 mostra-se algumas converses de tipos e seus efeitos. Para essas converses foi assumido uma palavra de 16 bits. Tabela 6.1 - Converses de tipos e seus efeitos Tipo Destino signed char char char char int int float double Tipo da Expresso char short int int long int long int float double long double Possvel Informao Perdida Se valor > 127, o destino negativo Os 8 bits mais significativos Os 8 bits mais significativos Os 24 bits mais significativos Os 16 bits mais significativos A parte fracionria e possivelmente mais Preciso, o resultado arredondado Preciso, o resultado arredondado // // // // Linha Linha Linha Linha 1 2 3 4

Para utilizar a tabela acima a fim de fazer uma converso no mostrada, simplesmente converta um tipo por vez at acabar. por exemplo, para converter double em int, primeiro converta double em float e, ento, float em int.

LINGUAGEM C

6.2 Operadores Aritmticos

A tabela 6.2 mostra os operadores aritmticos suportados pela linguagem. Tabela 6.2 - Operadores aritmticos Operador + * / % -++ Ao Subtrao, tambm menos unrio Adio Multiplicao Diviso Mdulo da Diviso (resto) Decremento Incremento

O menos unrio multiplica seu nico operando por -1. Isso , qualquer nmero precedido por um sinal Quando / aplicado a um inteiro ou caractere, qualquer resto truncado. O operador mdulo % tambm, trabalha em C da mesma forma que em outras linguagens, devolvendo o resto de uma diviso inteira. Contudo, % no pode ser usado nos tipos em ponto flutuante.

6.2.1 Incremento e Decremento

A linguagem C inclui dois operadores que geralmente no encontramos em outras linguagens. So os operadores de incremento (++) e decremento (--), os quais somam 1 ao seu operando, e subtraem 1 de seu operando, respectivamente. x++; ou ++x; ou x = x + 1; x--; ou --x; ou x = x - 1; Quando usados em uma expresso tem seus efeitos alterados pela posio do sinal de decremento e incremento. Se o operador de incremento ou decremento preceder seu operando, C executa a operao de incremento ou decremento antes de usar o valor do operando. Se o operador estiver aps seu operando, C usa o valor do operando antes de increment-lo ou decrement-lo. Exemplo 6.3 x = 10; y = ++x; /*y recebe 11*/ x = 10; y = x++; /* y recebe 10 */

A precedncia dos operadores aritmticos a seguinte: ++ * + -/ % Mais baixa Mais alta

Os operadores do mesmo nvel de precedncia so avaliados pelo compilador da esquerda para a direita.

6.2.2 Operadores Aritmticos de Atribuio

A tabela 6.3 mostra os operadores aritmticos de atribuio suportados pela linguagem.

LINGUAGEM C

Tabela 6.3 - Operadores aritmticos de atribuio Operador x -= y x += y x *= y x /= y x %= y Ao x=x-y x=x+y x=x*y x=x/y x=x%y

As expresses com este operadores so mais compactas e normalmente produzem um cdigo de mquina mais eficiente.

6.3 Operadores Relacionais e Lgicos

A tabela 6.4 mostra os operadores relacionais e lgicos suportados pela linguagem C. Tabela 6.4 - Operadores relacionais e lgicos Operador > >= < <= == != Ao Maior que Maior ou igual que Menor que Menor ou igual que Igual Diferente Operador && || ! Ao AND OR NOT

Em C, verdadeiro qualquer valor diferente de zero, e falso zero. As expresses que usam operadores relacionais ou lgicos devolvem zero para falso e 1 para verdadeiro. Lembre-se de que toda expresso relacional e lgica produz como resiltado 0 ou 1. A precedncia dos operadores relacionais e lgicos a seguinte: ! > == && || Mais alta >= != < <=

Mais baixa

6.4 Operadores de Ponteiros & e *

Um ponteiro um endereo na memria de uma varivel. Uma varivel de ponteiro uma varivel especialmente declarada para guardar um ponteiro para seu tipo especificado. O primeiro operador de ponteiro &. Ele um operador unrio que devolve o endereo na memria de seu operando. Por exemplo, m = &cont; atribui o endereo de memria da varivel cont em m. Este tipo de operando no pode ser utilizado em trs casos: 1. &(cont + 4) - sempre associa-se a uma varivel e no expresso; 2. &3 - constantes no so vlidas;

LINGUAGEM C

3. variveis declaradas com classe de armazenamento register (no existe endereo para registrador). O segundo operador *. Ele um operador unrio que devolve o valor da varivel localizada no endereo que o segue. Por exemplo, se m contm o endereo da varivel cont, q = *m; coloca o valor de cont em q. Os seguintes operadores * e & colocam o valor 10 na varivel chamada target. O resultado (o valor 10) deste programa mostrado na tela. Exemplo 6.5 #include stdio.h #include <stdio.h> void main() { int target, source; int *m; source = 10; m = &source; target = *m; printf(%d,target); }

6.5 Operador Vrgula

O operador vrgula usado para encadear diversas expresses. O lado esquerdo de um operador vrgula sempre avaliado como void. Isso significa que a expresso do lado direito se torna o valor de toda a expresso separada por vrgulas. Exemplo 6.6 x = (y = 3, y + 1); No exemplo 6.5, primeiro y recebe 3 e, em seguida, atribui o valor 4 a x.

6.6 Expresses
Operadores, constantes e variveis so os elementos que constituem as expresses. Uma expresso em qualquer combinao vlida desses elementos.

6.6.1 Converso de Tipos em Expresses

Quando constantes e variveis de tipos diferentes so misturadas em uma expresso, elas so convertidas a um mesmo tipo. O compilador C converte todos os operandos no tipo do maior operando, o que denominado promoo de tipo. Isso feito operao por operao, como descrito nas regras de converso de tipos abaixo. SE um operando long double ENTO o segundo convertido para long double. SENO, SE um operando double ENTO o segundo convertido para double. SENO, SE um operando float ENTO o segundo convertido para float. SENO, SE um operando unsigned long

LINGUAGEM C

ENTO o segundo convertido para unsigned long. SENO, SE um operando long ENTO o segundo convertido para long. SENO, SE um operando unsigned ENTO o segundo convertido para unsigned. H ainda um caso adicional especial: se um operando long e o outro unsigned, e se o valor do unsigned no pode ser representado por um long, os dois operandos so convertidos para unsigned long. Considere as converses de tipo que ocorrem no exemplo 6.6. Primeiro, o caractere ch convertido para um inteiro e float f convertido para double. Em seguida, o resultado de ch/i convertido para double porque f*d double. O resultado final double porque, nesse momento, os dois operandos so double. Exemplo 6.7 char ch; int i; float f; double d; result= ( ch / i )

( f * d )

( f + i );

int

double

float

double

double

6.6.2 Casts
A linguagem permite que uma expresso pode ser forada a ser de um tipo especificado usando uma construo chamada cast. A forma geral de um cast (tipo) expresso onde um tipo um tipo de dado padro de C. Por exemplo, para ter certeza de que a expresso x /2 ser do tipo float, escreve-se (float) x/2; Neste caso se a varivel x fosse um inteiro mpar sem o cast seu valor reria um inteiro (o que no seria verdadeiro). Entretanto, com o uso do Cast oa varivel x definida como um float o que tornar o seu resultado um float. Como um operador, um cast unrio e tem a mesma precedncia de qualquer outro operador unrio.

LINGUAGEM C

6.6.3 Espaamento e Parnteses

A linguagem C no limita o espaamento ou tabulaes em uma expresso. Ajudam a aumentar a legibilidade do programa. O excesso de parnteses no causa erros, isto , colocar parnteses onde no necessita, no provoca erros, mas dificulta a leitura do programa.

LINGUAGEM C

7. Algumas funes de E/S

Neste captulo ser visto algumas funes como scanf (), getchar() e putchar(). Tais funes encontram-se no arquivo stdio.h.

7.1 Funo scanf()

Esta funo serve para ler dados formatados da entrada padro (teclado). Sua sintaxe similar de printf(), isto , uma expresso de controles seguida por uma lista de argumentos separados por vrgulas. A principal diferena que os argumentos de scanf() devem ser endereos de variveis. Para enviar o endereo de cada argumento utiliza-se o operador &. Sintaxe: scanf(expresso_de_controle,lista_de_argumentos) A expresso de controle pode conter cdigos de formatao, precedidos por um sinal %. Alm disso, o caractere * colocado aps o % que avisa funo que deve ser lido um valor do tipo indicado pela especificao, mas no deve ser atribudo a nenhuma varivel (no deve ter parmetros na lista de argumentos para estas especificaes). Tabela 7.1 - Cdigos de formatao do comando scanf() CDIGO printf() %c %d ou %i %e %f %g %o %s %u %x %l %% Exemplo 7.1 #include <stdio.h> void main() { char a; printf(Digite um caractere e veja-o em decimal, ); printf ( octal e hexadecimal. \n); scanf(%c,&a); printf(\n%c=%d dec., %o oct. e %x hex. \n,a,a,a,a); } Execuo (faa voc mesmo): FORMATO L um nico caractere simples L um inteiro decimal L um nmero em notao cientfica L um nmero em ponto flutuante L um nmero em ponto flutuante L um nmero em octal L um nmero em cadeia de Caracteres L um decimal sem sinal L um hexadecimal L um inteiro longo Busca por um conjunto de caracteres

LINGUAGEM C

Ateno: quando a funo scanf() for utilizada para ler caracteres (isto , utilizar o %c), deve-se adicionar a linha de comando flush(stdin); aps a linha da funo scanf(). Esta funo limpa o bufer do teclado j que o %c considera o ENTER como um novo caracter.

7.2 Lendo e escrevendo caracteres

A funo getchar() l um caractere do teclado (este comando necessita o pressionamento da tecla <ENTER> aps o caractere), e putchar() escreve um caracter na tela. A funo getchar() espera at que uma tecla seja pressionada (a qual mostrada na tela) e devolve o seu valor. A funo putchar() escreve seu argumento caractere na tela a partir da posio atual do cursor. Os prottipos para getchar() e putchar() so mostrados aqui: int getchar(void); int putchar(int c); A funo getchar() devolve um inteiro, mas o byte de baixa ordem contm o caractere. Alm disso, pode-se chamar putchar() com um argumento caractere. A funo putchar() devolve o caractere escrito, ou EOF (definida em stdio.h e geralmente igual a -1), se ocorreu algum erro. A funo putchar() no acrescenta um \n a sada. Exemplo 7.4 #include <stdio.h> void main() { char ch; printf(Digite algum caractere:); ch=getchar(); printf(\n A tecla pressionada eh ); putchar(ch); }

7.3 Exerccios
1. Escreva um programa que leia 3 nmeros e mostre a sua mdia. 2. Escreva um programa que leia 2 nmeros e mostre qual o maior. 3. Faa um programa que leia dois nmeros e em seguida mostre ,o produto a soma e a subtrao entre eles. 4. Faa um programa que leia 3 variveis a, b e c, coeficientes de uma equao do 2 grau e escreva as duas razes da equao.

x=

b , 2a

onde

= b 2 4ac

5. Escreva um programa onde o usurio entra com um nmero qualquer e o programa responda se o nmero e par ou impar . Se for par emite a mensagem O nmero par ou caso contrrio O nmero impar .

LINGUAGEM C

8. Comandos Condicionais
Neste captulo sero vistos os comandos condicionais da linguagem C.

8.1 Comando if
Sintaxe: if (<expresso>) <comando>; else <comando>; Onde comando pode ser um nico comando, um bloco de comandos ou nada (no caso de comandos vazios). A clusula else opcional. Exemplo 8.1 if (x != 0) x = 0; Obs.: Caso haja um else ele pertence ao if mais prximo. Exemplo 8.2 if (a > 5) { if (a < 10) b = 3; } else b = 7; No exemplo 8.2, se no fosse separado por chaves o comando if mais interno o else pertenceria ao mesmo e no ao mais externo. Exemplo 8.3 /* Programa para adivinhar um numero */ #include stdio.h #include stdlib.h void main() { int num, tentativa; num = rand(); /*gera numero aleatorio entre 0 e 32767*/ scanf(%d, &tentativa); if (tentativa == num) printf(* * * CERTO * * *); } Lembre-se que para montar um bloco de comando somente necessrio usar o abre e fecha chaves para marcar incio e fim de bloco de comandos respectivamente.

8.2 Comando switch

C tem um comando interno de seleo mltipla, switch, que testa sucessivamente o valor de uma expresso contra uma lista de constantes inteiras ou de caractere. Sintaxe: switch (<expresso>) { case <valor1> : <seqncia de comandos> break;

LINGUAGEM C

case <valor2> : <seqncia de comandos> break; default: <seqncia de comandos> } O valor da expresso testado, na ordem, contra os valores das constantes especificadas nos comandos case. Quando uma coincidncia for encontrada, a seqncia de comandos associada quele case ser executada at que o comando break ou o fim do comando switch seja alcanado. O comando default (opcional) executado no momento em que no coincidir nenhum valor. Exemplo 8.4 #include <stdio.h> void main() { char opcao; printf(1. Opcao 1 \n); printf(2. Opcao 2 \n); printf(3. Opcao 3 \n); printf(Opcao:); opcao=getchar(); switch(opcao) { case 1: printf (\nVoc escolheu a opcao 1); break; case 2: printf (\n Voc escolheu a opcao 2); break; case 3: printf (\n Voc escolheu a opcao 3); break; default: printf (\n Nenhuma opcao selecionada); break; } }

8.3 Exerccios
1. Escrever um programa que leia 3 pares de cordenadas (x,y), que definam 3 pontos e: Verificar se eles formam um tringulo : no podem estar alinhados e no podem haver pontos sobrepostos. calcular os lados do tringulo. classificar o tipo do tringulo: eqiltero, issceles ou escaleno. acutngulo, obtusngulo ou retngulo 2. Escreva um programa que leia 3 nmeros e os escreve em ordem crescente. 3. Faa um programa que leia um nmero inteiro, verifique se positivo ou negativo e escreva uma mensagem apropriada. 4. Faa um programa contendo um menu com as seguintes opes : S - soma P - produto U - subtrao D - diviso Q - sair O programa deve conter uma funo para executar cada tarefa pedida: soma , subtrao etc . Quando o usurio teclar ESC o programa deve terminar.

LINGUAGEM C

9. Estrutura de Repetio (Laos)

9.1 Lao for
Comando de repetio condicional com inicializao e incremento. Sintaxe: for(inicializao; condio;incremento) comando; Onde comando um comando vazio, um comando simples, ou um bloco de comandos. Primeiro executado a inicializao que consiste em atribuies iniciais. Depois testada a condio (expresso relacional) de controle do lao. O incremento executado aps a execuo do comando ou bloco de comandos. O fim do lao determinado pelo valor falso que a condio se apresenta. Exemplo 9.1 #include stdio.h void main() { int x; for(x=1; x<=100; x++) printf(%d,x); } No programa acima x inicializado com 1. Uma vez que x menor que 100, printf() executado e x incrementado em 1 e testado para ver se ainda menor ou igual a 100. Esse processo se repete at que x fique maior que 100; nesse ponto, o lao termina. Ento este programa imprime na tela os nmeros de 1 a 100.

9.2 Lao while

Comando de repetio condicional. Sintaxe: while(condio) comando; Onde comando um comando vazio, uma comando simples, ou um bloco de comandos. Primeiro testada a condio (expresso relacional) de controle do lao. E a cada execuo de comando repetido o teste de condio. O fim do lao determinado pelo valor falso que a condio se apresenta. Exemplo 9.2 #include <stdio.h> void main() { int cont=0; char ch; while((c=getchar()) != 0) cont++; printf(Foram lidos %d caracteres,cont); }

9.3 Lao do-while

Ao contrrio dos comandos for e while, que testam a condio do lao no comeo, o lao dowhile verifica a condio ao final do lao. Sintaxe:

LINGUAGEM C

do <comando> while(condio); Exemplo 9.2 #include <stdio.h> void main() { char opcao; printf(1. Opcao 1 \n); printf(2. Opcao 2 \n); printf(3. Opcao 3 \n); printf(Opcao:); do { opcao=getchar(); switch(opcao) { case 1: printf (\nVoc escolheu a opcao 1); break; case 2: printf (\n Voc escolheu a opcao 2); break; case 3: printf (\n Voc escolheu a opcao 3); break; printf (\n Nenhuma opcao selecionada); break; }} while (opcao != 1 && opcao != 2 && opcao != 3); } default:

9.4 Comandos break e exit()

O comando break pode ser usado no corpo de qualquer estrutura de lao C. Causa a sada imediata do lao e o controle passa para o prximo comando do programa. Sintaxe: break; Pode-se sair de um programa usando a funo exit() da biblioteca padro. Essa funo provoca uma terminao imediata do programa inteiro, forando um retorno ao sistema operacional. Sintaxe: void exit(int cdigo_de_retorno); O valor de cdigo_de_retorno retornado ao processo chamador (sistema operacional). O zero geralmente usado como um cdigo de retorno que indica uma terminao normal do programa. Exemplo 9.3 #include <stdio.h> void main() { char opcao; printf(1. Opcao 1 \n); printf(2. Opcao 2 \n); printf(3. Opcao 3 \n); printf(4. Abandonar \n); printf(Opcao:); do { opcao=getchar(); switch(opcao) { case 1: printf (\nVoc escolheu a opcao 1); break;

LINGUAGEM C case 2: printf (\n Voc escolheu a opcao 2); break; case 3: printf (\n Voc escolheu a opcao 3); break; case 4: exit(0); /* retorna ao SO */ }} while (opcao != 1 && opcao != 2 && opcao != 3); }

9.5 Exerccios
1. Escreva um programa para calcular o fatorial de um nmero lido. 2. Escreva um programa para ler um caracter de comparao e vrios caracteres de entrada finalizados por 0 e contar o nmero de vezes que o caracter de comparao apareceu. 3. Escrever um programa que mostre os nmeros primos entre 1 e 100. 4. Escreva um programa que leia um nmero no determinado de valores positivos, e mostre a soma e mdia dos respectivos nmeros ao ser lido um valor negativo. 5. Faa um programa que leia um nmero (inteiro) e escreva todos os seus divisores. 6. Faa um programa que receba como entrada uma quantia em dinheiro e mostre na tela a quantidade de notas de 5, 10, 50 e 100 so necessrias para representar o valor. O programa deve contabilizar a partir das notas de 100. 7. Suponha um nmero N qualquer: se N par ento N agora N / 2; se N mpar N agora 3*N + 1. Assim para N = 3 calculamos a seguinte tabela : 3 10 4 2 10 5 2 1 5 16 1 4 16 8 4 2 8 4 2 1 Observe que a partir de sete iteraes a seqncia 4 2 1 comea a se repetir . Faa um programa que calcule para um dado N o nmero de iteraes at se chegar ao primeiro 1 . 8. Faa um programa que imprima os elementos de uma PA e o somatrio da mesma dados : primeiro termo , numero de termos e razo 9. Faa um programa que imprima um elemento da seqncia de Fibonacci, dado o numero do elemento. 10. Faa um programa onde o usurio entra com um nmero decimal e o mesmo calcula e imprime o nmero no sistema binrio . 11. Faa um programa onde o usurio entra com dois nmeros A e B o programa devolve como resultado A elevado a B . 12. Escreva um programa que solicite ao usurio trs nmeros inteiros a,b,c onde a maior que 1 . Seu programa deve somar todos os inteiros entre b e c divisveis por a.

LINGUAGEM C

10. Funes
A forma geral de uma funo : Sintaxe: tipo_funo nome_funo (lista_de_parmetros) declarao_parmetros { corpo_funo; } Exemplo 10.1 int soma(int x, int y) { ... } ou int soma(x, y) int x,y; { ... } As funes retornam um valor (do tipo indicado em tipo_funo). O valor retornado pela funo dado pelo comando return (o valor retornado pode ou no ser utilizado). Existem dois tipos de passagem de argumentos: por valor e por referncia. A segunda realizada atravs de apontadores. Exemplo 10.2 int pot(x,n) int x,n; { int p; for(p=1;n>0;n--) p *= x; return p; } /* x elevado na n potncia */

No exemplo 11.2, os argumentos foram passados por valor e a funo retorna um valor do tipo inteiro. A chamada seria: a = pot(10,2); No exemplo 11.3, nenhum valor retornado (por isso usa-se o tipo void) mas realizado uma troca dos valores das variveis, necessitando de uma passagem de parmetros por referncia. Exemplo 10.3 void troca(a,b) int *a, *b; { int aux; aux = *a; *a = *b; *b = aux; } /* troca os valores das variveis */ /* usa-se ponteiros para referenciar */ /* o contedo do endereo da varivel */

A chamada para esta funo seria:

LINGUAGEM C int x=1,y=2; troca(&x,&y); Na passagem de parmetros por referncia passado explicitamente o endereo da varivel com o uso do operador &. Quando o argumento for uma matriz automaticamente ser passado o endereo da matriz para a funo. A linguagem C aceita chamadas recursivas de funes.

10.1 Localizao das funes

Existem basicamente duas posies possveis para escrevermos o corpo de uma funo: ou antes ou depois do programa principal. Podemos ainda escrever uma funo no mesmo arquivo do programa principal ou em arquivo separado.

10.1.1 Corpo da funo antes do programa principal (no mesmo arquivo)

Quando escrevemos a definio de uma funo antes do programa principal e no mesmo arquivo deste, nenhuma outra instruo necessria. Exemplo 10.4 float media2(float a, float b){ float med; med = (a + b) / 2.0; return(med); } // funo

void main() { // programa principal float num_1, num_2, med; puts(Digite dois nmeros:); scanf(%f %f, &num_1, &num_2); med = media2(num_1, num_2); // chamada da funo printf(\nA media destes nmeros e %f, med); }

10.1.2 Corpo da funo depois do programa principal (no mesmo arquivo)

Quando escrevemos a definio de uma funo depois do programa principal e no mesmo arquivo deste, devemos incluir um prottipo da funo chamada. Um prottipo uma instruo que define o nome da funo, seu tipo de retorno e a quantidade e o tipo dos argumentos da funo. O prottipo de uma funo indica ao compilador quais so as funes usadas no programa principal os tipo. A sintaxe geral para isto a seguinte: Sintaxe: void main() { tipo nomef(...); ... var = nomef(...) ... } tipo nomef(...){ [corpo de funo] // programa principal // prottipo da funo // chamada a funo

// definio da funo

LINGUAGEM C }

Exemplo 10.5 #include <stdio.h> void main() { // programa principal float media2(float,float); // prottipo de media2() float num_1, num_2, med; puts(Digite dois nmeros:); scanf(%f %f, &num_1, &num_2); med = media2(num_1, num_2); // chamada a funo printf(\nA media destes nmeros e %f, med); } float media2(float a, float b){ // funo media2() float med; med = (a + b) / 2.0; return(med); } Observe que o prottipo de uma funo nada mais que a declarao da funo sem o seu corpo. Observe ainda que na lista de argumentos do prottipo podem ser escritos apenas os tipos dos argumentos.

10.1.3 Corpo da funo escrito em arquivo separado

Em C, como em muitas outras linguagens, permitido que o usurio crie uma funo em um arquivo e um programa que a chame em outro arquivo distinto. Esta facilidade permite a criao de bibliotecas de usurio: um conjunto de arquivos contendo funes escritas pelo usurio. Esta possibilidade uma grande vantagem utilizada em larga escala por programadores profissionais. Quando escrevemos a definio de uma funo em arquivo separado do programa principal devemos incluir este arquivo no conjunto de arquivos de compilao do programa principal. Esta incluso feita com a diretiva #include. Esta diretiva, vista nas sees 2.4.2 e 3.7.1, instrui o compilador para incluir na compilao do programa outros arquivos que contem a definio das funes de usurio e de biblioteca. Sintaxe: #include path void main() { ... var = nomef(...) ... } // incluso da funo // programa principal // chamada a funo

Na diretiva #include, indicamos entre aspas duplas o caminho de localizao do arquivo onde est definida a funo chamada. Exemplo 10.6 #include c:\tc\userbib\stat.h // incluso da funo void main() { // programa principal float num_1, num_2, med; puts(Digite dois nmeros:); scanf(%f %f, &num_1, &num_2); med = media2(num_1, num_2); // chamada a funo printf(\nA media destes nmeros e %f, med); }

LINGUAGEM C

10.2 Prottipo de funes

O padro ANSI C expandiu a declarao tradicional de funo, permitindo que a quantidade e os tipos dos argumentos das funes sejam declarados. A definio expandida chamada prottipo de funo. Prottipos de funes no faziam parte da linguagem C original. Prottipos permitem que C fornea uma verificao mais forte dos tipos. Prottipos de funes ajudam a detectar erros antes que eles ocorram. verificado nmero de parmetros, compatibilidade de tipos, entre outras. Existem trs tipos de declarao de prottipos: Sintaxe tipo_funo nome_funo(); tipo_funo nome_funo(lista_tipo_argumentos); tipo_funo nome_funo(lista_tipo_nome_argumentos); Exemplo int pot(); int pot(int,int); int pot(int x, int y);

10.3 Diretiva #define

A diretiva #define pode ser usada para definir constantes simblicas com nomes apropriados. Por exemplo, a constante PI pode ser definida com o valor 3.14159. #define PI 3.14159 S pode ser escrito um comando destes por linha, e no h ponto-e-vrgula aps qualquer diretiva do pr-processador. Esta diretiva usada para definir macros com argumentos. #define AREA(x) (4*PI*x*x) A declarao acima define a funo AREA() a qual calcula a rea de uma esfera. A vantagem desta declarao no tipagem do argumento x. No deve haver espaos entre o nome da macro e seus identificadores.

10.4 Exerccios
1. Escreva um programa que receba como parmetro um ndice (float). Aps, ler uma sequncia de nmeros (a qual termina por 0) e exibir o seu valor multiplicado pelo ndice. A funo que transforma uma string em um float atof(char *x). 2. Escreva uma funo que receba um caracter como argumento e que retorne a letra maiscula se a mesma for minscula. funes: islower(int ch), toupper(int ch). 3. Implementar as seguintes funes: strlen(), strcat(), e strcpy()

LINGUAGEM C

11. Vetores e Matrizes

Vetores e matrizes so estruturas de dados usada para representar uma certa quantidade de variveis de valores homogneos. Em C, estas estruturas precisam ser declaradas, como quaisquer outras variveis, para que o compilador conhea o tipo do vetor ou da matriz e reserve espao de memria suficiente para armazen-lo. O que diferencia a declarao de uma matriz ou vetor da declarao de qualquer varivel a parte que segue o nome, isto , os pares de colchetes ([ e ]) que envolvam um nmero inteiro, que indica ao compilador o tamanho da matriz. int notas[5]; A declarao acima aloca um intervalo de memria com nome notas para armazenar 5 elementos do tipo int. Por definio um vetor ou matriz composto por elementos de um nico tipo. Para a declarao de mais de uma dimenso em C necessrio o nmero de par de colchetes ser igual ao nmero de dimenses. Isto , se a matriz for de duas dimenses teremos uma declarao assim: int notas[5][5]; que declara uma matriz bi-dimensional; para trs dimenses assim int notas[5][5][5]; que declara uma matriz tridimensional e assim por diante. O limite de ndices definido pelo compilador ou pela memria. Os elementos do vetor ou da matriz so sempre enumerados por ndices iniciados por 0 (zero). Exemplo 11.1 for (i=0;i<5;i++) { printf(Digite a nota do aluno %d:,i); scanf(%d, &notas[i]); } Obs.: A linguagem C no realiza verificao de limites em matrizes!!!

11.1 Inicializao de Vetores e Matrizes

Como o C permite a inicializao de variveis bsicas, tambm permitido a inicializao de vetores e matrizes. Exemplo 11.2 int TAB[5]={1,5,10,15,20} int MAT[5][6]={ { 1, 0, 1, { 0, 1, 0, { 1, 0, 1, { 0, 1, 0, { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 1 0 1 0 }, }, }, }, } };

Obs.: Quando houver uma inicializao de um vetor ou uma matriz na declarao, pode-se suprimir sempre o valor do primeiro colchete, isto , pelo nmero de argumentos ele assume o nmero do primeiro colchete. Exemplo 11.3 int TAB[]={1,5,10,15,20}

LINGUAGEM C int MAT[][6]={ { { { { { 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0 1 0 1 0 }, }, }, }, } };

11.2 Matrizes e Vetores como argumento de Funes

O C permite que passe matrizes ou vetores como argumento de uma funo. Mas h uma peculiaridade na passagem de parmetros: a forma como ela passada. O nome de uma matriz ou vetor desacompanhado de colchetes equivalente ao endereo da matriz ou do vetor, isto , passagem por referncia. Quando o nome estiver acompanhado de um indexador passado como argumento o contedo daquela posio da matriz ou do vetor, isto , passagem por valor.

11.3 Limites
Na linguagem C, devemos ter cuidado com os limites de um vetor. Embora na sua declarao, tenhamos definido o tamanho de um vetor, o C no faz nenhum teste de verificao de acesso a um elemento dentro do vetor ou no. Por exemplo se declaramos um vetor como int valor[5], teoricamente s tem sentido usarmos os elementos valor[0], ..., valor[4]. Porm, o C no acusa erro se usarmos valor[12] em algum lugar do programa. Estes testes de limite devem ser feitos logicamente dentro do programa. Este fato se deve a maneira como o C trata vetores. A memria do microcomputador um espao (fsico) particionado em pores de 1 byte. Se declaramos um vetor como int vet[3], estamos reservando 6 bytes (3 segmentos de 2 bytes) de memria para armazenar os seus elementos. O primeiro segmento ser reservado para vet[0], o segundo segmento para vet[1] e o terceiro segmento para vet[2]. O segmento inicial chamado de segmento base, de modo que vet[0] ser localizado no segmento base. Quando acessamos o elemento vet[i], o processador acessa o segmento localizado em base+i. Se i for igual a 2, estamos acessando o segmento base+2 ou vet[2](o ultimo segmento reservado para o vetor). Porm, se i for igual a 7, estamos a acessando segmento base+7 que no foi reservado para os elementos do vetor e que provavelmente est sendo usado por uma outra varivel ou contm informao espria (lixo). Observe que acessar um segmento fora do espao destinado a um vetor pode destruir informaes reservadas de outras variveis. Estes erros so difceis de detectar pois o compilador no gera nenhuma mensagem de erro... A soluo mais adequada sempre avaliar os limites de um vetor antes de manipul-lo. A princpio este fato poderia parecer um defeito da linguagem, mas na verdade trata-se de um recurso muito poderoso do C. Poder manipular sem restries todos os segmentos de memria uma flexibilidade apreciada pelos programadores.

11.4 Strings
Em C no existe um tipo de dados string como na linguagem "Pascal". Ao contrrio, as string so implementadas como cadeia de caracteres, terminados pelo caracter null (\0). O caracter null serve como uma marca de fim de string para as funes que lidam com strings. Como em qualquer vetor, os caracteres da string podem ser individualmente acessados. A declarao:

LINGUAGEM C char nome[15]; reserva um espao de memria para uma string de tamanho 14, pois o dcimo-quinto byte para o caracter null. A manipulao de strings pode ser feita atravs de funes ou elemento a elemento como se fosse um vetor. Exemplo 11.4 char str[2]; str[0] = U; str[1] = /0;

/* Caracter NULL para finalizar string */

Como todo vetor as strings podem ser inicializadas, como mostram o exemplo 10.5: Exemplo 11.5 char nome[]={C,a,r,l,o,s,\0}; char nome[]=Carlos; char nomes[][8]={Eduardo, Andre, Adriana, Carla, Jose};

11.4.1 Leitura de Strings

Para ler uma string pode-se utilizar a funo scanf() ou a funo gets() da biblioteca C para receber a string.

11.4.1.1 Funo scanf()

A funo scanf() bastante limitada para a leitura de strings. Pois no pode haver espaos em branco na string lida. O que vier aps o espao em branco eliminado. Exemplo 11.6 #include <stdio.h> void main() { char nome[15]; printf(Digite seu nome:); scanf(%s,&nome); printf(Saudacoes %s,nome); } Execuo Digite seu nome: Carlos Alberto Saudacoes, Carlos

11.4.1.2 Funo gets()

A funo gets() bastante conveniente para a leitura de strings. O seu propsito unicamente ler uma string da sua entrada padro que por default o teclado. Visto que uma string no tem um tamanho pr-determinado, gets() l caracteres at encontrar o de nova linha (\n) que gerado ao pressionar a tecla [Enter]. Todos os caracteres anteriores ao \n so armazenados na string e ento includo o caractere \0. Caracteres brancos como espaos e tabulaes so aceitveis como parte da string.

LINGUAGEM C

Exemplo 11.7 #include <stdio.h> void main() { char nome[15]; printf(Digite seu nome:); gets(nome); printf(Saudacoes %s,nome); } Execuo Digite seu nome: Carlos Alberto Saudacoes, Carlos Alberto

11.4.2 Escrita de Strings

Para escrever uma string pode-se utilizar a funo printf() ou a funo puts() da biblioteca C.

11.4.2.1 Funo printf()

A funo printf() ao imprimir a string no realiza uma nova linha, como definido na sua implementao. Em compensao uma funo que pode ser usada para impresso de mais que uma string por linha.

11.4.2.2 Funo puts()

A funo puts() o complementa de gets(). O seu propsito unicamente imprimir a string apontada pelo seu argumento. O endereo desta string deve ser mandado para puts() como argumento. O prximo exemplo ilustra algumas das muitas possibilidades de seu uso. /* mostra o uso de putc() */ #include <stdio.h> void main() { char nome[81]; puts(Digite seu nome:); gets(nome); puts(Saudacoes, ); puts(nome); puts(puts() pula de linha sozinha); puts(&nome[4]); } Execuo Digite seu nome: Carlos Alberto Saudacoes, Carlos Alberto puts() pula de linha sozinha los Alberto A funo puts() reconhece /0como fim de string. Cada impresso de puts(), ele acaba com um caracter de nova linha. Utilizando a funo printf() o mesmo efeito seria:

LINGUAGEM C printf(%s\n,nome); puts(nome);

11.4.3 Funes de Manipulao de Strings

Como strings so implementadas como vetores, os operadores usuais no podem ser aplicados sobre este tipo de dado. Por exemplo: comparao atribuio no so suportados por este tipo de dado. As funes descritas nas prximas sees utilizam o cabealho padro STRING.H.

11.4.3.1 Funo strlen()

Devolve o comprimento da string terminada por um nulo apontada por str. O nulo no contado. Sintaxe: size_t strlen(char *str); Exemplo 11.8 printf(%d,strlen(ola)); /* O resultado 3 */

11.4.3.2 Funo strcat()

Concatena uma cpia de str2 em str1 e termina str1 com um nulo. Como no existe verificao de limites, de inteira responsabilidade do usurio que o tamanho de str1 seja suficientemente grande para armazenar seu contedo original e o de str2. Sintaxe: char *strcat(char *str1, const char *str2); Exemplo 11.9 printf(%s,strcat(ola, mundo)); /* O resultado ola mundo */

11.4.3.3 Funo strcmp()

Compara lexicograficamente duas strings e devolve um inteiro baseado no resultado como mostrado aqui: Valor Menor que zero Zero Maior que zero Sintaxe: int strcmp(const char *str1, const char *str2); Significado str1 menor que str2 str1 igual a str2 str1 maior que str2

11.4.3.4 Funo strcpy()

Copia o contedo de str2 em str1. str2 deve ser um ponteiro para uma string terminada com um nulo. A funo strcpy() devolve um ponteiro para str1. Sintaxe:

LINGUAGEM C char *strcpy(char *str1, const char *str2); Exemplo 11.10 char str[80]; strcpy(str, mundo); /* copia mundo na string str */

11.4.4 Exemplo Geral

O programa abaixo exemplifica o uso das funes descritas anteriormente. Exemplo 11.11 #include stdio.h #include string.h void main() { char s1[80], s2[80]; gets(s1); gets(s2); printf(comprimento: %d %d \n, strlen(s1), strlen(s2)); if (!strcmp(s1,s2)) printf(As strings sao iguais\n); strcat(s1,s2); printf(%s\n,s1); strcpy(s1, Isso e um teste \n); printf(s1); } Ao rodar este programa e entrar com as strings ola e ola, a sada ser comprimentos: 3 3 As strings so iguais aloalo Isso e um teste

11.5 Exerccios
1. 2. Faa um programa que leia 10 valores inteiros e escreva-os na ordem inversa a que foram lidos. Faa um programa que leia 10 valores inteiros, calcule sua mdia e escreva todos os valores que esto abaixo da mdia. Calcular os nmeros primos entre 0 e 100 (inclusive) utilizando o crivo de Eritstenes: Usar um vetor de 101 inteiros; zerar o vetor; repetir de 2 a 100 para cada nmero: somar 1 a todos os contadores dos seus mltiplos. ao final os nmeros que possuem 0 no vetor so primos. Escreva um programa que leia um vetor de 100 posies e mostre-o em ordem crescente e decrescente. Faa um programa que leia uma matriz M[10][10] e some todos os elementos abaixo da diagonal principal. Faa um programa que leia 3 nomes (at 30 letras) e os escreva em ordem alfabtica. Escreva um programa que leia um nmero indeterminado de caracteres e conta o nmero de vezes que cada letra (A-Z) aparece:

3.

4.

5.

6. 7.

LINGUAGEM C

Desconsiderar se a letra maiscula ou minscula; Termina com o caracter 0. 8. 9. Faa um programa que leia uma matriz M[4][4] e mostra a sua transposta. Escreva uma funo que realize a multiplicao de matrizes.

10. Escrever a funo atoi() (recebe uma string como parmetro e transforma em um inteiro). 11. Escreva uma funo que receba um vetor e o tamanho do mesmo e troque os elementos (1 com o ltimo, o 2 com o penltimo e assim por diante).

LINGUAGEM C

12. E/S com Arquivo

So grupos de dados armazenados em meio no voltil (disco, fita, entre outros). So utilizados para armazenar dados de forma permanente. A linguagem C no contm nenhum comando de E/S. Ao contrrio, todas as operaes de E/S ocorrem atravs de chamadas a funes da biblioteca C padro. Essa abordagem faz o sistema de arquivos de C extremamente poderoso e flexvel. O sistema de E/S de C nico, porque dados podem ser transferidos na sua representao binria interna ou em um formato de texto.

12.1 Streams
A linguagem C oferece uma abstrao da interface para controle de E/S, independente do dispositivo real (terminais, acionadores de disco, acionadores de fita, entre outros) que acessado. Sendo que o dispositivo real chamado de arquivo. Existem dois tipos de streams: texto e binria. A primeira uma seqncia de caracteres organizados em linhas e terminadas por um caractere de nova linha (depende da implementao). A segunda uma seqncia de bytes com uma correspondncia de um para um com aqueles encontrados no dispositivo externo - isto , no ocorre nenhuma traduo de caracteres.

12.2 Arquivos
Um arquivo pode ser qualquer coisa, desde um arquivo em disco at um terminal ou uma impressora. Associa-se uma stream com um arquivo especfico realizando uma operao de abertura. Todos as streams so iguais, mas no todos os arquivos. Isto , um arquivo disco pode suportar acesso aleatrio enquanto um teclado no pode. Cada stream associada a um arquivo tem uma estrutura de controle de arquivo do tipo FILE. Essa estrutura definida no cabealho STDIO.H. Todos os arquivos so fechados automaticamente quando o programa termina, normalmente com main() retornando ao sistema operacional ou uma chamada exit(). Os arquivos no so fechados quando um programa quebra (crash).

12.3

Sistema de Arquivos

O sistema de arquivos ANSI composto de diversas funes inter-relacionadas. As mais comuns so mostradas na tabela 15.1. Essas funes exigem que o cabealho STDIO.H seja includo em qualquer programa em que so utilizadas. Tabela 12.1 - Funes mais comuns do sistema de arquivo com buffer Nome fopen() fclose() putc() fputc() getc() fgetc() fseek() fprintf() fscanf() Funo Abre um arquivo Fecha um arquivo Escreve um caractere em um arquivo O mesmo que putc() L um caractere de um arquivo O mesmo que getc() Posiciona o arquivo em um byte especfico para um arquivo o que printf() para o console para um arquivo o que scanf() para o console

LINGUAGEM C

feof() ferror() rewind() remove() fflush()

Devolve verdadeiro se o fim de arquivo for atingido Devolve verdadeiro se ocorreu um erro Repe o indicador de posio de arquivo no incio do arquivo Apaga um arquivo Descarrega um arquivo

O arquivo cabealho STDIO.H fornece os prottipos para as funes de E/S e define estes trs tipos: size_t, fpos_t e FILE. O tipo size_t essencialmente o mesmo que um unsigned, assim como o fpos_t. O tipo FILE discutido na prxima seo. STDIO.H define vrias macros como: EOF, SEEK_SET, SEEK_CUR e SEEK_END. A macro EOF geralmente definida como -1 e o valor quando uma funo de entrada tenta ler alm do final do arquivo. As outras macros so usadas com fseek(), que uma funo que executa acesso aleatrio em um arquivo.

12.4 Estrutura FILE

Para a manipulao de arquivos utilizado a declarao de ponteiro (ponteiro de arquivo). Isto , um ponteiro para informaes que definem vrios dados sobre o arquivo, como o seu nome, status, e a posio atual do arquivo. Um ponteiro de arquivo uma varivel ponteiro do tipo FILE . Todas as funes so realizadas utilizando o ponteiro. Para a declarao de um ponteiro de arquivo utiliza-se a seguinte sintaxe:

Sintaxe:
FILE *<var> Exemplo 12.1 FILE *fp;

12.5 Abertura de Arquivos

A funo fopen() abre uma stream para uso e associa um arquivo a ela. Retorna o ponteiro de arquivo associado a esse arquivo. Sintaxe: FILE *fopen(const char * <nome_ arquivo>, const char *<modo_abertura>); O modo de abertura define a forma como feito o acesso aos dados (somente leitura, leitura e escrita, etc). As forma principais so apresentadas na tabela 15.2. Tabela 12.2 - Os modos de abertura vlidos Modo r w a rb wb ab r+ w+ a+ r+b ou rb+ w+b ou wb+ a+b ou ab+ Significado Abre um arquivo texto para leitura Cria um arquivo texto para escrita Anexa a um arquivo texto Abre um arquivo binrio para leitura Cria um arquivo binrio para escrita Anexa a um arquivo binrio Abre um arquivo texto para leitura/escrita Cria um arquivo texto para leitura/escrita Anexa ou cria um arquivo texto para leitura/escrita Abre um arquivo binrio para leitura/escrita Cria um arquivo binrio para leitura/escrita Anexa a um arquivo binrio para leitura/escrita

LINGUAGEM C

Exemplo 12.2 FILE *arq; /* ponteiro de arquivo */ arq = fopen(dados.dat,wb); Se ao abrir um arquivo para leitura o mesmo no existir a funo fopen retorna um ponteiro nulo (NULL). arq = fopen(dados.dat,rb); if (arq= =NULL) arq=fopen(dados.dat,wb);

12.6 Fechamento de Arquivo

A funo fclose() fecha uma stream que foi aberta atravs de uma chamada fopen(). Esta funo tem a seguinte sintaxe: Sintaxe: int fclose(FILE *fp); onde fp o ponteiro de arquivo devolvido pela chamada fopen(). O valor de retorno 0 significa uma operao de fechamento bem-sucedida.

12.7 Verificando fim de arquivo

Alm de realizar um teste para fim de arquivo como no exemplo 15.3 pode-se utilizar uma funo como feof() que devolve verdadeiro quando for encontrado o fim de arquivo. O prottipo desta funo est declarado abaixo: Sintaxe: int feof(FILE *fp); Esta funo pode ser aplicada tanto para arquivo texto como para arquivos binrios.

12.8 Comando de gravao em modo texto formatado

Como extenso das funes bsicas de E/S j discutidas, o sistema de E/S com buffer inclui fprintf() e fscanf(). Essas funes se comportam exatamente como printf() e scanf() exceto por operarem em arquivos. Os prottipos de fprintf() e fscanf() so Sintaxe: int fprintf(FILE *fp, const char *control_string, ...); int fscanf(FILE *fp, const char *control_string, ...); onde fp um ponteiro de arquivo devolvido por uma chamada fopen(). fprintf() e fscanf() direcionam suas operaes de E/S para o arquivo apontado por fp. A fscanf() devolve o nmero de elementos lidos, convertidos e armazenados. No caso de fim de arquivo o fscanf() devolve o valor EOF.

LINGUAGEM C

O exemplo 15.10 mostra um programa que l uma string e um inteiro do teclado, escreve-os em um arquivo em disco e em seguida l e mostra a informao na tela. Exemplo 12.20 #include stdio.h #include stdlib.h #include io.h void main(void) { FILE *fp; char s[80]; int t; if((fp=fopen(teste,w))==NULL) { printf(Arquivo nao pode ser aberto\n); exit(1); } printf(entre com uma string e um nmero: ); fscanf(stdin, %s%d, s, &t); /* le do teclado */ fprintf(fp, %s %d, s, t); /* escreve no arquivo */ fclose(fp); if((fp=fopen(teste,w))==NULL) { printf(Arquivo nao pode ser aberto\n); exit(1); } fscanf(fp, %s%d, s, &t); /* le do arquivo */ fprintf(stdout, %s %d, s, t); /* imprime na tela */ } A formatao realizada para leitura e escrita de dados pode comprometer a velocidade de processamento do programa.

12.9 Streams Padro

Sempre que um programa iniciado trs streams padres so abertas automaticamente: stdin stdout stderr stdaux stdprn (entrada padro - teclado); (sada padro - tela); (sada de erro padro - tela); (sada auxiliar padro - porta serial); (impressora padro - impressora paralela).

Essas streams podem ser utilizadas normalmente para executar operaes de E/S bufferizada, como mostra o exemplo 15.10 na leitura de variveis pelo teclado.

12.10 Exerccios
1. 2. Faa um programa que escreva os nmeros de 0 a 10 em um arquivo. Faa um programa que leia 11 nmeros de um arquivo.

LINGUAGEM C

13. Bibliografia
BERRY, J. Programando em C++. So Paulo: Makron Books, 1991. ECKEL, B. C++. So Paulo: McGraw-Hill, 1991. ELLIS, M. A. et alli C++: Manual de referncia completo. Rio de Janeiro: Campus, 1993. IBPI. Dominando a Linguagem C. Rio de Janeiro: IBPI, 1993. MIZRAHI, V. V. Treinamento em Linguagem C. So Paulo: McGraw-Hill, 1990. PAPPAS, C. H.; MURRAY, W. Turbo C++ completo e total. So Paulo: McGraw-Hill, 1991. SCHILDT, H. C Completo e total. So Paulo: McGraw-Hill, 1991.