Introduo linguagem C

Centro Nacional de Alto Desempenho CENAPAD-SP Prof. Carlos e!ollo A!ril de "#$%

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
& curso foi estruturado em cinco aulas sendo cada aula tendo uma parte te'rica e uma parte pr(tica com e)erc*cios e la!orat'rios. &s cap*tulos seguem a se+uencia das aulas. $ Introduo " Aula $, Estrutura de um programa C- declarao de .ari(.eis primiti.as e .alores literais. % Aula ", Declarao de .ari(.eis deri.adas e construo de e)press/es. 0 Aula %, Controles de flu)os- estrutura de fun/es- !locos e escopo. 1 Aula 0, 2erenciamento de mem'ria 3 Aula 1, 4i!lioteca padro C e entrada5sa*da 6 7aterial E)tra,

1.2 A tipografia usada na apostila:

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

E)emplo if( <expresso lgica> ) <bloco> [eles <bloco>] & comando 8if9 o!rigatoriamente rece!e um par:metro ;e)presso l'gica< e um ;!loco<. &pcialmente depois pode-se ter o 8else9. 7as se ti.ermos o comando 8else9- o!rigatoriamente teremos um ;!loco< depois. E)emplo, if( 1 > 2 ) comando1(); [eles comando2();]

1.3 Linguagem de Programao C

