Introduo linguagem C

Centro Nacional de Alto Desempenho CENAPAD-SP Prof. Carlos Rebollo Abril de 2013

1 Sumrio

1 Introduo....................................................................................................................... 7 1.1 O Curso.................................................................................................................... 7 1.2 A tipografia usada na apostila:.................................................................................7 1.3 Linguagem de Programao C.................................................................................. 7 1.4 Prin !pios do padro C.............................................................................................. " 1.4.1 #pirit of C.......................................................................................................... " 1.4.2 $raduo: #pirit of C.......................................................................................... " 2 Aula 1............................................................................................................................ 11 2.1 Primeiro Programa em C ........................................................................................ 11 2.1.1 O omando printf............................................................................................ 1% 2.2 A linguagem de programao C............................................................................. 1% 2.3 $ipo de dado em C................................................................................................. 17 2.4 &e larao de 'ari()eis primiti)as........................................................................1" 2.% $ipos de dados primiti)os e )ari()eis.....................................................................21 2.%.1 *um+ri os inteiros.......................................................................................... 21 2.%.2 *um+ri os ponto flutuante..............................................................................2% 2.%.3 Cara tere........................................................................................................ 27 2., 'alores literais........................................................................................................ 2" 2.,.1 Literal num+ri a inteira...................................................................................2" 2.,.2 Literal num+ri a ponto flutuantes...................................................................2" 2.,.3 Literal ara tere e string................................................................................. 31 3 Aula 2............................................................................................................................ 33 3.1 'ari()eis deri)adas................................................................................................ 33 3.2 Arra-s..................................................................................................................... 33 3.2.1 &e larao de )ari()eis arra-.........................................................................33 3.2.2 Ini iali.ao de )ari()eis Arra-s.....................................................................3% 3.2.3 /tili.ao de )ari()eis Arra-...........................................................................3% 3.3 #tring...................................................................................................................... 37 3.4 #tru t..................................................................................................................... 3" 3.4.1 &e larao de stru t....................................................................................... 3" 3.4.2 /tili.ao de stru t.......................................................................................... 41 3.4.3 Ini iali.ao de stru t...................................................................................... 41 3.% /nion...................................................................................................................... 43 3.%.1 &e larao de union....................................................................................... 43 3.%.2 /tili.ao de union.......................................................................................... 4% 3.%.3 Ini iali.ao de union...................................................................................... 47 3., 0num...................................................................................................................... 4" 3.,.1 &e larao de enum....................................................................................... 4" 3.,.2 /tili.ao de enum.......................................................................................... %1 3.,.3 Ini iali.ao de enum...................................................................................... %1 3.,.4 $-pedef............................................................................................................ %3 3.7 01press2es............................................................................................................. %% 3.7.1 Operadores un(rio3 4in(rios e tern(rios..........................................................%% 3.7.1.1 Operadores aritm+ti os............................................................................%% 3.7.1.2 Operadores rela ionais.............................................................................%7 3.7.1.3 Operadores l5gi os................................................................................... %7 3.7.1.4 Operadores 4it......................................................................................... %" 3.7.1.% Operadores de atri4uio.........................................................................%" 3.7.1., Operador mem4ro.................................................................................... ,1 3.7.1.7 Operadores de geren iamento de mem5ria.............................................,1 3.7.1.6 Operador ondi ional............................................................................... ,3

3.7.1." Operador de on)erso............................................................................,3 3.6 Pre ed7n ia de operadores:...................................................................................,3 Aula 3............................................................................................................................ ,7 4.1 8lo os..................................................................................................................... ,7 4.2 0s opo.................................................................................................................... ,7 4.3 Instruo de seleo.............................................................................................. ," 4.3.1 Instruo if...................................................................................................... ," 4.3.2 Instruo s9it :.............................................................................................. 71 4.4 Instruo de interao............................................................................................ 73 4.4.1 Instruo 9:ile................................................................................................ 73 4.4.2 Instruo do ; 9:ile......................................................................................... 7% 4.4.3 Instruo for.................................................................................................... 77 4.4.4 Instruo ontinue e 4rea<..............................................................................7" 4.% Instruo de salto goto........................................................................................... 7" 4., =un2es.................................................................................................................. 61 4.,.1 &e larao...................................................................................................... 63 4.,.2 &efinio......................................................................................................... 63 4.,.3 /tili.ao......................................................................................................... 6% Aula 4............................................................................................................................ 6" %.1 >eren iamento de mem5ria...................................................................................6" %.1.1 Ponteiro e endereo de mem5ria....................................................................6" %.1.2 Alo ao din?mi a.......................................................................................... "1 %.1.3 Ponteiros para arra-........................................................................................ "3 %.1.4 Ponteiros para string....................................................................................... "% %.1.% Ponteiro para estruturas.................................................................................. "% %.1., Ponteiros para funo...................................................................................... "7 %.1.7 Ponteiros omo par?metros de funo............................................................"7 %.2 &urao de arma.enamento do o4@eto.................................................................."" %.3 0spe ifi ao de lasse de arma.enamento.........................................................."" %.3.1 01tern.............................................................................................................. "" %.3.2 #tati ............................................................................................................. 1A1 %.3.3 Const............................................................................................................. 1A3 %.3.4 Begister e restri t.......................................................................................... 1A3 Aula %.......................................................................................................................... 1A% ,.1 8i4liote a padro C.............................................................................................. 1A% ,.2 Botinas de entrada e sa!da................................................................................... 1A% ,.2.1 ArCui)os........................................................................................................ 1A% ,.2.2 0ntrada e sa!da............................................................................................. 1A7 ,.2.2.1 #a!da de dados formatada.....................................................................1A7 ,.2.2.2 0ntrada de dados formatada..................................................................1A7 ,.2.3 $ratamento de erro........................................................................................ 1A7 ,.2.3.1 =un2es Dteis para o tratamento de erro...............................................1A" ,.2.4 Passagem de par?metros para o programa...................................................113 Eaterial 01tra.............................................................................................................. 11%

1 Introduo
1.1 O Curso
O curso foi estruturado em cinco aulas sendo cada aula tendo uma parte terica e uma parte prtica com exerccios e laboratrios. Os captulos seguem a sequencia das aulas. 1 Introduo 2 Aula 1: Estrutura de um programa C, declarao de variveis primitivas e valores literais. 3 Aula 2: Declarao de variveis derivadas e construo de expresses. 4 Aula 3: Controles de fluxos, estrutura de funes, blocos e escopo. 5 Aula 4: Gerenciamento de memria 6 Aula 5: Biblioteca padro C e entrada/sada 7 Material Extra:

1.2 A tipografia usada na apostila:

<item> [item] Esse item obrigatrio Esse item opcional

Exemplo if( <expresso lgica> ) <bloco> [else <bloco>] O comando if obrigatoriamente recebe um parmetro <expresso lgica> e um <bloco>. Opcionalmente depois pode-se ter o else. Mas se tivermos o comando else, obrigatoriamente teremos um <bloco> depois. Exemplo: if( 1 > 2 ) comando1(); else comando2();

1.3 Linguagem de Programao C

A linguagem de programao C pode ser descrita como: Imperativa: o programa descreve uma sequencia lgica de passos que devem ser executados para resolver o problema. Em oposio ao paradigma declarativo que se expressa o que se espera obter e no os passos para se chegar nesse objetivo. Procedural: o programa estruturado usado procedimentos, no caso do C, o nome funes. Alto nvel ( com acesso a baixo nvel): uma linguagem com um nvel de abstrao relativamente elevado, longe do cdigo de mquina e mais prximo linguagem humana. Compilada: o cdigo fonte em texto puro traduzido, ou seja compilado para uma linguagem de mquina gerando um arquivo executvel. Multi-plataforma: praticamente para todas as plataformas foi implementado pelo menos um compilador C. Podemos tambm usar o compilador de uma plataforma e gerar executveis de outras plataformas ( cross compiler). Tipo de dado esttico: Todos os objetos em C tem um tipo definido seja uma varivel, literal, funo, etc.. .Esse tipo no alterado durante a existencial do objeto.

1.4 Princpios do padro C 1.4.1 Spirit of C

Trust the programmer. Dont prevent the programmer from doing what needs to be done. Keep the language small and simple. Provide only one way to do an operation. Make it fast, even if it is not guaranteed to be portable.

1.4.2 Traduo: Spirit of C

Confie no programador No impea o programador de fazer o que precisa fazer. Mantenha a linguagem de programao pequena e simples. Disponha somente uma opo de operao. Faa a linguagem rpida, mesmo que no tenha portabilidade.

2 Aula 1
2.1 Acesso ao ambiente CENAPAD utilizando Windows.
1. clica-se no cone do putty

2. Na tela de conexo do putty

Na primeira vez preencha hostname e saved session com cenapad.unicamp.br. Depois clica-se save. Depois de salvo, clica-se open. Nas outras vezes somente clica-se na sesso salva, e depois open. 3. No terminal preencha o login e password com as informaes da conta recebida no primeiro dia de aula.

2.1.1 Acesso ao ambiente pelo linux

Para acessar o ambiente pelo linux, utilizamos o ssh. O usurio tem que ser substituindo usuario pelo login passado no primeiro dia de aula. #ssh usuario@cenapad.unicamp.br Password:

2.1.2 Sobre o ambiente CENAPAD.

Os ambientes CENAPAD tem como sistema operacional o Linux ou Unix. No curso vamos ver alguns comandos bsicos para poder editar os exemplos e exerccios.
&iret5rio atual Listar arCui)os e pastas 0ntrar em uma pasta #air dessa pasta Copiar um arCui)o Benomear um arCui)o Fp9d Fls F d pasta F d ursoG F d .. F p origem destino F p e1emploA1. teste. Fm) origem destino Fm) teste. testeA1.

O ambiente CENAPAD no tem programas grficos para edio de arquivos. Os editores em linha de comando so o vi e o nano. Para quem j conhece essas ferramentas poder escolher a que mais confortvel. Quem est conhecendo agora, indicamos o nano pela facilidade nos comandos.
0ditar um arCui)o e1istente Para na)egar entre as lin:as ou posi2es utili.e as te las HsetaI Fnano arCui)o Fnano testeA1.

Para sair do programa te le CtrlJK

#e o arCui)o no foi alterado3 o programa sai sem perguntar nada. #e for um arCui)o alterado3 ele perguntar( H#a)e modiffied 4ufferI &igite HLI. 0le onfirmar( o nome do arCui)o3 apenas te le H0nterI.

2.2 Primeiro Programa em C

exemplo01.c 1. ! 2. ! nome" exemplo#1.c $. ! descri%o" primeiro exemplo em & '. ! data" 1( #) 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. imprime 1om dia 1#. printf(21om dia3n4); 11. ret-rn #; 12.5

Um programa em C um texto com palavras em ingls e simbolos que tem regras lxicas e semnticas distintas. Essas regras que formam a estrutura e as regras para escrever um programa na linguagem C. Podemos comear a definir dois tipos bsicos de texto que podemos encontrar, textos da linguagem e textos de comentrios. Textos da linguagem formam a estrutura do programa e comentrios servem para documentar o programa e so ignorados pelo compilador. Os comentrios podem ser de uma linha ou comentrios de mltiplas linhas. Comentrios de mltiplas linhas comeam com /* e terminam com */ tudo que estiver entre esses smbolos considerado comentrio. Comentrio de uma linha inicia com // e termina no final da linha. Nesse exemplo podemos identificar comentrio de vrias linhas da linha 1 at a 5. Comentrio de uma linha temos na linha 9. exemplo01.c 1$. ! 1'. ! nome" exemplo#1.c 1*. ! descri%o" primeiro exemplo em & 1+. ! data" 1( #) 2#12 1(. ! 1).,incl-de <stdio..> 10.int main() 2#./ 21. imprime 1om dia 22. printf(21om dia3n4); 2$. ret-rn #; 2'.5 Se removermos os comentrios, ficaramos com: exemplo01.c 1. 2. $. '. *. +.,incl-de <stdio..> (.int main() )./ 0. 1#. printf(21om dia3n4); 11. ret-rn #; 12.5 Se olharmos o cdigo fonte sem os comentrios, a primeira linha com algum comando a linha 6. Essa linha que inicia com #, que indica um comando especial chamado de pr-processamento. Esse comando, o include, recebe como parmetro um nome de arquivo que o compilador l o contedo e coloca no exato lugar do comando. Normalmente veremos o comando include com arquivos com extenso .h que tem o significado de header ( cebealho ) que so arquivo de definies. Nesse caso o arquivo stdio.h um arquivo da biblioteca padro C que define funes de entrada e sada de informaes ( printf na linha 10 ).

