Escolar Documentos
Profissional Documentos
Cultura Documentos
Apostila C
Apostila 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,
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.
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.
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
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.
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.
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
$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'.
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.
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
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#
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.
(.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.
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.
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
(.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
(.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.
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() )./
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 #;
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.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;
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./
`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
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);
.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
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.
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.
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. /
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# ; )
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
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
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);
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. ! 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;
!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 #;
'./ *. +. (. ). 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.,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;
free(o-troarraB);o-troarraB=HKJJ; ret-rn #;
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. ! 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. ! 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
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
'.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
* 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.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
*.2.2.1
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
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.1
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 ;; !
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 ;; $#.!
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/