A linguagem de programao C pode ser descrita como, Imperati.a, o programa descre.e uma se+uencia l'gica de passos +ue de.em ser e)ecutados para resol.er o pro!lema. Em oposio ao paradigma declarati.o +ue se e)pressa o +ue se espera o!ter e no os passos para se chegar nesse o!=eti.o. Procedural, o programa > estruturado usado procedimentos- no caso do C- o nome > fun/es. Alto n*.el ? com acesso a !ai)o n*.el@, uma linguagem com um n*.el de a!strao relati.amente ele.ado- longe do c'digo de m(+uina e mais pr')imo linguagem humana. Compilada, o c'digo fonte em te)to puro > traduAido- ou se=a compilado para uma linguagem de m(+uina gerando um ar+ui.o e)ecut(.el. 7ulti-plataforma, praticamente para todas as plataformas foi implementado pelo menos um compilador C. Podemos tam!>m usar o compilador de uma plataforma e gerar e)ecut(.eis de outras plataformas ? 8cross compiler9@. Bipo de dado est(tico, Bodos os o!=etos em C tem um tipo definido se=a uma .ari(.el- literalfuno- etc.. .Esse tipo no > alterado durante a e)istencial do o!=eto.

1.

Prin!"pios do padro C

1. .1 Spirit of C
Brust the programmer. DonCt pre.ent the programmer from doing Dhat needs to !e done. Eeep the language small and simple. Pro.ide onlF one DaF to do an operation. 7aGe it fast- e.en if it is not guaranteed to !e porta!le.

1. .2 #raduo: Spirit of C
Confie no programador No impea o programador de faAer o +ue precisa faAer. 7antenha a linguagem de programao pe+uena e simples. Disponha somente uma opo de operao. Haa a linguagem r(pida- mesmo +ue no tenha porta!ilidade.

2 Aula 1
2.1 Primeiro Programa em C
e)emplo#$.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 Da linha $ +ue comea com 85I9 at> a linha 1 8I59 temos um coment(rio. Bemos outro coment(rio na linha J +ue comea com 8559 e comenta o c'digo at> o final da linha. &s coment(rios so usados para documentar o c'digo fonte e o compilador ignora eles. Alias- o compilador C ignora tam!>m caracteres de formatao como espao ou ta! e)tra. Poder*amos escre.er esse e)emplo sem usar nenhuma formatao de c'digo mas > uma !oa pr(tica de programao a formatao padro do c'digo fonte. Sem os coment(rios- ficar*amos com, e)emplo#$.c 1. 2. $. '. *. +.,incl-de <stdio..> (.int main() )./ 0. 1#. printf(21om dia3n4); 11. ret-rn #; 12.5 Se olharmos o c'digo fonte sem os coment(rios- a primeira linha com algum comando > a linha 3. Essa linha +ue inicia com 8K9- +ue est( no inicio do c'digo fonte > comando especial chamado pr>processamento. Esse comando- o 8include9 rece!e como par:metro um nome de ar+ui.o +ue o compilador lL o conteMdo e coloca no e)ato lugar do comando.

 Normalmente .eremos o comando include com ar+ui.os com e)tenso 8.h9 +ue tem o significado de 8header9 ? ce!ealho @ +ue so ar+ui.o de defini/es. Nesse caso o ar+ui.o 8stdio.h9 > um ar+ui.o da !i!lioteca padro C +ue define fun/es de entrada e sa*da de informa/es ? 8printf9 na linha $# @. Nogo depois- temos a linha 6 com 8int main?@9 +ue > a definio de uma funo em C. Nesse caso a funo com o nome 8main9 ? principal em inglLs@. Om programa pode ter .(rias fun/es mas somente uma com o nome 8main9 +ue indica aonde o programa ir( iniciar +uando for e)ecutado. Alias- o C > 8casesenseti.e9 e diferencia letras minusculas de maiMsculas, 8main9 > diferente de 87AIN9 e > diferente de 87ain9. A funo 8main9 tem uma pala.ra antes o 8int9 +ue > uma pala.ra +ue define um tipo de dado +ue > inteiro. A funo 8main9 +ue por analogia da matem(tica ? F P f?)@ @ tem um .alor de retorno- ou ser o resultado da funo. Programas tem uma funo 8main9 mas se esti.ermos programando !i!liotecas +ue apenas disponi!iliAam uma coleo de fun/es- no ter*amos a funo 8main9 e o programador +ue for usar essa !i!lioteca > +ue .ai definir um 8main9 em seu programa. A funo 8main9 inicia na linha Q com o caractere 8R8 e termina na linha $" com o caractere 8S9. Boas as linhas entre a Q e $" esto na funo 8main9 ou mais tecnicamente no escopo da funo 8main9. Na linha $$ temos uma outra funo a 8printf9 +ue como analogia a fun/es em matem(tica ? F P f?)@ @rece!e como par:metro um te)to 84om diaTn9. A funo 8printf9 imprime na tela do usu(rio o +ue rece!e como par:metro ? 84om diaTn9 @. Na linha $" temos a linha 8return #U9 +ue > um comando especial +ue alem de sair da funo- ela especifica o .alor de retorno. Hun/es retornam ao ponto +ue ela foi chamado. No caso de 8main9- ela retorna para +uem e)ecutou o programa. A con.eno > +ue +uando retornamos Aero ? # @ num programa- +uer diAer +ue ele funcionou como esperado e se ti.er .alor diferente de Aero- seria o nMmero de algum erro. Agora .amos compilar esse primeiro e)emplo, Na pasta da aula#$ e)ecutamos, icc 6o exemplo#1 exemplo#1.c 67all Para e)ecutar o programa, . exemplo#1 Sa*da na tela, 1om dia Note +ue os caracteres 8Tn9 no so e)i!idos por+ue essa se+uencia representa o car(cter de no.a-linha. E)istem outras se+uencias especiais +ue .eremos durante o curso.

2.1.1 O !omando printf

Durante o curso usaremos o printf como ferramenta nos nossos la!orat'rios. Agora apresentaremos o !(sico necess(rio para os la!orat'rios e no ultimo dia .eremos melhor a formatao de dados. formato do printf printf(2string formata%o48 9ar8 9ar8 9ar8 ...); A 8string de formatao9 > um te)to +ue podemos escre.er literalmente ou podemos indicar locais para a incluso de .ari(.eis usando 8V9 e um +ualificador +ue define o tipo e a formatao de sa*da de cada item. Para cada 8V9 +ue achamos- ele ira usar uma .ari(.el da lista de .ari(.eis.
Letra i ou d u o F ou 1 = ou f 0 ou e > ou g A ou a s &es rio Inteiro Inteiro sem sinal O tal sem sinal Ge1ade 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 p Ponteiro e1emploA2.

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(<1# = >d >i >- >o >x3n<8 1#81#81#81#81#); 12. printf(<61# = >d >i >- >o >x3n<8 61#861#861#861#861#); 1$. printf(<#.1# = >f >e >g >a >x3n<8 #.1#8#.1#8#.1#8#.1#8#.1#); 1'. printf(<6#.1# = >f >e >g >a 3n<8 6#.1#86#.1#86#.1#86#.1#); 1*. printf(<c.ar = >c string = >s3n<8 ?a?8 <1om dia<); 1+. ret-rn #; 1(.5

2.2 A linguagem de programao C

A linguagem de programao C +uando processa um ar+ui.o de programa ela separa o te)to em elementos +ue chamamos de to+uem. Podemos classificar os to+uens em, pala.ra reser.adaidentificador- constantes- literal string e pontuao.

Pala.ras reser.adas como o nome diA- so pala.ras +ue =( tem um uso definido na linguagem de programao e +ue no poder*amos usar para outra finalidade como usar como o nome de uma .ari(.el. A linguagem de programao C tem poucas pala.ras reser.adas 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 +ue podemos dar ou identificar os o!=etos em C. Identificador pode ser uma .ari(.el- uma funo- uma tag- mem!ro de uma estrutura ou unio- um nome tFpedef- um nome de la!elum par:metro de macro. Podemos usar o mesmo identificador para tipos diferentes em pontos? escopos @ diferentes do programacomo podemos ter uma .ari(.el com o mesmo nome de funo. Constantes e literal string so como descre.o os .alores no c'digo fonte como o .alor num>rico $# ou o car(cter WaW ou no caso de constante sting 84om dia9. Pontuao so s*m!olos usados tanto nas opera/es matem(ticas ou l'gicas ou para delimitar o escopo ou final de linha.

2.3 #ipo de dado em C

Como a linguagem C > de tipagem est(tica- tanto os .alores literais +uanto .ari(.eis tem um tipo de dado definido. Podemos separar os tipos de dados em primiti.os e deri.ados. &s tipos de dados primiti.os > definido pela linguagem de programao- os deri.ados so definidos pelo programador compondo com tipos primiti.os ou usando tipos deri.ados =( definidos. &s tipos de dados primiti.os podem ser di.ididos em grupos, Num>ricos inteiros, representam nMmeros naturais sem frao. Num>ricos ponto flutuante, representam nMmeros reais com frao. Caractere, epresentam somente um caractere.

Esses grupos de tipos de dados so escalares podendo realiAar todas as opera/es matem(ticas- l'gicas e comparati.as. Isso > natural para nMmeros mas o caractere > a representao em !it de um .alor num>rico e essa representao > definida pela ta!ela ASCII ? letra WaW > o nMmero J6@. &s tipos de dados deri.ados, String, Em C string > um .etor de .(rios caracteres. ArraF, Estrutura +ue podemos agrupar .alores em formato de .etores ou matriAes de .(ria dimens/es. Cada um pode ser referenciado pelo um indice num>rico. Struct, Estrutura +ue podemos agrupar .ari(.eis de tipo diferente. Cada .ari(.el componente > referenciada pelo nome dela. Onion, Estrutura an(loga ao struct mas todas as .ari(.eis ocupam o mesmo espao na mem'ria. Osado para economiAar mem'ria. Enum, Estrutura de dado aonde posso enumerar op/es usando nomes.

2.

$e!larao de %ari&eis primiti&as.

As .ari(.eis em C so de tipagem est(tica +ue definimos na declarao dela informando o tipo e o nome. Para usar uma .ari(.el ela de.e ser declarada antes mas a declarao +ue pode ser feita em +ual+uer parte do c'digo fonte. & formato da declarao da .ari(.el, <tipo> nome; @e formos declarar -ma 9ariA9el do tipo int ( inteiro ). int contador; Podemos tam!>m declarar .ari(.eis do mesmo tipo na mesma linha separadas por .irgula. <tipo> 9ar18 9ar28 9arn; @e formos declarar x8B8C como int int x8B8C; As .ari(.eis em C no so inicialiAadas- o compilador apenas reser.a a mem'ria necess(ria. Essa posio de memoria pode conter alguma informao de um programa +ue foi e)ecutado antes. Para inicialiAar uma .ari(.el atri!u*mos algum .alor inicial para essa .ari(.el. Podemos apro.eitar a declarao da .ari(.el para a inicialiAao dela. <tipo> nome=9alor; :ara inicialiCar o contador int contador=1; :odemos tambm declarar e inicialiCar 9Arias 9ariA9eis int x=#8B=#8C=#; :odemos inicialiCar a 9ariA9el depois de declarar int contador; int x8B8C; contador =1; x=#; B=C=#;

Om e)emplo completo seria, e)emplo#%.c 1. ! 2. ! nome" exemplo#$.c $. ! descri%o" Declara%o e inicialiCa%o de 9ariA9eis '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. Declara%o e inicialiCa%o de 9ariA9eis 1#. int contador=#; 11. int x=18B=18C=1; 12. imprime 1om dia 1$. printf(21om dia3n4); 1'. ret-rn #; 1*.5

2.' #ipos de dados primiti&os e &ari&eis.

&s tipos de dados primiti.os podem ser di.ididos em grupos, Num>ricos inteiros, representam nMmeros naturais sem frao. Num>ricos ponto flutuante, representam nMmeros reais com frao. Caractere, epresentam somente um caractere. Nulo, epresenta o tipo .oid.

2.'.1 (um)ri!os inteiros

No C temos o inteiro +ue > representado por int e suas .aria/es como signed5unsigned short5long5long long. Essas .aria/es definem a capacidade de representao num>rica. Essas defini/es de capacidade de .ari(.el podem .ariar de acordo com a ar+uitetura do am!iente de programao e se for preciso ter( +ue ser tradada pelo programador ?Haa a linguagem r(pida- mesmo +ue no tenha porta!ilidade@. A capacidade num>rica > calculada de acordo com a +uantidade de !its +ue > proporcional a magnitude num>rica. Se o .alor e)trapolar esse limite pode ocorrer( pro!lemas o.erfloD. & padro do tipo de dado > signed int mas podemos omitir a pala.ra 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 H I327,7 ... J327,7 K 1, 4its sem sinal H A ... ,%%3% K 1, 4its H I327,7 ... J327,7 K 1, 4its sem sinal H A ... ,%%3% K 32 4its H I2147463,47 ... J2147463,47 K 32 4its sem sinal H A ... 42"4",72"% K ,4 4its H I"223372A3,6%477%6A7 J"223372A3,6%477%6A7 K ,4 4its sem sinal 1644,744A737A"%%1,1% K H A ... ...

A declarao de .ari(.eis segue a mesma regra, <tipo> nome; Om e)emplo no c'digo fonte e)emplo#0.c 1. ! 2. ! nome" exemplo#'.c $. ! descri%o" Declara%o de 9ariA9eis inteiras '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. s.ort int Em; 1#. -nsigned s.ort int idade; 11. long int cm; 12. -nsigned long int saldoFcc; 1$. long long int mm; 1'. -nsigned long long int molec-las; 1*. ret-rn #; 1+.5 Podemos .erificar se o am!iente +ue estamos usando segue o padro C usando a funo siAeof. Essa funo retorna a +uantidade de !Ftes +ue so Q !its. e)emplo#1.c 1. ! 2. ! nome" exemplo#*.c $. ! descri%o" Declara%o de 9ariA9eis inteiras '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. printf(2s.ort int = >l-3n48 siCeof(s.ort int)); 1#. printf(2-nsigned s.ort int = >l-3n48 siCeof(-nsigned s.ort int)); 11. printf(2long int = >l-3n48 siCeof(long int)); 12. printf(2-nsigned long int = >l-3n48 siCeof(-nsigned long int));

printf(2long long int = >l-3n48 siCeof(long long int)); printf(2-nsigned long long int = >l-3n48 siCeof(-nsigned long long int)); 1*. ret-rn #; 1+.5 1$. 1'.

2.'.2 (um)ri!os ponto flutuante

No C nMmeros de ponto flutuante pode ser representado por float ou dou!le e suas .aria/es. Essas .aria/es definem a capacidade de representao num>rica. Essas defini/es de capacidade de .ari(.el podem .ariar de acordo com a ar+uitetura do am!iente de programao e se for preciso ter( +ue ser tradada pelo programador ?Haa a linguagem r(pida- mesmo +ue no tenha porta!ilidade@. A capacidade num>rica > calculada de acordo com a +uantidade de !its +ue > proporcional a magnitude num>rica. Se o .alor e)trapolar esse limite pode ocorrer( pro!lemas o.erfloD e underfloD. No temos a definio de signed e unsigned.

$ipo float dou4le long dou4le

Capa idade 1, 4its ,2 4its ,4 4its

A declarao de .ari(.eis segue a mesma regra, <tipo> nome; Om e)emplo no c'digo fonte e)emplo#3.c 1. ! 2. ! nome" exemplo#+.c $. ! descri%o" Declara%o de 9ariA9eis ponto fl-t-ante. '. ! data" #) #' 2#1$ *. ! +.,incl-de <stdio..> (.int main() )./ 0. float Em; 1#. do-ble cm; 11. long do-ble mm; 12. ret-rn #; 1$.5 Podemos .erificar se o am!iente +ue estamos usando segue o padro C usando a funo siAeof. Essa funo retorna a +uantidade de !Ftes +ue so Q !its.

e)emplo#6.c 1. ! 2. ! nome" exemplo#(.c $. ! descri%o" Declara%o de 9ariA9eis inteiras '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. printf(2float = >l-3n48 siCeof(float)); 1#. printf(2do-ble = >l-3n48 siCeof(do-ble)); 11. printf(2long do-ble = >l-3n48 siCeof(long do-ble)); 12. ret-rn #; 1$.5

2.'.3 Cara!tere.
No C caractere representa uma letra somente +ue > o tipo char. & char > um tipo escalar por+ue cada letra pode ser representada pelo um nMmero como na ta!ela ASCII. String em c no > um tipo primiti.o. String > implementado como um .etor de char.

$ipo :ar unsigned :ar 9 :arLt

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

A declarao de .ari(.eis segue a mesma regra, <tipo> nome; Om e)emplo no c'digo fonte e)emplo#Q.c 1. ! 2. ! nome" exemplo#).c $. ! descri%o" Declara%o de 9ariA9eis caractere. '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. c.ar letra; 1#. -nsigned c.ar nota; 11. Gc.arFt l-tf); 12. ret-rn #; 1$.5 Podemos .erificar se o am!iente +ue estamos usando segue o padro C usando a funo siAeof. Essa funo retorna a +uantidade de !Ftes +ue so Q !its.

e)emplo#J.c 1. ! 2. ! nome" exemplo#0.c $. ! descri%o" Declara%o de 9ariA9eis inteiras '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. printf(2c.ar = >l-3n48 siCeof(c.ar)); 1#. printf(2-nsigned c.ar = >l-3n48 siCeof(-nsigned c.ar)); 11. printf(2Gc.arFt = >l-3n48 siCeof(Gc.arFt)); 12. ret-rn #; 1$.5

2.* %alores literais

&s .alores literais em C so de tipagem est(tica e o compilador +ualifica os literais de acordo com o conteMdo deles ou podemos indicar usando prefi)os +ue o +ualificam. Podemos descre.er literais de tipos primiti.os e literais de tipos deri.ados, Niteral num>rica inteira. Niteral num>rica ponto flutuantes. Niteral caractere e string.

2.*.1 Literal num)ri!a inteira.

Podemos representar .alores inteiros em !ase decimal- octal e he)adecimal. Podemos tam!>m +ualificar o inteiro como long- long long ou unsigned. HImeros na base 1# # 8 1 8 $ ... 1# 8 11 ... 8 1## 8 61## HImeros na base octal inicia com # #8 #18 #$8 #(8 1#8 118 ...8 1##8 6#1## HImeros na base .exadecimal inicia com #x #x#8 #x18 #xa8 #xb8 #x1#...#x1##8 6#x1## :ara representar long -samos -m l o- J somo s-fixo e long long -samos dois ll o- JJ 1l8 $J8 #(J8 #xal8 #x1##JJ8 6#x1##JJ :ara representar -nsigned -samos -m - o- K como s-fixo 1-8 $K8 #(K8 #xa-8 #x1##K8 6#x1##K

2.*.2 Literal num)ri!a ponto flutuantes.

Podemos representar literais ponto flutuante na notao normal e na notao cientifica. Am!os as nota/es podem ser representadas na !ase decimal e he)adecimal. & +ualificador padro > signed float mas podemos mudar para float ou para long dou!le.

Para representar um numero ponto flutuante usamos o ponto para separar a parte inteira da frao. Se no ti.er a parte fracionada podemos colocar 8.#9 ou apenas 8.9 HImeros na base 1# #.* 8 *.# 8 *. :odemos -sar a nota%o cientifica #.*e1#8 *.#e28 *.E$ HImeros na base .exadecimal iniciamos com #x #x#.*p# 8 #x*.#p1 8 #x*.p#

2.*.3 Literal !ara!tere e string.

Niterais caractere representam somente um caractere e representamos ele entre aspas simples 8W9. A linguagem C tra!alha com string sendo um con=unto de caractere como um .etor. Caracteres so escalares e podemos realiAar todas as opera/es.

Jetras ?a?8 ?b?8 ?c? :odemos -sar seL-encias de escape ?3??8 ?34?8 ?3M3? :odemos tambem -sar cdigo octal e .exadecimal ?3#1'1?8 ?3x+1? Jiteral string -samos aspas d-plas 21om dia4

3 Aula 2
3.1 %ari&eis deri&adas
&s tipos de dados deri.ados o programador define o formato do dado. Xuando ele define o tipo de dado ele de.e tam!>m implementar rotinas ou fun/es +ue tra!alhem com esse tipo de dado.

3.2 Arra+s
ArraFs representam em matem(tica .etores e matriAes. Em C tanto .etores +uanto matriAes so implementados usando uma .ari(.el com *ndices num>ricos +ue endeream os elemento unicamente.

3.2.1 $e!larao de &ari&eis arra+.

Para declarar um arraF- precisamos definir o tipo de dado dos elementos e a +uantidade. <tipo> nome[taman.o]; -m 9etor <tipo> nome[taman.o1][taman.o2]; matriC de d-as dimensNes. Podemos declarar .ari(.eis primiti.as- .etores e matriAes na mesma linha. <tipo> primiti9o8 9etor[tam9]8 matriC[tamm][tamm]; & tipo de dado pode ser um tipo um tipo primiti.o ou um tipo deri.ado. & *ndice inicia sempre com # at> o tamanho declarado menos um. Om erro comum > declarar um .etor de tamanho ) e usar a posio ). & C ir( permitir mas isso seria acesso inde.ido a mem'ria e o efeito disso no pode ser pre.isto. e)emplo$#.c 1. ! 2. ! nome" exemplo1#.c $. ! descri%o" Declara%o de 9etores e matriCes '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int idade; 1#. int dataHascimento[$]; 11. int matriC2D[1#][1#]8 matriC$D[1#][1#][1#]; 12. ret-rn #; 1$.5

3.2.2 Ini!iali,ao de &ari&eis Arra+s.

Xuando declaramos um .etor ou uma matriA a linguagem de programao no inicialiAa eles com algum .alor- ele apenas reser.a mem'ria suficiente para o .etor ou a matriA inteira e essa posio da mem'ria pode ter .alores +ue outro programa +ue e)ecutou antes dei)ou na mem'ria. Para inicialiAar usamos o formato, <tipo> 9etor[tam] = / literal18 literal28 literal$8 literaltam 5; <tipo> matriC[x][B] = / /literal8 literal58 /literal8literal5 5; Om e)emplo completo seria, e)emplo$$.c 1. ! 2. ! nome" exemplo11.c $. ! descri%o" Declara%o e inicialiCa%o de 9etores e matriCes '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int idade=$'; 1#. int dataHascimento[$]=/$81810()5; 11. int matriC2D[2][2] = / /#8158 /1#8115 5; 12. int o-tra2D[2][2] = / #8 18 1#8 11 5; 1$. int diasOes[] = /$18208$18$#8$18$#8$18$18$#8$18$#8$15; 1'. ret-rn #; 1*.5

3.2.3 -tili,ao de &ari&eis Arra+.

Xuando compomos um .etor ou uma matriA com um tipo primiti.o- podemos usar as opera/es +ue o C implementa indicando item por item. No podemos usar o formato de inicialiAao para atri!uir .alores para matriAes. <tipo> nome[tam]; nome[posi%o] = literal; nome = /9al189al289al$5; erro de comila%o printf(2nome[>d]=>d3n48posi%o8nome[posi%o]); Om erro comum > tentar usar uma posio fora do limite da arraF e pode gerar comportamentos inesperados no programa. Podendo at> parar a e)ecuo atual ?8tra.ar9@. Om e)emplo completo seria, e)emplo$".c 1. ! 2. ! nome" exemplo12.c $. ! descri%o" Declara%o e -tiliCa%o de 9etores e matriCes '. ! data" #0 #' 2#1$ *. ! +.,incl-de <stdio..>

(.int main() )./ 0. int idade=$*; 1#. int dataHascimento[$]; 11. dataHascimento[#]=$; 12. dataHascimento[1]=1; 1$. dataHascimento[2]=10(); 1'. printf(2Data de nascimento >d >d >d8 idade = >d3n48 dataHascimento[#]8 dataHascimento[1]8 1*. dataHascimento[2]8 idade ); 1+. ret-rn #; 1(.5

3.3 String
String em C > implementado como um .etor de char +ue termina com um caractere especial WT#W. Se ti.ermos uma string 8Be)to9 ela teria 3 posi/es iniciando com # at> 1.

e 1 t o MA

Om erro comum > tentar usar uma posio fora do limite da string e pode gerar comportamentos inesperados no programa. Om outro pro!lema > apagar o caractere de final de string WT#W. Se no ti.er esse caractere a string ir( transpor o limite at> +ue em alguma outra posio da mem'ria ti.er um WT#W.

c.ar c.ar c.ar c.ar

string[taman.o]; string[taman.o]=4Pexto4; string[]=4Pexto4; string[taman.o]= /?P?8 ?e?8 ?x?8 ?t?8 ?o?8 ?3#? 5;

String como .etor funciona como arraF- no pode-se alterar o tamanho dela automaticamente mas podemos alterar caractere por caractere como se fosse um .etor. c.ar string[taman.o]=4Pexto4; string[#]=?t?; Om e)emplo completo seria, e)emplo$%.c 1. ! 2. ! nome" exemplo1$.c $. ! descri%o" Declara%o e -tiliCa%o de strings '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. c.ar nome[]=4&arlos QenriL-e Rebollo4; 1#. c.ar profissao[0]=4Snalista4;

11.

printf(2Home >s ( letra inicial >c) profisso >s 3n48 nome8 nome[#]8 profissao); 12. ret-rn #; 1$.5

3.

Stru!t

Struct so estrutura +ue podemos agrupar .ari(.eis com tipos de dado diferente e sendo cada posio dela sendo nomeada. Podemos compor structs com .ari(.eis do tipo primiti.o ou com tipos deri.ados at> compor struct com struct.

3. .1 $e!larao de stru!t
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 .ari(.eis usando esse nome. ;tipos< .arsU so as .ari(.eis componente dessa struct .structs so .ari(.eis do stipo struct nometipo Na linha struct nometipo outro.ar estamos declarando outra .aria.el do tipo struct nometipo +ue =( foi definido.

Om e)emplo completo seria, e)emplo$0.c 1. ! 2. ! nome" exemplo1'.c $. ! descri%o" Declara%o de str-ct '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. str-ct data 1#. / 11. int dia8mes8ano; 12. 5 .oTe; 1$. str-ct data aman.a;

1'. 1*.5

ret-rn #;

3. .2 -tili,ao de stru!t
Para utiliAar uma struct usamos cada .ari(.el componente separadamente usando .ar.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; Om e)emplo completo seria, e)emplo$1.c 1. ! 2. ! nome" exemplo1*.c $. ! descri%o" Declara%o de str-ct '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. str-ct data 1#. / 11. int dia8mes8ano; 12. 5 .oTe; 1$. str-ct data aman.a; 1'. .oTe.dia=1(; 1*. .oTe.mes=1#; 1+. .oTe.ano=2#12; 1(. aman.a = .oTe U 1; erro de compila%o 1). printf(2Data de .oTe >d >d >d3n48 .oTe.dia8 .oTe.mes8 .oTe.ano); 10. ret-rn #; 2#.5

3. .3 Ini!iali,ao de stru!t
Podemos inicialiAar 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;

Om e)emplo completo seria e)emplo$3.c 1. ! 2. ! nome" exemplo1+.c $. ! descri%o" Declara%o8 inicialiCa%o e -tiliCa%o de str-ct '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. str-ct data 1#. / 11. int dia8mes8ano; 12. 5 .oTe = / .dia = 1(8 .mes = 1#8 .ano = 2#12 5; 1$. str-ct data aman.a; 1'. aman.a.dia=.oTe.diaU1; 1*. aman.a.mes=.oTe.mes; 1+. aman.a.ano=aman.a.ano; 1(. printf(2Data de .oTe >d >d >d3n48 .oTe.dia8 .oTe.mes8 .oTe.ano); 1). printf(2Data de aman.a >d >d >d3n48 aman.a.dia8 aman.a.mes8 aman.a.ano); 10. ret-rn #; 2#.5

3.' -nion
Onion > um tipo de estrutura an(loga ao struct mas todas as .ari(.eis ocupam o mesmo espao na mem'ria. Osado para economiAar mem'ria. & tamanho total dessa estrutura > o tamanho da maior .ari(.el componente.

3.'.1 $e!larao 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 .ari(.eis usando esse nome. ;tipos< .arsU so as .ari(.eis componente dessa union .unions so .ari(.eis do stipo union nometipo

Na linha union nometipo outra.ar estamos declarando outra .ari(.el do tipo union nometipo +ue =( foi definido.

Om e)emplo completo seria, e)emplo$6.c 1. ! 2. ! nome" exemplo1(.c $. ! descri%o" Declara%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 bigFreal; 1'. 5 9al1; 1*. -nion 9alor 9al2; 1+. ret-rn #; 1(.5

3.'.2 -tili,ao de union

Para utiliAar uma union usamos cada .ari(.el componente separadamente usando .ar.componente mas ao contrario da struct somente uma delas ter( um .alor significati.o. Om erro comum ao usar union > definir uma .ari(.el componente de um tipo e usar uma outra .ari(.el componente de outro tipo. Para a utiliAao correta da union precisaria de uma .ari(.el au)iliar +ue indi+ue +ual a .ari(.el +ue tem o .alor significati.o. -nion nometipo / <tipo1> 9ar1; <tipo2> 9ar2; ... <tipon> 9arn; 5 9-nion189-nion1; -nion nometipo o-tra9ar; 9-nion.9ar1=9alor1; 9-nion.9ar2=9alor2; $Q.Om e)emplo completo seria, e)emplo$Q.c 1. ! 2. ! nome" exemplo1).c $. ! descri%o" Declara%o e -tiliCa%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 bigFreal; 1'. 5 9al1; 1*. 9al1.inteiro=1#; 1+. printf(<inteiro >d3n<8 9al1.inteiro); 1(. printf(<real >f3n<8 9al1.real); 1). printf(<bigFreal >f3n<8 9al1.bigFreal); 10. 9al1.real=1.*; 2#. printf(<inteiro >d3n<8 9al1.inteiro); 21. printf(<real >f3n<8 9al1.real); 22. printf(<bigFreal >f3n<8 9al1.bigFreal); 2$. ret-rn #; 2'.5
/m e1emplo aonde usaIse uma )ari()el au1iliar:

str-ct tagged-nion / en-m /KHVH;7H8 WHP8 J;HX8 D;K1JE8 :;WHPER5 code; -nion / int i; long l; do-ble d; 9oid !p; 5 -; 5; referencia .ttp" c6faL.com str-ct tagged-nion..tml

3.'.3 Ini!iali,ao de union

Podemos inicialiAar 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; Om e)emplo completo seria e)emplo$J.c 1. ! 2. ! nome" exemplo10.c $. ! descri%o" Declara%o8 inicialiCa%o e -tiliCa%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 bigFreal; 1'. 5 9al1= / .inteiro=1# 5; 1*. -nion 9alor 9al2; 1+. 9al2.real = 1.*; 1(. printf(<inteiro >d3n<8 9al1.inteiro); 1). printf(<real >f3n<8 9al1.real); 10. ret-rn #; 2#.5

3.* .num
Enum > um tipo de estrutura de dado aonde posso enumerar op/es usando nomes. Esses nomes so significati.os para o C e representam constantes com o .alor num>rico. Cada constante tem um .alor num>rico e por padro inicia com # e > incrementado para cada constante. Podemos alterar esses .alores.

3.*.1 $e!larao 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 .ari(.eis usando esse nome. constsU so as contastantes dessa unum. .enums so .ari(.eis do stipo enum nometipo Na linha enum nometipo outra.ar estamos declarando outra .ari(.el do tipo enum nometipo +ue =( foi definido.

Om e)emplo completo seria, e)emplo"#.c 1. ! 2. ! nome" exemplo2#.c $. ! descri%o" Declara%o de en-m '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./

0. 1#. 11. 12. 1$.5

en-m cores / 9ermel.o8 9erde8 aC-l 5 9al1; en-m estadoFci9il / solteiro=18 casado8 9i-9o=*8 desL-itado 5; en-m estadoFci9il 9al2; ret-rn #;

3.*.2 -tili,ao de enum.

Para utiliAar uma enum usamos cada .ari(.el como se fosse uma .ari(.el primiti.a mas a diferena > +ue as constantes so como identificadores. en-m nometipo / const1 8const28 constm 5; 5 9en-m189en-m2; en-m nometipo o-tra9ar; 9en-m1=const1; printf(2>- >-3n489en-m18 const2); Om e)emplo completo seria, e)emplo"$.c 1. ! 2. ! nome" exemplo21.c $. ! descri%o" Declara%o e -tiliCa%o de en-m '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. en-m cores / 9ermel.o8 9erde8 aC-l 5 9al1; 1#. en-m estadoFci9il / solteiro=18 casado8 9i-9o=*8 desL-itado 5; 11. en-m estadoFci9il 9al2; 12. 9al1=aC-l; 1$. 9al2=casado; 1'. printf(2cores >- >- >-3n48 9ermel.o8 9erde8 aC-l ); 1*. printf(29aria9eis >- >- 3n48 9al18 9al2 ); 1+. ret-rn #; 1(.5

3.*.3 Ini!iali,ao de enum.

Podemos inicialiAar 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); Om e)emplo completo seria

e)emplo"".c 1. ! 2. ! nome" exemplo22.c $. ! descri%o" Declara%o8 inicialiCa%o e -tiliCa%o de en-m '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. en-m cores / 9ermel.o8 9erde8 aC-l 5 9al1=aC-l; 1#. en-m estadoFci9il / solteiro=18 casado8 9i-9o=*8 desL-itado 5; 11. en-m estadoFci9il 9al2; 12. 9al2=casado; 1$. printf(2cores >- >- >-3n48 9ermel.o8 9erde8 aC-l ); 1'. printf(29aria9eis >- >- 3n48 9al18 9al2 ); 1*. ret-rn #; 1+.5

3.*. #+pedef
BFpedef define um alias para definio de tipos. tBpedef tipo nomeFtipo [s-lfixo]; nomeFtipo 9ar;
/m e1emplo ompleto seria:

e)emplo"%.c 1. ! 2. ! nome" exemplo2$.c $. ! descri%o" tBpedef '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. 1#. tBpedef int inta8 intb[2]8 intc[2][2]; 11. tBpedef c.ar c.ara8 c.arb[1#]; 12. tBpedef str-ct tipostr-ct / int x; 5 no9oFtipo; no9oFtipo no 9ariA9el 1$. 1'. inta ia = 1#; 1*. intb ib = / 1 8 2 5; 1+. intc ic = / /1 8 25 8 /11 8 125 5; 1(. c.ara ca = ?a?; 1). c.arb cb = 2Qello4; 10. no9oFtipo ta = / .x = 1## 5; 2#. o- declarar str-ct tipostr-ct ta = / .x = 1## 5; 21. 22. printf( 2ia=>d8 ib[1]=>d8 ic[1][1]=>d3n48 ia8 ib[1]8 ic[1][1]); 2$. printf( 2ia=>c8 ib=>s3n48 ca8 cb); 2'. printf( 2ta.x=>d3n48 ta.x ); 2*. 2+. ret-rn #; 2(.5

3./ .0press1es
Oma e)presso > uma se+uencia de operadores e operandos +ue resulta em um .alor ou +ue resulta em um o!=eto ou em uma funo funo- ou +ue resulte em uma atri!uio- ou +ue faa um con=unto dessas a/es. As e)press/es so a.aliadas da es+uerda para a direita o!edecendo a precedLncia do operadores. int x; x = 1; x = x U 2 ! 2; nesse caso seria 1 U ( 2 ! 2 ) = * Se precisar alterar a precedLncia dos operadores podemos colocar entre parenteses. int x; x = 1; x = (x U 2) ! 2;
Os operadores podem ser di)ididos didati amente entre operadores un(rios3 4in(rios e tern(rios.

3./.1 Operadores unrio2 3inrios e ternrios.

&peradores podem ser classificado de acordo com a +uantidade de operandos. Em C temos operadores un(rios- !in(rios e tern(rios. Esses operadores podem ser didaticamente classificados como, aritm>ticos- relacionais- l'gicoscondicionais- operador !it- atri!uio- mem!ro ? estruturas @ e gerenciamento de mem'ria e con.erso.

3./.1.1

Operadores aritm)ti!os.

&peradores aritm>ticos podem ser usados em +ual+uer tipo de dado escalar se=a nMmeros inteiros- reais e caractere. Xuando realiAamos opera/es com o mesmo tipo de dado o resultado > do mesmo tipo. Se forem do tipo diferente- a con.erso ser( autom(tica e tenta con.erter para o tipo mais apropriado para a operao. &s operadores !in(rios so, I ? multiplicao @- 5 ? di.iso @- V ? modulo @- Y ? soma@- - ?su!trao@. &s operadores un(rios so, Y ?positi.o@ e -? negati.o@- YY ?incremento@ -- ?decremento@
e1emplo24.

1. ! 2. ! nome" exemplo2'.c $. ! descri%o" ;peradores aritmticos binArios '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x=18B=$8C=*; 1#. x=BUC; 11. C=x>B; 12. B=C x; int int = int 1$. x=6x;

1'. 1*. 1+. 1(. 1).5

B=UB; C = xUU U UUB; printf(2x=>i8 B=>i e C=>i3n48 ret-rn #;

x8 B8 C );

&s operadores YY e Z podem ser prefi)os e sulfi)os e tem o formato, UU9ar o- 9arUU 669ar o- 9ar66 o .ar tem +ue ser um l.alue- ou se=a- uma .ari(.el escalar. A diferena do prefi)o e sufi)o > +ue no prefi)o- o operador incrementa a .ari(.el e depois fornece para a e)presso o .alor dela. No caso do sufi)o- ele fornece o .alor atual dela e depois a .ari(.el > incrementada.

3./.1.2

Operadores rela!ionais.

&peradores relacionais comparam dois .alores e retornar( .erdadeiro ou falso. No C .erdadeiro > nMmero $ e falso nMmero #. &s operadores !in(rios so, ; ?menor@- < ?maior@- ;P ? menor ou igual@- < ? maior ou igual@- PP ? igual @ e [P diferente.
e1emplo2%.

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

3./.1.3

Operadores l4gi!os

&peradores l'gicos !in(rios comparam dois .alores l'gicos e retornam um .alor l'gico. Podemos comparar +ual+uer .alor escalar e se o .alor escalar for # ? Aero @ ser( falso caso contrario ser( .erdadeiro. & resultado ser( # ou $. & Mnico operador l'gico un(rio > negao ?[@. &s operadores !in(rios so, \\ ? and @ e ]] ?ou@ &s operadores un(rios so, [?negao@

e1emplo2,.

1. ! 2. ! nome" exemplo2+.c $. ! descri%o" ;peradores lgicos '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x8B8C; 1#. x = 1 ZZ #; 11. B = x [[ 2#; 12. C = Yx; 1$. printf(2x=>i8 B=>i e C=>i3n48 1'. ret-rn #; 1*.5

x8 B8 C );

3./.1.

Operadores 3it

&s operadores !it operam com dois .alores em l'gica !in(ria e retornaria um escalar. &s operadores !in(rios so, \ ? e !in(rio @- ] ? ou !in(rio @- ^ ? ou e)clusi.o@- ;; ? shift para es+uerda@ e << shift para a direita. & operador un(rio >, _ ?not@
e1emplo27.

1. ! 2. ! nome" exemplo2(.c $. ! descri%o" ;peradores bit binArios '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x=18B=18C=1; 1#. x = 1 << 1; 11. B = 1# Z $; 12. C = 1# [ $; 1$. printf(2x=>i8 B=>i e C=>i3n48 x8 B8 C ); 1'. printf(2\x=>i3n48\x); 1*. ret-rn #; 1+.5

3./.1.'

Operadores de atri3uio

& grupo de operadores de atri!uio tem o formado, l9al-e operador r9al-e l.alue > o .alor da es+uerda +ue tem +ue ser um o!=eto modific(.el como uma .ari(.el. r.alue pode ser uma e)presso- uma .ari(.el ou um literal.

&s operadores so, atri!uio simples ?P@ e atri!uio com operador YP- -P- IP- 5P- VP- \P- ]P- ^P- ;;P<<P.
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=#8B=#8C=1#; 1#. x = 1; 11. BU= xU1; 12. C>=B; 1$. printf(2x=>i8 B=>i e C=>i3n48 x8 B8 C ); 1'. ret-rn #; 1*.5

3./.1.*

Operador mem3ro

&peradores mem!ro so usados para acessar mem!ros de estruturas struct e union. E)istem dois operadores o 8.9 ? ponto @ e o 8-<9 ?trao ponto@. & primeiro > mem!ro de estrutura e o segundo > mem!ro de ponteiro +ue .eremos mais adiante no curso. e)emplo"J.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. 5 .oTe = / .dia = 1(8 .mes = 1#8 .ano = 2#12 5; 1$. printf(2Data de .oTe >d >d >d3n48 .oTe.dia8 .oTe.mes8 .oTe.ano); 1'. ret-rn #; 1*.5

3./.1./

Operadores de geren!iamento de mem4ria

`amos listar os operadores de gerenciamento de mem'ria +ue .eremos mais adiante no curso. &peradores un(rios, ab ? operador arraF@- I ? ponteiro@- \ ? endereo de@- -< ? mem!ro de ponteiro para@.

3./.1.5

Operador !ondi!ional

& Mnico operador condicional e tam!em o Mnico operador tern(rio. & formato dele >, expresso M Retorno 9erdadeiro " retorno falso; & operador a.alia a e)presso- se esse .alor escalar for # ele > falso e retorna o .alor falso- caso contr(rio o .erdadeiro. Ele seira um if5else em uma e)press/es.
e1emplo3A.

1. ! 2. ! nome" exemplo$#.c $. ! descri%o" ;peradores relacionais binArios '. ! data" #$ 1# 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x=18B=$8C=*; 1#. x = x>B M x " B; 11. C = YC M 1# " CU1#; 12. printf(2x=>i8B=>i e C=>i 3n48 x8 B8 C ); 1$. ret-rn #; 1'.5

3./.1.6

Operador de !on&erso.

Podemos usar o operador de con.erso para alterar o tipo da .ari(.el e do literal. ( tipo ) 9alor Pomos usar essa con.erso para poder usar o 859 com .ari(.eis int. int x=18B=2; float C=(float)x B; C=x (float)C; C=(float)x (float)C; Osaremos essa con.erso em c(lculos matem(ticos e em gerenciamento de mem'riaU

3.5 Pre!ed7n!ia de operadores:

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

Aula 3
.1 8lo!os
Em C criamos !locos com os caracteres 8R8 e 8S9 +ue agrupam logicamente um con=unto de comandos se=a para formar um !loco de uma funo ou at> um !loco anonimo. 4locos tam!>m delimitam o escopo.
e1emplo31.

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

.2 .s!opo
Om identificador pode ser um o!=eto- uma funo- uma tag- mem!ro de estrutura- mem!ro de unio- ou enumerao- um nome tFpedef- um nome de la!el. & escopo define o limite aonde um identificador pode ser .isto- ou se=a- ser usado. Podemos ter escopo de ar+ui.o- !loco- funo e declarao de funo. Como podemos declara o!=etos em +ual+uer parte do programa- podemos identificar se dois o!=etos esto no mesmo escopo +uando eles terminam no mesmo ponto. & nome do identificador tem +ue ser Mnico no mesmo escopo. Se for de escopos diferentes- a declarao do escopo interno esconde a declarao do escopo e)terna.
e1emplo32.

1. ! 2. ! nome" exemplo$2.c $. ! descri%o" Escopo em & '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x=1; 1#. / 11. c.ar x=?a?; esse ] sobrepNe a declara%o anterior 12. / 1$. int x=2#; 1'. printf(2Dentro do bloco interno >d3n48x);

1*. 1+. 1(. 1). 10. 2#. 21.5

5 printf(2Dentro do bloco >c3n48x);

int x=1##; no mesmo escopo printf(2^ora do escopo >d3n48 x); ret-rn #;

.3 Instruo de seleo
Instru/es de seleo des.iam o caminho l'gico do programa +ue > e)ecutar uma linha por .eA de cima para !ai)o. Dependendo da instruo e da condio e)ecutar um comando5!loco ou outro ou nenhum.

.3.1 Instruo if
A instruo if tem os formatos, if( condi%o ) comando; if( condi%o ) / bloco do if 5 & comando if testa se condio > .erdadeira- isso > o resultado > diferente de Aero. Se sim > e)ecutado o comando ou o !loco do if. A condio pode ser um literal- uma .ari(.el ou uma e)presso. Podemos usar o if em con=unto com o else 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;

Om e)emplo completo seria,

e1emplo33.

1. ! 2. ! nome" exemplo$$.c $. ! descri%o" if '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x=18B=$; 1#. if( x > B ) 11. / 12. printf(2x maior L-e B3n4); 1$. 5 1'. else if( x < B ) 1*. / 1+. printf(2x menor L-e B3n4); 1(. 5 1). else 10. / 2#. printf(2x no ig-al a B3n4); 21. 5 22. ret-rn #; 2$.5 & comando if pode conter comando if +ue chamamos if alinhados. Xuando temos ifs alinhado o indicado > usar sempre !locos para no confundir +ual else > a+uele if.

.3.2 Instruo s9it!:

A instruo sDitch tem o formato, sGitc. ( expresso ) / case n-mero" comandos; breaE; case o-troFn-mero" comandos; breaE; defa-lt" comandos; breaE; 5 A instruo sDitch a.alia a e)presso e realiAa um salto para o case +ue se=a o mesmo .alor. A e)presso > do tipo int ou +ue possa con.erter em int. Cada case nMmero > um seletor de salto e o C comea a e)ecutar o c'digo a partir desse ponto at> encontrar a instruo !reaG +ue para a e)ecuo. & default > uma case +ue > selecionado se nenhum outro case for selecionado.

Om e)emplo completo seria,

e1emplo34.

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

Instruo de interao

Instru/es de interao des.iam o caminho l'gico do programa +ue > e)ecutar uma linha por .eA somente uma .eA para dependendo da instruo e de sua condio e)ecutar um comando5!loco uma .eA- .(rias .eAes ou nenhuma. Om erro comum > usar uma instruo de interao +ue nunca chega a condio de parada e fica e)ecutado sem parar. Isso > chamado de loop infinito.

. .1 Instruo 9:ile
A instruo Dhile tem os formatos G.ile ( condi%o ) comando; o- -sando o bloco G.ile ( condi%o ) / comandos do bloco G.ile 5 & Dhile a.alia a condio e en+uanto ela for .erdadeira esse comando ou !loco > e)ecutado. Essa condio pode ser um literal- uma .ari(.el ou uma e)presso. Se o .alor escalar for Aero > falso caso contr(rio > .erdadeiro.

Om e)emplo completo seria,

e1emplo3%.

1. ! 2. ! nome" exemplo$*.c $. ! descri%o" G.ile '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int cont=1; 1#. G.ile( cont <=1# ) 11. / 12. printf(2cont=>d3n48cont); 1$. contUU; 1'. 5 1*. G.ile( cont66 ) 1+. printf(2cont=>d3n48cont); 1(. ret-rn #; 1).5 No e)emplo anterior o primeiro Dhile e)i!iu +uais .alores para cont e o segundo Dhilec Xual seria a diferena no segundo Dhile se usarmos 8--cont9 ou 8cont--9c Beria alguma diferenac

. .2 Instruo do ; 9:ile
A instruo do5Dhile tem o formato, do instr-%o; G.ile( condi%o ); o- com bloco do / bloco do do 5 G.ile( condi%o ); A instruo do5Dhile > parecida com a Dhile mas o teste de condio fica no final do comando5!loco e independente da condio esse comando5!loco ser( e)ecutado pelo menos uma .eA. Om e)emplo 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#. do 11. /

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

5 G.ile( cont <=1# ); do printf(2cont=>d3n48cont); G.ile( cont66 ); ret-rn #;

printf(2cont=>d3n48cont); contUU;

No e)emplo anterior o primeiro do5Dhile e)i!iu +uais .alores para cont e o segundo do5Dhilec Xual seria a diferena no segundo do5Dhile se usarmos 8--cont9 ou 8cont--9c Beria alguma diferenac

. .3 Instruo for
A instruo for tem os formatos, for( inicialiCa%o ; condi%o ; expresso ) comando; for( inicialiCa%o ; condi%o ; expresso ) / comandos do bloco for 5 & comando for tem trLs e)press/es +ue didaticamente chamamos de inicialiAao- condio e e)presso. & for e)ecuta primeiramente e somente uma .eA o inicialiAao- depois e)ecuta a condio se .erdadeira e)ecuta o comando5!loco. Nas outras .eAes- e)ecuta a e)presso- a.alia a condio e se for .erdadeira continua e)ecutando o comando5!loco. A e)presso inicialiAao normalmente > uma atri!uio inicial a uma .ari(.el contador mas pode ser +ual+uer e)presso ou pode ser omitida do comando. Essa e)presso pode ser uma declarao. A e)presso condio > a.aliada como .erdadeira ou falsa. A e)presso normalmente > um incremento da .ari(.el contador mas pode ser +ual+uer e)presso ou pode ser omitidaU
e1emplo37.

1. ! 2. ! nome" exemplo$(.c $. ! descri%o" for '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int cont; 1#. for( cont=1 ; cont<=1# ; contUU) 11. printf(2cont=>d3n48cont); 12. for( ; cont >=# ; cont66 ) 1$. / 1'. printf(2cont=>d3n48cont); 1*. 5 1+. for( ; cont<=1# ; )

1(. 1). 10. 2#.

U ) 21. printf(2cont=>d e o-tro=>d3n48cont8 o-tro); 22. ret-rn #; 2$.5

printf(2cont=>d3n48contUU); for( int o-tro=1 ; o-tro<=1# ; o-troUU ) printf(2o-tro=>d3n48o-troUU); for( int o-tro=1#8cont=1 ; o-tro>=# ZZ cont<=1# ; o-tro668contU

Compilando esse programa com -dall tem o alerta 8declaration hides .aria!le cont9. Xue +ue isso +uer diAerc

. . Instruo !ontinue e 3rea<

As instru/es continue e !reaG so usadas dentro de instruo de interao e no caso do !reaG tam!>m na instruo seleo sDitch. & continue para a e)cusso normal e .ai para o final do !loco de loop. & !reaG para a e)ecuo normal e termina o !loco de loop.
e1emplo36.

1. ! 2. ! nome" exemplo$).c $. ! descri%o" G.ile e do G.ile '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int cont=1; 1#. G.ile( contUU <=1# ) 11. / 12. if( cont==$ ) contin-e; 1$. if( cont==* ) breaE; 1'. printf(2cont1=>d3n48cont); 1*. 5 1+. do 1(. / 1). if( cont==$ ) contin-e; 10. if( cont==* ) breaE; 2#. printf(2cont2=>d3n48cont); 21. 5 G.ile( cont66 >= # ); 22. for( cont=1 ; cont <= 1# ; contUU) 2$. / 2'. if( cont==$ ) contin-e; 2*. if( cont==* ) breaE; 2+. printf(2cont$=>d3n48cont); 2(. 5 G.ile( cont66 >= # ); 2). ret-rn #; 20.5

.' Instruo de salto goto

A instruo de salto des.ia o caminho l'gico de e)ecuo para outro ponto no c'digo +ue definimos com um nome- um la!el. & formato da instruo goto ... label" comando; goto label; Om e)emplo 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#. inicio" 11. printf(<cont1=>d3n<8UUcont); 12. if( cont<=1# ) goto inicio; 1$. else goto fim; 1'. printf(2Pexto final3n4); 1*. fim" 1+. ret-rn #; 1(.5 No e)emplo acima o 8Be)to final9 > e)i!idoc Por +uec

.* =un1es
Hun/es so estruturas +ue permite +ue o programa se=a desen.o.ido em !locos funcionais. A funo em C como fun/es em matem(tica- rece!e par:metros e gere um .alor de resultado. No C os par:metros e o resultado so tipados. E)emplo0#.c 1. ! 2. ! nome" exemplo'#.c $. ! descri%o" f-n%Nes '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int inc(int x) )./ 0. xUU; 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#. int 9ar=#; 21. printf(<inc(9ar)=>d3n<8inc(9ar)); 22. printf(<dec(9ar)=>d3n<8dec(9ar)); 2$. 9ar=inc(9ar); 2'. printf(<inc(9ar)=>d3n<8inc(9ar)); 2*. printf(<dec(9ar)=>d3n<8dec(9ar)); 2+. ret-rn #; 2(.5

.*.1 $e!larao
A declarao da funo > opcional mas uma funo somente pode ser chamada depois de ser declarada ou de ser definida. Isso +uer diAer +ue se uma funo precisa dentro dela chamar outra funo- essa outra funo de.e estar definida ou declarada anteriormente. Normalmente colocamos as declara/es em ar+ui.os header ?.h@ e inclu*mos ela no nosso c'digo fonte. Nesse caso no precisar*amos nos preocupar com a ordem de definio e ordem das chamadas de fun/es. A declarao tem o formato, tipo nome^-ncao ( par1 8 par2 8 ... 8 parn ); & tipo pode ser +ual+uer um. & nome da funo tem +ue ser Mnico. &s par:metros podem ser declara/es completas ou pode ser somente o tipo. Om e)emplo seria, e)emplo0$.h 1. ! 2. ! nome" exemplo'1.. $. ! descri%o" declara%o de f-n%Nes '. ! data" #+ 11 2#12 *. ! +.9oid inc(int x); (.9oid dec(int ); ).int s-m(int x8 int B); 0.int s-b(int8 int); & tipo .oid +uer diAer +ue a funo no tem retorno. & C$$ define tam!>m eNoreturn para indicar uma funo +ue no retorna .alor. No foi implementado em todos os compiladores.

.*.2 $efinio
A definio da funo > a funo com o seu !loco de comandos. tipo nome^-ncao ( par1 8 par2 8 ... 8 parn ) / bloco da f-n%o 5 &s par:metros agora tem +ue estar completamente declarados com o nome e tipo. Esses par:metros criam identificadores +ue esto no escopo de declarao de funo. Essas .ari(.eis somente so .is*.eis dentro da funo. Om e)emplo seria, e)emplo0".c 1. ! 2. ! nome" exemplo'2.c $. ! descri%o" declara%o de f-n%Nes '. ! data" 1# #' 2#1$ *. ! +.9oid inc(int x) (./ ). xUU; 0.5 1#.9oid dec(int x) 11./ 12. x66; 1$.5 1'.int s-m(int x8 int B) 1*./ 1+. ret-rn x U B; 1(.5 1).int s-b(int x8 int B) 10./ 2#. ret-rn x _ B; 21.5

.*.3 -tili,ao
Para usar uma funo !asta chamar ela com os par:metros. E)emplo0%.c 1.,incl-de <stdio..> 2.,incl-de 2exemplo'1..4 $. incl-ir o conteIdo do arL-i9o exemplo'2.c aL-i pode isar o incl-de '.int main() *./ +. int x=18B=$; (. inc(x); ). dec(B); 0. printf(2x=>d8 B=>d3n48x8B); 1#. x=s-m(x8B);

11. 12. 1$.5

printf(2x=>d8 B=>d3n48x8B); ret-rn #;

Xuais os .alores de ) e F depois de chamada as fun/es inc e decc Hoi alterado os .alores de ) e Fc Na chamada da funo o +ue > passado > o .alor dela. Isso +uer diAer se alteramos dentro da funo o .alor de uma .ari(.el- estamos alterando o .alor de outra .ari(.el em outro escopo. No C podemos usar ponteiros para poder criar fun/es +ue alteram as .ari(.eis.

' Aula
'.1 >eren!iamento de mem4ria
A linguagem C como as linguagens de programao de alto n*.el gerenciam automaticamente a utiliAao de memoria nos programas. & C +uando declaramos um o!=eto ele reser.a memoria suficiente e +uando esse o!=eto sai do escopo atual- o C desaloca essa memoria. & C permite tam!>m o gerenciamento de memoria pelo programador. Esse gerenciamento de memoria +ue .eremos no curso.

'.1.1 Ponteiro e endereo de mem4ria

Bodos os programas ou o mesmo o sistema operacional +uando for ser e)ecutado- ele e lido para a memoria e depois comea a e)ecuo. Bodos os o!=etos como funo- .ari(.el e constantes esto na memoria na e)ecuo e cada um deles tem um endereo Mnico- o endereo de memoria. & tamanho do endereo de memoria depende da ar+uitetura %"!its ou 30 !its. Bodas as .ari(.eis tem algum .alor se=a num>rico ou caractere mas o ponteiro e uma .ari(.el especial +ue o conteMdo dela e um endereo de memoria. Como o c o tipo > fortemente e estaticamente tipado- o ponteiro tam!>m tem um tipo definido e tam!>m precisamos declarar antes de usar. tipo !ponteiro; Antes de usar esse ponteiro- precisamos inicialiAar ele. Podemos inicialiAar ele estaticamente apontando para uma .ari(.el e)istente ou alocar dinamicamente uma regio. Haremos agora estaticamente. ponteiro = Z9aria9el; ponteiro = o-troFponteiro; Podemos declarar e atri!uir num so comando, tipo !ponteiro1 = Z9aria9el; tipo !ponteiro2 = o-troFponteiro; Para usar o conteudo dele ou o endereo dele, printf(2Endere%o = >p e 9alor = >d3n48 ponteiro8 !ponteiro); printf(2Endere%o = >p e 9alor = >d3n48 Z9aria9el8 9aria9el); Om e)emplo completo seria,
01emplo44.

1. ! 2. ! nome" exemplo''.c $. ! descri%o" ponteiros '. ! data" #+ 11 2#12 *. ! +.,incl-de <stdio..> (.int main() )./ 0. int x=18B=$; 1#. int !px=ZB8 !pB=ZB;

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

!px=!pxU!pB; px=pB; !px=1##; printf(2x=>d8 B=>d3n48 x8 B); printf(2!px=>d8 !pB=>d3n48 !px8 !pB); printf(2px=>p8 pB=>p3n48 px8 pB); printf(2Zx=>p8 ZB=>p3n48 Zx8 ZB); ret-rn #;

'.1.2 Alo!ao din?mi!a

& C permite +ue o programador alo+ue memoria dinamicamente. 7as +uando o programador aloca memoria- ele tem +ue gerenciar todas as etapas, alocao- inicialiAao- manter acess*.el em pelo menos uma .ari(.el em um escopo- desalocar a memoria- garantir +ue no se=a utiliAado memoria desalocada ou no alocada. Para o curso usarmos a alocao din:mica dispon*.el na !i!lioteca padro C, 9oid !malloc(siCeFt taman.o); 9oid !calloc( siCeFt L-antidade8 siCeFt taman.o); 9oid !realloc( 9oid !ponteiro8 siCeFt taman.o); 9oid free( 9oid !ponteiro); As fun/es de alocao de memoria retornam um ponteiro para o tipo .oidI. Ponteiro para .oid > um ponteiro +ue podemos con.erter seguramente para ponteiro para +ual+uer tipo. Essa soluo possi!ilitou ter uma Mnica funo +ue alocasse memoria para +ual+uer tipo de dado. Para atri!uir um ponteiro .oidI para uma .ari(.el usamos o con.ersor de tipo- e para acertar o tamanho correto para a alocacao- usamos a funo siAeof. tipo !ponteiro = (tipo !)malloc( siCeof(tipo) ); A funo calloc aloca .etores, tipo !p9etor = (tipo!)calloc( taman.o8 siCeof( tipo )); A funao realloc > e)ecutado passando um ponteiro e)istente para alterar o tamanho dele. & no.o ponteiro > diferente do antigo +ue > desalocado. & realloc retorna o no.o ponteiro. ponteiro = realloc( ponteiro8 siCeof(tipo) ! L-antidade ); A funo free desaloca a mem'ria. 7esmo tendo chamado malloc- calloc ou realloc no mesmo ponteiro somente .ou ter um comando free. free( ponteiro ); ponteiro=HKJJ; Xuando desalocamos um ponteiro > recomend(.el atri!uir NONN para esse ponteiro. Primeiro para +ue a memoria desalocada no se possa ser usada por esse ponteiro e segundo- > assegurado +ue no se=a e)ecutado o free com esse endereo desalocado.
01emplo4%.

1.,incl-de <stdio..> 2.,incl-de <stdlib..> $.int main()

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

int !px8!pB; int x=18B=$; px=(int !)malloc(siCeof(int)); pB=(int !)malloc(siCeof(int)); !px=1#; !pB=$#; !px=!pxU!pB; px=pB; !px=1##; printf(<x=>d8 B=>d3n<8 x8 B); printf(<!px=>d8 !pB=>d3n<8 !px8 !pB); printf(<px=>p8 pB=>p3n<8 px8 pB); printf(<Zx=>p8 ZB=>p3n<8 Zx8 ZB); free(px); free(pB); printf(<Depois de free()3n<); printf(<px=>p8 pB=>p3n<8 px8 pB); px=pB=HKJJ; printf(<px=>p8 pB=>p3n<8 px8 pB); free(px); free(pB); ret-rn #;

'.1.3 Ponteiros para arra+

Ponteiros e arraF na linguagem C so correlatos. & C trata arraFs como ponteiros tendo a primeira posio +ue > o elemento .etora#b e calcula a posio no en>simo elemento multiplicando pelo tamanho de cada elemento. Bemos +ue p.etora#b > igual a Ip.etor. Alias como o ponteiro em si > escalar- podemos somar ponteiros. Se precisamos usar o elemento *ndice $# podemos usar .etoraJb- p.eloraJb ou I?p.etorYJ@. & C na e)presso I?p.etorYJ@ no soma J !Ftes ou !its e sim J I o tamanho de cada elemento.
01emplo4,.

1.,incl-de <stdio..> 2.,incl-de <stdlib..> $.int main() './ *. int !parraB; +. parraB=(int!)calloc(1#8siCeof(int)); (. int !o-troarraB=(int!)calloc(1#8siCeof(int)); ). parraB[#]=1; 0. parraB[0]=1#; 1#. printf(<>d >p3n<8 parraB[#]8 ZparraB[#]); 11. printf(<>d >p3n<8 parraB[0]8 ZparraB[0]); 12. printf(<>d >p3n<8 !(parraB)8 parraB); 1$. printf(<>d >p3n<8 !(parraBU0)8 (parraBU0)); 1'. parraB=realloc(parraB8siCeof(int)!2#); 1*. parraB[10]=1##; 1+. printf(<>d >p3n<8 parraB[#]8 ZparraB[#]); 1(. printf(<>d >p3n<8 parraB[10]8 ZparraB[10]); 1). printf(<>d >p3n<8 !(parraBU10)8 (parraBU10)); 10. free(parraB);parraB=HKJJ;

2#. 21. 22.5

free(o-troarraB);o-troarraB=HKJJ; ret-rn #;

'.1. Ponteiros para string

No C string e ponteiros para string so relacionados como arraF e ponteiros para arraF. A direrena > +ue a string tem um caractere especial 8T#9 +ue diA aonde termina a 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(siCeof(c.ar)!2#); 11. nome[#]=?&?; 12. nome[1]=?a?; 1$. nome[2]=?r?; 1'. nome[$]=?l?; 1*. nome[']=?o?; 1+. nome[*]=?s?; 1(. nome[+]=?3#?; 1). printf(<Home >s ( letra inicial >c )(>>p >p)3n<8 nome8 nome[#]8 nome); 10. free(nome); nome=HKJJ; 2#. ret-rn #; 21.5 Por+ue no printf +uando passamos ponteiro para int usamos Iponteiro e agora para string usamos apenas ponteiroc

'.1.' Ponteiro para estruturas

Ponteiros para estrutura se comportaria como um ponteiro regular. Somente o aceso ao conteMdo dele +ue foi simplificado. Para acessar um item seria ?Iponteiro@.item- mas podemos usar o operador -< como ponteiro-<item.
e1emplo46.

1. ! 2. ! nome" exemplo').c $. ! descri%o" Declara%o de str-ct '. ! data" 1# #' 2#1$ *. ! +.,incl-de <stdio..> (.int main() )./ 0. str-ct data 1#. / 11. int dia8mes8ano;

5 dia = /.dia=1(8 .mes=1#8 .ano=2#125; str-ct data !pdia=Zdia; printf(<Data de .oTe >d >d >d3n<8 pdia6>dia8 (!pdia).mes8 dia.ano); 1*. ret-rn #; 1+.5 12. 1$. 1'.

'.1.* Ponteiros para funo

Hun/es como todo identificador no C pode ser acessado usando ponteiros. tipo (!pf-ncao)(arg18 arg28 argn); tipo !pf-ncao () declara pf-ncao L-e retorna ponteiros (tipo!) pf-ncao=Zf-ncao; (!pf-ncao)(par18 par28 parn); pf-ncao(par18 par28 parn);
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 B) 0./ 1#. ret-rn x U B; 11.5 12. 1$.int main() 1'./ 1*. int (!psom)(int8int)=Zsom; 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

'.1./ Ponteiros !omo par?metros de funo

No C os par:metros so passados por .alor na chamada da funo. Para conseguir alterar o .alor de uma .ari(.el podemos passa um ponteiro. Bam!>m usa-se ponteiros para passar dados grandes como estruturas por+ue no ser( preciso realiAar a c'pia dos dados na chamada da funo. E)emplo1#.h 1. ! 2. ! nome" exemplo*#.. $. ! descri%o" ponteiros como par`metros de f-n%o '. ! data" #+ 11 2#12 *. ! +.9oid inc(int !x) (./ ). (!x)UU;

0.5 1#.9oid dec(int !x) 11./ 12. (!x)66; 1$.5 E)emplo1#.c 1.,incl-de<stdio..> 2.,incl-de <exemplo*#..< $. '.int main() *./ +. int x=18 B=$; (. printf(<x=>d e B=>d3n<8x8B); ). inc(Zx); 0. dec(ZB); 1#. printf(<x=>d e B=>d3n<8x8B); 11. ret-rn #; 12.5 No e)emplo anterior o incremento e decremento > feito no formato ?I)@YY e ?I)--@ por+ue no poderia ser feito como I)YY e I)--c

'.2 $urao de arma,enamento do o3@eto

A alocao din:mica de mem'ria e)trapola o escopo aonde realiAamos a alocao e a desalocao de mem'ria. 7as o ponteiro como sendo uma .ari(.el comum est( limitado ao escopo aonde foi declarado e precisamos ter como acessar essa mem'ria para poder chamar a funo free. A maioria dos sistemas opercionais- +uando o progama termina- ele desalocada toda memoria alocada para o programa mas como o C tam!>m > portado para plataformas com sistema operacional simplificado ou at> mesmo sem sistema operacional- ficou sendo uma pratica de !oa programao desalocadar toda memoria alocada no pr'prio programa.

'.3 .spe!ifi!ao de !lasse de arma,enamento

Xuando declaramos um o!=eto como uma .ari(.el ou uma funo podemos tam!>m especificar a classe de armaAenamento dela +ue pode ser e)tern- static e register. &s o!=etos so classificados como armaAenamento local ou e)terno. ArmaAenamento local > somente .isto no escopo de declarao. ArmaAenamento e)terno e)trapola o escopo.

'.3.1 .0tern
Classifica os o!=etos com armaAenamento e)terno. Se for uma .ari(.el- ela far( referencia a uma outra .ari(.el declarada em um ar+ui.o header ou em outro programa. Se for uma funo- como toda as fun/es =( tem o escopo e)tern- isso seria redundante. e)emplo1$.c

1. ! 2. ! nome" exemplo*1.c $. ! descri%o" '. ! data" #+ 11 2#12 *. ! +.int 9aria9el=21; e)emplo1".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

'.3.2 Stati!
Oma .ari(.el declarada como static no escopo de funo e no escopo glo!al. No escopo de funo a .ari(.el > inicialiAada somente uma .eA e esse armaAenamento dura toda a e)ecuo do programa mesmo +ue o escopo dela este=a limitado. e)emplo1%.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 9arUU; 12.5 1$. 1'.int main() 1*./ 1+. printf(<&onta=>d3n<8conta()); 1(. printf(<&onta=>d3n<8conta()); 1). printf(<&onta=>d3n<8conta());

10. 2#.5

ret-rn #;

No escopo glo!al- essa .ari(.el ficaria como escopo interno e no poderia declarar uma outra .ari(.el como e)tern. ar+ui.o$.c static int 9ar=1$; ar+ui.o".c extern int 9ar;

isso no f-ncionaria

'.3.3 Const
& +ualificador const especifica +ue o o!=eto no poder( ser alterado depois da declarao. const int 9ar=1#; 9ara=2#; erro Xuando tra!alhamos com ponteiros- podemos ter ponteiros para contantes - ponteiros contantes para .ari(.el e ponteiros constantes para contantes. ponteiro para constante const int !ptrFtoFconstant=Z9ar; !ptrFtoFconstant=1##; erro ptrFtoFconstant=Zo-tro9ar; ;V ponteiro contante para 9aria9el int !const constantFptr=Z9ar; !constantFptr=1##; ;V constantFptr=Zo-tro9ar; erro ponteiro constante para constante const int ! const constFptrFtoFconst=Z9ar; !constFptrFtoFconst=1##; erro constFptrFtoFconst=Zo-tro9ar; erro

'.3. Aegister e restri!t

egister +ualifica uma .ari(.el a ser otimiAada o acesso a ela usando registradores da pr'pria CPO e.itando o acesso a mem'ria A7. & compilador pode ignorar isso se no puder realiAar essa otimiAao. estrict > um +ualificador de ponteiros +ue diA para o compilador +ue o programador no ir( usar outro ponteiro como acesso alternati.o para essa .ari(.el. Com essa restrio o compilador pode otimiAar o c'digo.

* Aula '
*.1 8i3liote!a padro C
A !i!lioteca padro C ou 8C standard li!rarF9 > a !i!lioteca padro definido pela IS& para +ue todo compilador C de.e fornecer. A !i!lioteca padro C fornece macros- definio de tipos e fun/es para lidar com strings- computao matem(tica- processamento de entrada5sa*da- alocao de mem'ria e muitas outras fun/es para os ser.ios do sistema operacional. f( .imos o comando printf e a parte de alocao de mem'ria- agora iremos .er so!re processamento de entrada e sa*da.

*.2 Aotinas de entrada e sa"da

& C a!strai todas as rotinas de entrada e sa*da com ar+ui.os. Xuando usamos o printf- o comando en.ia informao para um ar+ui.o +ue o C define como stdout ou se=a sa*da padro. E)istem outros como stderr para sa*da de erro e stdin para entrada padro ?teclado@.

*.2.1 ArBui&os
& C define o tipo HINE para tratar ar+ui.os. Para tra!alhar com ar+ui.os precisamos- declarar uma .ari(.el HINE- a!rir o ar+ui.o- escre.er ou ler- fechar o ar+ui.o. Para declarar uma .ari(.el HINE, ^WJE !arL-i9o; Para a!ri o ar+ui.o usamos, arL-i9o = fopen(2arL-i9o48 modo); 8ar+ui.o9 > o nome do ar+ui.o modo > o modo de a!ertura do ar+ui.o
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 a!rir um ar+ui.o tempor(rio usando, arL-i9o = tmpfile(HKJJ);

Para fechar o ar+ui.o usamos, int fclose( arL-i9o );

*.2.2 .ntrada e sa"da

A !i!lioteca padro C define entrada e sa*da formatada- caractere e direta. Iremos usar as rotinas de entrada e sa*da formatada no curso por ser considerada mais did(tica.

*.2.2.1

Sa"da de dados formatada

A !li!lioteca padro C define .(rias fun/es para tratar sa*da formatada- iremos tratar da printf e da fprintf. A funo fptintf tem o formato, fprintf( arL-i9o 8 2formato48 9ar18 9ar28 9arn); & ar+ui.o pode ser um +ue declaramos e a!rimos anteriormente ou pode ser um +ue o C define como , stdout ou stderr. A funo printf no tem a opo ar+ui.o mas ela a!re o stdout, printf(2formato48 9ar18 9ar28 9arn); fprintf( stdo-t 8 2formato48 9ar18 9ar28 9arn);

*.2.2.2

.ntrada de dados formatada

A !i!lioteca padro C define .(rias fun/es para tratar entrada formatada- iremos tratar da scanf e da fscanf. A funo fscanf tem o formato, fscanf( arL-i9o8 2formato48 Z9ar18 Z9ar28 Z9arn); A funo scanf no tem a opo ar+ui.o mas ela a!re o stdin scanf(2formato48 Z9ar18 Z9ar28 Z9arn); fscanf( stdin8 2formato48 Z9ar18 Z9ar28 Z9arn);

*.2.3 #ratamento de erro

Xuando lidamos com entrada e sa*da pode ocorrer erros se=a de acesso- permisso ou nome de ar+ui.o ou no formato do dado. Para esses pro!lemas- o programador precisa tratar isso no c'digo fonte.

*.2.3.1

=un1es Cteis para o tratamento de erro

Para detectar o final de ar+ui.o, int feof( arL-i9o ); feof retorna .erdadeiro para final de ar+ui.o- caso contrario retorna falso. Para detectar erro na leitura5escrita, int ferror(arL-i9o); ferror retorna Aero +uando no h( erro- caso retorne um nMmero- esse nMmero > o c'digo do erro. Para e)i!ir uma mensagem padro de erro ? sa*da em stderr@, 9oid perror(2texto4); Para traduAir o ero num>rico para te)to, c.ar !strerror (errorn-m); Para .erificar o comando fopen. ^WJE !fp; fp=fopen(2arL-i9o.txt484modo4); if( fp == HKJJ ) / printf( 2Erro no fopen() codigo >d 6 >s3n48 errno, s rerror(errno)); ! e"se # //$"o%o &r'(i)o *+ ! ,&r& )erifi%&r erro n& ff(n-.o /rin f e n& f(n-.o fs%&nf f/rin f(f/,0%s0,01e2 o3n0); if( errno ) /error(04rro %o5 & f(n%&o f/ in f0); fs%&nf(f/,0%s0,&)&r); if( errno ) /error(04rro %o5 & f(n%&o fs%&nf0); 65 e2e5/"o %o5/"e o seri&:e)emplo10.c 1./* 2. * no5e: e2e5/"o78.% $. * 9es%ri-.o: '. * 9& &: :;/;8/<;:= *. */ +.>in%"(9e <s 9io.?> (.>in%"(9e <s 9"i$.?> ).>in%"(9e <errno.?> 0.in 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. 2 0,0C0); if( f/ == D6BB ) # /error(04rro %o5 & f(n%&o fo/en0); ! e"se # for( in %=: ; %<=:; ; %++ ) # f/rin f(f/,0%9 0, %); if( errno ) /error(04rro %o5 & f(n%&o f/ in f0); ! f/rin f(f/,03n0); ! f%"ose(f/) ; re (rn ;; !

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

e1emplo%%.

1./* 2. * no5e: e2e5/"o77.% $. * 9es%ri-.o: '. * 9& &: :;/;8/<;:= *. */ +.>in%"(9e <s 9io.?> (.>in%"(9e <s 9"i$.?> ).>in%"(9e <errno.?> 0.in 5&in() 1#.# 11. @AB4 *f/; 12. f/=fo/en(0e2e5/"o78. 2 0,0r0); 1$. in 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/rin f(s 9o( ,0D(5ero %93n0,n(5); 2+. ! 2(. ! 2). f%"ose(f/); 20. re (rn ;; $#.!

*.2. ,&ss&Ee5 9e /&rF5e ros /&r& o /roEr&5&.

G(&n9o /re%is&5os /&ss&r /&rF5e ros /&r& o /roEr&5&, esses /&rF5e ros s.o /&ss&9os /&r& & f(n-.o 5&in. ,&r& /o9er er &%esso & ess&s f(n-Hes, /re%is&5os 9e%"&r&r 5&in %o5 /&rF5e ros: in 5&in(in &rE%, %?&r *&rE)[]) &rE% I (5 in eiro '(e %on & '(&n os /&rF5e ros for5&5 /&ss&9os. &rE)[;] I o no5e 9o /roEr&5&. &rE)[:] & I &rE)[&rE%-:] s.o os /&rF5e ros. 65 e2e5/"o %o5/"e o seri&: e)emplo13.c 1. ! 2. ! nome" exemplo**.c $. ! descri%o" '. ! data" #$ 1# 2#12 *. ! +.>in%"(9e <s 9io.?> (.>in%"(9e <s 9"i$.?> ).>in%"(9e <errno.?> 0. 1#.in 5&in(in &rE%, %?&r *&rE)[]) 11.# 12. for( in %on =; ; %on <&rE% ; %on ++) 1$. /rin f(0&rE)[%9]=30%s303n0, %on , &rE)[%on ]); 1'. re (rn ;; 1*.! ,&r& e2e%( &r: ./e2e5/"o7J ./e2e5/"o7J /&r: /&r< : < = 1o9os os /&rF5e ros s.o e2 os: /&r& %on)er er e"es ( i"ize &s f(n-Hes 9e %on)ers.o: 9o($"e & of(s rinE); in & oi(s rinE); "onE in & o"(s rinE); "onE "onE in & o"" (s rinE); // erros s.o r& &9os n& )&riK)e" errno

/ L& eri&" 42 r&

4sse %(rso e)e %o5o referen%i& o /&9r.o %o5o (5 %(rso in ro9( Mrio. * /&9r&o N:: &/resen & o( ros re%(rsos %o5o ?re&9s, (sso 9e es r( (r&s EenIri%&s, en re o( ros. ? /://CCC.o/en-s 9.orE/O %:/s%<</CE:8/CCC/9o%s/n:7P;./9f

Q 5&iori& 9&s f(n-Hes 9& $i$"io e%& /&9r.o /er5i e5 /roEr&5&r %M9iEos inseE(ros, isso e, /o9e5 sofrer & &'(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& eri&" ? /s://CCC.se%(re%o9inE.%er .orE/%onf"(en%e/9is/"&R/se%%o9e/N4S1+N+Te%( re+No9inE+T &n9&r9 U()i9&s fre'(en es: ? /://%-f&'.%o5/