Logo depois, na linha 7 int main() a definio de uma funo em C. Nesse caso a funo com o nome main ( principal em ingls). Um programa pode ter vrias funes mas somente uma com o nome main que indica aonde o programa iniciar quando for executado. Alias, o C case-sensetive e diferencia letras minsculas de maisculas: main diferente de MAIN e diferente de Main. A funo main tem uma palavra antes o int que uma palavra que define um tipo de dado em C que representa inteiro. A funo main que por analogia da matemtica (y = f(x)) tem um valor de retorno, valor de resultado da funo. Programas tem uma funo main mas se estivermos programando bibliotecas que apenas disponibilizam uma coleo de funes, no teramos a funo main e o programador que for usar essa biblioteca que vai definir um main em seu programa. A funo main inicia na linha 8 com o caractere { e termina na linha 12 com o caractere }. Toas as linhas entre a 8 e 12 esto na funo main ou mais tecnicamente no escopo da funo main. Toda a linha de comando em C termina com ;. Na linha 11 temos uma outra funo a printf que como analogia a funes em matemtica ( y = f(x) ), recebe como parmetro um texto Bom dia\n. A funo printf imprime na tela do usurio o que recebe como parmetro ( Bom dia\n ). Na linha 12 temos a linha return 0; que um comando especial que alm de sair da funo, e nesse caso do programa, ela especifica o valor de retorno. Funes retornam ao ponto que ela foi chamado. No caso de main, ela retorna para quem executou o programa. A conveno que quando retornamos zero ( 0 ) num programa, quer dizer que ele funcionou como esperado e se tiver valor diferente de zero, seria o nmero de algum erro. Agora vamos compilar esse primeiro exemplo: Na pasta exemplos executamos: icc 6o exemplo#1 exemplo#1.c 67all Para executar o programa: . exemplo#1 Sada na tela: 1om dia Note que os caracteres \n no so exibidos porque essa sequencia representa o carcter de nova-linha. Existem outras sequencias especiais que veremos durante o curso.

2.2.1 O comando printf

Durante o curso usaremos o printf como ferramenta nos nossos laboratrios. Agora apresentaremos o bsico necessrio para os laboratrios e no ltimo dia veremos melhor a formatao de dados. formato do printf printf(2string formata%o48 [9ar8 9ar8 9ar8...]);

A string de formatao um texto que podemos escrever literalmente ou podemos indicar locais para a incluso de variveis usando % e um qualificador que define o tipo e a formatao de sada de cada item. Para cada % que achamos, ele ira usar uma varivel da lista de variveis. printf(2:d :d :d 3n48 1 8 2 8 $ ); para cada :d o printf coloca o 9alor do prximo literal o- 9ari;9el
Letra i ou d u o K ou 1 = ou f 0 ou e > ou g A ou a s p &es rio Inteiro Inteiro sem sinal O tal sem sinal Me1ade imal sem sinal Ponto flutuante. Ponto flutuante notao ientifi a. /sar a mel:or representao e ou f Ponto flutuante em :e1ade imal om sinal Cara tere. #tring Ponteiro

#e olo armos um N1 Cue no ondi. om o tipo da )ari()el ou literal3 o ompilador a)isar( mas dei1ar( passar. Ouando for e1e utado3 esse erro fi ar( aparente. 01emploA2.

1. ! 2. ! nome" exemplo#2.c $. ! descri%o" <rintf '. ! data" #) #' 2#1$ *. ! +.,incl-de <stdio..> (.int main() )./ 0. = comando printf 1#. printf(>1om dia3n>); 11. printf(>?11) 1# @ 12. printf(>?12) 61# @ 1$. printf(>?1$) #.1# @ 1'. printf(>?1') 6#.1# @ 1*. printf(>?1*) c.ar @ 1+. ret-rn #; 1(.5

:d8:i8:-8:o8:x3n>81#81#81#81#81#); :d8:i8:-8:o8:x3n>861#861#861#861#861#); :f8:e8:g8:a8:x3n>8#.1#8#.1#8#.1#8#.1#8#.1#); :f8:e8:g8:a 3n> 86#.1#86#.1#86#.1#86#.1#); :c string @ :s3n>8 AaA 8>1om dia>);

2.2.2 Exerccio ambiente CENAPAD

1) Entre no ambiente CENAPAD utilizando ssh ou putty 2) Entre no diretrio curso_c 3) Crie um programa em C com o nome nome.c. Esse programa imprimir o seu nome. Pode utilizar como exemplo o programa exemplo01.c. 4) Compile esse programa. 5) Execute ele.

2.3 A linguagem de programao C

O compilador C quando processa um arquivo ele separa o texto em elementos que chamamos de toquem. Que so partes atmicas, que sozinho tem uma funo prpria no programa. Podemos classificar os toquens em: palavra reservada, identificador, constantes, literal string e pontuao. Palavras reservadas so palavras tem um uso definido na linguagem de programao e que no poderamos usar para outra finalidade como usar como o nome de uma varivel. A linguagem de programao C tem poucas palavras reservadas comparado com outras linguagens de programao e podemos listar elas:
auto break case char const continue default do double else enum enum float for goto if inline int long register restrict return return signed sizeof static struct switch typedef union unsigned void volatile while _Bool _Complex _Imaginary

Identificador o nome que podemos dar ou identificar os objetos em C. Identificador pode ser uma varivel, uma funo, uma tag, membro de uma estrutura ou unio, um nome typedef, um nome de label, um parmetro de macro. Podemos usar o mesmo identificador para tipos diferentes em pontos(escopos) diferentes do programa, como podemos ter uma varivel com o mesmo nome de funo. Constantes e literal string so como descrevo os valores no cdigo fonte. Por exemplo o valor numrico 10 ou o carcter 'a' ou no caso de constante string Bom dia. Pontuao so smbolos usados tanto nas operaes matemticas ou lgicas ou para delimitar o escopo ou final de linha.

2.4 Tipo de dado em C

Como a linguagem C de tipagem esttica, tanto os valores literais quanto variveis so de um tipo de dado definido. Podemos separar esses tipos de dados em primitivos e derivados. Os tipos de dados primitivos so definidos pela linguagem de programao, os derivados so definidos pelo programador compondo com tipos primitivos ou usando tipos derivados j definidos. Os tipos de dados primitivos podem ser divididos didaticamente em grupos: Numricos inteiros: representam nmeros naturais sem frao. Numricos ponto flutuante: representam nmeros reais com frao. Caractere: Representam somente um caractere.

Esses grupos de tipos de dados so escalares podendo realizar todas as operaes matemticas, lgicas e comparativas. Isso natural para nmeros mas o caractere a representao em bit de um valor numrico e essa representao definida pela tabela ASCII ( letra 'a' o nmero 97). Os tipos de dados derivados: String: Em C string um vetor de vrios caracteres. Array: Estrutura que podemos agrupar valores em formato de vetores ou matrizes de vria dimenses. Cada um pode ser referenciado pelo um ndice numrico. Struct: Estrutura que podemos agrupar variveis de tipo diferente. Cada varivel componente referenciada pelo nome dela. Union: Estrutura anloga ao struct mas todas as variveis ocupam o mesmo espao na memria. Usado para economizar memria. Enum: Estrutura de dado aonde posso enumerar opes usando nomes.

2.5 Declarao de Variveis primitivas.

Para usar variveis em C precisamos primeiramente declara-la informando o nome e o tipo dela. <tipo> nome; Be formos declarar -ma 9ari;9el do tipo int ( inteiro ). int contador; Podemos tambm declarar variveis do mesmo tipo na mesma linha separadas por virgula. <tipo> 9ar18 9ar28 9arn; Be formos declarar x8C8D como int ( inteiro ) int x8C8D; As variveis em C, por padro, no so inicializadas, o compilador apenas reserva a memria necessria ao tipo dela. Essa posio de memoria pode conter alguma informao de um programa que foi executado

antes. Depois que um programa executa, a memria no apagada e sim sobreposta por outro programa. Para inicializar uma varivel atribumos algum valor neutro para essa varivel. Podemos aproveitar a declarao da varivel para a inicializao dela. <tipo> nome@9alor; <ara inicialiDar o contador int contador@1; <odemos tambm declarar e inicialiDar 9;rias 9ari;9eis int x@#8C@#8D@#; <odemos inicialiDar a 9ari;9el depois de declarar int contador; int x8C8D; contador @1; x@#; C@D@#; Um exemplo completo seria: exemplo03.c 1. ! 2. ! nome" exemplo#$.c $. ! descri%o" Eeclara%o e inicialiDa%o de 9ari;9eis '. ! data" 11 #2 2#1' *. ! +.,incl-de <stdio..> (.int main() )./ 0. Eeclara%o e inicialiDa%o de 9ari;9eis 1#. int contador@#; 11. int x@18C@1; 12. c.ar c; 1$. c@AxA; 1'. 1*. printf(21om dia3n4); 1+. printf(2contador@:d3n48contador); 1(. printf(2x@:d8 C@:d3n48x8C); 1). printf(2c@:c3n48c); 10. 2#. ret-rn #; 21.5

2.6 Tipos de dados primitivos e variveis.

Os tipos de dados primitivos podem ser divididos em grupos: Numricos inteiros: representam nmeros naturais sem frao. Numricos ponto flutuante: representam nmeros reais com frao.

Caractere: Representam somente um caractere. Nulo: Representa o tipo void.

2.6.1 Numricos inteiros

No C nmeros inteiros so representados por int e suas variaes como signed/unsigned short/long/long long. Essas variaes definem a capacidade de representao numrica. Quanto maior a capacidade, maior o nmero que poder representar. Essas definies de capacidade de varivel podem variar de acordo com a arquitetura do ambiente computacional e se for preciso ter que ser tradada pelo programador (Faa a linguagem rpida, mesmo que no tenha portabilidade). A capacidade numrica calculada de acordo com a quantidade de bits, que proporcional a magnitude numrica. Se o valor extrapolar esse limite pode ocorrer problemas overflow. Por exemplo, se um short int x = 32767 e somarmos +1 ele ficar com -32767. O padro do tipo de dado signed int mas podemos omitir a palavra signed. Declarar o tipo signed int igual a int.
$ipo s:ort int unsigned s:ort int int unsigned int long int unsigned long int long long int unsigned long long int Capa idade 1, 4its P Q327,7 ... J327,7 R 1, 4its sem sinal P A ... ,%%3% R 1, 4its P Q327,7 ... J327,7 R 1, 4its sem sinal P A ... ,%%3% R 32 4its P Q2147463,47 ... J2147463,47 R 32 4its sem sinal P A ... 42"4",72"% R ,4 4its P Q"223372A3,6%477%6A7 J"223372A3,6%477%6A7 R ,4 4its sem sinal 1644,744A737A"%%1,1% R P A ... ...

A declarao de variveis segue a mesma regra: <tipo> nome;

Um exemplo completo exemplo04.c 1. ! 2. ! nome" exemplo#'.c $. ! descri%o" Eeclara%o de 9ari;9eis inteiras '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..>

(.int main() )./ 0. s.ort int Fm; 1#. -nsigned s.ort int idade; 11. long int cm; 12. -nsigned long int saldoGcc; 1$. long long int mm; 1'. -nsigned long long int molec-las; 1*. ret-rn #; 1+.5 Podemos verificar se o ambiente que estamos usando segue o padro C usando a funo sizeof. Essa funo retorna a quantidade de bytes que so 8 bits. exemplo05.c 1. ! 2. ! nome" exemplo#*.c $. ! descri%o" Eeclara%o de 9ari;9eis inteiras '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. printf(2s.ort int @ :l-3n48 siDeof(s.ort int)); 1#. printf(2-nsigned s.ort int @ :l-3n48 siDeof(-nsigned s.ort int)); 11. printf(2long int @ :l-3n48 siDeof(long int)); 12. printf(2-nsigned long int @ :l-3n48 siDeof(-nsigned long int)); 1$. printf(2long long int @ :l-3n48 siDeof(long long int)); 1'. printf(2-nsigned long long int @ :l-3n48 siDeof(-nsigned long long int)); 1*. ret-rn #; 1+.5

2.6.2 Numricos ponto flutuante

No C nmeros de ponto flutuante pode ser representado por float ou double e suas variaes. Essas variaes definem a capacidade de representao numrica. Quanto maior a quantidade de bits, maior a capacidade de representao numrica. Se o valor extrapolar esse limite pode ocorrer problemas overflow e underflow. Overflow pode ser como o exemplo com nmeros inteiros. J o Undeflow quando um nmero to pequeno como 0,000000000001 com 12 casas, mas o tipo somente aceitaria 10 e nesse caso ele seria arredondado para zero. Essas definies de capacidade de varivel podem variar de acordo com a arquitetura e do ambiente computacional e se for preciso ter que ser tradada pelo programador (Faa a linguagem rpida, mesmo que no tenha portabilidade).

$ipo float

Capa idade 1, 4its

dou4le long dou4le

,2 4its ,4 4its

A declarao de variveis segue a mesma regra: <tipo> nome; Um exemplo no cdigo fonte exemplo06.c 1. ! 2. ! nome" exemplo#+.c $. ! descri%o" Eeclara%o de 9ari;9eis ponto fl-t-ante. '. ! data" #) #' 2#1$ *. ! +.,incl-de <stdio..> (.int main() )./ 0. float Fm; 1#. do-ble cm; 11. long do-ble mm; 12. ret-rn #; 1$.5 Podemos verificar se o ambiente que estamos usando segue o padro C usando a funo sizeof. Essa funo retorna a quantidade de bytes que so 8 bits. exemplo07.c 1. ! 2. ! nome" exemplo#(.c $. ! descri%o" Eeclara%o de 9ari;9eis inteiras '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. printf(2float @ :l-3n48 siDeof(float)); 1#. printf(2do-ble @ :l-3n48 siDeof(do-ble)); 11. printf(2long do-ble @ :l-3n48 siDeof(long do-ble)); 12. ret-rn #; 1$.5

