Apostila C PDF

Introduo linguagem C
Centro Nacional de Alto Desempenho

CENAPAD-SP
Prof. Carlos Rebollo
Abril de 2013
1 Sumrio
1 Introduo....................................................................................................................... 7
1.1 O Curso.................................................................................................................... 7
1.2 A tipografia usada na apostila:................................................................................. 7
1.3 Linguagem de Programao C.................................................................................. 7
1.4 Prin!pios do padro C.............................................................................................. "
1.4.1 #pirit of C.......................................................................................................... "
1.4.2 $raduo: #pirit of C.......................................................................................... "
2 Aula 1............................................................................................................................ 11
2.1 Primeiro Programa em C ........................................................................................ 11
2.1.1 O omando printf............................................................................................ 1%
2.2 A linguagem de programao C............................................................................. 1%
2.3 $ipo de dado em C................................................................................................. 17
2.4 &elarao de 'ari()eis primiti)as........................................................................1"
2.% $ipos de dados primiti)os e )ari()eis.....................................................................21
2.%.1 *um+rios inteiros.......................................................................................... 21
2.%.2 *um+rios ponto flutuante..............................................................................2%
2.%.3 Caratere........................................................................................................ 27
2., 'alores literais........................................................................................................ 2"
2.,.1 Literal num+ria inteira................................................................................... 2"
2.,.2 Literal num+ria ponto flutuantes...................................................................2"
2.,.3 Literal aratere e string................................................................................. 31
3 Aula 2............................................................................................................................ 33
3.1 'ari()eis deri)adas................................................................................................ 33
3.2 Arra-s..................................................................................................................... 33
3.2.1 &elarao de )ari()eis arra-.........................................................................33
3.2.2 Iniiali.ao de )ari()eis Arra-s.....................................................................3%
3.2.3 /tili.ao de )ari()eis Arra-...........................................................................3%
3.3 #tring...................................................................................................................... 37
3.4 #trut..................................................................................................................... 3"
3.4.1 &elarao de strut....................................................................................... 3"
3.4.2 /tili.ao de strut.......................................................................................... 41
3.4.3 Iniiali.ao de strut...................................................................................... 41
3.% /nion...................................................................................................................... 43
3.%.1 &elarao de union....................................................................................... 43
3.%.2 /tili.ao de union.......................................................................................... 4%
3.%.3 Iniiali.ao de union...................................................................................... 47
3., 0num...................................................................................................................... 4"
3.,.1 &elarao de enum....................................................................................... 4"
3.,.2 /tili.ao de enum.......................................................................................... %1
3.,.3 Iniiali.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+tios............................................................................%%
3.7.1.2 Operadores relaionais.............................................................................%7
3.7.1.3 Operadores l5gios................................................................................... %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 gereniamento de mem5ria.............................................,1
3.7.1.6 Operador ondiional............................................................................... ,3
3.7.1." Operador de on)erso............................................................................ ,3
3.6 Preed7nia de operadores:................................................................................... ,3
4 Aula 3............................................................................................................................ ,7
4.1 8loos..................................................................................................................... ,7
4.2 0sopo.................................................................................................................... ,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 &elarao...................................................................................................... 63
4.,.2 &efinio......................................................................................................... 63
4.,.3 /tili.ao......................................................................................................... 6%
% Aula 4............................................................................................................................ 6"
%.1 >ereniamento de mem5ria................................................................................... 6"
%.1.1 Ponteiro e endereo de mem5ria....................................................................6"
%.1.2 Aloao din?mia.......................................................................................... "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 0speifiao de lasse de arma.enamento..........................................................""
%.3.1 01tern.............................................................................................................. ""
%.3.2 #tati............................................................................................................. 1A1
%.3.3 Const............................................................................................................. 1A3
%.3.4 Begister e restrit.......................................................................................... 1A3
, Aula %.......................................................................................................................... 1A%
,.1 8i4liotea 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
7 Eaterial 01tra.............................................................................................................. 11%
1 Introduo
1.1 O Curso
O curso foi estruturado em cinco aulas sendo cada aula tendo uma parte terica e uma parte prtica com
exerccios e laboratrios. Os captulos seguem a sequencia das aulas.
1 Introduo
2 Aula 1: Estrutura de um programa C, declarao de variveis primitivas e valores literais.
3 Aula 2: Declarao de variveis derivadas e construo de expresses.
4 Aula 3: Controles de fluxos, estrutura de funes, blocos e escopo.
5 Aula 4: Gerenciamento de memria
6 Aula 5: Biblioteca padro C e entrada/sada
7 Material Extra:
1.2 A tipografia usada na apostila:
<item> Esse item obrigatrio
[item] Esse item opcional
Exemplo
if( <expresso lgica> ) <bloco>
[else <bloco>]
O comando if obrigatoriamente recebe um parmetro <expresso lgica> e um <bloco>.
Opcionalmente depois pode-se ter o else. Mas se tivermos o comando else, obrigatoriamente teremos
um <bloco> depois.
Exemplo:
if( 1 > 2 )
comando1();
else
comando2();
1.3 Linguagem de Programao C
A linguagem de programao C pode ser descrita como:
Imperativa: o programa descreve uma sequencia lgica de passos que devem ser executados para
resolver o problema. Em oposio ao paradigma declarativo que se expressa o que se espera obter
e no os passos para se chegar nesse objetivo.
Procedural: o programa estruturado usado procedimentos, no caso do C, o nome funes.
Alto nvel ( com acesso a baixo nvel): uma linguagem com um nvel de abstrao relativamente
elevado, longe do cdigo de mquina e mais prximo linguagem humana.
Compilada: o cdigo fonte em texto puro traduzido, ou seja compilado para uma linguagem de
mquina gerando um arquivo executvel.
Multi-plataforma: praticamente para todas as plataformas foi implementado pelo menos um
compilador C. Podemos tambm usar o compilador de uma plataforma e gerar executveis de
outras plataformas ( cross compiler).
Tipo de dado esttico: Todos os objetos em C tem um tipo definido seja uma varivel, literal,
funo, etc.. .Esse tipo no alterado durante a existencial do objeto.
1.4 Princpios do padro C
1.4.1 Spirit of C
Trust the programmer.
Dont prevent the programmer from doing what needs to be done.
Keep the language small and simple.
Provide only one way to do an operation.
Make it fast, even if it is not guaranteed to be portable.
1.4.2 Traduo: Spirit of C
Confie no programador
No impea o programador de fazer o que precisa fazer.
Mantenha a linguagem de programao pequena e simples.
Disponha somente uma opo de operao.
Faa a linguagem rpida, mesmo que no tenha portabilidade.
2 Aula 1
2.1 Acesso ao ambiente CENAPAD utilizando Windows.
1.clica-se no cone do putty
2.Na tela de conexo do putty
Na primeira vez preencha hostname e saved session com cenapad.unicamp.br. Depois clica-se
save. Depois de salvo, clica-se open. Nas outras vezes somente clica-se na sesso salva, e depois
open.
3.No terminal preencha o login e password com as informaes da conta recebida no primeiro dia
de aula.
2.1.1 Acesso ao ambiente pelo linux
Para acessar o ambiente pelo linux, utilizamos o ssh. O usurio tem que ser substituindo usuario pelo
login passado no primeiro dia de aula.
#ssh usuario@cenapad.unicamp.br
Password:
2.1.2 Sobre o ambiente CENAPAD.
Os ambientes CENAPAD tem como sistema operacional o Linux ou Unix. No curso vamos ver alguns
comandos bsicos para poder editar os exemplos e exerccios.
&iret5rio atual Fp9d
Listar arCui)os e pastas Fls
0ntrar em uma pasta Fd pasta
Fd ursoG
#air dessa pasta Fd ..
Copiar um arCui)o Fp origem destino
Fp e1emploA1. teste.
Benomear um arCui)o Fm) origem destino
Fm) teste. testeA1.
O ambiente CENAPAD no tem programas grficos para edio de arquivos. Os editores em linha de
comando so o vi e o nano. Para quem j conhece essas ferramentas poder escolher a que mais
confortvel. Quem est conhecendo agora, indicamos o nano pela facilidade nos comandos.
0ditar um arCui)o e1istente Fnano arCui)o
Fnano testeA1.
Para na)egar entre as lin:as ou posi2es
utili.e as telas HsetaI
Para sair do programa tele CtrlJK #e o arCui)o no foi alterado3 o programa sai
sem perguntar nada.
#e for um arCui)o alterado3 ele perguntar(
H#a)e modiffied 4ufferI &igite HLI. 0le
onfirmar( o nome do arCui)o3 apenas tele
H0nterI.
2.2 Primeiro Programa em C
exemplo01.c
1.!
2. ! nome" exemplo#1.c
$. ! descri%o" primeiro exemplo em &
'. ! data" 1(#)2#12
*. !
+.,incl-de <stdio..>
(.int main()
)./
0. imprime 1om dia
1#. printf(21om dia3n4);
11. ret-rn #;
12.5
Um programa em C um texto com palavras em ingls e simbolos que tem regras lxicas e semnticas
distintas. Essas regras que formam a estrutura e as regras para escrever um programa na linguagem C.
Podemos comear a definir dois tipos bsicos de texto que podemos encontrar, textos da linguagem e
textos de comentrios. Textos da linguagem formam a estrutura do programa e comentrios servem para
documentar o programa e so ignorados pelo compilador.
Os comentrios podem ser de uma linha ou comentrios de mltiplas linhas. Comentrios de mltiplas
linhas comeam com /* e terminam com */ tudo que estiver entre esses smbolos considerado
comentrio. Comentrio de uma linha inicia com // e termina no final da linha.
Nesse exemplo podemos identificar comentrio de vrias linhas da linha 1 at a 5. Comentrio de uma
linha temos na linha 9.
exemplo01.c
1$.!
1'. ! nome" exemplo#1.c
1*. ! descri%o" primeiro exemplo em &
1+. ! data" 1(#)2#12
1(. !
1).,incl-de <stdio..>
10.int main()
2#./
21. imprime 1om dia
22. printf(21om dia3n4);
2$. ret-rn #;
2'.5
Se removermos os comentrios, ficaramos com:
exemplo01.c
1.
2.
$.
'.
*.
(.int main()
)./
0.
11. ret-rn #;
12.5
Se olharmos o cdigo fonte sem os comentrios, a primeira linha com algum comando a linha 6. Essa
linha que inicia com #, que indica um comando especial chamado de pr-processamento. Esse
comando, o include, recebe como parmetro um nome de arquivo que o compilador l o contedo e
coloca no exato lugar do comando.
Normalmente veremos o comando include com arquivos com extenso .h que tem o significado
de header ( cebealho ) que so arquivo de definies. Nesse caso o arquivo stdio.h um
arquivo da biblioteca padro C que define funes de entrada e sada de informaes ( printf na
linha 10 ).
Logo depois, na linha 7 int main() a definio de uma funo em C. Nesse caso a funo com o nome
main ( principal em ingls). Um programa pode ter vrias funes mas somente uma com o nome main
que indica aonde o programa iniciar quando for executado. Alias, o C case-sensetive e diferencia
letras minsculas de maisculas: main diferente de MAIN e diferente de Main.
A funo main tem uma palavra antes o int que uma palavra que define um tipo de dado em C que
representa inteiro. A funo main que por analogia da matemtica (y = f(x)) tem um valor de retorno,
valor de resultado da funo.
Programas tem uma funo main mas se estivermos programando bibliotecas que apenas
disponibilizam uma coleo de funes, no teramos a funo main e o programador que for
usar essa biblioteca que vai definir um main em seu programa.
A funo main inicia na linha 8 com o caractere { e termina na linha 12 com o caractere }. Toas as linhas
entre a 8 e 12 esto na funo main ou mais tecnicamente no escopo da funo main. Toda a linha de
comando em C termina com ;.
Na linha 11 temos uma outra funo a printf que como analogia a funes em matemtica ( y = f(x) ),
recebe como parmetro um texto Bom dia\n. A funo printf imprime na tela do usurio o que recebe
como parmetro ( Bom dia\n ).
Na linha 12 temos a linha return 0; que um comando especial que alm de sair da funo, e nesse caso
do programa, ela especifica o valor de retorno.
Funes retornam ao ponto que ela foi chamado. No caso de main, ela retorna para quem
executou o programa. A conveno que quando retornamos zero ( 0 ) num programa, quer dizer
que ele funcionou como esperado e se tiver valor diferente de zero, seria o nmero de algum erro.
Agora vamos compilar esse primeiro exemplo:
Na pasta exemplos executamos:
icc 6o exemplo#1 exemplo#1.c 67all
Para executar o programa:
.exemplo#1
Sada na tela:
1om dia
Note que os caracteres \n no so exibidos porque essa sequencia representa o carcter de nova-linha.
Existem outras sequencias especiais que veremos durante o curso.
2.2.1 O comando printf
Durante o curso usaremos o printf como ferramenta nos nossos laboratrios. Agora apresentaremos o
bsico necessrio para os laboratrios e no ltimo dia veremos melhor a formatao de dados.
formato do printf
printf(2string formata%o48 [9ar8 9ar8 9ar8...]);
A string de formatao um texto que podemos escrever literalmente ou podemos indicar locais para a
incluso de variveis usando % e um qualificador que define o tipo e a formatao de sada de cada
item. Para cada % que achamos, ele ira usar uma varivel da lista de variveis.
printf(2:d :d :d 3n48 1 8 2 8 $ );
para cada :d o printf coloca o 9alor do prximo literal o- 9ari;9el
Letra &esrio
i ou d Inteiro
u Inteiro sem sinal
o Otal sem sinal
K ou 1 Me1adeimal sem sinal
= ou f Ponto flutuante.
0 ou e Ponto flutuante notao ientifia.
> ou g /sar a mel:or representao e ou f
A ou a Ponto flutuante em :e1adeimal om sinal
Caratere.
s #tring
p Ponteiro
#e oloarmos um N1 Cue no ondi. om o tipo da )ari()el ou literal3 o ompilador a)isar(
mas dei1ar( passar. Ouando for e1eutado3 esse erro fiar( aparente.
01emploA2.
1.!
$. ! descri%o" <rintf
'. ! data" #)#'2#1$
*. !
(.int main()
)./
0. = comando printf
1#. printf(>1om dia3n>) ;
11. printf(>?11) 1# @ :d8:i8:-8:o8:x3n>81#81#81#81#81#) ;
12. printf(>?12) 61# @ :d8:i8:-8:o8:x3n>861#861#861#861#861#) ;
1$. printf(>?1$) #.1# @ :f8:e8:g8:a8:x3n>8#.1#8#.1#8#.1#8#.1#8#.1#) ;
1'. printf(>?1') 6#.1# @ :f8:e8:g8:a 3n> 86#.1#86#.1#86#.1#86#.1#) ;
1*. printf(>?1*) c.ar @ :c string @ :s3n>8 AaA 8>1om dia>) ;
1+. ret-rn # ;
1(.5
2.2.2 Exerccio ambiente CENAPAD
1)Entre no ambiente CENAPAD utilizando ssh ou putty
2)Entre no diretrio curso_c
3)Crie um programa em C com o nome nome.c. Esse programa imprimir o seu nome. Pode utilizar
como exemplo o programa exemplo01.c.
4)Compile esse programa.
5)Execute ele.
2.3 A linguagem de programao C
O compilador C quando processa um arquivo ele separa o texto em elementos que chamamos de
toquem. Que so partes atmicas, que sozinho tem uma funo prpria no programa. Podemos classificar
os toquens em: palavra reservada, identificador, constantes, literal string e pontuao.
Palavras reservadas so palavras tem um uso definido na linguagem de programao e que no
poderamos usar para outra finalidade como usar como o nome de uma varivel.
A linguagem de programao C tem poucas palavras reservadas comparado com outras linguagens de
programao e podemos listar elas:
auto enum restrict unsigned
break enum return void
case float return volatile
char for signed while
const goto sizeof _Bool
continue if static _Complex
default inline struct _Imaginary
do int switch
double long typedef
else register union
Identificador o nome que podemos dar ou identificar os objetos em C. Identificador pode ser uma
varivel, uma funo, uma tag, membro de uma estrutura ou unio, um nome typedef, um nome de label,
um parmetro de macro.
Podemos usar o mesmo identificador para tipos diferentes em pontos(escopos) diferentes do programa,
como podemos ter uma varivel com o mesmo nome de funo.
Constantes e literal string so como descrevo os valores no cdigo fonte. Por exemplo o valor numrico
10 ou o carcter 'a' ou no caso de constante string Bom dia.
Pontuao so smbolos usados tanto nas operaes matemticas ou lgicas ou para delimitar o escopo
ou final de linha.
2.4 Tipo de dado em C
Como a linguagem C de tipagem esttica, tanto os valores literais quanto variveis so de um tipo de
dado definido. Podemos separar esses tipos de dados em primitivos e derivados.
Os tipos de dados primitivos so definidos pela linguagem de programao, os derivados so definidos
pelo programador compondo com tipos primitivos ou usando tipos derivados j definidos.
Os tipos de dados primitivos podem ser divididos didaticamente em grupos:
Numricos inteiros: representam nmeros naturais sem frao.
Numricos ponto flutuante: representam nmeros reais com frao.
Caractere: Representam somente um caractere.
Esses grupos de tipos de dados so escalares podendo realizar todas as operaes matemticas, lgicas e
comparativas. Isso natural para nmeros mas o caractere a representao em bit de um valor
numrico e essa representao definida pela tabela ASCII ( letra 'a' o nmero 97).
Os tipos de dados derivados:
String: Em C string um vetor de vrios caracteres.
Array: Estrutura que podemos agrupar valores em formato de vetores ou matrizes de vria
dimenses. Cada um pode ser referenciado pelo um ndice numrico.
Struct: Estrutura que podemos agrupar variveis de tipo diferente. Cada varivel componente
referenciada pelo nome dela.
Union: Estrutura anloga ao struct mas todas as variveis ocupam o mesmo espao na memria.
Usado para economizar memria.
Enum: Estrutura de dado aonde posso enumerar opes usando nomes.
2.5 Declarao de Variveis primitivas.
Para usar variveis em C precisamos primeiramente declara-la informando o nome e o tipo dela.
<tipo> nome;
Be formos declarar -ma 9ari;9el do tipo int ( inteiro ).
int contador;
Podemos tambm declarar variveis do mesmo tipo na mesma linha separadas por virgula.
<tipo> 9ar18 9ar28 9arn;
Be formos declarar x8C8D como int ( inteiro )
int x8C8D;
As variveis em C, por padro, no so inicializadas, o compilador apenas reserva a memria necessria ao
tipo dela. Essa posio de memoria pode conter alguma informao de um programa que foi executado
antes. Depois que um programa executa, a memria no apagada e sim sobreposta por outro
programa.
Para inicializar uma varivel atribumos algum valor neutro para essa varivel. Podemos aproveitar a
declarao da varivel para a inicializao dela.
<tipo> nome@9alor;
<ara inicialiDar o contador
int contador@1;
<odemos tambm declarar e inicialiDar 9;rias 9ari;9eis
int x@#8C@#8D@#;
<odemos inicialiDar a 9ari;9el depois de declarar
int contador;
int x8C8D;
contador @1;
x@#;
C@D@#;
Um exemplo completo seria:
exemplo03.c
1.!
2. ! nome" exemplo#$.c
$. ! descri%o" Eeclara%o e inicialiDa%o de 9ari;9eis
'. ! data" 11#22#1'
*. !
(.int main()
)./
0. Eeclara%o e inicialiDa%o de 9ari;9eis
1#. int contador@#;
11. int x@18C@1;
12. c.ar c;
1$. c@AxA;
1'.
1*. printf(21om dia3n4);
1+. printf(2contador@:d3n48contador);
1(. printf(2x@:d8 C@:d3n48x8C);
1). printf(2c@:c3n48c);
10.
2#. ret-rn #;
21.5
2.6 Tipos de dados primitivos e variveis.
Os tipos de dados primitivos podem ser divididos em grupos:
Numricos inteiros: representam nmeros naturais sem frao.
Numricos ponto flutuante: representam nmeros reais com frao.
Caractere: Representam somente um caractere.
Nulo: Representa o tipo void.
2.6.1 Numricos inteiros
No C nmeros inteiros so representados por int e suas variaes como signed/unsigned
short/long/long long. Essas variaes definem a capacidade de representao numrica. Quanto maior a
capacidade, maior o nmero que poder representar.
Essas definies de capacidade de varivel podem variar de acordo com a arquitetura do ambiente
computacional e se for preciso ter que ser tradada pelo programador (Faa a linguagem rpida, mesmo
que no tenha portabilidade).
A capacidade numrica calculada de acordo com a quantidade de bits, que proporcional a magnitude
numrica. Se o valor extrapolar esse limite pode ocorrer problemas overflow.
Por exemplo, se um short int x = 32767 e somarmos +1 ele ficar com -32767.
O padro do tipo de dado signed int mas podemos omitir a palavra signed. Declarar o tipo signed int
igual a int.
$ipo Capaidade
s:ort int 1, 4its P Q327,7 ... J327,7 R
unsigned s:ort int 1, 4its sem sinal P A ... ,%%3% R
int 1, 4its P Q327,7 ... J327,7 R
unsigned int 1, 4its sem sinal P A ... ,%%3% R
long int 32 4its P Q2147463,47 ... J2147463,47 R
unsigned long int 32 4its sem sinal P A ... 42"4",72"% R
long long int ,4 4its P Q"223372A3,6%477%6A7 ...
J"223372A3,6%477%6A7 R
unsigned long long int ,4 4its sem sinal P A ...
1644,744A737A"%%1,1% R
A declarao de variveis segue a mesma regra:
<tipo> nome;
Um exemplo completo
exemplo04.c
1.!
2. ! nome" exemplo#'.c
$. ! descri%o" Eeclara%o de 9ari;9eis inteiras
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. s.ort int Fm;
1#. -nsigned s.ort int idade;
11. long int cm;
12. -nsigned long int saldoGcc;
1$. long long int mm;
1'. -nsigned long long int molec-las;
1*. ret-rn #;
1+.5
Podemos verificar se o ambiente que estamos usando segue o padro C usando a funo sizeof. Essa
funo retorna a quantidade de bytes que so 8 bits.
exemplo05.c
1.!
2. ! nome" exemplo#*.c
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. printf(2s.ort int @ :l-3n48 siDeof(s.ort int));
1#. printf(2-nsigned s.ort int @ :l-3n48 siDeof(-nsigned s.ort int));
11. printf(2long int @ :l-3n48 siDeof(long int));
12. printf(2-nsigned long int @ :l-3n48 siDeof(-nsigned long int));
1$. printf(2long long int @ :l-3n48 siDeof(long long int));
1'. printf(2-nsigned long long int @ :l-3n48 siDeof(-nsigned long
long int));
1*. ret-rn #;
1+.5
2.6.2 Numricos ponto flutuante
No C nmeros de ponto flutuante pode ser representado por float ou double e suas variaes. Essas
variaes definem a capacidade de representao numrica. Quanto maior a quantidade de bits, maior a
capacidade de representao numrica. Se o valor extrapolar esse limite pode ocorrer problemas
overflow e underflow.
Overflow pode ser como o exemplo com nmeros inteiros. J o Undeflow quando um nmero to
pequeno como 0,000000000001 com 12 casas, mas o tipo somente aceitaria 10 e nesse caso ele seria
arredondado para zero.
Essas definies de capacidade de varivel podem variar de acordo com a arquitetura e do ambiente
computacional e se for preciso ter que ser tradada pelo programador (Faa a linguagem rpida, mesmo
que no tenha portabilidade).
$ipo Capaidade
float 1, 4its
dou4le ,2 4its
long dou4le ,4 4its
<tipo> nome;
Um exemplo no cdigo fonte
exemplo06.c
1.!
2. ! nome" exemplo#+.c
$. ! descri%o" Eeclara%o de 9ari;9eis ponto fl-t-ante.
'. ! data" #)#'2#1$
*. !
(.int main()
)./
0. float Fm;
1#. do-ble cm;
11. long do-ble mm;
12. ret-rn #;
1$.5
exemplo07.c
1.!
2. ! nome" exemplo#(.c
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. printf(2float @ :l-3n48 siDeof(float));
1#. printf(2do-ble @ :l-3n48 siDeof(do-ble));
11. printf(2long do-ble @ :l-3n48 siDeof(long do-ble));
12. ret-rn #;
1$.5
2.6.3 Caractere.
No C caractere representa uma letra somente que o tipo char. O char um tipo escalar porque cada letra
pode ser representada por um nmero como na tabela ASCII.
String em c no um tipo primitivo. String implementado como um vetor de char. Veremos esse
tipo na prxima aula.
$ipo Capaidade
:ar 1 4-te
unsigned :ar 1 4-te
9:arGt 4 4-tes
<tipo> nome;
Um exemplo no cdigo fonte
exemplo08.c
1.!
2. ! nome" exemplo#).c
$. ! descri%o" Eeclara%o de 9ari;9eis caractere.
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. c.ar letra;
1#. -nsigned c.ar nota;
11. Hc.arGt -tf;
12. ret-rn #;
1$.5
exemplo09.c
1.!
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. printf(2c.ar @ :l-3n48 siDeof(c.ar));
1#. printf(2-nsigned c.ar @ :l-3n48 siDeof(-nsigned c.ar));
11. printf(2Hc.arGt @ :l-3n48 siDeof(Hc.arGt));
12. ret-rn #;
1$.5
2.6.4 Nulo (void)
O tipo void um tipo de dados neutro que representa a ausncia de valores.
Podemos usar void como
Retorno de funo: para indicar que a funo no retorna nenhum valor.
Argumento de funo. Indicamos e reforamos que a funo no recebe parmetros.
Ponteiros void. Ponteiro neutro de tipo.
2.7 Valores literais
Os valores literais em C so de tipagem esttica e o compilador qualifica os literais de acordo com o
contedo deles ou podemos indicar usando prefixos que o qualificam. Podemos descrever literais de
tipos primitivos e literais de tipos derivados:
Literal numrica inteira.
Literal numrica ponto flutuantes.
Literal caractere e string.
2.7.1 Literal numrica inteira.
Podemos representar valores inteiros em base decimal, octal e hexadecimal. Podemos tambm qualificar
o inteiro como long, long long ou unsigned.
IJmeros na base 1#
# 8 1 8 $ ... 1# 8 11 ... 8 1## 8 61##
IJmeros na base octal inicia com #
#8 #18 #$8 #(8 1#8 #118 ...8 1##8 6#1##
IJmeros na base .exadecimal inicia com #x
#x#8 #x18 #xa8 #xb8 #x1#...#x1##8 6#x1##
<ara representar long -samos -m l o- ? somo s-fixo e long long
-samos dois ll o- ??
1l8 $?8 #(?8 #xal8 #x1##??8 6#x1##??
<ara representar -nsigned -samos -m - o- K como s-fixo
1-8 $K8 #(K8 #xa-8 #x1##K8 6#x1##K
2.7.2 Literal numrica ponto flutuantes.
Podemos representar literais ponto flutuante na notao decimal e na notao cientifica. Ambos as
notaes podem ser representadas na base decimal e hexadecimal. O qualificador padro signed float
mas podemos mudar para float ou para long double.
Para representar um numero ponto flutuante usamos o ponto para separar a parte inteira da frao. Se
no tiver a parte fracionada podemos colocar .0 ou apenas .
IJmeros na base 1#
#.* 8 *.# 8 *.
IJmeros log do-ble
#.*?8 *.#?8 *.?
<odemos -sar a nota%o cientifica
#.*e1#8 *.#e28 *.E$
IJmeros na base .exadecimal iniciamos com #x
#x#.*p# 8 #x*.#p1 8 #x*.p#
2.7.3 Literal caractere e string.
Literais caractere representam somente um caractere e representamos ele entre aspas simples '. A
linguagem C trabalha com string sendo um conjunto de caractere como um vetor. Caracteres so
escalares e podemos realizar todas as operaes.
?etras
AaA8 AbA8 AcA
<odemos -sar seL-encias de escape
A3AA8 A34A8 A3M3A
<odemos tambem -sar cdigo octal e .exadecimal
A3#1'1A8 A3x+1A
?iteral string -samos aspas d-plas
21om dia4
2.7.4 Printf e os tipos de dados
Para cada tipo de dado primitivo existe uma diretiva do printf e podemos listar elas
Letra &esrio
i ou d Inteiro
u Inteiro sem sinal
:u s:ort int
lu long int
llu long long int
f dou4le;float
Lf long dou4le
2.8 Exerccios
1.Complete os cdigos abaixo:
&digo N
1.,incl-de <stdio..>
2.GGGGGGGGGGGGGGGGGGGG
$./
'. printf(21om dia3n4)GGG
*. ret-rnGGG;
+.GGG
&digo 1
1.,GGG <stdio..>
2.int main()
$.GGG
'. int aGGGG;
*. float GGG@2.1;
+. long GGG x@2$.1?;
(. printf(2a@:d3n48GGG);
). printf(2C@:f3n48C);
0. printf(2x@:?d3n4GGG x)GGG
1#. GGGG;
11.5
1.Faa um programa em c com o nome lab01.c declarando e inicializando as variveis:
a) Inteiros para: dia, ms, ano, idade.
b) char letra
c) Pontos flutuantes para: altura, peso
d) Ponto flutuante para pi ( 3, 14159265358979323846).
2.Altere o lab01.c e acrescente comandos printf para imprimir:
a) altura = xxx, peso = xxx
b) letra = x
c) pi = 3.14159265358979323846
Ser impressa todas as casas do nmero pi?
d) Data de nascimento d/m/a tenho n anos
3.Faa a cpia do lab01.c com o nome lab01nc.c e altere todos os literais para notao cientfica, caso
possa ser aplicado.
3 Aula 2
3.1 Variveis derivadas
Os tipos de dados derivados o programador que define o formato do dado e ele tambm deve
implementar rotinas ou funes que trabalhem com esse tipo de dado. A linguagem de programao no
fornece operadores nesses tipos de dados.
3.2 Arrays
Arrays representam em matemtica vetores e matrizes. Em C tanto vetores quanto matrizes so
implementados usando uma varivel composta de vrias posies indexadas numericamente.
O C padro 99 e posteriores aceita o formato VLA ( laviable-length array array de tamanho varivel ) que
quer dizer que podemos definir o tamanho do array na execuo do programa, diferente da alocao
esttica que definida na compilao. No confundir com alocao dinmica que poderia alterar
dinamicamente o tamanho do array em qualquer hora do cdigo. O C aceta array estatico e VLA mas no
array dinamico. Nesse caso podemos utilizar alocao dinamica de memoria.
NrraC est;tico
int 9etor[1#];
NrraC O?N
n @ arg-mento(1);
int 9etor[n];
a
NrraC dinPmico8 somente para exemplo8 no existe no &
int 9etor[1#];
no9oGtaman.o(9etor82#);
3.2.1 Declarao de variveis array.
Para declarar um array, precisamos definir o tipo de dado dos elementos e a quantidade.
<tipo> nome[taman.o] -m 9etor ;
<tipo> nome[taman.o1][taman.o2] matriD de d-as dimensQes. ;
Podemos declarar variveis primitivas, vetores e matrizes na mesma linha.
<tipo> primiti9o8 9etor[tam9]8 matriD[tamm][tamm];
O tipo de dado pode ser um tipo primitivo ou um tipo derivado.
Um erro comum declarar um vetor de tamanho x e usar a posio x. O C permitir mas isso seria
acesso indevido a memria e o efeito disso no pode ser previsto.
exemplo10.c
1.!
2. ! nome" exemplo1#.c
$. ! descri%o" Eeclara%o de 9etores e matriDes
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. int idade;
1#. int dataIascimento[$];
11. int matriD2E[1#][1#]8 matriD$E[1#][1#][1#];
12. ret-rn #;
1$.5
3.2.2 Inicializao de variveis Arrays.
Quando declaramos um vetor ou uma matriz a linguagem de programao no inicializa eles com algum
valor, ele apenas reserva memria suficiente para o vetor ou a matriz inteira e essa posio da memria
pode ter valores que outro programa que executou antes deixou na memria.
No padro C99 podemos usar literais compostos para inicializar os vetores.
Para inicializar usamos o formato:
= padro &00 aceita literais compostos
<tipo> 9etor[tam] @ / literal18 literal28 literal$8 literaltam 5;
<tipo> matriD[x][C] @ / /literal8 literal58 /literal8literal5 5;
Be o compilador no aceitar o padro &008 teremos L-e pop-lar o
9etor com atrib-i%Qes
<tipo> 9etor[tam];
9etor[#]@9alor;
9etor[1]@9alor at tam61 ;
exemplo11.c
1.!
2. ! nome" exemplo11.c
$. ! descri%o" Eeclara%o e inicialiDa%o de 9etores e matriDes
'. ! data" 1$#22#1'
*. !
(.int main()
)./
0. int idade@$';
1#.
11. int dataIascimento[$]@/$81810()5;
12.
1$. int matriD2E[2][2] @ / /#8158 /1#8115 5;
1'.
1*. int o-tra2E[2][2] @ / #8 18 1#8 11 5;
1+.
1(. int diasRes[] @ /$18208$18$#8$18$#8$18$18$#8$18$#8$15;
1).
10. int nao&00[2];
2#. nao&00[#]@1#;
21. nao&00[1]@2#;
22.
2$. ret-rn #;
2'.5
3.2.3 Utilizao de variveis Array.
Quando compomos um vetor ou uma matriz com um tipo primitivo, podemos usar as operaes que o C
implementa indicando item por item. No podemos usar o formato de literais compostos para atribuir
valores para matrizes.
<tipo> nome[tam];
nome[posi%o] @ literal;
nome @ /9al189al289al$5 erro de compila%o ;
printf(2nome[:d]@:d3n48posi%o8nome[posi%o]);
Um erro comum tentar usar uma posio fora do limite da array e pode gerar comportamentos
inesperados no programa. Podendo at parar a execuo atual (travar).
exemplo12.c
1.!
$. ! descri%o" Eeclara%o e -tiliDa%o de 9etores e matriDes
'. ! data" #0#'2#1$
*. !
(.int main()
)./
0. int idade@$*;
1#.
11. int dataIascimento[$];
12. dataIascimento[#]@$;
1$. dataIascimento[1]@1;
1'. dataIascimento[2]@10();
1*.
1+. printf(2Eata de nascimento :d:d:d8 idade @ :d3n48
dataIascimento[#]8 dataIascimento[1]8
1(. dataIascimento[2]8 idade );
1).
10. ret-rn #;
2#.5
3.3 String
String em C implementado como um vetor de char que termina com um caractere especial '\0'. Se
tivermos uma string Texto ela teria 6 posies (mais a posio do caracter nlo) iniciando com 0 at 5.
$ e 1 t o SA
Um erro comum tentar usar uma posio fora do limite da string e pode gerar comportamentos
inesperados no programa.
Um outro problema apagar o caractere de final de string '\0'. Se no tiver esse caractere uma
funo que trabalhe com string ir transpor o limite dela at que em alguma outra posio
aleatria da memria tiver um '\0' o que pode gerar acesso indevido a memria.
c.ar string[taman.o];
c.ar string[taman.o]@4Sexto4;
c.ar string[]@4Sexto4;
c.ar string[taman.o]@ /ASA8 AeA8 AxA8 AtA8 AoA8 A3#A 5;
String como vetor funciona como array, no pode-se alterar o tamanho dela automaticamente mas
podemos alterar caractere por caractere como se fosse um vetor. Podemos tambm utilizar funes que
tratam de string. A biblioteca padro do C tem vrias funes que trabalham com string.
c.ar string[taman.o]@4Sexto4;
string[#]@AtA;
exemplo13.c
1.!
2. ! nome" exemplo1$.c
$. ! descri%o" Eeclara%o e -tiliDa%o de strings
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. c.ar nome[]@4&arlos TenriL-e Uebollo4;
1#. c.ar profissao[0]@4Nnalista4;
11.
12. printf(2Iome :s ( letra inicial :c) profisso :s 3n48 nome8
nome[#]8 profissao);
1$.
1'. ret-rn #;
1*.5
3.4 Struct
Struct so estrutura que agrupam variveis com tipos de dado diferente e sendo cada posio nomeada e
no indexada como vetores. Podemos compor structs com variveis do tipo primitivo ou com tipos
derivados at compor struct com struct.
3.4.1 Declarao de struct
Para declarar uma struct usamos o modelo:
str-ct nometipo
/
<tipo1> 9ar1;
<tipo2> 9ar2;
...
<tipon> 9arn;
5 9str-ct189str-ct1;
str-ct nometipo o-tra9ar;
Nesse caso:
nometipo: o nome desse tipo struct, podemos declarar variveis usando esse nome.
<tipos> vars; so as variveis componente dessa struct
vstructs so variveis do stipo struct nometipo
Na linha struct nometipo outrovar estamos declarando outra variavel do tipo struct nometipo que
j foi definido.
exemplo14.c
1.!
2. ! nome" exemplo1'.c
$. ! descri%o" Eeclara%o de str-ct
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. str-ct data
1#. /
11. int dia8mes8ano;
12. 5 .oVe;
1$.
1'. str-ct data aman.a;
1*.
1+. ret-rn #;
1(.5
3.4.2 Utilizao de struct
Para utilizar uma struct usamos cada varivel componente separadamente usando var.componente
str-ct nometipo
/
<tipo1> 9ar1;
<tipo2> 9ar2;
...
<tipon> 9arn;
5 9str-ct189str-ct1;
str-ct nometipo o-tra9ar;
9str-ct.9ar1@9alor1;
9str-ct.9ar2@9alor2;
exemplo15.c
1.!
2. ! nome" exemplo1*.c
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. str-ct data
1#. /
12. 5 .oVe;
1$.
1*.
1+. .oVe.dia@1(;
1(. .oVe.mes@1#;
1). .oVe.ano@2#12;
10.
2#. aman.a @ .oVe W 1 erro de compila%o ;
21.
22. printf(2Eata de .oVe :d:d:d3n48 .oVe.dia8 .oVe.mes8 .oVe.ano);
2$. ret-rn #;
2'.5
3.4.3 Inicializao de struct
Podemos inicializar uma struct usando o formato:
str-ct nometipo
/
<tipo1> 9ar1;
<tipo2> 9ar2;
...
<tipon> 9arn;
5 9str-ct1@/ .9a1@lalor18 .9ar2@9alor28 .9arn@9aln 5;
str-ct nometipo o-tra9ar@/ .9a1@lalor18 .9ar2@9alor28 .9arn@9aln 5;
Um exemplo completo seria
exemplo16.c
1.!
2. ! nome" exemplo1+.c
$. ! descri%o" Eeclara%o8 inicialiDa%o e -tiliDa%o de str-ct
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. str-ct data
1#. /
12. 5 .oVe @ / .dia @ 1(8 .mes @ 1#8 .ano @ 2#12 5;
1$.
1*.
1+. aman.a.dia@.oVe.diaW1;
1(. aman.a.mes@.oVe.mes;
1). aman.a.ano@aman.a.ano;
10.
2#. printf(2Eata de .oVe :d:d:d3n48 .oVe.dia8 .oVe.mes8 .oVe.ano);
21. printf(2Eata de aman.a :d:d:d3n48 aman.a.dia8 aman.a.mes8
aman.a.ano);
22.
2$. ret-rn #;
2'.5
3.5 Union
Union um tipo de estrutura anloga ao struct mas todas as variveis ocupam o mesmo espao na
memria. Usado para economizar memria. O tamanho total dessa estrutura o tamanho da maior
varivel componente.
3.5.1 Declarao de union
Para declarar uma struct usamos o modelo:
-nion nometipo
/
<tipo1> 9ar1;
<tipo2> 9ar2;
...
<tipon> 9arn;
5 9-nion189-nion1;
-nion nometipo o-tra9ar;
Nesse caso:
nometipo: o nome desse tipo union, podemos declarar variveis usando esse nome.
<tipos> vars; so as variveis componente dessa union
vunions so variveis do stipo union nometipo
Na linha union nometipo outravar estamos declarando outra varivel do tipo union nometipo que
j foi definido.
exemplo17.c
1.!
2. ! nome" exemplo1(.c
$. ! descri%o" Eeclara%o de -nion
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. -nion 9alor
1#. /
11. int inteiro;
12. float real;
1$. do-ble bigGreal;
1'. 5 9al1;
1*.
1+. -nion 9alor 9al2;
1(.
1). ret-rn #;
10.5
3.5.2 Utilizao de union
Para utilizar uma union usamos cada varivel componente separadamente usando var.componente mas
ao contrrio da struct somente uma delas ter um valor significativo.
Um erro comum ao usar union definir uma varivel componente de um tipo e usar uma outra
varivel componente de outro tipo. Para a utilizao correta da union precisaria de uma varivel
auxiliar que indique qual a varivel que tem o valor significativo.
-nion nometipo
/
<tipo1> 9ar1;
<tipo2> 9ar2;
...
<tipon> 9arn;
5 9-nion189-nion1;
-nion nometipo o-tra9ar;
9-nion.9ar1@9alor1;
9-nion.9ar2@9alor2;
exemplo18.c
1.!
2. ! nome" exemplo1).c
$. ! descri%o" Eeclara%o e -tiliDa%o de -nion
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. -nion 9alor
1#. /
11. int inteiro;
12. float real;
1'. 5 9al1;
1*.
1+. 9al1.inteiro@1# ;
1(.
1). printf(>inteiro :d3n>8 9al1.inteiro) ;
10. printf(>real :f3n>8 9al1.real) ;
2#. printf(>bigGreal :f3n>8 9al1.bigGreal) ;
21.
22. 9al1.real@1.* ;
2$.
2'. printf(>inteiro :d3n>8 9al1.inteiro) ;
2*. printf(>real :f3n>8 9al1.real) ;
2+. printf(>bigGreal :f3n>8 9al1.bigGreal) ;
2(.
2). ret-rn #;
20.5
/m e1emplo aonde usaQse uniom om uma )ari()el au1iliar:
str-ct tagged-nion /
en-m /KIXI=7I8 YIS8 ?=IZ8 E=K1?E8 <=YISEU5 code ;
-nion /
int i ;
long l ;
do-ble d ;
9oid !p ;
5 - ;
5;
referencia .ttp"c6faL.comstr-cttagged-nion..tml
3.5.3 Inicializao de union
Podemos inicializar uma union usando o formato:
-nion nometipo
/
<tipo1> 9ar1;
<tipo2> 9ar2;
...
<tipon> 9arn;
5 9-nion@/ .9arx@lalorx 5;
-nion nometipo o-tra9ar@/ .9arx@lalorx 5;
exemplo19.c
1.!
$. ! descri%o" Eeclara%o8 inicialiDa%o e -tiliDa%o de -nion
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. -nion 9alor
1#. /
11. int inteiro;
12. float real;
1'. 5 9al1@ / .inteiro@1# 5;
1*.
1+. -nion 9alor 9al2;
1(.
1). 9al2.real @ 1.* ;
10.
2#. printf(>inteiro :d3n>8 9al1.inteiro) ;
21. printf(>real :f3n>8 9al1.real) ;
22. ret-rn #;
2$.5
3.6 Enum
Enum um tipo de estrutura de dado aonde posso enumerar opes usando nomes. Esses nomes so
significativos para o C e representam constantes com o valor numrico. Cada constante da enumerao
tem um valor numrico e por padro inicia com 0 e incrementado para cada constante. Podemos alterar
esses valores.
3.6.1 Declarao de enum.
Para declarar uma enum usamos o modelo:
en-m nometipo / const1[@9alor1] 8const2[@9alor2]8 constm[@9alorm] 5;
5 9en-m189en-m2;
en-m nometipo o-tra9ar;
Nesse caso:
nometipo: o nome desse tipo enum, podemos declarar variveis usando esse nome.
consts; so as contastantes dessa unum.
venums so variveis do stipo enum nometipo
Na linha enum nometipo outravar estamos declarando outra varivel do tipo enum nometipo que
j foi definido.
exemplo20.c
1.!
2. ! nome" exemplo2#.c
$. ! descri%o" Eeclara%o de en-m
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. en-m cores / 9ermel.o8 9erde8 aD-l 5 9al1;
1#.
11. en-m estadoGci9il / solteiro@18 casado8 9i-9o@*8 desL-itado 5;
12.
1$. en-m estadoGci9il 9al2;
1'.
1*. ret-rn #;
1+.5
3.6.2 Utilizao de enum.
Para utilizar uma enum usamos cada varivel diretamente no cdigo fonte. Cada uma das opes ter um
nmero associado, enumerado.
en-m nometipo / const1 8const28 constm 5;
5 9en-m189en-m2;
9en-m1@const1;
printf(2:- :-3n489en-m18 const2);
exemplo21.c
1.!
$. ! descri%o" Eeclara%o e -tiliDa%o de en-m
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. en-m cores / 9ermel.o8 9erde8 aD-l 5 9al1;
1#.
12.
1'.
1*. 9al1@aD-l;
1+. 9al2@casado;
1(.
1). printf(2cores :- :- :-3n48 9ermel.o8 9erde8 aD-l );
10. printf(29aria9eis :- :- 3n48 9al18 9al2 );
2#.
21. ret-rn #;
22.5
3.6.3 Inicializao de enum.
Podemos inicializar uma enum usando o formato:
en-m nometipo / const1 8const28 constm 5;
5 9en-m1@const189en-m2@const2;
9en-m1@const1;
printf(2:- :-3n489en-m18 9en-m2);
exemplo22.c
1.!
$. ! descri%o" Eeclara%o8 inicialiDa%o e -tiliDa%o de en-m
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. en-m cores / 9ermel.o8 9erde8 aD-l 5 9al1@aD-l;
1#.
12.
1'.
1*. 9al2@casado;
1+.
1(. printf(2cores :- :- :-3n48 9ermel.o8 9erde8 aD-l );
1). printf(29aria9eis :- :- 3n48 9al18 9al2 );
10.
2#. ret-rn #;
21.5
3.6.4 Typedef
Typedef define tipos de dados definidos pelo programador que a linguagem de programao reconhece
como um tipo definido.
O tipo de dado novo dependedo como foi criado pode ser primitivo ou derivado e seguir as mesmas
regras seja na declarao, inicializao e utilizao.
tCpedef tipo nomeGtipo [s-lfixo];
nomeGtipo 9ar;
/m e1emplo ompleto seria:
exemplo23.c
1.!
2. ! nome" exemplo2$.c
$. ! descri%o" tCpedef
'. ! data" #$1#2#12
*. !
(.int main()
)./
0.
1#. tCpedef int inta8 intb[2]8 intc[2][2];
11. tCpedef c.ar c.ara8 c.arb[];
12. tCpedef str-ct tipostr-ct / int x 5 no9oGtipo no9oGtipo no ; ;
9ari;9el
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 @ AaA;
1). c.arb cb @ 2Tello4;
10. no9oGtipo 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.7 Expresses
Uma expresso uma sequencia de operadores e operandos que resulta em um valor ou que resulta em
um objeto ou em uma funo, ou que resulte em uma atribuio, ou que faa um conjunto dessas aes.
As expresses so avaliadas da esquerda para a direita obedecendo a precedncia dos operadores.
int x;
x @ 1;
x @ x W 2 ! 2 nesse caso seria 1 W ( 2 ! 2 ) @ * ;
Se precisar alterar a precedncia dos operadores podemos colocar entre parenteses.
int x;
x @ 1;
x @ (x W 2) ! 2;
3.7.1 Operadores unrio, binrios e ternrios.
Operadores podem ser classificado de acordo com a quantidade de operandos. Em C temos operadores
unrios, binrios e ternrios.
Esses operadores podem ser didaticamente classificados como: aritmticos, relacionais, lgicos,
condicionais, operador bit, atribuio, membro ( estruturas ) e gerenciamento de memria e converso.
3.7.2 Operadores aritmticos.
Operadores aritmticos podem ser usados em qualquer tipo de dado escalar seja nmeros inteiros, reais e
caractere. Quando realizamos operaes com o mesmo tipo de dado o resultado do mesmo tipo. Se
forem do tipo diferente, a converso ser automtica e tentar converter para o tipo mais apropriado para
a operao.
Os operadores binrios so: * ( multiplicao ), / ( diviso ), % ( modulo ), + ( soma), - (subtrao).
Os operadores unrios so: + (positivo) e -( negativo), ++ (incremento) (decremento)
e1emplo24a.
1.!
2. ! nome" exemplo2'.c
$. ! descri%o" =peradores aritmticos bin;rios
'. ! data" 1$#22#1'
*. !
(.int main()
)./
0. int x@18C@$8D@*;
1#.
11. x@CWD;
12. D@x:C;
1$. C@Dx int int @ int ;
1'. x@6x;
1*.
1+. printf(2x@:i8 C@:i e D@:i3n48 x8 C8 D );
1(. ret-rn #;
1).5
Os operadores ++ e - podem ser prefixos e sulfixos e tem o formato:
WW9ar o- 9arWW
669ar o- 9ar66
o var tem que ser um lvalue, ou seja, uma varivel escalar e que possa ser atribudo valores ( no
constante).
A diferena do prefixo e sufixo que no prefixo o operador incrementa a varivel e depois fornece para a
expresso o valor dela. No caso do sufixo, ele fornece o valor atual dela e depois a varivel
incrementada.
e1emplo244.
1.!
2. ! nome" exemplo2'b.c
$. ! descri%o" =peradores WW e 66
'. ! data" 1$#22#1'
*. !
(.int main()
)./
0. int x@18C@$8D@*;
1#. C@xWW;
11. D@WWx;
12. printf(2x@:i8 C@:i e D@:i3n48 x8 C8 D );
1$. ret-rn #;
1'.5
3.7.3 Operadores relacionais.
Operadores relacionais comparam dois valores e dependendo do operador e operandos retornar
verdadeiro ou falso. No C falso o nmero zero e verdadeiro qualquer outro nmero. Nesse caso
verdadeiro nmero 1.
Os operadores binrios so: < (menor), > (maior), <= ( menor ou igual), > ( maior ou igual), == ( igual ) e !=
(diferente).
e1emplo2%.
1.!
2. ! nome" exemplo2*.c
$. ! descri%o" =peradores relacionais bin;rios
'. ! data" 1##'2#1$
*. !
(.int main()
)./
0. int x@18C@$8D@* ;
1#.
11. printf(>x>C :i8 x<D :i e C<@D :i3n>8 x>C8 x<D8 C<@D ) ;
12.
1$. printf(>x@@C :d e x[@D :d3n>8 x@@C8 x[@D ) ;
1'.
1*. printf(>:d3n>8 D > C > x) ;
1+.
1(. ret-rn # ;
1).5
3.7.4 Operadores lgicos
Operadores lgicos binrios comparam dois valores lgicos e retornam um valor lgico. Podemos
comparar qualquer valor escalar e se o valor escalar for 0 ( zero ) ser falso caso contrario ser verdadeiro.
O resultado ser 0 ou 1. O nico operador lgico unrio negao (!).
Os operadores binrios so: && ( and ) e || (ou)
Os operadores unrios so: !(negao)
e1emplo2,.
1.!
2. ! nome" exemplo2+.c
$. ! descri%o" =peradores lgicos
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. int x8C8D;
1#.
11. x @ 1 \\ #;
12.
1$. C @ x ]] 2#;
1'.
1*. D @ [x;
1+.
1(. printf(2x@:i8 C@:i e D@:i3n48 x8 C8 D );
1). ret-rn #;
10.5
3.7.5 Operadores bit
Os operadores bit operam com dois valores em lgica binria e retornaria um escalar. No vamos detalhar
esses operadores nesse curso porque necessitaria de conhecimento de calculo binrio que foge o escopo
de curso bsico.
Os operadores binrios so: & ( e binrio ), | ( ou binrio ), ^ ( ou exclusivo), << ( shift para esquerda) e >>
shift para a direita.
O operador unrio : ~ (not)
e1emplo27.
1.!
2. ! nome" exemplo2(.c
$. ! descri%o" =peradores bit bin;rios
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. int x@18C@18D@1;
1#.
11. x @ 1 << 1;
12. C @ 1# \ $;
1$. D @ 1# ] $;
1'.
1*. printf(2x@:i8 C@:i e D@:i3n48 x8 C8 D);
1+. printf(2^x@:i3n48^x);
1(.
1). ret-rn #;
10.5
3.7.6 Operadores de atribuio
O grupo de operadores de atribuio tem o formado:
l9al-e operador r9al-e
lvalue o valor da esquerda que tem que ser um objeto modificvel como uma varivel.
rvalue pode ser uma expresso, uma varivel ou um literal.
Os operadores so: atribuio simples (=) e atribuio com operador +=, -=, *=, /=, %=, &=, |=, ^=, <<=,
>>=.
e1emplo26.
1.!
2. ! nome" exemplo2).c
$. ! descri%o" =peradores de atrib-i%o
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. int x@#8C@#8D@1#;
1#.
11. x @ 1;
12. CW@ xW1;
1$. D:@C;
1'.
1*. printf(2x@:i8 C@:i e D@:i3n48 x8 C8 D );
1+.
1(. ret-rn #;
1).5
3.7.7 Operador membro
Operadores membro so usados para acessar membros de estruturas struct e union. Existem dois
operadores o . ( ponto ) e o -> (trao ponto). O primeiro membro de estrutura e o segundo membro
de ponteiro que veremos mais adiante no curso.
exemplo29.c
1.!
$. ! descri%o" =perador membro
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. str-ct data
1#. /
11. int dia8mes8ano ;
12.
1$. 5 .oVe @ / .dia @ 1(8 .mes @ 1#8 .ano @ 2#12 5;
1'.
1*. printf(2Eata de .oVe :d:d:d3n48 .oVe.dia8 .oVe.mes8 .oVe.ano);
1+.
1(. ret-rn #;
1).5
3.7.8 Operadores de gerenciamento de memria
Vamos listar os operadores de gerenciamento de memria que veremos mais adiante no curso.
Operadores unrios: [] ( operador array), * ( ponteiro), & ( endereo de), -> ( membro de ponteiro para).
3.7.9 Operador condicional
O nico operador condicional e tambem o nico operador ternrio. O formato dele :
expresso M Uetorno 9erdadeiro " retorno falso;
O operador avalia a expresso, se esse valor escalar for 0 ele falso e retorna o valor falso, caso contrrio o
verdadeiro. Ele seira um if/else em uma expresses.
e1emplo3A.
1.!
2. ! nome" exemplo$#.c
$. ! descri%o" =peradores relacionais bin;rios
'. ! data" #$1#2#12
*. !
(.int main()
)./
0. int x@18C@$8D@*;
1#.
11. x @ x>C M x " C;
12. D @ [D M 1# " DW1#;
1$.
1'. printf(2x@:i8C@:i e D@:i 3n48 x8 C8 D );
1*.
1+. ret-rn #;
1(.5
3.7.10 Operador de converso.
Podemos usar o operador de converso para alterar o tipo da varivel e do literal.
( tipo ) 9alor
Pomos usar essa converso para poder usar o / com variveis int.
int x@18C@2;
float D@(float)xC ;
D@x(float)D;
D@(float)x(float)D;
3.8 Precedncia de operadores:
Em uma expresso os operadores so executados na ordem de sua precedncia ou podemos usar o
parentes para forar a ordem.
_ @ ' W ) ' ;
_ @ ( ' W ) ) ';
() [] . -> expr++ expr--
* & + - ! ~ ++expr --expr (typecast) sizeof
* / %
+ -
>> <<
< > <= >=
== !=
& ^ |
&&
||
?:
= += -= *= /= %= >>= <<= &= ^= |= e o ,
3.9 Exerccios
1.Complete ou corrija os cdigos abaixo:
&digo N
2.int main()
$./
'. int 9etor @ / 1828$8'8* 5;
*. float precos[2]@ /1.00 2.00 10.00 100.005
+. c.ar string[1*]@4Yntrod-%o ao &4;
(. str-ct data / dia8 mes8 ano 5 @ /.dia@2#8 .mes@28 .ano@2#1'5;
). cores / 9erde8 9ermel.o8 aD-l 5;
0. ret-rn #;
1#.5
&digo 1
2.int main()
$./
'. float a@1.#8b@1#.#8c@1##.#8d@1###.#;
*. float media @ a W b W c W d '.#;
+. int T @ ' 1a W 1b W 1c W 1d;
(. int aGmaiorGb @ a b;
). int bGmaiorGc @ b c;
0. int aGmaiorGc @ aGmaiorGb bGmaiorGc;
1#. int 9alorGmaiorGab @ aGmaiorGb M b " a;
11. ret-rn #;
12.5
2.Calcule: ( Pode usar um programa em C )
a) =s 9alores de x8C8D
int x@18C@$ ;
float D@*8H@( ;
x@HWC2 ;
D@xWD2 ;
b) =s 9alores de x8C8D8a8b
int x@18C@$ ;
int a@xWW ;
int b@WWx ;
CW@a ;
x6@bWW ;
int D@x666x ;
c) =s 9alores de x8C8D8a8b
int x@18C@$ ;
int a@x>CMx"C ;
int b@[xMx"^x ;
x@aMa"bWbMb"1 ;
3. Crie um arquivo lab02.c declarando:
a)Uma string nome_curso
b) Dois vetores data_inicio e data_fim ( dia/mes/ano )
c)enumeracao curso = curso_c, curso_mpi, curso_openmp
d) Imprima ( altere o %x de acordo com o tipo da varivel):
"Nome do curso = %x"
"Data de inicio %x/%x/%x"
"Data final %x/%x/%x"
"Curso %x"
4.Faca uma copia do lab02.c para lab02e.c
a)Declare uma struct tregistro com
Uma string nome_curso
Dois vetores data_inicio e data_fim
uma enumerao curso = curso_c, curso_mpi, curso_openmp
Declare uma varivel registro do tipo tregistro e inicialize os valores.
b)Imprima usando varivel registro:
"Data de final %x/%x/%x"
"Curso %x"
5.Faca uma copia do lab02.c para lab02t.c
a)Declare typedef para
Uma string tnome_curso
vetor tdata para ser usado como data ( dia/mes/ano).
enumeracao tcurso = curso_c, curso_mpi, curso_openmp
typedef struct tregistro com os typedef anteriores
Uma varivel registro do tipo tregistro e inicialize ela.
b) Imprima usando registro
"Data de final %x/%x/%x"
"Curso %x"
4 Aula 3
4.1 Blocos
Em C criamos blocos com os caracteres { e } que agrupam logicamente um conjunto de comandos seja
para formar um bloco de uma funo ou at um bloco annimo. Blocos tambm delimitam o escopo.
e1emplo31.
1.!
2. ! nome" exemplo$1.c
$. ! descri%o" 1locos em &
'. ! data" #+112#12
*. !
(.int main()
)./
0.
11.
12. /
1$. printf(2Eentro do bloco3n4);
1'. 5
1*.
1+. ret-rn #;
1(.5
4.2 Escopo
Se lembrarmos que identificador pode ser um objeto, uma funo, uma tag, membro de estrutura,
membro de unio, ou enumerao, um nome typedef, um nome de label. O escopo define o limite aonde
um identificador pode ser visto, ou seja, ser usado. Podemos ter escopo de arquivo, bloco, funo e
declarao de funo.
Como podemos declarar objetos em qualquer parte do programa, podemos identificar se dois objetos
esto no mesmo escopo quando eles terminam no mesmo ponto. O nome do identificador tem que ser
nico no mesmo escopo. Se for de escopos diferentes, a declarao do escopo interno esconde a
declarao do escopo externa.
e1emplo32.
1.!
$. ! descri%o" Escopo em &
'. ! data" #+112#12
*. !
+.
(.int 9arGa@1# ;
).
1#.int main()
11./
12. int x@1;
1$. /
1'. c.ar x@AaA esse _ sobrepQe a declara%o anterior ;
1*. /
1+. int x@2#;
1(. int 9arGb@2#;
1). printf(2Eentro do bloco interno :d3n48x);
10. printf(29arGa@:d89arGb@:d3n489arGa89arGb);
2#. 5
21. printf(2Eentro do bloco :c3n48x);
22. 5
2$. int x@1## no mesmo escopo ;
2'. printf(29arGa@:d3n489arGa);
2*. printf(29arGb@:d3n489arGb);
2+. printf(2`ora do escopo :d3n48 x);
2(. ret-rn #;
2).5
4.3 Instruo de seleo
Instrues de seleo desviam o caminho lgico do programa que seria executar uma linha por vez de
cima para baixo. Dependendo da instruo e da condio executar um comando/bloco ou outro ou
nenhum.
4.3.1 Instruo if
A instruo if avalia a condio, caso seja verdadeira, ele executa o comando/bloco se no, o
comando/bloco ignorado. A instruo if tem os formatos:
if( condi%o ) comando;
if( condi%o )
/
bloco do if
5
O comando if avalia se condio verdadeira, isso o resultado diferente de zero. Se sim executado o
comando ou o bloco do if. A condio pode ser um literal, uma varivel ou uma expresso.
Podemos usar o if em conjunto com o eles que seria o comando/bloco executado caso o teste seja falso.
else comando;
if( condi%o )
/
bloco do if
5
else
/
bloco do else
5
podemos tambm combinar os dois
else
/
bloco do else
5
o-
if( condi%o )
/
bloco do if
5
else comando else;
e1emplo33.
1.!
2. ! nome" exemplo$$.c
$. ! descri%o" if
'. ! data" #+112#12
*. !
(.int main()
)./
0. int x@18C@$;
1#. if( x > C )
11. /
12. printf(2x maior L-e C3n4);
1$. 5
1'. else if( x < C )
1*. /
1+. printf(2x menor L-e C3n4);
1(. 5
1). else
10. /
2#. printf(2x no ig-al a C3n4);
21. 5
22.
2$. if( x @@ C );
2'. printf(2<orL-e essa lin.a impressaM3n4);
2*.
2+. ret-rn #;
2(.5
O comando if pode conter internamente outro if que chamamos if alinhados. Quando temos ifs
alinhado o indicado usar sempre blocos para no confundir qual if faz referencia com qual else.
4.3.2 Instruo switch
A instruo switch composta por uma expresso e vrios cases. Dependendo do valor da expresso, ele
passar a executar o case especfico. Seria uma sintaxe de vrios if-else seguidos. A instruo switch tem o
formato:
sHitc. ( expresso )
/
case n-mero" comandos breaF ; ;
case o-troGn-mero" comandos breaF ; ;
defa-lt" comandos breaF ; ;
5
A instruo switch avalia a expresso e realiza um salto para o case que tenha o mesmo valor.
A expresso do tipo int ou que possa converter em int.
Cada case nmero um seletor de salto e o C comea a executar o cdigo a partir desse ponto at
encontrar a instruo break que para a execuo ou o final do comando switch.
O default uma case que selecionado se nenhum outro case for selecionado.
e1emplo34.
1.!
2. ! nome" exemplo$'.c
$. ! descri%o" sHitc.
'. ! data" #+112#12
*. !
(.int main()
)./
0. int x@$;
1#. sHitc.( x )
11. /
12. case 1" printf(2x@13n4) breaF ; ;
1$. case 2" printf(2x@23n4);
1'. case $" printf(2x@$3n4) breaF ; ;
1*. defa-lt" printf(2o 9alor x@ diferente de todos os cases3n4);
1+. 5
1(. ret-rn #;
1).5
Para teste, retire os comandos break do exemplo anterior e defina o x como 2. Compile, execute e
verifique o que impresso.
4.4 Instruo de interao
Instrues de interao desviam o caminho lgico do programa que seria executar uma linha por vez
somente uma vez para dependendo da instruo e de sua condio executar um comando/bloco uma
vez, vrias vezes ou nenhuma.
Um erro comum usar uma instruo de interao que nunca chega a condio de parada e fica
executado sem parar. Isso chamado de loop infinito.
4.4.1 Instruo while
A instruo while tem os formatos
H.ile ( condi%o )
comando;
o- -sando o bloco
H.ile ( condi%o )
/
comandos do bloco H.ile
5
O while avalia a condio e enquanto ela for verdadeira esse comando ou bloco executado. Essa
condio pode ser uma varivel ou uma expresso. Se o valor escalar for zero falso caso contrrio
verdadeiro.
e1emplo3%.
1.!
2. ! nome" exemplo$*.c
$. ! descri%o" H.ile
'. ! data" #+112#12
*. !
(.int main()
)./
0. int cont@1;
1#.
11. H.ile( cont <@1# )
12. /
1$. printf(2&1 cont@:d3n48cont);
1'. contWW;
1*. 5
1+.
1(. H.ile( cont66 )
1). printf(2&2 cont@:d3n48cont);
10.
2#. H.ile( contWW <@1# );
21. printf(2&$ cont@:d3n48cont);
22. ret-rn #;
2$.5
No exemplo anterior o primeiro while exibiu quais valores para cont e o segundo while? Qual seria a
diferena no segundo while se usarmos --cont ou cont--? Teria alguma diferena?
4.4.2 Instruo do / while
A instruo do/while tem o formato:
do
instr-%o;
H.ile( condi%o );
o- com bloco
do
/
bloco do do
5
H.ile( condi%o );
A instruo do/while parecida com a while mas o teste de condio fica no final do comando/bloco e
independente da condio esse comando/bloco ser executado pelo menos uma vez.
e1emplo3,.
1.!
2. ! nome" exemplo$+.c
$. ! descri%o" do
'. ! data" #+112#12
*. !
(.int main()
)./
0. int cont@1;
1#.
11. do
12. /
1$. printf(2&1 cont@:d3n48cont);
1'. contWW;
1*. 5
1+. H.ile( cont <@1# );
1(.
1). do
10. printf(2&2 cont@:d3n48cont);
2#. H.ile( cont66 );
21.
22. ret-rn #;
2$.5
No exemplo anterior o primeiro do/while exibiu quais valores para cont e o segundo do/while? Qual seria
a diferena no segundo do/while se usarmos --cont ou cont--? Teria alguma diferena?
4.4.3 Instruo for
A instruo for tem os formatos:
for( inicialiDa%o condi%o expresso ) ; ;
comando;
for( inicialiDa%o condi%o expresso ) ; ;
/
comandos do bloco for
5
O comando for tem trs expresses que didaticamente chamamos de inicializao, condio e expresso.
O for executa primeiramente e somente uma vez a inicializao, depois executa a condio, se ela for
verdadeira executa o comando/bloco. Nas prximas vezes, executa a expresso, avalia a condio e se for
verdadeira executa novamente o comando/bloco.
A expresso inicializao normalmente uma atribuio inicial a uma varivel contador mas pode ser
qualquer expresso ou pode ser omitida do comando. No C99 essa expresso pode ser a declarao de
uma varivel que ter o escopo de bloco for.
A condio pode ser uma expresso avaliada como verdadeira ou falsa.
A expresso normalmente um incremento da varivel contador mas pode ser qualquer expresso ou
pode ser omitida.
e1emplo37.
1.!
2. ! nome" exemplo$(.c
$. ! descri%o" for
'. ! data" #+112#12
*. !
(.int main()
)./
0. int cont;
1#.
11. for( cont@1 cont<@1# contWW) ; ;
1$.
1'. for( cont >@# cont66 ) ; ;
1*. /
1+. printf(2&2 cont@:d3n48cont);
1(. 5
1).
10. for( cont<@1# ) ; ;
2#. printf(2&$ cont@:d3n48contWW);
21.
22. for( int o-tro@1 o-tro<@1# o-troWW ) ; ;
2$. printf(2&' o-tro@:d3n48o-troWW);
2'.
2*. for( int o-tro@1#8cont@1 o-tro>@# \\ cont<@1# o-tro668contWW ) ; ;
2+. printf(2&* cont@:d e o-tro@:d3n48cont8 o-tro);
2(.
2). ret-rn #;
20.5
Compilando esse programa com -Wall tem o alerta declaration hides variable cont. Que isso quer dizer?
4.4.4 Instruo continue e break
As instrues continue e break so usadas dentro das instrues de interao e no caso do break tambm
na instruo seleo switch.
O continue sendo executado dentro de uma instruo de interao, ele para a execuo normal do bloco,
e passa a executar a prxima interao. O break tambm para a execuo normal mas ele termina a
execuo de interao.
e1emplo36.
1.!
2. ! nome" exemplo$).c
$. ! descri%o" H.ile e do H.ile
'. ! data" #+112#12
*. !
(.int main()
)./
0. int cont@1;
1#. H.ile( contWW <@1# )
11. /
12. if( cont@@$ ) contin-e;
1$. if( cont@@* ) breaF;
1'. printf(2&1 cont@:d3n48cont);
1*. 5
1+.
1(. do
1). /
10. if( cont@@$ ) contin-e;
2#. if( cont@@* ) breaF;
22. 5 H.ile( cont66 >@ # );
2$.
2'. for( cont@1 cont <@ 1# contWW) ; ;
2*. /
2+. if( cont@@$ ) contin-e;
2(. if( cont@@* ) breaF;
2). printf(2&$ cont@:d3n48cont);
20. 5;
$#. ret-rn #;
$1.5
4.5 Instruo de salto goto
A instruo de salto goto desvia o caminho lgico de execuo para outro ponto no cdigo que
definimos com um nome, um label.
O formato da instruo goto
...
label"
comando;
goto label;
e1emplo3".
1.!
$. ! descri%o" goto
'. ! data" #+112#12
*. !
(.int main()
)./
0. int cont@# ;
1#.
11. inicio"
12.
1$. printf(>cont1@:d3n>8WWcont) ;
1'.
1*. if( cont<@1# ) goto inicio;
1+. else goto fim;
1(.
1). printf(2Sexto final3n4);
10.
2#. fim"
21.
22. ret-rn #;
2$.5
No exemplo acima o Texto final exibido? Por qu?
4.6 Funes
Funes so estruturas que permite que o programa seja desenvolvido em blocos funcionais. A funo
em C como funes em matemtica, recebe parmetros e gera um valor de resultado. No C os parmetros
e o resultado so tipados.
Exemplo40.c
1.!
2. ! nome" exemplo'#.c
$. ! descri%o" f-n%Qes
'. ! data" #+112#12
*. !
(.int inc(int x)
)./
0. xWW;
1#. ret-rn x;
11.5
12.int dec(int x)
1$./
1'. x66;
1*. ret-rn x;
1+.5
1(.
1).int main()
10./
2#.
21. int 9ar@# ;
22. printf(>inc(9ar)@:d3n>8inc(9ar)) ;
2$. printf(>dec(9ar)@:d3n>8dec(9ar)) ;
2'.
2*. 9ar@inc(9ar);
2+.
2(. printf(>inc(9ar)@:d3n>8inc(9ar)) ;
2). printf(>dec(9ar)@:d3n>8dec(9ar)) ;
20.
$#. ret-rn #;
$1.5
4.6.1 Declarao
A declarao da funo opcional mas uma funo somente pode ser chamada depois de ser declarada
ou de ser definida. Se uma funo precisa chamar outra funo, essa outra funo deve estar definida ou
declarada anteriormente.
Normalmente colocamos as declaraes em arquivos header (.h) e inclumos ela no nosso cdigo fonte.
Nesse caso no precisaramos nos preocupar com a ordem de definio e ordem das chamadas de
funes.
A declarao tem o formato:
tipo nome`-ncao ( par1 8 par2 8 ... 8 parn );
O tipo pode ser qualquer um. Se a funo no for retornar valores, podemos indicar com void.
O nome da funo tem que ser nico no escopo.
Os parmetros podem ser declaraes completas ou pode ser somente o tipo. Se a funo no recebe
parmetros podemos deixar os parentes vazio () ou indicar com (void)
Um exemplo seria:
exemplo41.h
1.!
2. ! nome" exemplo'1..
$. ! descri%o" declara%o de f-n%Qes
'. ! data" #+112#12
*. !
+.9oid inc(int x);
(.9oid dec(int );
).int s-m(int x8 int C);
0.int s-b(int8 int);
O tipo void quer dizer que a funo no tem retorno. O C11 define tambm _Noreturn para indicar uma
funo que no retorna valor. _Noreturn no foi implementado em todos os compiladores.
4.6.2 Definio
A definio da funo a funo com o seu bloco de comandos.
tipo nome`-ncao ( par1 8 par2 8 ... 8 parn )
/
bloco da f-n%o
5
Os parmetros agora tem que estar completamente declarados com o nome e tipo. Esses parmetros
criam identificadores que esto no escopo de declarao de funo. Essas variveis somente so visveis
dentro da funo.
Um exemplo seria:
exemplo42.c
1.!
2. ! nome" exemplo'2.c
$. ! descri%o" declara%o de f-n%Qes
'. ! data" 1##'2#1$
*. !
+.9oid inc(int x)
(./
). xWW;
0.5
1#.9oid dec(int x)
11./
12. x66;
1$.5
1'.int s-m(int x8 int C)
1*./
1+. ret-rn x W C;
1(.5
1).int s-b(int x8 int C)
10./
2#. ret-rn x a C;
21.5
4.6.3 Utilizao
Para usar uma funo basta chamar ela com os parmetros.
Exemplo43.c
2.,incl-de 2exemplo'1..4
$. incl-ir o conteJdo do arL-i9o exemplo'2.c aL-i pode isar o
incl-de
'.int main()
*./
+. int x@18C@$ ;
(. inc(x);
). dec(C);
0. printf(2x@:d8 C@:d3n48x8C);
1#. x@s-m(x8C);
11. printf(2x@:d8 C@:d3n48x8C);
12. ret-rn #;
1$.5
Quais os valores de x e y depois de chamada as funes inc e dec? Foi alterado os valores de x e y?
Na chamada da funo o que passado o valor dela. Isso quer dizer se alteramos dentro da funo o
valor de uma varivel, estamos alterando o valor da varivel que est no escopo da funo e no a
varivel usada na chamada da funo. No C podemos usar ponteiros para poder criar funes que alteram
as variveis passadas.
4.7 Exerccios
1.Crie os arquivo lab03.h ( declaraes somente) e lab03.c ( definies e a funo main ) contendo:
a)Uma funo int parImpar ( int num ) que imprimi se num par o impar. A funo tambm
retorna 0 para par e 1 para impar. ( x % 2 = 0 par e x % 2 = 1 impar )
O numero %x par ou O numero %x impar
b)Uma funo somatorio ( int num ) usando o comando while para retornar o somatrio de num
( num(1) = 1, num(2)=2+1, num(3)=3+2+1. A funo retorna o somatrio e tambm imprime:
Somatorio de %x = %res
c) Uma funo fatorial usando o comando for ( fatorial de 1!=1, 2!=2*1, 3!=3*2*1). A funo
retorna o fatorial e tambm imprime:
%x! = %x
d)Uma funo saltoPara ( inicio, fim, salta, para ) que executa um loop for com inicio e fim, se o
contador for igual a salta executar o continue e se for para executar o break. Se no for salta ou
para imprima o contador.
e)Uma funo imprima_cor
Defina um typedef no header: typedef enum { verde, vermelho, azul } tcores;
Uma funo int imprima_cor( tcores var )
Na funo implemente um switch com
case cor: printf(texto cor\n); break
default: printf(cor nao cadastrada\n); break;
f)Na funo main faa pelo menos uma chamada de funo para cada funo do laboratrio.
5 Aula 4
5.1 Gerenciamento de memria
A linguagem C como as linguagens de programao de alto nvel gerenciam automaticamente a
utilizao de memria nos programas. O C quando declaramos um objeto ele reserva memria suficiente
e quando esse objeto sai do escopo atual, o C desaloca essa memria. O C permite tambm o
gerenciamento de memria pelo programador. Esse gerenciamento de memria que veremos agora.
5.1.1 Ponteiro e endereo de memria
Todos os programas ou o mesmo o sistema operacional quando executado, ele e lido para a memria e
depois comea a execuo. Todos os objetos como funo, varivel e constantes esto na memria na
execuo e cada um deles tem um endereo nico, o endereo de memria. O tamanho desse endereo
de memria depende da arquitetura 32bits ou 64 bits.
Todas as variveis tem algum valor seja numrico ou caractere mas o ponteiro e uma varivel especial que
o contedo dela um endereo de memria. Como o C fortemente e estaticamente tipado, o ponteiro
tambm tem um tipo definido e tambm precisamos declarar antes de usar.
tipo !ponteiro;
Antes de usar esse ponteiro, precisamos inicializar ele. Podemos inicializar ele estaticamente apontando
para uma varivel existente ou alocar dinamicamente uma regio. Faremos agora estaticamente.
ponteiro @ \9aria9el;
o-troGponteiro @ ponteiro;
Podemos declarar e atribuir num s comando:
tipo !ponteiro @ \9aria9el;
tipo ! o-troGponteiro @ ponteiro;
Para usar o contedo dele ou o endereo dele:
printf(2Endere%o @ :p e 9alor @ :d3n48 ponteiro8 !ponteiro);
printf(2Endere%o @ :p e 9alor @ :d3n48 \9aria9el8 9aria9el);
01emplo44.
1.!
2. ! nome" exemplo''.c
$. ! descri%o" ponteiros
'. ! data" #+112#12
*. !
(.int main()
)./
0. int x@18C@$ ;
1#. int !px@\C8 !pC@\C;
11. !px@!pxW!pC;
12.
1$. printf(2x@:d8 C@:d3n48 x8 C);
1'. printf(2!px@:d8 !pC@:d3n48 !px8 !pC);
1*. printf(2px@:p8 pC@:p3n48 px8 pC);
1+. printf(2\x@:p8 \C@:p3n48 \x8 \C);
1(. ret-rn #;
1).5
5.1.2 Alocao dinmica
O C permite que o programador aloque memria dinamicamente. Mas quando o programador aloca
memria, ele tem que gerenciar todas as etapas: alocao, inicializao, manter acessvel esse endereo
de memria em pelo menos uma varivel, desalocar a memria, garantir que no seja utilizado essa
memria desalocada.
Para o curso usarmos a alocao dinmica disponvel na biblioteca padro C:
9oid !malloc(siDeGt taman.o);
9oid !calloc( siDeGt L-antidade8 siDeGt taman.o);
9oid !realloc( 9oid !ponteiro8 siDeGt taman.o);
9oid free( 9oid !ponteiro);
A funo malloc retorna um ponteiro do tamanho do parametro tamanho). Podemos utilizar o funo
sizeof ( tipo ) para especificar o tamanho correto.
tipo !ponteiro @ malloc( siDeof(tipo) );
A funo calloc aloca vetores:
tipo !p9etor @ calloc( taman.o8 siDeof( tipo ));
podemos -sar o malloc tambem
tipo !p9etor @ malloc( siDeof( tipo ) ! taman.o ) ;
A funao realloc executado passando um ponteiro existente para alterar o tamanho dele. O novo
ponteiro diferente do antigo que desalocado. O realloc retorna o novo ponteiro.
ponteiro @ realloc( ponteiro8 siDeof(tipo) ! L-antidade );
A funo free desaloca a memria. Mesmo tendo chamado malloc, calloc ou realloc no mesmo ponteiro
somente vou ter um comando free.
free( ponteiro );
ponteiro@IK??;
Quando desalocamos um ponteiro recomendvel atribuir NULL para a varivel. Primeiro para que a
memria desalocada no se possa ser usada por esse ponteiro e segundo, assegurado que no seja
executado o free com esse endereo desalocado que gera um erro de execuo parando a execuo do
programa.
01emplo4%.
2.,incl-de <stdlib..>
$.int main()
'./
*. int !px8!pC ;
+. int x@18C@$ ;
(.
). px@malloc(siDeof(int)) ;
0. pC@malloc(siDeof(int)) ;
1#.
11. !px@1# ;
12. !pC@$# ;
1$. !px@!pxW!pC;
1'.
1*. printf(>x@:d8 C@:d3n>8 x8 C) ;
1+. printf(>!px@:d8 !pC@:d3n>8 !px8 !pC) ;
1(. printf(>px@:p8 pC@:p3n>8 px8 pC) ;
1). printf(>\x@:p8 \C@:p3n>8 \x8 \C) ;
10.
2#. free(px) ;
21. free(pC) ;
22.
2$. printf(>Eepois de free()3n>) ;
2'. printf(>px@:p8 pC@:p3n>8 px8 pC) ;
2*. px@pC@IK?? ;
2+. printf(>px@:p8 pC@:p3n>8 px8 pC) ;
2(.
2). free(px) ;
20. free(pC) ;
$#.
$1. ret-rn # ;
$2.5
5.1.3 Ponteiros para array
Ponteiros e array na linguagem C so tipos diferentes mas as operaes e utilizaes so iguais. O C trata
arrays como ponteiros tendo a primeira posio que o elemento vetor[0] e calcula a posio no ensimo
elemento multiplicando pelo tamanho de cada elemento. Temos que pvetor[0] igual a *pvetor.
Alias como o ponteiro em si escalar, podemos somar ponteiros. Se precisamos usar o elemento ndice 10
podemos usar vetor[9], pvelor[9] ou *(pvetor+9). O C na expresso *(pvetor+9) no soma 9 bytes ou bits e
sim 9 * o tamanho de cada elemento.
01emplo4,.
2.,incl-de <stdlib..>
$.int main()
'./
*. int !parraC ;
+. parraC@(int!)calloc(1#8siDeof(int)) ;
(. int !o-troarraC@(int!)calloc(1#8siDeof(int)) ;
).
0. parraC[#]@1 ;
1#. parraC[0]@1# ;
11.
12. printf(>:d :p3n>8 parraC[#]8 \parraC[#]) ;
1$. printf(>:d :p3n>8 parraC[0]8 \parraC[0]) ;
1'. printf(>:d :p3n>8 !(parraC)8 parraC) ;
1*. printf(>:d :p3n>8 !(parraCW0)8 (parraCW0)) ;
1+.
1(. parraC@realloc(parraC8siDeof(int)!2#) ;
1). parraC[10]@1## ;
10.
2#. printf(>:d :p3n>8 parraC[#]8 \parraC[#]) ;
21. printf(>:d :p3n>8 parraC[10]8 \parraC[10]) ;
22. printf(>:d :p3n>8 !(parraCW10)8 (parraCW10)) ;
2$.
2'. free(parraC) parraC@IK?? ; ;
2*. free(o-troarraC) o-troarraC@IK?? ; ;
2+.
2(. ret-rn # ;
2).5
5.1.4 Ponteiros para string
No C string e ponteiros para string so relacionados como array e ponteiros para array. A direrena que a
string tem um caractere especial \0 que diz aonde indica o final da string.
e1emplo47.
1.!
2. ! nome" exemplo'(.c
$. ! descri%o" <onteiros para strings
'. ! data" #$1#2#12
*. !
(.,incl-de <stdlib..>
).int main()
0./
1#. c.ar !nome@(c.ar!)malloc(siDeof(c.ar)!2#) ;
11. nome[#]@A&A ;
12. nome[1]@AaA ;
1$. nome[2]@ArA ;
1'. nome[$]@AlA ;
1*. nome[']@AoA ;
1+. nome[*]@AsA ;
1(. nome[+]@A3#A ;
1). printf(>Iome :s ( letra inicial :c )(::p :p)3n>8 nome8 nome[#]8
nome) ;
10. free(nome) nome@IK?? ; ;
2#. ret-rn # ;
21.5
Porque no printf quando passamos ponteiro para int usamos *ponteiro e agora para string usamos
apenas ponteiro?
5.1.5 Ponteiro para estruturas
Ponteiros para estrutura se comportaria como um ponteiro regular. Somente o aceso ao contedo dele
que foi simplificado. Para acessar um item seria (*ponteiro).item, mas podemos usar o operador -> como
ponteiro->item.
e1emplo46.
1.!
2. ! nome" exemplo').c
'. ! data" 1##'2#1$
*. !
(.int main()
)./
0. str-ct data
1#. /
11. int dia8mes8ano ;
12. 5 dia @ /.dia@1(8 .mes@1#8 .ano@2#125 ;
1$.
1'. str-ct data !pdia@\dia ;
1*.
1+. printf(>Eata de .oVe :d:d:d3n>8 pdia6>dia8 (!pdia).mes8
dia.ano) ;
1(.
1). ret-rn # ;
10.5
Porque no podemos usar *ponteiro.item ?
5.1.6 Ponteiros para funo
Funes como todo identificador no C pode ser acessado usando ponteiros. Vamos explicar o conseito
bsico de ponteiros para funo para reforar como est organizado o gerenciamento de memria no C.
tipo (!pf-ncao)(arg18 arg28 argn) ;
tipo !pf-ncao () declara pf-ncao L-e retorna ponteiros (tipo!)
pf-ncao@\f-ncao;
(!pf-ncao)(par18 par28 parn);
pf-ncao(par18 par28 parn);
2A.e1emplo4".
1.!
2. ! nome" exemplo'0.c
$. ! descri%o" ponteiro para str-ct
'. ! data" #$1#2#12
*. !
(.
).int som(int x8 int C)
0./
1#. ret-rn x W C ;
11.5
12.
1$.int main()
1'./
1*. int (!psom)(int8int)@\som ;
1+. printf(>f-ncao psom end@:p res-ltado@:d3n>8psom8psom(182)) ;
1(. printf(>f-ncao printf end@:p 3n>8printf) ;
1). ret-rn # ;
10.5
5.1.7 Ponteiros como parmetros de funo
No C os parmetros so passados por valor na chamada da funo. Para conseguir alterar o valor de uma
varivel na funo podemos passa um ponteiro. Tambm usa-se ponteiros para passar dados grandes
como estruturas porque no ser preciso realizar a cpia dos dados na chamada.
Exemplo50.h
1.!
2. ! nome" exemplo*#..
$. ! descri%o" ponteiros como parPmetros de f-n%o
'. ! data" #+112#12
*. !
+.9oid inc(int !x)
(./
). (!x)WW;
0.5
1#.9oid dec(int !x)
11./
12. (!x)66;
1$.5
Exemplo50.c
1.,incl-de<stdio..>
2.,incl-de >exemplo*#..>
$.
'.int main()
*./
+. int x@18 C@$ ;
(. printf(>x@:d e C@:d3n>8x8C) ;
). inc(\x) ;
0. dec(\C) ;
1#. printf(>x@:d e C@:d3n>8x8C) ;
11. ret-rn # ;
12.5
No exemplo anterior o incremento e decremento feito no formato (*x)++ e (*x--) porque no poderia ser
feito como *x++ e *x--?
5.1.8 Alocao dinmica e escopo.
A alocao dinmica de memria extrapola o escopo aonde realizamos a alocao e a desalocao de
memria. Mas o ponteiro como sendo uma varivel comum est limitado ao escopo aonde foi declarado
e precisamos ter como acessar essa memria para poder chamar a funo free. A maioria dos sistemas
operacionais, quando o programa termina, ele desalocada toda memria alocada para o programa mas
como o C tambm portado para plataformas com sistema operacional simplificado ou at mesmo sem
sistema operacional, ficou sendo uma pratica de boa programao desalocar toda memria alocada no
prprio programa.
5.2 Durao de armazenamento do objeto
A durao de armazenamento de um objeto est relacionado ao escopo dele e como e quando o objeto
vlido e pode ser acessado. Se desararmos uma varivel global, ela ficar disponvel durante a execuo
do programa e ser visvel em todo o programa. Se declarar uma varivel em um bloco, a durao e
visibilidade dele ficar restrita ao bloclo.
Podemos alterar esse comportamento com os qualificadores extern, static e register.
5.3 Especificao de classe de armazenamento
Quando declaramos um objeto como uma varivel ou uma funo podemos tambm especificar a classe
de armazenamento dela que pode ser extern, static e register.
Os objetos so classificados como armazenamento local ou externo. Armazenamento local somente
visto no escopo de declarao. Armazenamento externo extrapola o escopo.
5.3.1 Extern
Classifica os objetos com armazenamento externo. Se for uma varivel, ela far referencia a uma outra
varivel declarada em um arquivo header ou em outro programa. Se for uma funo, como toda as
funes j tem o escopo extern, isso seria redundante.
exemplo51.c
1.!
2. ! nome" exemplo*1.c
$. ! descri%o"
'. ! data" #+112#12
*. !
+.int 9aria9el@21;
exemplo52.c
1.!
2. ! nome" exemplo*2.c
$. ! descri%o"
'. ! data" #$1#2#12
*. !
(.
).extern int 9aria9el ;
0.int main()/
1#. printf(>9aria9el externa@:d3n>89aria9el);
11. ret-rn #;
12.5
Para compilar:
,icc 67all 6c exemplo*1.c
,icc 67all 6c exemplo*2.c
,icc 67all exemplo*1.o exemplo*2.o 6o exemplo*1e*2
,.exemplo*1e*2
5.3.2 Static
Uma varivel declarada como static no escopo de funo e no escopo global.
No escopo de funo a varivel inicializada somente uma vez e esse armazenamento dura toda a
execuo do programa mesmo que o escopo dela esteja limitado. O valor dela tambm conservado.
exemplo53.c
1.!
2. ! nome" exemplo*$.c
$. ! descri%o"
'. ! data" #$1#2#12
*. !
(.
).int conta()
0./
1#. static int 9ar@1;
11. ret-rn 9arWW;
12.5
1$.
1'.int main()
1*./
1+. printf(>&onta@:d3n>8conta());
1(. printf(>&onta@:d3n>8conta());
1). printf(>&onta@:d3n>8conta());
10. ret-rn #;
2#.5
No escopo global, essa varivel ficaria como escopo interno e no poderia declarar uma outra varivel
como extern.
arquivo1.c
static int 9ar@1$;
arquivo2.c
extern int 9ar isso no f-ncionaria ;
5.3.3 Const
O qualificador const especifica que o objeto no poder ser alterado depois da declarao.
const int 9ar@1#;
9ara@2# erro ;
Quando trabalhamos com ponteiros, podemos ter ponteiros para contantes , ponteiros contantes para
varivel e ponteiros constantes para contantes.
ponteiro para constante
const int !ptrGtoGconstant@\9ar ;
!ptrGtoGconstant@1## erro ;
ptrGtoGconstant@\o-tro9ar =X ;
ponteiro contante para 9aria9el
int !const constantGptr@\9ar ;
!constantGptr@1## =X ;
constantGptr@\o-tro9ar erro ;
ponteiro constante para constante
const int ! const constGptrGtoGconst@\9ar;
!constGptrGtoGconst@1## erro ;
constGptrGtoGconst@\o-tro9ar erro ;
5.3.4 Register e restrict
Register qualifica uma varivel a ser otimizada o acesso a ela usando registradores da prpria CPU
evitando o acesso memria RAM. O compilador pode ignorar isso se no puder realizar essa otimizao.
Restrict um qualificador de ponteiros que diz para o compilador que o programador no usar outro
ponteiro como acesso alternativo para essa varivel. Com essa restrio o compilador pode otimizar o
cdigo.
5.4 Exerccios
1.Crie o arquivo lab04.c na funo main declare e inicialize
a)Variveis:
int num=10;
int data[3]={19,4,2013};
char hello=Hello;
struct sponto { int x,y,z } ponto = { 10 , 20 , 30 };
b)Ponteiros e inicialize apontando para as variveis criadas anteriormente.
*pnum ponteiro para num
*pdata ponteiro para data
*phello ponteiro para hello
*pponto ponteiro para ponto
c)Imprima essas mensagens usando os ponteiros:
num=%d \n
data=%d \n
hello=%s \n
ponto.x=%d, ponto.y=%d, ponto.z=%d \n
2.Crie lab04d.c ( pode ser cpia do lab04.c )
a)Defina
struct ponto
b)variveis ponteiros e utilize malloc ou calloc para alocar memria
*pnum do tipo ponteiro para int
*pdata do tipo ponteiro para vetor int
*phello do tipo ponteiro para char
*pponto do tipo ponteiro para struct ponto
c)Imprima essas mensagens usando os ponteiros:
num=%d \n
data=%d \n
hello=%s \n
ponto.x=%d, ponto.y=%d, ponto.z=%d \n
3.Crie o lab04s.c com uma funo acumulador( init num ). Use uma varivel static. A funo imprime
acumulou %d\n.
4.Crie:
a)lab04e.h com definio de acumulador( init num );
b)lab04e.c com include de lab04e.h e o corpo da funo acumulador( init num ){}
c)lab04i.c com include de lab04e.h. Na funo main realize chamadas para acumulador
d)compile e gere lab04e.o e lab04i.o. Depois gere o lab04e executvel.
6 Aula 5
6.1 Biblioteca padro C
A biblioteca padro C ou C standard library a biblioteca padro definido pela ISO para que todo
compilador C deve fornecer.
A biblioteca padro C fornece macros, definio de tipos e funes para lidar com strings, computao
matemtica, processamento de entrada/sada, alocao de memria e muitas outras funes para os
servios do sistema operacional.
J vimos o comando printf e a parte de alocao de memria, agora iremos ver sobre processamento de
entrada e sada.
6.2 Rotinas de entrada e sada
O C abstrai todas as rotinas de entrada e sada com arquivos. Quando usamos o printf, o comando envia
informao para um arquivo que o C define como stdout ou seja sada padro. Existem outros como
stderr para sada de erro e stdin para entrada padro (teclado).
6.2.1 Arquivos
O C define o tipo FILE para tratar arquivos. Para trabalhar com arquivos precisamos, declarar uma varivel
FILE, abrir o arquivo, escrever ou ler, fechar o arquivo.
Para declarar uma varivel FILE:
`Y?E !arL-i9o;
Para abri o arquivo usamos:
arL-i9o @ fopen(2arL-i9o48 modo);
arquivo o nome do arquivo
modo o modo de abertura do arquivo
Modo Aruivo existente Aruivo inexistente
r A4rir para leitura erro
9 Apaga onteDdo3 esre)e Cria um no)o
a Aresenta onteDdo no
final.
Cria um no)o
4 8in(rio
Podemos abrir um arquivo temporrio usando:
arL-i9o @ tmpfile(IK??);
Para fechar o arquivo usamos:
int fclose( arL-i9o );
6.2.2 Entrada e sada
A biblioteca padro C define entrada e sada formatada, caractere e direta. Iremos usar as rotinas de
entrada e sada formatada no curso por ser considerada mais didtica.
6.2.2.1 Sada de dados formatada
A bliblioteca padro C define vrias funes para tratar sada formatada, iremos tratar da printf e da
fprintf.
A funo fptintf tem o formato:
fprintf( arL-i9o 8 2formato48 9ar18 9ar28 9arn);
O arquivo pode ser um que declaramos e abrimos anteriormente ou pode ser um que o C define como :
stdout ou stderr.
A funo printf no tem a opo arquivo mas ela abre o stdout:
printf(2formato48 9ar18 9ar28 9arn);
fprintf( stdo-t 8 2formato48 9ar18 9ar28 9arn);
6.2.2.2 Entrada de dados formatada
A biblioteca padro C define vrias funes para tratar entrada formatada, iremos tratar da scanf e da
fscanf.
A funo fscanf tem o formato:
fscanf( arL-i9o8 2formato48 \9ar18 \9ar28 \9arn);
A funo scanf no tem a opo arquivo mas ela abre o stdin
scanf(2formato48 \9ar18 \9ar28 \9arn);
fscanf( stdin8 2formato48 \9ar18 \9ar28 \9arn);
6.2.3 Tratamento de erro
Quando lidamos com entrada e sada pode ocorrer erros seja de acesso, permisso ou nome de arquivo
ou no formato do dado. Para esses problemas, o programador precisa tratar isso no cdigo fonte.
6.2.3.1 Funes teis para o tratamento de erro
Para detectar o final de arquivo:
int feof( arL-i9o );
feof retorna verdadeiro para final de arquivo, caso contrrio retorna falso.
Para detectar erro na leitura/escrita:
int ferror(arL-i9o) ;
ferror retorna zero quando no h erro, caso retorne um nmero, esse nmero o cdigo do erro.
Para exibir uma mensagem padro de erro ( sada em stderr):
9oid perror(2texto4);
Para traduzir o ero numrico para texto:
c.ar !strerror (errorn-m);
Para verificar o comando fopen.
`Y?E !fp;
fp@fopen(2arL-i9o.txt484modo4);
if( fp @@ IK?? )
/
printf( 2Erro no fopen() codigo :d 6 :s3n48 errno,
strerror(errno))
!
e"se
#
//$"o%o &r'(i)o *+
!
,&r& )erifi%&r erro n& f(n-.o /rintf e n& f(n-.o fs%&nf
f/rintf(f/,0%s0,01e2to3n0)
if( errno ) /error(04rro %o5 & f(n%&o f/tintf0)
fs%&nf(f/,0%s0,&)&r)
if( errno ) /error(04rro %o5 & f(n%&o fs%&nf0)
65 e2e5/"o %o5/"eto seri&:exemplo54.c
1./*
2. * no5e: e2e5/"o78.%
$. * 9es%ri-.o:
'. * 9&t&: :;/;8/<;:=
*. */
+.>in%"(9e <st9io.?>
(.>in%"(9e <st9"i$.?>
).>in%"(9e <errno.?>
0.int 5&in()
1#.#
11. @AB4 *f/
12. f/=fo/en(0e2e5/"o78.t2t0,0C0)
1$. if( f/ == D6BB )
1'. #
1*. /error(04rro %o5 & f(n%&o fo/en0)
1+. !
1(. e"se
1). #
10. for( int %=: %<=:; %++ )
2#. #
21. f/rintf(f/,0%9 0, %)
22. if( errno ) /error(04rro %o5 & f(n%&o f/tintf0)
2$. !
2'. f/rintf(f/,03n0)
2*. !
2+. f%"ose(f/) ret(rn ; !
,&r& "er o &r'(i)o:
e1emplo%%.
1./*
2. * no5e: e2e5/"o77.%
$. * 9es%ri-.o:
'. * 9&t&: :;/;8/<;:=
*. */
+.>in%"(9e <st9io.?>
(.>in%"(9e <st9"i$.?>
0.int 5&in()
1#.#
11. @AB4 *f/
12. f/=fo/en(0e2e5/"o78.t2t0,0r0)
1$. int n(5
1'. if( f/ == D6BB )
1*. #
1+. /error(04rro %o5 & f(n%&o fo/en0)
1(. !
1). e"se
10. #
2#. C?i"e ( fs%&nf(f/,0%90, &n(5) != 4*@ )
21. #
22. if( errno )
2$. /error(04rro %o5 & f(n%&o fs%&nf0)
2'. e"se
2*. f/rintf(st9o(t,0D(5ero %93n0,n(5)
2+. !
2(. !
2). f%"ose(f/)
20. ret(rn ;
$#.!
6.2.4 ,&ss&Ee5 9e /&rF5etros /&r& o /roEr&5&.
G(&n9o /re%is&5os /&ss&r /&rF5etros /&r& o /roEr&5&, esses /&rF5etros
s.o /&ss&9os /&r& & f(n-.o 5&in. ,&r& /o9er ter &%esso & ess&s f(n-Hes,
/re%is&5os 9e%"&r&r 5&in %o5 /&rF5etros:
int 5&in(int &rE%, %?&r *&rE)[])
&rE% I (5 inteiro '(e %ont& '(&ntos /&rF5etros for5&5 /&ss&9os.
&rE)[;] I o no5e 9o /roEr&5&.
&rE)[:] &tI &rE)[&rE%-:] s.o os /&rF5etros.
65 e2e5/"o %o5/"eto seri&:
exemplo56.c
1.!
2. ! nome" exemplo**.c
$. ! descri%o"
'. ! data" #$1#2#12
*. !
+.>in%"(9e <st9io.?>
(.>in%"(9e <st9"i$.?>
0.
1#.int 5&in(int &rE%, %?&r *&rE)[])
11.#
12. for( int %ont=; %ont<&rE% %ont++)
1$. /rintf(0&rE)[%9]=30%s303n0, %ont, &rE)[%ont])
1'. ret(rn ;
1*.!
,&r& e2e%(t&r:
./e2e5/"o7J
./e2e5/"o7J /&r: /&r< : < =
1o9os os /&rF5etros s.o te2tos: /&r& %on)erter e"es (ti"ize &s f(n-Hes
9e %on)ers.o:
9o($"e &tof(strinE)
int &toi(strinE)
"onE int &to"(strinE)
"onE "onE int &to"" (strinE)
// erros s.o tr&t&9os n& )&riK)e" errno
6.3 Exerccios
1.Crie os arquivos lab05w.c e lab05r.c
a)O lab05w.c faa um loop for de 1 a 20 e grave o valor do ndice no arquivo lab05.txt
b)O lab05r.c faa um loop while lendo do arquivo os nmeros, teste fim de arquivo.
c)Nesses exemplos utilize o tratamento de erro.
2.Crie o arquivo lab05wp.c que abre o arquivo que recebe como parmetro na linha de comando e
acrescente no final do arquivo lab05.txt. Converter os parmetros para inteiro antes de gravar.
3.A biblioteca C padro fornece muitas funes interessantes que no poderia abordar aqui no
curso mas se olhar na documentao dessas funes, poder com facilidade utilizar ela em algum
programa. No Linux padro essas funes so documentadas com o man.
a)Verifique a documentao de duas funes matemticas pow e sqrt. Se tiver dificuldade no
ingls, converse com o instrutor.
man pow
man sqrt
b)Escolha uma das funes e escreva o programa lab05rf.c como cpia do lab05r.c e a cada
nmero lido imprima pow(%d) = %f ou sqrt(%d)=%f.
c)De acordo com a documentao, precisa colocar um header a mais e uma linha a mais na
compilao (link).
7 L&teri&" 42tr&
4sse %(rso te)e %o5o referen%i& o /&9r.o %o5o (5 %(rso intro9(tMrio. *
/&9r&o N:: &/resent& o(tros re%(rsos %o5o t?re&9s, (sso 9e estr(t(r&s
EenIri%&s, entre o(tros.
?tt/://CCC.o/en-st9.orE/Ot%:/s%<</CE:8/CCC/9o%s/n:7P;./9f
Q 5&iori& 9&s f(n-Hes 9& $i$"iote%& /&9r.o /er5ite5 /roEr&5&r %M9iEos
inseE(ros, isso e, /o9e5 sofrer &t&'(e 9e seE(r&n-& %o5o $(ffer
o)erf"oC. ,ens&r e5 seE(r&n-& e essen%i&". ,o9e %o5e-&r %o5 esse
5&teri&"
?tt/s://CCC.se%(re%o9inE.%ert.orE/%onf"(en%e/9is/"&R/se%%o9e/N4S1+N+Te%(
re+No9inE+Tt&n9&r9
U()i9&s fre'(entes:
?tt/://%-f&'.%o5/

Apostila C PDF

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila C PDF

Enviado por

Direitos autorais:

Formatos disponíveis

Introduo linguagem C

Centro Nacional de Alto Desempenho

Você também pode gostar