2.6.3 Caractere.
No C caractere representa uma letra somente que o tipo char. O char um tipo escalar porque cada letra pode ser representada por um nmero como na tabela ASCII. String em c no um tipo primitivo. String implementado como um vetor de char. Veremos esse tipo na prxima aula.

$ipo :ar unsigned :ar 9 :arGt

Capa idade 1 4-te 1 4-te 4 4-tes

A declarao de variveis segue a mesma regra: <tipo> nome; Um exemplo no cdigo fonte exemplo08.c 1. ! 2. ! nome" exemplo#).c $. ! descri%o" Eeclara%o de 9ari;9eis caractere. '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. c.ar letra; 1#. -nsigned c.ar nota; 11. Hc.arGt -tf; 12. ret-rn #; 1$.5 Podemos verificar se o ambiente que estamos usando segue o padro C usando a funo sizeof. Essa funo retorna a quantidade de bytes que so 8 bits. exemplo09.c 1. ! 2. ! nome" exemplo#0.c $. ! descri%o" Eeclara%o de 9ari;9eis inteiras '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. printf(2c.ar @ :l-3n48 siDeof(c.ar)); 1#. printf(2-nsigned c.ar @ :l-3n48 siDeof(-nsigned c.ar)); 11. printf(2Hc.arGt @ :l-3n48 siDeof(Hc.arGt)); 12. ret-rn #; 1$.5

2.6.4 Nulo (void)

O tipo void um tipo de dados neutro que representa a ausncia de valores. Podemos usar void como Retorno de funo: para indicar que a funo no retorna nenhum valor.

Argumento de funo. Indicamos e reforamos que a funo no recebe parmetros. Ponteiros void. Ponteiro neutro de tipo.

2.7 Valores literais

Os valores literais em C so de tipagem esttica e o compilador qualifica os literais de acordo com o contedo deles ou podemos indicar usando prefixos que o qualificam. Podemos descrever literais de tipos primitivos e literais de tipos derivados: Literal numrica inteira. Literal numrica ponto flutuantes. Literal caractere e string.

2.7.1 Literal numrica inteira.

Podemos representar valores inteiros em base decimal, octal e hexadecimal. Podemos tambm qualificar o inteiro como long, long long ou unsigned. IJmeros na base 1# # 8 1 8 $ ... 1# 8 11 ... 8 1## 8 61## IJmeros na base octal inicia com # #8 #18 #$8 #(8 1#8 #118 ...8 1##8 6#1## IJmeros na base .exadecimal inicia com #x #x#8 #x18 #xa8 #xb8 #x1#...#x1##8 6#x1## <ara representar long -samos -m l o- ? somo s-fixo e long long -samos dois ll o- ?? 1l8 $?8 #(?8 #xal8 #x1##??8 6#x1##?? <ara representar -nsigned -samos -m - o- K como s-fixo 1-8 $K8 #(K8 #xa-8 #x1##K8 6#x1##K

2.7.2 Literal numrica ponto flutuantes.

Podemos representar literais ponto flutuante na notao decimal e na notao cientifica. Ambos as notaes podem ser representadas na base decimal e hexadecimal. O qualificador padro signed float mas podemos mudar para float ou para long double. Para representar um numero ponto flutuante usamos o ponto para separar a parte inteira da frao. Se no tiver a parte fracionada podemos colocar .0 ou apenas . IJmeros na base 1# #.* 8 *.# 8 *. IJmeros log do-ble #.*?8 *.#?8 *.?

<odemos -sar a nota%o cientifica #.*e1#8 *.#e28 *.E$ IJmeros na base .exadecimal iniciamos com #x #x#.*p# 8 #x*.#p1 8 #x*.p#

2.7.3 Literal caractere e string.

Literais caractere representam somente um caractere e representamos ele entre aspas simples '. A linguagem C trabalha com string sendo um conjunto de caractere como um vetor. Caracteres so escalares e podemos realizar todas as operaes.

?etras AaA8 AbA8 AcA <odemos -sar seL-encias de escape A3AA8 A34A8 A3M3A <odemos tambem -sar cdigo octal e .exadecimal A3#1'1A8 A3x+1A ?iteral string -samos aspas d-plas 21om dia4

2.7.4 Printf e os tipos de dados

Para cada tipo de dado primitivo existe uma diretiva do printf e podemos listar elas

Letra i ou d u :u lu llu f Lf

&es rio Inteiro Inteiro sem sinal s:ort int long int long long int dou4le;float long dou4le

2.8 Exerccios
1. Complete os cdigos abaixo:

&digo N 1.,incl-de <stdio..> 2.GGGGGGGGGGGGGGGGGGGG $./ '. printf(21om dia3n4)GGG *. ret-rnGGG; +.GGG &digo 1 1.,GGG <stdio..> 2.int main() $.GGG '. int aGGGG; *. float GGG@2.1; +. long GGG x@2$.1?; (. printf(2a@:d3n48GGG); ). printf(2C@:f3n48C); 0. printf(2x@:?d3n4GGG x)GGG 1#. GGGG; 11.5 1.Faa um programa em c com o nome lab01.c declarando e inicializando as variveis: a) Inteiros para: dia, ms, ano, idade. b) char letra c) Pontos flutuantes para: altura, peso d) Ponto flutuante para pi ( 3, 14159265358979323846). 2.Altere o lab01.c e acrescente comandos printf para imprimir: a) altura = xxx, peso = xxx b) letra = x c) pi = 3.14159265358979323846 Ser impressa todas as casas do nmero pi? d) Data de nascimento d/m/a tenho n anos 3.Faa a cpia do lab01.c com o nome lab01nc.c e altere todos os literais para notao cientfica, caso possa ser aplicado.

3 Aula 2
3.1 Variveis derivadas
Os tipos de dados derivados o programador que define o formato do dado e ele tambm deve implementar rotinas ou funes que trabalhem com esse tipo de dado. A linguagem de programao no fornece operadores nesses tipos de dados.

3.2 Arrays
Arrays representam em matemtica vetores e matrizes. Em C tanto vetores quanto matrizes so implementados usando uma varivel composta de vrias posies indexadas numericamente. O C padro 99 e posteriores aceita o formato VLA ( laviable-length array array de tamanho varivel ) que quer dizer que podemos definir o tamanho do array na execuo do programa, diferente da alocao esttica que definida na compilao. No confundir com alocao dinmica que poderia alterar dinamicamente o tamanho do array em qualquer hora do cdigo. O C aceta array estatico e VLA mas no array dinamico. Nesse caso podemos utilizar alocao dinamica de memoria. NrraC est;tico int 9etor[1#]; NrraC O?N n @ arg-mento(1); int 9etor[n]; a NrraC dinPmico8 somente para exemplo8 no existe no & int 9etor[1#]; no9oGtaman.o(9etor82#);

3.2.1 Declarao de variveis array.

Para declarar um array, precisamos definir o tipo de dado dos elementos e a quantidade. <tipo> nome[taman.o]; -m 9etor <tipo> nome[taman.o1][taman.o2]; matriD de d-as dimensQes. Podemos declarar variveis primitivas, vetores e matrizes na mesma linha. <tipo> primiti9o8 9etor[tam9]8 matriD[tamm][tamm]; O tipo de dado pode ser um tipo primitivo ou um tipo derivado. Um erro comum declarar um vetor de tamanho x e usar a posio x. O C permitir mas isso seria acesso indevido a memria e o efeito disso no pode ser previsto.

exemplo10.c 1. ! 2. ! nome" exemplo1#.c $. ! descri%o" Eeclara%o de 9etores e matriDes '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int idade; 1#. int dataIascimento[$]; 11. int matriD2E[1#][1#]8 matriD$E[1#][1#][1#]; 12. ret-rn #; 1$.5

3.2.2 Inicializao de variveis Arrays.

Quando declaramos um vetor ou uma matriz a linguagem de programao no inicializa eles com algum valor, ele apenas reserva memria suficiente para o vetor ou a matriz inteira e essa posio da memria pode ter valores que outro programa que executou antes deixou na memria. No padro C99 podemos usar literais compostos para inicializar os vetores. Para inicializar usamos o formato: = padro &00 aceita literais compostos <tipo> 9etor[tam] @ / literal18 literal28 literal$8 literaltam 5; <tipo> matriD[x][C] @ / /literal8 literal58 /literal8literal5 5; Be o compilador no aceitar o padro &008 teremos L-e pop-lar o 9etor com atrib-i%Qes <tipo> 9etor[tam]; 9etor[#]@9alor; 9etor[1]@9alor; at tam61 Um exemplo completo seria: exemplo11.c 1. ! 2. ! nome" exemplo11.c $. ! descri%o" Eeclara%o e inicialiDa%o de 9etores e matriDes '. ! data" 1$ #2 2#1' *. ! +.,incl-de <stdio..> (.int main() )./ 0. int idade@$'; 1#. 11. int dataIascimento[$]@/$81810()5; 12. 1$. int matriD2E[2][2] @ / /#8158 /1#8115 5; 1'. 1*. int o-tra2E[2][2] @ / #8 18 1#8 11 5;

1+. 1(. 1). 10. 2#. 21. 22. 2$. 2'.5

int diasRes[] @ /$18208$18$#8$18$#8$18$18$#8$18$#8$15; int nao&00[2]; nao&00[#]@1#; nao&00[1]@2#; ret-rn #;

3.2.3 Utilizao de variveis Array.

Quando compomos um vetor ou uma matriz com um tipo primitivo, podemos usar as operaes que o C implementa indicando item por item. No podemos usar o formato de literais compostos para atribuir valores para matrizes. <tipo> nome[tam]; nome[posi%o] @ literal; nome @ /9al189al289al$5; erro de compila%o printf(2nome[:d]@:d3n48posi%o8nome[posi%o]); Um erro comum tentar usar uma posio fora do limite da array e pode gerar comportamentos inesperados no programa. Podendo at parar a execuo atual (travar). Um exemplo completo seria: exemplo12.c 1. ! 2. ! nome" exemplo12.c $. ! descri%o" Eeclara%o e -tiliDa%o de 9etores e matriDes '. ! data" #0 #' 2#1$ *. ! +.,incl-de <stdio..> (.int main() )./ 0. int idade@$*; 1#. 11. int dataIascimento[$]; 12. dataIascimento[#]@$; 1$. dataIascimento[1]@1; 1'. dataIascimento[2]@10(); 1*. 1+. printf(2Eata de nascimento :d :d :d8 idade @ :d3n48 dataIascimento[#]8 dataIascimento[1]8 1(. dataIascimento[2]8 idade ); 1). 10. ret-rn #; 2#.5

3.3 String
String em C implementado como um vetor de char que termina com um caractere especial '\0'. Se tivermos uma string Texto ela teria 6 posies (mais a posio do caracter nlo) iniciando com 0 at 5.

e 1 t o SA

Um erro comum tentar usar uma posio fora do limite da string e pode gerar comportamentos inesperados no programa. Um outro problema apagar o caractere de final de string '\0'. Se no tiver esse caractere uma funo que trabalhe com string ir transpor o limite dela at que em alguma outra posio aleatria da memria tiver um '\0' o que pode gerar acesso indevido a memria. c.ar string[taman.o]; c.ar string[taman.o]@4Sexto4; c.ar string[]@4Sexto4; c.ar string[taman.o]@ /ASA8 AeA8 AxA8 AtA8 AoA8 A3#A 5; String como vetor funciona como array, no pode-se alterar o tamanho dela automaticamente mas podemos alterar caractere por caractere como se fosse um vetor. Podemos tambm utilizar funes que tratam de string. A biblioteca padro do C tem vrias funes que trabalham com string. c.ar string[taman.o]@4Sexto4; string[#]@AtA; Um exemplo completo seria: exemplo13.c 1. ! 2. ! nome" exemplo1$.c $. ! descri%o" Eeclara%o e -tiliDa%o de strings '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. c.ar nome[]@4&arlos TenriL-e Uebollo4; 1#. c.ar profissao[0]@4Nnalista4; 11. 12. printf(2Iome :s ( letra inicial :c) profisso :s 3n48 nome8 nome[#]8 profissao); 1$. 1'. ret-rn #; 1*.5

3.4 Struct
Struct so estrutura que agrupam variveis com tipos de dado diferente e sendo cada posio nomeada e no indexada como vetores. Podemos compor structs com variveis do tipo primitivo ou com tipos derivados at compor struct com struct.

3.4.1 Declarao de struct

Para declarar uma struct usamos o modelo: str-ct nometipo / <tipo1> 9ar1; <tipo2> 9ar2; ... <tipon> 9arn; 5 9str-ct189str-ct1; str-ct nometipo o-tra9ar;

Nesse caso: nometipo: o nome desse tipo struct, podemos declarar variveis usando esse nome. <tipos> vars; so as variveis componente dessa struct vstructs so variveis do stipo struct nometipo Na linha struct nometipo outrovar estamos declarando outra variavel do tipo struct nometipo que j foi definido.

Um exemplo completo seria: exemplo14.c 1. ! 2. ! nome" exemplo1'.c $. ! descri%o" Eeclara%o de str-ct '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. str-ct data 1#. / 11. int dia8mes8ano; 12. 5 .oVe; 1$. 1'. str-ct data aman.a; 1*. 1+. ret-rn #; 1(.5

3.4.2 Utilizao de struct

Para utilizar uma struct usamos cada varivel componente separadamente usando var.componente str-ct nometipo / <tipo1> 9ar1; <tipo2> 9ar2; ... <tipon> 9arn; 5 9str-ct189str-ct1; str-ct nometipo o-tra9ar; 9str-ct.9ar1@9alor1; 9str-ct.9ar2@9alor2;

Um exemplo completo seria: exemplo15.c 1. ! 2. ! nome" exemplo1*.c $. ! descri%o" Eeclara%o de str-ct '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. str-ct data 1#. / 11. int dia8mes8ano; 12. 5 .oVe; 1$. 1'. str-ct data aman.a; 1*. 1+. .oVe.dia@1(; 1(. .oVe.mes@1#; 1). .oVe.ano@2#12; 10. 2#. aman.a @ .oVe W 1; erro de compila%o 21. 22. printf(2Eata de .oVe :d :d :d3n48 .oVe.dia8 .oVe.mes8 .oVe.ano); 2$. ret-rn #; 2'.5

3.4.3 Inicializao de struct

Podemos inicializar uma struct usando o formato: str-ct nometipo / <tipo1> 9ar1; <tipo2> 9ar2; ... <tipon> 9arn; 5 9str-ct1@/ .9a1@lalor18 .9ar2@9alor28 .9arn@9aln 5; str-ct nometipo o-tra9ar@/ .9a1@lalor18 .9ar2@9alor28 .9arn@9aln 5; Um exemplo completo seria exemplo16.c 1. ! 2. ! nome" exemplo1+.c $. ! descri%o" Eeclara%o8 inicialiDa%o e -tiliDa%o de str-ct '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. str-ct data 1#. / 11. int dia8mes8ano; 12. 5 .oVe @ / .dia @ 1(8 .mes @ 1#8 .ano @ 2#12 5; 1$. 1'. str-ct data aman.a; 1*. 1+. aman.a.dia@.oVe.diaW1; 1(. aman.a.mes@.oVe.mes; 1). aman.a.ano@aman.a.ano; 10. 2#. printf(2Eata de .oVe :d :d :d3n48 .oVe.dia8 .oVe.mes8 .oVe.ano); 21. printf(2Eata de aman.a :d :d :d3n48 aman.a.dia8 aman.a.mes8 aman.a.ano); 22. 2$. ret-rn #; 2'.5

3.5 Union
Union um tipo de estrutura anloga ao struct mas todas as variveis ocupam o mesmo espao na memria. Usado para economizar memria. O tamanho total dessa estrutura o tamanho da maior varivel componente.

3.5.1 Declarao de union

Para declarar uma struct usamos o modelo: -nion nometipo / <tipo1> 9ar1; <tipo2> 9ar2; ... <tipon> 9arn; 5 9-nion189-nion1; -nion nometipo o-tra9ar; Nesse caso: nometipo: o nome desse tipo union, podemos declarar variveis usando esse nome. <tipos> vars; so as variveis componente dessa union vunions so variveis do stipo union nometipo Na linha union nometipo outravar estamos declarando outra varivel do tipo union nometipo que j foi definido.

Um exemplo completo seria: exemplo17.c 1. ! 2. ! nome" exemplo1(.c $. ! descri%o" Eeclara%o de -nion '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. -nion 9alor 1#. / 11. int inteiro; 12. float real; 1$. do-ble bigGreal; 1'. 5 9al1; 1*. 1+. -nion 9alor 9al2; 1(. 1). ret-rn #; 10.5

3.5.2 Utilizao de union

Para utilizar uma union usamos cada varivel componente separadamente usando var.componente mas ao contrrio da struct somente uma delas ter um valor significativo.

 Um erro comum ao usar union definir uma varivel componente de um tipo e usar uma outra varivel componente de outro tipo. Para a utilizao correta da union precisaria de uma varivel auxiliar que indique qual a varivel que tem o valor significativo. -nion nometipo / <tipo1> 9ar1; <tipo2> 9ar2; ... <tipon> 9arn; 5 9-nion189-nion1; -nion nometipo o-tra9ar; 9-nion.9ar1@9alor1; 9-nion.9ar2@9alor2; Um exemplo completo seria: exemplo18.c 1. ! 2. ! nome" exemplo1).c $. ! descri%o" Eeclara%o e -tiliDa%o de -nion '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. -nion 9alor 1#. / 11. int inteiro; 12. float real; 1$. do-ble bigGreal; 1'. 5 9al1; 1*. 1+. 9al1.inteiro@1#; 1(. 1). printf(>inteiro :d3n>8 9al1.inteiro); 10. printf(>real :f3n>8 9al1.real); 2#. printf(>bigGreal :f3n>8 9al1.bigGreal); 21. 22. 9al1.real@1.*; 2$. 2'. printf(>inteiro :d3n>8 9al1.inteiro); 2*. printf(>real :f3n>8 9al1.real); 2+. printf(>bigGreal :f3n>8 9al1.bigGreal); 2(. 2). ret-rn #; 20.5

/m e1emplo aonde usaQse uniom om uma )ari()el au1iliar:

str-ct tagged-nion / en-m /KIXI=7I8 YIS8 ?=IZ8 E=K1?E8 <=YISEU5 code; -nion / int i; long l; do-ble d; 9oid !p; 5 -; 5; referencia .ttp" c6faL.com str-ct tagged-nion..tml

3.5.3 Inicializao de union

Podemos inicializar uma union usando o formato: -nion nometipo / <tipo1> 9ar1; <tipo2> 9ar2; ... <tipon> 9arn; 5 9-nion@/ .9arx@lalorx 5; -nion nometipo o-tra9ar@/ .9arx@lalorx 5; Um exemplo completo seria exemplo19.c 1. ! 2. ! nome" exemplo10.c $. ! descri%o" Eeclara%o8 inicialiDa%o e -tiliDa%o de -nion '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. -nion 9alor 1#. / 11. int inteiro; 12. float real; 1$. do-ble bigGreal; 1'. 5 9al1@ / .inteiro@1# 5; 1*. 1+. -nion 9alor 9al2; 1(. 1). 9al2.real @ 1.*; 10. 2#. printf(>inteiro :d3n>8 9al1.inteiro); 21. printf(>real :f3n>8 9al1.real); 22. ret-rn #; 2$.5

3.6 Enum
Enum um tipo de estrutura de dado aonde posso enumerar opes usando nomes. Esses nomes so significativos para o C e representam constantes com o valor numrico. Cada constante da enumerao tem um valor numrico e por padro inicia com 0 e incrementado para cada constante. Podemos alterar esses valores.

3.6.1 Declarao de enum.

Para declarar uma enum usamos o modelo: en-m nometipo / const1[@9alor1] 8const2[@9alor2]8 constm[@9alorm] 5; 5 9en-m189en-m2; en-m nometipo o-tra9ar; Nesse caso: nometipo: o nome desse tipo enum, podemos declarar variveis usando esse nome. consts; so as contastantes dessa unum. venums so variveis do stipo enum nometipo Na linha enum nometipo outravar estamos declarando outra varivel do tipo enum nometipo que j foi definido.

Um exemplo completo seria: exemplo20.c 1. ! 2. ! nome" exemplo2#.c $. ! descri%o" Eeclara%o de en-m '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. en-m cores / 9ermel.o8 9erde8 aD-l 5 9al1; 1#. 11. en-m estadoGci9il / solteiro@18 casado8 9i-9o@*8 desL-itado 5; 12. 1$. en-m estadoGci9il 9al2; 1'. 1*. ret-rn #; 1+.5

3.6.2 Utilizao de enum.

Para utilizar uma enum usamos cada varivel diretamente no cdigo fonte. Cada uma das opes ter um nmero associado, enumerado. en-m nometipo / const1 8const28 constm 5; 5 9en-m189en-m2; en-m nometipo o-tra9ar; 9en-m1@const1; printf(2:- :-3n489en-m18 const2); Um exemplo completo seria: exemplo21.c 1. ! 2. ! nome" exemplo21.c $. ! descri%o" Eeclara%o e -tiliDa%o de en-m '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. en-m cores / 9ermel.o8 9erde8 aD-l 5 9al1; 1#. 11. en-m estadoGci9il / solteiro@18 casado8 9i-9o@*8 desL-itado 5; 12. 1$. en-m estadoGci9il 9al2; 1'. 1*. 9al1@aD-l; 1+. 9al2@casado; 1(. 1). printf(2cores :- :- :-3n48 9ermel.o8 9erde8 aD-l ); 10. printf(29aria9eis :- :- 3n48 9al18 9al2 ); 2#. 21. ret-rn #; 22.5

3.6.3 Inicializao de enum.

Podemos inicializar uma enum usando o formato: en-m nometipo / const1 8const28 constm 5; 5 9en-m1@const189en-m2@const2; en-m nometipo o-tra9ar; 9en-m1@const1; printf(2:- :-3n489en-m18 9en-m2);

Um exemplo completo seria exemplo22.c 1. ! 2. ! nome" exemplo22.c $. ! descri%o" Eeclara%o8 inicialiDa%o e -tiliDa%o de en-m '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. en-m cores / 9ermel.o8 9erde8 aD-l 5 9al1@aD-l; 1#. 11. en-m estadoGci9il / solteiro@18 casado8 9i-9o@*8 desL-itado 5; 12. 1$. en-m estadoGci9il 9al2; 1'. 1*. 9al2@casado; 1+. 1(. printf(2cores :- :- :-3n48 9ermel.o8 9erde8 aD-l ); 1). printf(29aria9eis :- :- 3n48 9al18 9al2 ); 10. 2#. ret-rn #; 21.5

3.6.4 Typedef
Typedef define tipos de dados definidos pelo programador que a linguagem de programao reconhece como um tipo definido. O tipo de dado novo dependedo como foi criado pode ser primitivo ou derivado e seguir as mesmas regras seja na declarao, inicializao e utilizao. tCpedef tipo nomeGtipo [s-lfixo]; nomeGtipo 9ar;
/m e1emplo ompleto seria:

exemplo23.c 1. ! 2. ! nome" exemplo2$.c $. ! descri%o" tCpedef '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. 1#. tCpedef int inta8 intb[2]8 intc[2][2]; 11. tCpedef c.ar c.ara8 c.arb[]; 12. tCpedef str-ct tipostr-ct / int x; 5 no9oGtipo; 9ari;9el

no9oGtipo no

1$. 1'. 1*. 1+. 1(. 1). 10. 2#. 21. 22. 2$. 2'. 2*. 2+. 2(.5

inta ia @ 1#; intb ib @ / 1 8 2 5; intc ic @ / /1 8 25 8 /11 8 125 5; c.ara ca @ AaA; c.arb cb @ 2Tello4; no9oGtipo ta @ / .x @ 1## 5; o- declarar str-ct tipostr-ct ta @ / .x @ 1## 5; printf( 2ia@:d8 ib[1]@:d8 ic[1][1]@:d3n48 ia8 ib[1]8 ic[1][1]); printf( 2ia@:c8 ib@:s3n48 ca8 cb); printf( 2ta.x@:d3n48 ta.x ); ret-rn #;

3.7 Expresses
Uma expresso uma sequencia de operadores e operandos que resulta em um valor ou que resulta em um objeto ou em uma funo, ou que resulte em uma atribuio, ou que faa um conjunto dessas aes. As expresses so avaliadas da esquerda para a direita obedecendo a precedncia dos operadores. int x; x @ 1; x @ x W 2 ! 2; nesse caso seria 1 W ( 2 ! 2 ) @ * Se precisar alterar a precedncia dos operadores podemos colocar entre parenteses. int x; x @ 1; x @ (x W 2) ! 2;

3.7.1 Operadores unrio, binrios e ternrios.

Operadores podem ser classificado de acordo com a quantidade de operandos. Em C temos operadores unrios, binrios e ternrios. Esses operadores podem ser didaticamente classificados como: aritmticos, relacionais, lgicos, condicionais, operador bit, atribuio, membro ( estruturas ) e gerenciamento de memria e converso.

3.7.2 Operadores aritmticos.

Operadores aritmticos podem ser usados em qualquer tipo de dado escalar seja nmeros inteiros, reais e caractere. Quando realizamos operaes com o mesmo tipo de dado o resultado do mesmo tipo. Se forem do tipo diferente, a converso ser automtica e tentar converter para o tipo mais apropriado para a operao. Os operadores binrios so: * ( multiplicao ), / ( diviso ), % ( modulo ), + ( soma), - (subtrao). Os operadores unrios so: + (positivo) e -( negativo), ++ (incremento) (decremento)

e1emplo24a.

1. ! 2. ! nome" exemplo2'.c $. ! descri%o" =peradores aritmticos bin;rios '. ! data" 1$ #2 2#1' *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x@18C@$8D@*; 1#. 11. x@CWD; 12. D@x:C; 1$. C@D x; int int @ int 1'. x@6x; 1*. 1+. printf(2x@:i8 C@:i e D@:i3n48 x8 C8 D ); 1(. ret-rn #; 1).5 Os operadores ++ e - podem ser prefixos e sulfixos e tem o formato: WW9ar o- 9arWW 669ar o- 9ar66 o var tem que ser um lvalue, ou seja, uma varivel escalar e que possa ser atribudo valores ( no constante). A diferena do prefixo e sufixo que no prefixo o operador incrementa a varivel e depois fornece para a expresso o valor dela. No caso do sufixo, ele fornece o valor atual dela e depois a varivel incrementada.
e1emplo244.

1. ! 2. ! nome" exemplo2'b.c $. ! descri%o" =peradores WW e 66 '. ! data" 1$ #2 2#1' *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x@18C@$8D@*; 1#. C@xWW; 11. D@WWx; 12. printf(2x@:i8 C@:i e D@:i3n48 1$. ret-rn #; 1'.5

x8 C8 D );

3.7.3 Operadores relacionais.

Operadores relacionais comparam dois valores e dependendo do operador e operandos retornar verdadeiro ou falso. No C falso o nmero zero e verdadeiro qualquer outro nmero. Nesse caso verdadeiro nmero 1. Os operadores binrios so: < (menor), > (maior), <= ( menor ou igual), > ( maior ou igual), == ( igual ) e != (diferente).
e1emplo2%.

1. ! 2. ! nome" exemplo2*.c $. ! descri%o" =peradores relacionais bin;rios '. ! data" 1# #' 2#1$ *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x@18C@$8D@*; 1#. 11. printf(>x>C :i8 x<D :i e C<@D :i3n>8 x>C8 x<D8 C<@D ); 12. 1$. printf(>x@@C :d e x[@D :d3n>8 x@@C8 x[@D ); 1'. 1*. printf(>:d3n>8 D > C > x); 1+. 1(. ret-rn #; 1).5

3.7.4 Operadores lgicos

Operadores lgicos binrios comparam dois valores lgicos e retornam um valor lgico. Podemos comparar qualquer valor escalar e se o valor escalar for 0 ( zero ) ser falso caso contrario ser verdadeiro. O resultado ser 0 ou 1. O nico operador lgico unrio negao (!). Os operadores binrios so: && ( and ) e || (ou) Os operadores unrios so: !(negao)
e1emplo2,.

1. ! 2. ! nome" exemplo2+.c $. ! descri%o" =peradores lgicos '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x8C8D; 1#. 11. x @ 1 \\ #; 12. 1$. C @ x ]] 2#; 1'. 1*. D @ [x;

1+. 1(. 1). 10.5

printf(2x@:i8 C@:i e D@:i3n48 ret-rn #;

x8 C8 D );

3.7.5 Operadores bit

Os operadores bit operam com dois valores em lgica binria e retornaria um escalar. No vamos detalhar esses operadores nesse curso porque necessitaria de conhecimento de calculo binrio que foge o escopo de curso bsico. Os operadores binrios so: & ( e binrio ), | ( ou binrio ), ^ ( ou exclusivo), << ( shift para esquerda) e >> shift para a direita. O operador unrio : ~ (not)
e1emplo27.

1. ! 2. ! nome" exemplo2(.c $. ! descri%o" =peradores bit bin;rios '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x@18C@18D@1; 1#. 11. x @ 1 << 1; 12. C @ 1# \ $; 1$. D @ 1# ] $; 1'. 1*. printf(2x@:i8 C@:i e D@:i3n48 x8 C8 D); 1+. printf(2^x@:i3n48^x); 1(. 1). ret-rn #; 10.5

3.7.6 Operadores de atribuio

O grupo de operadores de atribuio tem o formado: l9al-e operador r9al-e lvalue o valor da esquerda que tem que ser um objeto modificvel como uma varivel. rvalue pode ser uma expresso, uma varivel ou um literal. Os operadores so: atribuio simples (=) e atribuio com operador +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=.

e1emplo26.

1. ! 2. ! nome" exemplo2).c $. ! descri%o" =peradores de atrib-i%o '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x@#8C@#8D@1#; 1#. 11. x @ 1; 12. CW@ xW1; 1$. D:@C; 1'. 1*. printf(2x@:i8 C@:i e D@:i3n48 x8 C8 D ); 1+. 1(. ret-rn #; 1).5

3.7.7 Operador membro

Operadores membro so usados para acessar membros de estruturas struct e union. Existem dois operadores o . ( ponto ) e o -> (trao ponto). O primeiro membro de estrutura e o segundo membro de ponteiro que veremos mais adiante no curso. exemplo29.c 1. ! 2. ! nome" exemplo20.c $. ! descri%o" =perador membro '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. str-ct data 1#. / 11. int dia8mes8ano; 12. 1$. 5 .oVe @ / .dia @ 1(8 .mes @ 1#8 .ano @ 2#12 5; 1'. 1*. printf(2Eata de .oVe :d :d :d3n48 .oVe.dia8 .oVe.mes8 .oVe.ano); 1+. 1(. ret-rn #; 1).5

3.7.8 Operadores de gerenciamento de memria

Vamos listar os operadores de gerenciamento de memria que veremos mais adiante no curso. Operadores unrios: [] ( operador array), * ( ponteiro), & ( endereo de), -> ( membro de ponteiro para).

3.7.9 Operador condicional

O nico operador condicional e tambem o nico operador ternrio. O formato dele : expresso M Uetorno 9erdadeiro " retorno falso; O operador avalia a expresso, se esse valor escalar for 0 ele falso e retorna o valor falso, caso contrrio o verdadeiro. Ele seira um if/else em uma expresses.
e1emplo3A.

1. ! 2. ! nome" exemplo$#.c $. ! descri%o" =peradores relacionais bin;rios '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x@18C@$8D@*; 1#. 11. x @ x>C M x " C; 12. D @ [D M 1# " DW1#; 1$. 1'. printf(2x@:i8C@:i e D@:i 3n48 x8 C8 D ); 1*. 1+. ret-rn #; 1(.5

3.7.10

Operador de converso.

Podemos usar o operador de converso para alterar o tipo da varivel e do literal. ( tipo ) 9alor Pomos usar essa converso para poder usar o / com variveis int. int x@18C@2; float D@(float)x C; D@x (float)D; D@(float)x (float)D;

3.8 Precedncia de operadores:

Em uma expresso os operadores so executados na ordem de sua precedncia ou podemos usar o parentes para forar a ordem. _ @ ' W ) '; _ @ ( ' W ) ) ';
() [] . -> expr++ expr-* & + - ! ~ ++expr --expr (typecast) sizeof * / % + >> << < > <= >= == != & ^ | && || ?: = += -= *= /= %= >>= <<= &= ^= |= e o ,

3.9 Exerccios
1. Complete ou corrija os cdigos abaixo: &digo N 1.,incl-de <stdio..> 2.int main() $./ '. int 9etor @ / 1828$8'8* 5; *. float precos[2]@ /1.00 2.00 10.00 100.005 +. c.ar string[1*]@4Yntrod-%o ao &4; (. str-ct data / dia8 mes8 ano 5 @ /.dia@2#8 .mes@28 .ano@2#1'5; ). cores / 9erde8 9ermel.o8 aD-l 5; 0. ret-rn #; 1#.5 &digo 1 1.,incl-de <stdio..> 2.int main() $./ '. float a@1.#8b@1#.#8c@1##.#8d@1###.#; *. float media @ a W b W c W d '.#; +. int T @ ' 1 a W 1 b W 1 c W 1 d; (. int aGmaiorGb @ a b; ). int bGmaiorGc @ b c; 0. int aGmaiorGc @ aGmaiorGb bGmaiorGc; 1#. int 9alorGmaiorGab @ aGmaiorGb M b " a; 11. ret-rn #; 12.5 2. Calcule: ( Pode usar um programa em C ) a) =s 9alores de x8C8D int x@18C@$; float D@*8H@(;

x@HWC 2; D@xWD 2; b) =s 9alores de x8C8D8a8b int x@18C@$; int a@xWW; int b@WWx; CW@a; x6@bWW; int D@x666x; c) =s 9alores de x8C8D8a8b int x@18C@$; int a@x>CMx"C; int b@[xMx"^x; x@aMa"bWbMb"1;

3. Crie um arquivo lab02.c declarando: a) Uma string nome_curso b) Dois vetores data_inicio e data_fim ( dia/mes/ano ) c) enumeracao curso = curso_c, curso_mpi, curso_openmp d) Imprima ( altere o %x de acordo com o tipo da varivel): "Nome do curso = %x" "Data de inicio %x/%x/%x" "Data final %x/%x/%x" "Curso %x"

4. Faca uma copia do lab02.c para lab02e.c a) Declare uma struct tregistro com Uma string nome_curso Dois vetores data_inicio e data_fim uma enumerao curso = curso_c, curso_mpi, curso_openmp Declare uma varivel registro do tipo tregistro e inicialize os valores.

b) Imprima usando varivel registro: "Nome do curso = %x" "Data de inicio %x/%x/%x"

"Data de final %x/%x/%x" "Curso %x"

5. Faca uma copia do lab02.c para lab02t.c a) Declare typedef para Uma string tnome_curso vetor tdata para ser usado como data ( dia/mes/ano). enumeracao tcurso = curso_c, curso_mpi, curso_openmp typedef struct tregistro com os typedef anteriores Uma varivel registro do tipo tregistro e inicialize ela.

b) Imprima usando registro "Nome do curso = %x" "Data de inicio %x/%x/%x" "Data de final %x/%x/%x" "Curso %x"

4 Aula 3
4.1 Blocos
Em C criamos blocos com os caracteres { e } que agrupam logicamente um conjunto de comandos seja para formar um bloco de uma funo ou at um bloco annimo. Blocos tambm delimitam o escopo.
e1emplo31.

1. ! 2. ! nome" exemplo$1.c $. ! descri%o" 1locos em & '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. 1#. printf(21om dia3n4); 11. 12. / 1$. printf(2Eentro do bloco3n4); 1'. 5 1*. 1+. ret-rn #; 1(.5

4.2 Escopo
Se lembrarmos que identificador pode ser um objeto, uma funo, uma tag, membro de estrutura, membro de unio, ou enumerao, um nome typedef, um nome de label. O escopo define o limite aonde um identificador pode ser visto, ou seja, ser usado. Podemos ter escopo de arquivo, bloco, funo e declarao de funo. Como podemos declarar objetos em qualquer parte do programa, podemos identificar se dois objetos esto no mesmo escopo quando eles terminam no mesmo ponto. O nome do identificador tem que ser nico no mesmo escopo. Se for de escopos diferentes, a declarao do escopo interno esconde a declarao do escopo externa.
e1emplo32.

1. ! 2. ! nome" exemplo$2.c $. ! descri%o" Escopo em & '. ! data" #+ 11 2#12 *. ! +. (.int 9arGa@1#; ). 0.,incl-de <stdio..> 1#.int main() 11./ 12. int x@1;

1$. 1'. 1*. 1+. 1(. 1). 10. 2#. 21. 22. 2$. 2'. 2*. 2+. 2(. 2).5

c.ar x@AaA; esse _ sobrepQe a declara%o anterior / int x@2#; int 9arGb@2#; printf(2Eentro do bloco interno :d3n48x); printf(29arGa@:d89arGb@:d3n489arGa89arGb); 5 printf(2Eentro do bloco :c3n48x);

int x@1##; no mesmo escopo printf(29arGa@:d3n489arGa); printf(29arGb@:d3n489arGb); printf(2`ora do escopo :d3n48 x); ret-rn #;

4.3 Instruo de seleo

Instrues de seleo desviam o caminho lgico do programa que seria executar uma linha por vez de cima para baixo. Dependendo da instruo e da condio executar um comando/bloco ou outro ou nenhum.

4.3.1 Instruo if
A instruo if avalia a condio, caso seja verdadeira, ele executa o comando/bloco se no, o comando/bloco ignorado. A instruo if tem os formatos: if( condi%o ) comando; if( condi%o ) / bloco do if 5 O comando if avalia se condio verdadeira, isso o resultado diferente de zero. Se sim executado o comando ou o bloco do if. A condio pode ser um literal, uma varivel ou uma expresso. Podemos usar o if em conjunto com o eles que seria o comando/bloco executado caso o teste seja falso. if( condi%o ) comando; else comando; if( condi%o ) / bloco do if 5 else / bloco do else 5

podemos tambm combinar os dois if( condi%o ) comando; else / bloco do else 5 oif( condi%o ) / bloco do if 5 else comando else; Um exemplo completo seria:
e1emplo33.

1. ! 2. ! nome" exemplo$$.c $. ! descri%o" if '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x@18C@$; 1#. if( x > C ) 11. / 12. printf(2x maior L-e C3n4); 1$. 5 1'. else if( x < C ) 1*. / 1+. printf(2x menor L-e C3n4); 1(. 5 1). else 10. / 2#. printf(2x no ig-al a C3n4); 21. 5 22. 2$. if( x @@ C ); 2'. printf(2<orL-e essa lin.a impressaM3n4); 2*. 2+. ret-rn #; 2(.5 O comando if pode conter internamente outro if que chamamos if alinhados. Quando temos ifs alinhado o indicado usar sempre blocos para no confundir qual if faz referencia com qual else.

4.3.2 Instruo switch

A instruo switch composta por uma expresso e vrios cases. Dependendo do valor da expresso, ele passar a executar o case especfico. Seria uma sintaxe de vrios if-else seguidos. A instruo switch tem o formato: sHitc. ( expresso ) / case n-mero" comandos; breaF; case o-troGn-mero" comandos; breaF; defa-lt" comandos; breaF; 5 A instruo switch avalia a expresso e realiza um salto para o case que tenha o mesmo valor. A expresso do tipo int ou que possa converter em int. Cada case nmero um seletor de salto e o C comea a executar o cdigo a partir desse ponto at encontrar a instruo break que para a execuo ou o final do comando switch. O default uma case que selecionado se nenhum outro case for selecionado. Um exemplo completo seria:
e1emplo34.

1. ! 2. ! nome" exemplo$'.c $. ! descri%o" sHitc. '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x@$; 1#. sHitc.( x ) 11. / 12. case 1" printf(2x@13n4); breaF; 1$. case 2" printf(2x@23n4); 1'. case $" printf(2x@$3n4); breaF; 1*. defa-lt" printf(2o 9alor x@ diferente de todos os cases3n4); 1+. 5 1(. ret-rn #; 1).5 Para teste, retire os comandos break do exemplo anterior e defina o x como 2. Compile, execute e verifique o que impresso.

4.4 Instruo de interao

Instrues de interao desviam o caminho lgico do programa que seria executar uma linha por vez somente uma vez para dependendo da instruo e de sua condio executar um comando/bloco uma vez, vrias vezes ou nenhuma.

 Um erro comum usar uma instruo de interao que nunca chega a condio de parada e fica executado sem parar. Isso chamado de loop infinito.

4.4.1 Instruo while

A instruo while tem os formatos H.ile ( condi%o ) comando; o- -sando o bloco H.ile ( condi%o ) / comandos do bloco H.ile 5 O while avalia a condio e enquanto ela for verdadeira esse comando ou bloco executado. Essa condio pode ser uma varivel ou uma expresso. Se o valor escalar for zero falso caso contrrio verdadeiro. Um exemplo completo seria:
e1emplo3%.

1. ! 2. ! nome" exemplo$*.c $. ! descri%o" H.ile '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int cont@1; 1#. 11. H.ile( cont <@1# ) 12. / 1$. printf(2&1 cont@:d3n48cont); 1'. contWW; 1*. 5 1+. 1(. H.ile( cont66 ) 1). printf(2&2 cont@:d3n48cont); 10. 2#. H.ile( contWW <@1# ); 21. printf(2&$ cont@:d3n48cont); 22. ret-rn #; 2$.5 No exemplo anterior o primeiro while exibiu quais valores para cont e o segundo while? Qual seria a diferena no segundo while se usarmos --cont ou cont--? Teria alguma diferena?

4.4.2 Instruo do / while

A instruo do/while tem o formato: do instr-%o; H.ile( condi%o ); o- com bloco do / bloco do do 5 H.ile( condi%o ); A instruo do/while parecida com a while mas o teste de condio fica no final do comando/bloco e independente da condio esse comando/bloco ser executado pelo menos uma vez. Um exemplo completo seria:
e1emplo3,.

1. ! 2. ! nome" exemplo$+.c $. ! descri%o" do '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int cont@1; 1#. 11. do 12. / 1$. printf(2&1 cont@:d3n48cont); 1'. contWW; 1*. 5 1+. H.ile( cont <@1# ); 1(. 1). do 10. printf(2&2 cont@:d3n48cont); 2#. H.ile( cont66 ); 21. 22. ret-rn #; 2$.5 No exemplo anterior o primeiro do/while exibiu quais valores para cont e o segundo do/while? Qual seria a diferena no segundo do/while se usarmos --cont ou cont--? Teria alguma diferena?

4.4.3 Instruo for

A instruo for tem os formatos: for( inicialiDa%o ; condi%o ; expresso ) comando; for( inicialiDa%o ; condi%o ; expresso ) / comandos do bloco for 5 O comando for tem trs expresses que didaticamente chamamos de inicializao, condio e expresso. O for executa primeiramente e somente uma vez a inicializao, depois executa a condio, se ela for verdadeira executa o comando/bloco. Nas prximas vezes, executa a expresso, avalia a condio e se for verdadeira executa novamente o comando/bloco. A expresso inicializao normalmente uma atribuio inicial a uma varivel contador mas pode ser qualquer expresso ou pode ser omitida do comando. No C99 essa expresso pode ser a declarao de uma varivel que ter o escopo de bloco for. A condio pode ser uma expresso avaliada como verdadeira ou falsa. A expresso normalmente um incremento da varivel contador mas pode ser qualquer expresso ou pode ser omitida.
e1emplo37.

1. ! 2. ! nome" exemplo$(.c $. ! descri%o" for '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int cont; 1#. 11. for( cont@1 ; cont<@1# ; contWW) 12. printf(2&1 cont@:d3n48cont); 1$. 1'. for( ; cont >@# ; cont66 ) 1*. / 1+. printf(2&2 cont@:d3n48cont); 1(. 5 1). 10. for( ; cont<@1# ; ) 2#. printf(2&$ cont@:d3n48contWW); 21. 22. for( int o-tro@1 ; o-tro<@1# ; o-troWW ) 2$. printf(2&' o-tro@:d3n48o-troWW); 2'. 2*. for( int o-tro@1#8cont@1 ; o-tro>@# \\ cont<@1# ; o-tro668contWW ) 2+. printf(2&* cont@:d e o-tro@:d3n48cont8 o-tro); 2(. 2). ret-rn #; 20.5

Compilando esse programa com -Wall tem o alerta declaration hides variable cont. Que isso quer dizer?

4.4.4 Instruo continue e break

As instrues continue e break so usadas dentro das instrues de interao e no caso do break tambm na instruo seleo switch. O continue sendo executado dentro de uma instruo de interao, ele para a execuo normal do bloco, e passa a executar a prxima interao. O break tambm para a execuo normal mas ele termina a execuo de interao.
e1emplo36.

1. ! 2. ! nome" exemplo$).c $. ! descri%o" H.ile e do H.ile '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int cont@1; 1#. H.ile( contWW <@1# ) 11. / 12. if( cont@@$ ) contin-e; 1$. if( cont@@* ) breaF; 1'. printf(2&1 cont@:d3n48cont); 1*. 5 1+. 1(. do 1). / 10. if( cont@@$ ) contin-e; 2#. if( cont@@* ) breaF; 21. printf(2&2 cont@:d3n48cont); 22. 5 H.ile( cont66 >@ # ); 2$. 2'. for( cont@1 ; cont <@ 1# ; contWW) 2*. / 2+. if( cont@@$ ) contin-e; 2(. if( cont@@* ) breaF; 2). printf(2&$ cont@:d3n48cont); 20. 5; $#. ret-rn #; $1.5

4.5 Instruo de salto goto

A instruo de salto goto desvia o caminho lgico de execuo para outro ponto no cdigo que definimos com um nome, um label. O formato da instruo goto ... label" comando;

goto label; Um exemplo completo seria:

e1emplo3".

1. ! 2. ! nome" exemplo$0.c $. ! descri%o" goto '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int cont@#; 1#. 11. inicio" 12. 1$. printf(>cont1@:d3n>8WWcont); 1'. 1*. if( cont<@1# ) goto inicio; 1+. else goto fim; 1(. 1). printf(2Sexto final3n4); 10. 2#. fim" 21. 22. ret-rn #; 2$.5 No exemplo acima o Texto final exibido? Por qu?

4.6 Funes
Funes so estruturas que permite que o programa seja desenvolvido em blocos funcionais. A funo em C como funes em matemtica, recebe parmetros e gera um valor de resultado. No C os parmetros e o resultado so tipados. Exemplo40.c 1. ! 2. ! nome" exemplo'#.c $. ! descri%o" f-n%Qes '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int inc(int x) )./ 0. xWW; 1#. ret-rn x; 11.5 12.int dec(int x) 1$./ 1'. x66; 1*. ret-rn x; 1+.5

1(. 1).int main() 10./ 2#. 21. int 9ar@#; 22. printf(>inc(9ar)@:d3n>8inc(9ar)); 2$. printf(>dec(9ar)@:d3n>8dec(9ar)); 2'. 2*. 9ar@inc(9ar); 2+. 2(. printf(>inc(9ar)@:d3n>8inc(9ar)); 2). printf(>dec(9ar)@:d3n>8dec(9ar)); 20. $#. ret-rn #; $1.5

4.6.1 Declarao
A declarao da funo opcional mas uma funo somente pode ser chamada depois de ser declarada ou de ser definida. Se uma funo precisa chamar outra funo, essa outra funo deve estar definida ou declarada anteriormente. Normalmente colocamos as declaraes em arquivos header (.h) e inclumos ela no nosso cdigo fonte. Nesse caso no precisaramos nos preocupar com a ordem de definio e ordem das chamadas de funes. A declarao tem o formato: tipo nome`-ncao ( par1 8 par2 8 ... 8 parn ); O tipo pode ser qualquer um. Se a funo no for retornar valores, podemos indicar com void. O nome da funo tem que ser nico no escopo. Os parmetros podem ser declaraes completas ou pode ser somente o tipo. Se a funo no recebe parmetros podemos deixar os parentes vazio () ou indicar com (void) Um exemplo seria: exemplo41.h 1. ! 2. ! nome" exemplo'1.. $. ! descri%o" declara%o de f-n%Qes '. ! data" #+ 11 2#12 *. ! +.9oid inc(int x); (.9oid dec(int ); ).int s-m(int x8 int C); 0.int s-b(int8 int); O tipo void quer dizer que a funo no tem retorno. O C11 define tambm _Noreturn para indicar uma funo que no retorna valor. _Noreturn no foi implementado em todos os compiladores.

4.6.2 Definio
A definio da funo a funo com o seu bloco de comandos. tipo nome`-ncao ( par1 8 par2 8 ... 8 parn ) / bloco da f-n%o 5 Os parmetros agora tem que estar completamente declarados com o nome e tipo. Esses parmetros criam identificadores que esto no escopo de declarao de funo. Essas variveis somente so visveis dentro da funo. Um exemplo seria: exemplo42.c 1. ! 2. ! nome" exemplo'2.c $. ! descri%o" declara%o de f-n%Qes '. ! data" 1# #' 2#1$ *. ! +.9oid inc(int x) (./ ). xWW; 0.5 1#.9oid dec(int x) 11./ 12. x66; 1$.5 1'.int s-m(int x8 int C) 1*./ 1+. ret-rn x W C; 1(.5 1).int s-b(int x8 int C) 10./ 2#. ret-rn x a C; 21.5

4.6.3 Utilizao
Para usar uma funo basta chamar ela com os parmetros. Exemplo43.c 1.,incl-de <stdio..> 2.,incl-de 2exemplo'1..4 $. incl-ir o conteJdo do arL-i9o exemplo'2.c aL-i pode isar o incl-de '.int main() *./ +. int x@18C@$; (. inc(x); ). dec(C); 0. printf(2x@:d8 C@:d3n48x8C); 1#. x@s-m(x8C);

11. 12. 1$.5

printf(2x@:d8 C@:d3n48x8C); ret-rn #;

Quais os valores de x e y depois de chamada as funes inc e dec? Foi alterado os valores de x e y? Na chamada da funo o que passado o valor dela. Isso quer dizer se alteramos dentro da funo o valor de uma varivel, estamos alterando o valor da varivel que est no escopo da funo e no a varivel usada na chamada da funo. No C podemos usar ponteiros para poder criar funes que alteram as variveis passadas.

4.7 Exerccios
1. Crie os arquivo lab03.h ( declaraes somente) e lab03.c ( definies e a funo main ) contendo: a) Uma funo int parImpar ( int num ) que imprimi se num par o impar. A funo tambm retorna 0 para par e 1 para impar. ( x % 2 = 0 par e x % 2 = 1 impar ) O numero %x par ou O numero %x impar b) Uma funo somatorio ( int num ) usando o comando while para retornar o somatrio de num ( num(1) = 1, num(2)=2+1, num(3)=3+2+1. A funo retorna o somatrio e tambm imprime: Somatorio de %x = %res c) Uma funo fatorial usando o comando for ( fatorial de 1!=1, 2!=2*1, 3!=3*2*1). A funo retorna o fatorial e tambm imprime: %x! = %x d) Uma funo saltoPara ( inicio, fim, salta, para ) que executa um loop for com inicio e fim, se o contador for igual a salta executar o continue e se for para executar o break. Se no for salta ou para imprima o contador. e) Uma funo imprima_cor Defina um typedef no header: typedef enum { verde, vermelho, azul } tcores; Uma funo int imprima_cor( tcores var ) Na funo implemente um switch com case cor: printf(texto cor\n); break default: printf(cor nao cadastrada\n); break; f) Na funo main faa pelo menos uma chamada de funo para cada funo do laboratrio.

5 Aula 4
5.1 Gerenciamento de memria
A linguagem C como as linguagens de programao de alto nvel gerenciam automaticamente a utilizao de memria nos programas. O C quando declaramos um objeto ele reserva memria suficiente e quando esse objeto sai do escopo atual, o C desaloca essa memria. O C permite tambm o gerenciamento de memria pelo programador. Esse gerenciamento de memria que veremos agora.

5.1.1 Ponteiro e endereo de memria

Todos os programas ou o mesmo o sistema operacional quando executado, ele e lido para a memria e depois comea a execuo. Todos os objetos como funo, varivel e constantes esto na memria na execuo e cada um deles tem um endereo nico, o endereo de memria. O tamanho desse endereo de memria depende da arquitetura 32bits ou 64 bits. Todas as variveis tem algum valor seja numrico ou caractere mas o ponteiro e uma varivel especial que o contedo dela um endereo de memria. Como o C fortemente e estaticamente tipado, o ponteiro tambm tem um tipo definido e tambm precisamos declarar antes de usar. tipo !ponteiro; Antes de usar esse ponteiro, precisamos inicializar ele. Podemos inicializar ele estaticamente apontando para uma varivel existente ou alocar dinamicamente uma regio. Faremos agora estaticamente. ponteiro @ \9aria9el; o-troGponteiro @ ponteiro; Podemos declarar e atribuir num s comando: tipo !ponteiro @ \9aria9el; tipo ! o-troGponteiro @ ponteiro; Para usar o contedo dele ou o endereo dele: printf(2Endere%o @ :p e 9alor @ :d3n48 ponteiro8 !ponteiro); printf(2Endere%o @ :p e 9alor @ :d3n48 \9aria9el8 9aria9el); Um exemplo completo seria:
01emplo44.

1. ! 2. ! nome" exemplo''.c $. ! descri%o" ponteiros '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x@18C@$; 1#. int !px@\C8 !pC@\C;

11. 12. 1$. 1'. 1*. 1+. 1(. 1).5

!px@!pxW!pC; printf(2x@:d8 C@:d3n48 x8 C); printf(2!px@:d8 !pC@:d3n48 !px8 !pC); printf(2px@:p8 pC@:p3n48 px8 pC); printf(2\x@:p8 \C@:p3n48 \x8 \C); ret-rn #;

5.1.2 Alocao dinmica

O C permite que o programador aloque memria dinamicamente. Mas quando o programador aloca memria, ele tem que gerenciar todas as etapas: alocao, inicializao, manter acessvel esse endereo de memria em pelo menos uma varivel, desalocar a memria, garantir que no seja utilizado essa memria desalocada. Para o curso usarmos a alocao dinmica disponvel na biblioteca padro C: 9oid !malloc(siDeGt taman.o); 9oid !calloc( siDeGt L-antidade8 siDeGt taman.o); 9oid !realloc( 9oid !ponteiro8 siDeGt taman.o); 9oid free( 9oid !ponteiro); A funo malloc retorna um ponteiro do tamanho do parametro tamanho). Podemos utilizar o funo sizeof ( tipo ) para especificar o tamanho correto. tipo !ponteiro @ malloc( siDeof(tipo) ); A funo calloc aloca vetores: tipo !p9etor @ calloc( taman.o8 siDeof( tipo )); podemos -sar o malloc tambem tipo !p9etor @ malloc( siDeof( tipo ) ! taman.o ); A funao realloc executado passando um ponteiro existente para alterar o tamanho dele. O novo ponteiro diferente do antigo que desalocado. O realloc retorna o novo ponteiro. ponteiro @ realloc( ponteiro8 siDeof(tipo) ! L-antidade ); A funo free desaloca a memria. Mesmo tendo chamado malloc, calloc ou realloc no mesmo ponteiro somente vou ter um comando free. free( ponteiro ); ponteiro@IK??; Quando desalocamos um ponteiro recomendvel atribuir NULL para a varivel. Primeiro para que a memria desalocada no se possa ser usada por esse ponteiro e segundo, assegurado que no seja executado o free com esse endereo desalocado que gera um erro de execuo parando a execuo do programa.

01emplo4%.

1.,incl-de <stdio..> 2.,incl-de <stdlib..> $.int main() './ *. int !px8!pC; +. int x@18C@$; (. ). px@malloc(siDeof(int)); 0. pC@malloc(siDeof(int)); 1#. 11. !px@1#; 12. !pC@$#; 1$. !px@!pxW!pC; 1'. 1*. printf(>x@:d8 C@:d3n>8 x8 C); 1+. printf(>!px@:d8 !pC@:d3n>8 !px8 !pC); 1(. printf(>px@:p8 pC@:p3n>8 px8 pC); 1). printf(>\x@:p8 \C@:p3n>8 \x8 \C); 10. 2#. free(px); 21. free(pC); 22. 2$. printf(>Eepois de free()3n>); 2'. printf(>px@:p8 pC@:p3n>8 px8 pC); 2*. px@pC@IK??; 2+. printf(>px@:p8 pC@:p3n>8 px8 pC); 2(. 2). free(px); 20. free(pC); $#. $1. ret-rn #; $2.5

5.1.3 Ponteiros para array

Ponteiros e array na linguagem C so tipos diferentes mas as operaes e utilizaes so iguais. O C trata arrays como ponteiros tendo a primeira posio que o elemento vetor[0] e calcula a posio no ensimo elemento multiplicando pelo tamanho de cada elemento. Temos que pvetor[0] igual a *pvetor. Alias como o ponteiro em si escalar, podemos somar ponteiros. Se precisamos usar o elemento ndice 10 podemos usar vetor[9], pvelor[9] ou *(pvetor+9). O C na expresso *(pvetor+9) no soma 9 bytes ou bits e sim 9 * o tamanho de cada elemento.
01emplo4,.

1.,incl-de <stdio..> 2.,incl-de <stdlib..> $.int main() './ *. int !parraC; +. parraC@(int!)calloc(1#8siDeof(int)); (. int !o-troarraC@(int!)calloc(1#8siDeof(int)); ). 0. parraC[#]@1;

1#. 11. 12. 1$. 1'. 1*. 1+. 1(. 1). 10. 2#. 21. 22. 2$. 2'. 2*. 2+. 2(. 2).5

parraC[0]@1#; printf(>:d printf(>:d printf(>:d printf(>:d :p3n>8 :p3n>8 :p3n>8 :p3n>8 parraC[#]8 \parraC[#]); parraC[0]8 \parraC[0]); !(parraC)8 parraC); !(parraCW0)8 (parraCW0));

parraC@realloc(parraC8siDeof(int)!2#); parraC[10]@1##; printf(>:d :p3n>8 parraC[#]8 \parraC[#]); printf(>:d :p3n>8 parraC[10]8 \parraC[10]); printf(>:d :p3n>8 !(parraCW10)8 (parraCW10)); free(parraC);parraC@IK??; free(o-troarraC);o-troarraC@IK??; ret-rn #;

5.1.4 Ponteiros para string

No C string e ponteiros para string so relacionados como array e ponteiros para array. A direrena que a string tem um caractere especial \0 que diz aonde indica o final da string.
e1emplo47.

1. ! 2. ! nome" exemplo'(.c $. ! descri%o" <onteiros para strings '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.,incl-de <stdlib..> ).int main() 0./ 1#. c.ar !nome@(c.ar!)malloc(siDeof(c.ar)!2#); 11. nome[#]@A&A; 12. nome[1]@AaA; 1$. nome[2]@ArA; 1'. nome[$]@AlA; 1*. nome[']@AoA; 1+. nome[*]@AsA; 1(. nome[+]@A3#A; 1). printf(>Iome :s ( letra inicial :c )(::p :p)3n>8 nome8 nome[#]8 nome); 10. free(nome); nome@IK??; 2#. ret-rn #; 21.5 Porque no printf quando passamos ponteiro para int usamos *ponteiro e agora para string usamos apenas ponteiro?

5.1.5 Ponteiro para estruturas

Ponteiros para estrutura se comportaria como um ponteiro regular. Somente o aceso ao contedo dele que foi simplificado. Para acessar um item seria (*ponteiro).item, mas podemos usar o operador -> como ponteiro->item.
e1emplo46.

1. ! 2. ! nome" exemplo').c $. ! descri%o" Eeclara%o de str-ct '. ! data" 1# #' 2#1$ *. ! +.,incl-de <stdio..> (.int main() )./ 0. str-ct data 1#. / 11. int dia8mes8ano; 12. 5 dia @ /.dia@1(8 .mes@1#8 .ano@2#125; 1$. 1'. str-ct data !pdia@\dia; 1*. 1+. printf(>Eata de .oVe :d :d :d3n>8 pdia6>dia8 (!pdia).mes8 dia.ano); 1(. 1). ret-rn #; 10.5 Porque no podemos usar *ponteiro.item ?

5.1.6 Ponteiros para funo

Funes como todo identificador no C pode ser acessado usando ponteiros. Vamos explicar o conseito bsico de ponteiros para funo para reforar como est organizado o gerenciamento de memria no C. tipo (!pf-ncao)(arg18 arg28 argn); tipo !pf-ncao () declara pf-ncao L-e retorna ponteiros (tipo!) pf-ncao@\f-ncao; (!pf-ncao)(par18 par28 parn); pf-ncao(par18 par28 parn);
2A.e1emplo4".

1. ! 2. ! nome" exemplo'0.c $. ! descri%o" ponteiro para str-ct '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (. ).int som(int x8 int C) 0./ 1#. ret-rn x W C; 11.5 12.

1$.int main() 1'./ 1*. int (!psom)(int8int)@\som; 1+. printf(>f-ncao psom end@:p res-ltado@:d3n>8psom8psom(182)); 1(. printf(>f-ncao printf end@:p 3n>8printf); 1). ret-rn #; 10.5

5.1.7 Ponteiros como parmetros de funo

No C os parmetros so passados por valor na chamada da funo. Para conseguir alterar o valor de uma varivel na funo podemos passa um ponteiro. Tambm usa-se ponteiros para passar dados grandes como estruturas porque no ser preciso realizar a cpia dos dados na chamada. Exemplo50.h 1. ! 2. ! nome" exemplo*#.. $. ! descri%o" ponteiros como parPmetros de f-n%o '. ! data" #+ 11 2#12 *. ! +.9oid inc(int !x) (./ ). (!x)WW; 0.5 1#.9oid dec(int !x) 11./ 12. (!x)66; 1$.5 Exemplo50.c 1.,incl-de<stdio..> 2.,incl-de >exemplo*#..> $. '.int main() *./ +. int x@18 C@$; (. printf(>x@:d e C@:d3n>8x8C); ). inc(\x); 0. dec(\C); 1#. printf(>x@:d e C@:d3n>8x8C); 11. ret-rn #; 12.5 No exemplo anterior o incremento e decremento feito no formato (*x)++ e (*x--) porque no poderia ser feito como *x++ e *x--?

5.1.8 Alocao dinmica e escopo.

A alocao dinmica de memria extrapola o escopo aonde realizamos a alocao e a desalocao de memria. Mas o ponteiro como sendo uma varivel comum est limitado ao escopo aonde foi declarado e precisamos ter como acessar essa memria para poder chamar a funo free. A maioria dos sistemas

operacionais, quando o programa termina, ele desalocada toda memria alocada para o programa mas como o C tambm portado para plataformas com sistema operacional simplificado ou at mesmo sem sistema operacional, ficou sendo uma pratica de boa programao desalocar toda memria alocada no prprio programa.

5.2 Durao de armazenamento do objeto

A durao de armazenamento de um objeto est relacionado ao escopo dele e como e quando o objeto vlido e pode ser acessado. Se desararmos uma varivel global, ela ficar disponvel durante a execuo do programa e ser visvel em todo o programa. Se declarar uma varivel em um bloco, a durao e visibilidade dele ficar restrita ao bloclo. Podemos alterar esse comportamento com os qualificadores extern, static e register.

5.3 Especificao de classe de armazenamento

Quando declaramos um objeto como uma varivel ou uma funo podemos tambm especificar a classe de armazenamento dela que pode ser extern, static e register. Os objetos so classificados como armazenamento local ou externo. Armazenamento local somente visto no escopo de declarao. Armazenamento externo extrapola o escopo.

5.3.1 Extern
Classifica os objetos com armazenamento externo. Se for uma varivel, ela far referencia a uma outra varivel declarada em um arquivo header ou em outro programa. Se for uma funo, como toda as funes j tem o escopo extern, isso seria redundante. exemplo51.c 1. ! 2. ! nome" exemplo*1.c $. ! descri%o" '. ! data" #+ 11 2#12 *. ! +.int 9aria9el@21; exemplo52.c 1. ! 2. ! nome" exemplo*2.c $. ! descri%o" '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (. ).extern int 9aria9el; 0.int main()/ 1#. printf(>9aria9el externa@:d3n>89aria9el); 11. ret-rn #; 12.5

Para compilar: ,icc 67all 6c exemplo*1.c ,icc 67all 6c exemplo*2.c ,icc 67all exemplo*1.o exemplo*2.o 6o exemplo*1e*2 ,. exemplo*1e*2

5.3.2 Static
Uma varivel declarada como static no escopo de funo e no escopo global. No escopo de funo a varivel inicializada somente uma vez e esse armazenamento dura toda a execuo do programa mesmo que o escopo dela esteja limitado. O valor dela tambm conservado. exemplo53.c 1. ! 2. ! nome" exemplo*$.c $. ! descri%o" '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (. ).int conta() 0./ 1#. static int 9ar@1; 11. ret-rn 9arWW; 12.5 1$. 1'.int main() 1*./ 1+. printf(>&onta@:d3n>8conta()); 1(. printf(>&onta@:d3n>8conta()); 1). printf(>&onta@:d3n>8conta()); 10. ret-rn #; 2#.5 No escopo global, essa varivel ficaria como escopo interno e no poderia declarar uma outra varivel como extern. arquivo1.c static int 9ar@1$; arquivo2.c extern int 9ar;

isso no f-ncionaria

5.3.3 Const
O qualificador const especifica que o objeto no poder ser alterado depois da declarao. const int 9ar@1#; 9ara@2#; erro

Quando trabalhamos com ponteiros, podemos ter ponteiros para contantes , ponteiros contantes para varivel e ponteiros constantes para contantes. ponteiro para constante const int !ptrGtoGconstant@\9ar; !ptrGtoGconstant@1##; erro ptrGtoGconstant@\o-tro9ar; =X ponteiro contante para 9aria9el int !const constantGptr@\9ar; !constantGptr@1##; =X constantGptr@\o-tro9ar; erro ponteiro constante para constante const int ! const constGptrGtoGconst@\9ar; !constGptrGtoGconst@1##; erro constGptrGtoGconst@\o-tro9ar; erro

5.3.4 Register e restrict

Register qualifica uma varivel a ser otimizada o acesso a ela usando registradores da prpria CPU evitando o acesso memria RAM. O compilador pode ignorar isso se no puder realizar essa otimizao. Restrict um qualificador de ponteiros que diz para o compilador que o programador no usar outro ponteiro como acesso alternativo para essa varivel. Com essa restrio o compilador pode otimizar o cdigo.

5.4 Exerccios
1. Crie o arquivo lab04.c na funo main declare e inicialize a) Variveis: int num=10; int data[3]={19,4,2013}; char hello=Hello; struct sponto { int x,y,z } ponto = { 10 , 20 , 30 };

b) Ponteiros e inicialize apontando para as variveis criadas anteriormente. *pnum ponteiro para num *pdata ponteiro para data *phello ponteiro para hello *pponto ponteiro para ponto

c) Imprima essas mensagens usando os ponteiros: num=%d \n data=%d \n hello=%s \n ponto.x=%d, ponto.y=%d, ponto.z=%d \n

2. Crie lab04d.c ( pode ser cpia do lab04.c ) a) Defina struct ponto

b) variveis ponteiros e utilize malloc ou calloc para alocar memria *pnum do tipo ponteiro para int *pdata do tipo ponteiro para vetor int *phello do tipo ponteiro para char *pponto do tipo ponteiro para struct ponto

c) Imprima essas mensagens usando os ponteiros: num=%d \n data=%d \n hello=%s \n ponto.x=%d, ponto.y=%d, ponto.z=%d \n

3. Crie o lab04s.c com uma funo acumulador( init num ). Use uma varivel static. A funo imprime acumulou %d\n. 4. Crie: a) lab04e.h com definio de acumulador( init num ); b) lab04e.c com include de lab04e.h e o corpo da funo acumulador( init num ){} c) lab04i.c com include de lab04e.h. Na funo main realize chamadas para acumulador d) compile e gere lab04e.o e lab04i.o. Depois gere o lab04e executvel.

6 Aula 5
6.1 Biblioteca padro C
A biblioteca padro C ou C standard library a biblioteca padro definido pela ISO para que todo compilador C deve fornecer. A biblioteca padro C fornece macros, definio de tipos e funes para lidar com strings, computao matemtica, processamento de entrada/sada, alocao de memria e muitas outras funes para os servios do sistema operacional. J vimos o comando printf e a parte de alocao de memria, agora iremos ver sobre processamento de entrada e sada.

6.2 Rotinas de entrada e sada

O C abstrai todas as rotinas de entrada e sada com arquivos. Quando usamos o printf, o comando envia informao para um arquivo que o C define como stdout ou seja sada padro. Existem outros como stderr para sada de erro e stdin para entrada padro (teclado).

6.2.1 Arquivos
O C define o tipo FILE para tratar arquivos. Para trabalhar com arquivos precisamos, declarar uma varivel FILE, abrir o arquivo, escrever ou ler, fechar o arquivo. Para declarar uma varivel FILE: `Y?E !arL-i9o; Para abri o arquivo usamos: arL-i9o @ fopen(2arL-i9o48 modo); arquivo o nome do arquivo modo o modo de abertura do arquivo
Modo r 9 a 4 Ar uivo existente A4rir para leitura A res enta final. 8in(rio Ar uivo inexistente erro

Apaga onteDdo3 es re)e Cria um no)o onteDdo no Cria um no)o

Podemos abrir um arquivo temporrio usando: arL-i9o @ tmpfile(IK??);

Para fechar o arquivo usamos: int fclose( arL-i9o );

6.2.2 Entrada e sada

A biblioteca padro C define entrada e sada formatada, caractere e direta. Iremos usar as rotinas de entrada e sada formatada no curso por ser considerada mais didtica.

6.2.2.1

Sada de dados formatada

A bliblioteca padro C define vrias funes para tratar sada formatada, iremos tratar da printf e da fprintf. A funo fptintf tem o formato: fprintf( arL-i9o 8 2formato48 9ar18 9ar28 9arn); O arquivo pode ser um que declaramos e abrimos anteriormente ou pode ser um que o C define como : stdout ou stderr. A funo printf no tem a opo arquivo mas ela abre o stdout: printf(2formato48 9ar18 9ar28 9arn); fprintf( stdo-t 8 2formato48 9ar18 9ar28 9arn);

6.2.2.2

Entrada de dados formatada

A biblioteca padro C define vrias funes para tratar entrada formatada, iremos tratar da scanf e da fscanf. A funo fscanf tem o formato: fscanf( arL-i9o8 2formato48 \9ar18 \9ar28 \9arn); A funo scanf no tem a opo arquivo mas ela abre o stdin scanf(2formato48 \9ar18 \9ar28 \9arn); fscanf( stdin8 2formato48 \9ar18 \9ar28 \9arn);

6.2.3 Tratamento de erro

Quando lidamos com entrada e sada pode ocorrer erros seja de acesso, permisso ou nome de arquivo ou no formato do dado. Para esses problemas, o programador precisa tratar isso no cdigo fonte.

6.2.3.1

Funes teis para o tratamento de erro

Para detectar o final de arquivo: int feof( arL-i9o ); feof retorna verdadeiro para final de arquivo, caso contrrio retorna falso. Para detectar erro na leitura/escrita: int ferror(arL-i9o); ferror retorna zero quando no h erro, caso retorne um nmero, esse nmero o cdigo do erro. Para exibir uma mensagem padro de erro ( sada em stderr): 9oid perror(2texto4); Para traduzir o ero numrico para texto: c.ar !strerror (errorn-m); Para verificar o comando fopen. `Y?E !fp; fp@fopen(2arL-i9o.txt484modo4); if( fp @@ IK?? ) / printf( 2Erro no fopen() codigo :d 6 :s3n48 errno, strerror(errno)) ! e"se # //$"o%o &r'(i)o *+ ! ,&r& )erifi%&r erro n& f(n-.o /rintf e n& f(n-.o fs%&nf f/rintf(f/,0%s0,01e2to3n0) if( errno ) /error(04rro %o5 & f(n%&o f/tintf0) fs%&nf(f/,0%s0,&)&r) if( errno ) /error(04rro %o5 & f(n%&o fs%&nf0) 65 e2e5/"o %o5/"eto seri&:exemplo54.c 1./* 2. * no5e: e2e5/"o78.% $. * 9es%ri-.o: '. * 9&t&: :;/;8/<;:= *. */ +.>in%"(9e <st9io.?> (.>in%"(9e <st9"i$.?> ).>in%"(9e <errno.?> 0.int 5&in() 1#.# 11. @AB4 *f/

12. 1$. 1'. 1*. 1+. 1(. 1). 10. 2#. 21. 22. 2$. 2'. 2*. 2+.

f/=fo/en(0e2e5/"o78.t2t0,0C0) if( f/ == D6BB ) # /error(04rro %o5 & f(n%&o fo/en0) ! e"se # for( int %=: %<=:; %++ ) # f/rintf(f/,0%9 0, %) if( errno ) /error(04rro %o5 & f(n%&o f/tintf0) ! f/rintf(f/,03n0) ! f%"ose(f/) ret(rn ; !

,&r& "er o &r'(i)o:

e1emplo%%.

1./* 2. * no5e: e2e5/"o77.% $. * 9es%ri-.o: '. * 9&t&: :;/;8/<;:= *. */ +.>in%"(9e <st9io.?> (.>in%"(9e <st9"i$.?> ).>in%"(9e <errno.?> 0.int 5&in() 1#.# 11. @AB4 *f/ 12. f/=fo/en(0e2e5/"o78.t2t0,0r0) 1$. int n(5 1'. if( f/ == D6BB ) 1*. # 1+. /error(04rro %o5 & f(n%&o fo/en0) 1(. ! 1). e"se 10. # 2#. C?i"e ( fs%&nf(f/,0%90, &n(5) != 4*@ ) 21. # 22. if( errno ) 2$. /error(04rro %o5 & f(n%&o fs%&nf0) 2'. e"se 2*. f/rintf(st9o(t,0D(5ero %93n0,n(5) 2+. ! 2(. ! 2). f%"ose(f/) 20. ret(rn ; $#.!

6.2.4 ,&ss&Ee5 9e /&rF5etros /&r& o /roEr&5&.

G(&n9o /re%is&5os /&ss&r /&rF5etros /&r& o /roEr&5&, esses /&rF5etros s.o /&ss&9os /&r& & f(n-.o 5&in. ,&r& /o9er ter &%esso & ess&s f(n-Hes, /re%is&5os 9e%"&r&r 5&in %o5 /&rF5etros: int 5&in(int &rE%, %?&r *&rE)[]) &rE% I (5 inteiro '(e %ont& '(&ntos /&rF5etros for5&5 /&ss&9os. &rE)[;] I o no5e 9o /roEr&5&. &rE)[:] &tI &rE)[&rE%-:] s.o os /&rF5etros. 65 e2e5/"o %o5/"eto seri&: exemplo56.c 1. ! 2. ! nome" exemplo**.c $. ! descri%o" '. ! data" #$ 1# 2#12 *. ! +.>in%"(9e <st9io.?> (.>in%"(9e <st9"i$.?> ).>in%"(9e <errno.?> 0. 1#.int 5&in(int &rE%, %?&r *&rE)[]) 11.# 12. for( int %ont=; %ont<&rE% %ont++) 1$. /rintf(0&rE)[%9]=30%s303n0, %ont, &rE)[%ont]) 1'. ret(rn ; 1*.! ,&r& e2e%(t&r: ./e2e5/"o7J ./e2e5/"o7J /&r: /&r< : < = 1o9os os /&rF5etros s.o te2tos: /&r& %on)erter e"es (ti"ize &s f(n-Hes 9e %on)ers.o: 9o($"e &tof(strinE) int &toi(strinE) "onE int &to"(strinE) "onE "onE int &to"" (strinE) // erros s.o tr&t&9os n& )&riK)e" errno

6.3 Exerccios
1. Crie os arquivos lab05w.c e lab05r.c a) O lab05w.c faa um loop for de 1 a 20 e grave o valor do ndice no arquivo lab05.txt b) O lab05r.c faa um loop while lendo do arquivo os nmeros, teste fim de arquivo. c) Nesses exemplos utilize o tratamento de erro. 2. Crie o arquivo lab05wp.c que abre o arquivo que recebe como parmetro na linha de comando e acrescente no final do arquivo lab05.txt. Converter os parmetros para inteiro antes de gravar. 3. A biblioteca C padro fornece muitas funes interessantes que no poderia abordar aqui no curso mas se olhar na documentao dessas funes, poder com facilidade utilizar ela em algum programa. No Linux padro essas funes so documentadas com o man. a) Verifique a documentao de duas funes matemticas pow e sqrt. Se tiver dificuldade no ingls, converse com o instrutor. man pow man sqrt

b) Escolha uma das funes e escreva o programa lab05rf.c como cpia do lab05r.c e a cada nmero lido imprima pow(%d) = %f ou sqrt(%d)=%f. c) De acordo com a documentao, precisa colocar um header a mais e uma linha a mais na compilao (link).

7 L&teri&" 42tr&
4sse %(rso te)e %o5o referen%i& o /&9r.o %o5o (5 %(rso intro9(tMrio. * /&9r&o N:: &/resent& o(tros re%(rsos %o5o t?re&9s, (sso 9e estr(t(r&s EenIri%&s, entre o(tros. ?tt/://CCC.o/en-st9.orE/Ot%:/s%<</CE:8/CCC/9o%s/n:7P;./9f Q 5&iori& 9&s f(n-Hes 9& $i$"iote%& /&9r.o /er5ite5 /roEr&5&r %M9iEos inseE(ros, isso e, /o9e5 sofrer &t&'(e 9e seE(r&n-& %o5o $(ffer o)erf"oC. ,ens&r e5 seE(r&n-& e essen%i&". ,o9e %o5e-&r %o5 esse 5&teri&" ?tt/s://CCC.se%(re%o9inE.%ert.orE/%onf"(en%e/9is/"&R/se%%o9e/N4S1+N+Te%( re+No9inE+Tt&n9&r9 U()i9&s fre'(entes: ?tt/://%-f&'.%o5/