Você está na página 1de 63

INTRODUO A

LINGUAGEM
C
PLANO DE AULA
COMPLADO PARA CURSO DE ENGENHARA ELTRCA
PROF: ROBSON FERRERA

Governador Valadares, 11 DE JULHO DE 1995.
SUMRIO
1 - NTRODUO
1.1 - HSTRCO
1.2 - CARACTERSTCAS DA LNGUAGEM
2 - PROGRAMA EXEMPLO
3 - TPOS DE VARVES E CONSTANTES
3.1 - CONSTANTES
Constantes Numricas
Constantes de Caractere
Sequncias de Escape
Strings
3.2 - TPOS DE VARVES
Declarao de uma varivel
Definio de uma varivel
Tipos de variveis
4 - OPERADORES
Operadores Aritmticos
Operadores Relacionais
Operadores Lgicos
Operadores Bit a Bit
Operador de Atribuio
Operador de Atribuio Reduzida
Operadores Pr e Ps-Fixados
Operadores Condicionais
5 - CONVERSES DE TPOS
Converses Automticas
Converses Foradas
6 - PRECEDNCA
7 - ORDEM DE AVALAO
8 - COMANDOS DE CONTROLE DE FLUXO
8.1 - O COMANDO F
8.2 - O COMANDO F-ELSE
8.3 - O COMANDO WHLE
8.4 - O COMANDO DO-WHLE
8.5 - O COMANDO FOR
8.6 - O COMANDO CONTNUE
8.7 - O COMANDO BREAK
8.8 - O COMANDO SWTCH
8.9 - O COMANDO GOTO
9 - FUNES
9.1 - CHAMADA DA FUNO
9.2 - PARMETROS E ARGUMENTOS
Os argumentos argc e argv da funo main()
9.3 - VALORES DE RETORNO
9.4 - ESCOPO DE VARVES
Variveis Locais ou Automticas
Variveis Globais
Variveis Externas
Variveis Estticas
Variveis Registradores
10 - MATRZES
10.1 - STRNGS
10.2 - MATRZES MULTDMENSONAS
10.3 - MATRZES PASSADAS PARA FUNES
10.4 - ORGANZAO DE MATRZES NA MEMRA
11 - PONTEROS
11.1 - PONTEROS E MATRZES
11.2 - ARTMTCA DE PONTEROS
11.3 - PONTEROS PARA MATRZES USANDO FUNES
12 - TPOS DE DADOS COMPLEXOS E ESTRUTURADOS
12.1 - ENUMERAES
12.2 - ESTRUTURAS
Atribuies entre Estruturas
Endereo da Estrutura
Passando e devolvendo estruturas para funes
Estruturas Aninhadas
Campos de bits
Ponteiros para Estruturas
12.3 - LSTAS ENCADEADAS
A funo malloc()
12.4 - UNES
Apndice A - ROTNAS DE ENTRADA E SADA (/O)
A funo printf()
A funo scanf()
As funes getchar() e putchar()
As funes gets() e puts()
Apndice B - PROGRAMA EXEMPLO PARA ROTNAS GRFCAS
Apndice C - DRETVAS DO PR-PROCESSADOR
BBLOGRAFA
1 - INTRODUO
Atualmente, uma das linguagens mais utilizadas por tcnicos e pesquisadores a
linguagem C. sto ocorre principalmente pela versatilidade e pela complexidade da linguagem,
que permitem a criao de programas muito sofisticados.
1.1 - HISTRICO
A primeira verso da linguagem foi desenvolvida por dois pesquisadores da Bell
Laboratories, Brian Kernighan e Dennis Ritchie. A empresa necessitava de uma linguagem
especificamente para escrever o sistema operacional UNX, mas C revelou-se to eficiente e
"transportvel" para outros sistemas operacionais, sistemas e hardwares que seu uso alastrou-
se rapidamente. Esta primeira verso, chamada "K&R" sofreu algumas modificaes com o
tempo, para adaptar-se a computadores com mais de 8 bits e assim nasceu a verso "ANS
C", considerada um padro da linguagem. Algum tempo depois, com a moda de programao
orientada a objetos, nasceu a verso C++ que no mais segue a programao linear. Vrias
empresas criaram seus prprios compiladores C e assim apareceram o MS C (Microsoft), o
Turbo C, Borland C, etc.
1.2 - CARACTERSTICAS DA LINGUAGEM
C uma linguagem compiIada, estruturada e de baixo nveI.
Linguagem compilada porque precisa ser escrita num editor de textos qualquer (que siga
o padro ASC), compilada (cada mdulo separadamente) e linkada para obter-se um
programa executvel. Certos softwares como o Turbo C e o Borland C permitem que se edite,
compile e linke os programas em C dentro de um mesmo ambiente, o que facilita muito a
manipulao.
uma linguagem estruturada porque segue o padro de blocos, como Pascal e Fortran
por exemplo, com alinhamentos cada vez mais direita, quanto mais "interno" a um bloco for
o comando e com execuo linear, sem utilizao de goto's, break's, etc.
Finalmente uma linguagem de baixo nvel por aproximar-se bastante da linguagem de
mquina, Assembler, que apesar de bastante rudimentar tem a capacidade de acessar
diretamente a memria, o hardware do computador, como registradores, portas, posies da
RAM, etc. Com isto, ganha-se muito em rapidez de execuo e em poder para utilizar
completamente os recursos do computador. importante salientar que apesar de ser possvel
utilizar-se funes muito complexas de baixo nvel em C, um programador no interessado
nisto ter uma linguagem to clara e fcil quanto qualquer outra de alto nvel, como Pascal,
por exemplo.
Outra caracterstica importante que C uma linguagem de estilo "livre", sem
formatao rigorosa como Fortran e Basic. Em Basic, cada linha contm um comando e cada
comando ocupa somente uma linha (s vezes, h at numerao das linhas). Em Fortran, os
arquivos de sada contm espaos reservados para cada string, valor de caractere ou espao
em branco que dever ser impresso. Nada disto ocorre em C. Desde que a sintaxe correta seja
seguida, no h maiores restries na linguagem. Ou melhor, quase no h. O programador
no pode esquecer que o compilador C diferencia caracteres minsculos de maisculos. Por
exemplo, as variveis "numero" e "Numero" so consideradas diferentes uma da outra na
linguagem C.
Um avano significativo que C possibilitou, foi escrever-se um programa numa
linguagem de alto nvel (que C no deixa de ser) e ter, aps a compilao, um cdigo gerado
diretamente em Assembler. Qual a vantagem nisto? Quem trabalha com circuitos contendo
microprocessadores ou microcontroladores sabe! At pouco tempo seria necessrio escrever
pginas de cdigo em Assembler para funes simples. Agora, com o uso de compiladores
como o Keil - C ou Avocet, o programador escreve o cdigo em C e o compilador encarrega-
se de transform-lo em Assembler.
Costuma-se dizer que o C uma linguagem extremamente "portvel". Ou seja, foi
desenvolvido para UNX, mas roda muito bem em DOS. Alm disto, um programa escrito em
C, para uma estao de trabalho provavelmente rodar num PC ou num computador mdio;
ou mesmo passar de um BM-PC para um Machintosh. sto ocorre porque C no rgido, no
tem funes pr-definidas de /O (alis, de nenhum tipo) para cada mquina e adapta-se a
qualquer hardware. Funes especficas (como entrada e sada) para cada mquina devem
ser escritas pelo prprio usurio e certamente estas no rodariam num hardware diferente.
Uma opo para o programador mais prtico (ou preguioso) procurar nas dezenas de
arquivos de biblioteca ".h" (por exemplo, "stdio.h") uma funo que se encaixe nas suas
necessidades. importante salientar que tambm estas funes (como por exemplo, printf(),
que imprime sadas formatadas na tela) foram desenvolvidas por usurios e no pertencem
linguagem original. Na verdade, quase tudo em C definido pelo usurio, da sua
complexidade e ao mesmo tempo, seu poder.
2 - PROGRAMA-EXEMPLO
O programa abaixo serve como ilustrao para a estrutura de um programa em C.
"
/***********************************************************/
/*** PROGRAMA C que demonstra como usar !r"as #r"m"t"as $r!%"cas ***/
/*** com mon"tor &GA ***/
/**********************************************************/
'"nc(ude )$ra#*"cs+*,
'"nc(ude )std"o+*,
'"nc(ude )std("-+*,
'"nc(ude )#rocess+*,
'"nc(ude )con"o+*,
'de%"ne TRUE .
'de%"ne MA/ 011
'de%"ne NAO 2n2
'de%"ne 3IM 2s2
o"d c"rcu(o4"nt5 "nt67
o"d -arra4"nt67
o"d e("#se4"nt5 "nt6 7
o"d ma"n4o"d6
8
"nt $dr"er 9 DETECT5 $mode5 errorcode5 "7
"nt m"d:5 m"d;7
c*ar c*7
"n"t$ra#*4<$dr"er5 <$mode5 = = 67

errorcode 9 $ra#*resu(t467
"% 4errorcode >9 $rO?6
8 #r"nt%4=Erro de @unABo Gr!%"caC Ds En=5 $ra#*errorms$ 4errorcode667
#r"nt%4=A#erte uma tec(a #ara #ararC =67
$etc*467
e:"t4.67
F
set-?co(or4GLACH67
%or4" 9 .17 c* >9 NAO7 " I9.11 6
8
c"rcu(o4"5 "67 // desen*a um c"rcu(o aJ"o
-arra4" I K167 // desen*a uma -arra c*e"a
e("#se4" I0115 " I L1167 // desen*a uma e("#se c*e"a
#r"nt%4=DeseMa cont"nuarN 4s/n6=67
c* 9 $etc*ar467
F

c(ose$ra#*467

F
o"d c"rcu(o4"nt :5 "nt ;6
/* desen*a um #equeno cOrcu(o */
8 setco(or4GLUE67
c"rc(e4:5 ;5P167
F
o"d -arra4"nt #os"cao6
/* desen*a uma -arra tr"d"mens"ona( */
8 setco(or4CQAN67
set%"((st;(e4LINER@ILL5 CQAN67
-arLd4#os"cao5 015 #os"cao I K15 S15 .K5 .67
F
o"d e("#se4"nt :5 "nt ;6
/* desen*a uma e("#se5 traAa e #reenc*e */
8 setco(or4MAGENTA67
set%"((st;(e43LA3TR@ILL5 MAGENTA67
%"((e(("#se4:5 ;5 P15 U167
F
"
Observe atentamente o programa. Este inicia com comentrios sobre o nome do
programa e o que ele faz. Em C, comentrios sempre esto entre os smbolos "/*" e "*/", ou
aps o smbolo "//". Ou seja, tudo que estiver entre "/* ... */" completamente ignorado pelo
compilador e tudo que estiver, na mesma linha, aps o "//" tambm o .
Em seguida, temos uma srie de comandos, chamados "diretivas", que no pertencem
linguagem C propriamente, sempre comeando com o smbolo "#". Estes comandos fazem
parte do que chamamos de "Pr-Processador". O pr-processador, como o nome diz, um
programa que examina o programa-fonte em C antes deste ser compilado e executa certas
modificaes nele, baseado nas diretivas. As diretivas mais comuns so "#include" e "#define".
A primeira, indica ao compilador quais arquivos de header (os "*.h") sero utilizados pelo
programa. A segunda, define constantes e macros para facilitar a visualizao do programa.
Para maiores informaes, vide Apndice C.
A rea seguinte a regio de declarao dos "prottipos de funes". sto necessrio,
em alguns compiladores C, para indicar ao compilador quais e qual o formato das funes que
existem no programa. Por exemplo, o prottipo "o"d c"rcu(o4"nt5 "nt6" diz ao compilador que
dentro deste cdigo ele encontrar uma funo chamada circulo, que recebe dois argumentos
do tipo int (inteiros) e no retorna valor algum (void) expresso chamadora.
As outras reas so todas funes. A primeira a funo principal do programa, main().
A funo main() sempre a primeira a ser executada num programa C, no importa onde
esteja localizada no cdigo. Neste programa foi colocada em primeiro lugar por conveno.
Note que uma funo inicia-se sempre com o nome desta (seu tipo e argumentos) e em
seguida temos o seu "corpo", sempre delimitado pelos caracteres "{" e "}". Tudo que estiver
entre os smbolos de abre e fecha-chaves faz parte do corpo de uma funo. Com exceo da
funo main(), que existe obrigariamente em qualquer programa C, todas as outras funes
foram previamente declaradas em prottipos.
No s as funes, mas tambm blocos de comandos so delimitados por "{" e "}". Note
o corpo do comando "for" do programa.
As variveis em C geralmente so declaradas no incio dos blocos, em alguns
compiladores por conveno e em outros por obrigao. Contudo, a rigor, as variveis podem
ser declaradas em qualquer ponto do programa (dentro do escopo necessrio, claro) desde
que antes de serem utilizadas.
Finalizando, note que a maioria dos comandos C terminam com o caractere "';" que
um anlogo do "End" utilizado em outras linguagens, como Fortran e Pascal.
Nos captulos seguintes todos os pontos discutidos acima sero explorados e o Apndice
C tem uma lista das diretivas mais comumente utilizadas.
3 - TIPOS DE VARIVEIS E CONSTANTES
3.1 - CONSTANTES
Uma constante tem valor fixo e inaltervel. Em C uma constante caractere escrita
entre aspas simples (" ' " e " ' "); uma cadeia de caracteres, entre aspas duplas (" " " e " " "); e
constantes numricas como o nmero propriamente dito.
Exemplos de constantes:
2c2
=meu #r"me"ro #ro$rama =
V
Constantes podem ser dos tipos:
- Constantes numricas - inteiros, octais, hexa, longas e ponto flutuante (reais).
Ex:
32 (inteiro) 034 (octal) 0xFE(hexa)
32L (longa) 567893 (longa implcito) 2.3 (double)
Como podemos notar, constantes inteiras no possuem ponto decimal; constantes octais
devem ser precedidas por um '0'; constantes hexa, por um '0x'; constantes longas devem ser
seguidas por um 'L', mas quando se trata de um nmero muito grande o compilador j entende
que um inteiro longo; e constantes double ou float tm ponto decimal flutuante.
- Constantes de Caractere - podem ser representadas por seu cdigo ASC, ou entre
aspas, ' ':
Ex: 2 A 2 9 WK (em ASC)
- Sequncias de Escape - So cdigos de tarefas a serem executadas na compilao,
representados por caracteres que no podem ser impressos.
Sequncia de escape Significado
\a Caractere Bell (ANS C)
\b Caractere de retrocesso (backspace)
\f Caractere de saltar pgina de formulrio
\n Caractere de nova linha
\r Caractere de retorno de carro
\t Caractere de tabulao horizontal
\v Caractere de tabulao vertical (ANS C)
\\ Caractere de contra-barra
\' Caractere de aspas simples
\" Caractere de aspas duplas
\? Caractere de ponto-de-interrogao
\nnn Valor ASC em octal
\xnnn Valor ASC em hexadecimal
\0 Caractere nulo
Ex: Teste o programinha:
'"nc(ude )std"o+*,
ma"n46
8
#r"nt%4=AEnGEnC=67
#r"nt%4=En=67
#r"nt%4=AEtGEtC=67
#r"nt%4=En=67
#r"nt%4=AGErC=67
#r"nt%4=En=67
#r"nt%4=AGE-E-C=67
#r"nt%4=En=67
#r"nt%4=#a$"na.E%#a$"na0E%#a$"naL=67
#r"nt%4=En=67
#r"nt%4=Gee#EaGee#EaGee#Ea=67
#r"nt%4=En=67
#r"nt%4=EAEGEC=67 /* O que acontece aqu" NNNN */
#r"nt%4=En=67
#r"nt%4= Os comandos do Dos estBo no CCEEDO3 =67
#r"nt%4=En=67
#r"nt%4=E=Cu"dado>E= nBo %ume =67
F
- Strings - Conjunto, srie ou sequncia de caracteres seguido do caractere ' \0 ' e
delimitado por " ".
Ex: "ABC" = 'A' + 'B' + 'C' + '\0'

3.2 - TIPOS DE VARIVEIS
As variveis so o aspecto fundamental de qualquer linguagem de computador. Uma
varivel em C um espao de memria reservado para armazenar um certo tipo de dado e
tendo um nome para referenciar seu contedo. Ao contrrio das constantes, uma varivel tem
seu valor mutvel, da o nome "varivel".
DecIarao de uma variveI: ocorre quando a varivel "apresentada" ao compilador.
O usurio declara que vai criar uma varivel de um certo tipo para utiliz-la em seu programa.
A sintaxe da declarao de uma varivel :
tipo_var nome_var ;
onde tipo_var o tipo de varivel criada e nome_var, o nome ou os nomes (separados
por vrgulas) das prprias.
Ex: "nt num ;
e assim est declarada a varivel "num" inteira.
Ex2:
%(oat ar.5 ar 05 ar L;
declara as variveis "var1" , "var2" e "var3", ao mesmo tempo, como sendo do tipo float.
Definio de uma variveI: ocorre quando a varivel j declarada recebe um valor,
uma atribuio. A definio da varivel pode ocorrer na mesma linha da declarao, mas
sempre depois desta e denominamos isto de "inicializao da varivel". A sintaxe da definio
de variveis :
nome_var 9 valor ;
onde nome_var o nome (ou nomes, separados por smbolos de igual) da varivel e
valor o valor atribudo mesma.
Ex:
num 9 K7 ou num. 9 num 0 9 numL 9 17
e assim o valor 5 (inteiro) atribudo varivel "num" e o mesmo valor, 0, atribudo a
trs variveis ao mesmo tempo.
Ex2:
c*ar : 9 2-27
neste caso a inicializao da varivel "x" como tendo o valor do caractere 'b' ocorreu
logo aps a declarao.
Tipos de Variveis: O tipo de uma varivel informa a quantidade de memria, em bytes
que esta ir ocupar. So eles:
Tipo Tamanho Escala
unsigned char 8 bits 0 a 255
char 8 bits -128 a 127
enum * 16 bits -32,768 a 32,767
unsigned int 16 bits 0 a 65,535
short int 16 bits -32,768 a 32,767
int 16 bits -32,768 a 32,767
unsigned long 32 bits 0 a 4,294,967,295
long 32 bits -2,147,483,648 a 2,147,483,647
fIoat 32 bits 3.4 * (10**-38) a 3.4 * (10**+38)
doubIe 64 bits 1.7 * (10**-308) a 1.7 * (10**+308)
long doubIe 80 bits 3.4 * (10**-4932) a 1.1 * (10**+4932)
void 0 sem valor
ponteiro tipo especial
Os tipos bsicos esto em negrito, os outros tipos so chamados de modificadores de
tipos e servem para alterar o tamanho de um tipo bsico. Por exemplo, em alguns
computadores, como o BM-370, o modificador "short" faz com que o tipo "int" fique com a
metade do tamanho, 8 bits. O tamanho dos tipos varia um pouco de mquina para mquina,
mas em geral seguem a tabela acima.
nteiros com e sem sinal so interpretados de maneira diferente pelo compilador. O bit
de ordem superior, bit 15, de um nmero inteiro com sinal sempre '0', quando o inteiro
positivo e '1' quando o nmero negativo. Se usarmos o modificador "unsigned" o compilador
vai ignorar o bit de sinal, tratando-o como um bit a maiso para nmeros positivos.
Ex:
= ma"n46
8
uns"$ned "nt M 9 WK1117
"nt " 9 M 7
#r"nt%4= Dd D u En=5 "5 M67
F =
O resultado ser:
XKLW WK111
Variveis tambm so modificadas por CIasses de Armazenamento: auto, static,
register e extern. sto ser visto mais tarde, quando estudarmos o escopo das variveis.
* O tipo "enum" um acrscimo recente ao C. definido como um conjunto de constantes
enumeradas. Cada constante associada a um valor inteiro.
Ex: " enum tipo_sinaltransito { vermelho amarelo verde!"
enum tipo_sinaltransito sinal" "
onde sinal s# pode ter um dos tr$s valores e vermelho tem o %ndice & amarelo tem o %ndice '
e verde (.
Exerccios:
1 - dentifique o tipo das seguintes constantes:
a)'\r' b) 2130 c) -123 d) 33.28 e) 0x42
f) 0101 g) 2.0e30 h) '\xDC' i) '\"'j) '\\' k) 'F'
l) 0 m) '\0'
2 - O que uma varivel, na linguagem C?
3 - Quais os 5 tipos bsicos de variveis em C?
4 - O tipo float ocupa o mesmo espao que ________ variveis do tipo char.
5 - Escreva um programa que contenha uma nica instruo e imprima na tela:
" Esta Y a ("n*a um+
Esta Y a ("n*a do"s+
um
do"s
tres "
4 - OPERADORES
A linguagem C rica em operadores, em torno de 40. Alguns so mais usados que
outros, como o caso dos operadores aritmticos que executam operaes aritmticas.
Os tipos de operadores so: Aritmticos, Relacionais, Lgicos, Bit a Bit, de Atribuio,
de Atribuio Reduzida, Pr e Ps-Fixados e Condicionais.
Operadores Aritmticos - Representam as operaes aritmticas bsicas de soma,
subtrao, diviso e multiplicao; alm dos operadores unrios (operam apenas sobre um
operando) de sinal negativo e positivo. So eles:
Binrios
+ Soma
- Subtrao
* Multiplicao
/ Diviso
% Mdulo (devolve o resto da diviso inteira)
Unrio
- Menos unrio
+ Mais unrio
Ex:
Expresso Tem o valor
5 + i 5 somado ao valor da varivel i
22.3 * f 22,3 multiplicado pelo valor da varivel f
k/3 o valor de k dividido por 3 *
x-y o valor de x menos o valor de y
22/3 7 ( como diviso de inteiros o resultado truncado)
22%3 1 ( este operador devolve o resto da diviso inteira)
-a -1 multiplicado ao valor da varivel a
Ex2:
= '"nc(ude )std"o+*,
o"d ma"n46
8
"nt %tem#5 ctem#7
#r"nt%4=D"$"te a tem#eratura em $raus Ce(s"usC =67
scan%4=Dd=5 <ctem#67
%tem# 9 S/K * ctem# I L07
#r"nt%4=Tem#eratura em $raus @a*ren*e"t Y Dd=5 %tem#67
F =
Resultado:
C,ctem#
D"$"te a tem#eratura em $raus Ce(s"usC 0.
Tem#eratura em $raus @a*ren*e"t Y WS
Operadores ReIacionais - So assim chamadas porque so utilizados para comparar,
relacionar dois operandos. So eles:
> Maior
>= Maior ou gual
< Menor
<= Menor ou gual
== gualdade
!= Diferena
O resultado da comparao ser sempre igual a 0 (Falso) ou 1 (Verdadeiro).
Ex:
Expresso Tem o valor
5< 3 0
3 < 5 1
5 == 5 1
3 == 5 0
i <= 3 0, se i>3 e 1, caso contrrio
Ex2:
= '"nc(ude )std"o+*,
o"d ma"n46
8 "nt erdad5 %a(so7
erdad 9 4.K ) 0167
%a(so 9 4.K 99 0167
#r"nt%4=&erdade"ro9 Dd5 %a(so9 Dd En=5 erdad5 %a(so67
F =
Note que o operador relacional "gual a" representado por dois sinais de igual. Se for
usado apenas um sinal, o compilador entender como uma atribuio e no como
comparao.
Ex:
: 9 9 0 est comparando se x ou no igual a 2
:90 est atribuindo o valor 2 a varivel x
Operadores Lgicos - So chamados de "lgicos" porque seguem a Lgica Booleana
de operao com bits. A diferena bsica que a rigor, a lgebra Booleana s utiliza dois
algarismos: o "0" e o "1", o "no" e o "sim", o "falso" e o "verdadeiro", o "espao" e a "marca",
etc. E em C, considera-se o nmero 0 como "falso" e todos os outros nmeros como
"verdadeiros". Os operadores lgicos so:
&& AND
|| OR
! NOT
A operao "E" (ou "AND") representada pelo smbolo "&&", exige que todos os
operandos sejam verdadeiros para que sua sada seja verdadeira.
A operao "OU" (ou "OR") representada pelo smbolo "||", exige que ao menos um dos
operandos seja verdadeiro para que sua sada seja verdadeira.
A operao "NO" ( ou "NOT") representada pelo smbolo "!", inverte o operando. Se for
falso, sua sada verdadeira e vice-versa.
Abaixo temos as Tabelas-Verdade da Lgica Booleana:
operando1 operando2 AND OR
falso falso falso falso
falso verdadeiro falso verdadeiro
verdadeiro falso falso verdadeiro
verdadeiro verdadeiro verdadeiro verdadeiro
operando NOT
falso verdadeiro
verdadeir
o
falso
Ex:
Expresso Tem o valor
5 || 3 1
5 || 0 1
5 && 3 1
5 && 0 0
0 || 0 0
i || j 0, se i e j forem 0 e 1, caso contrrio
!5 0
!0 1
Operadores Bit a Bit - Realizam as mesmas operaes que os lgicos, s que bit a bit
do nmero. Operam apenas em nmeros inteiros que so transformados em binrios e ento
sofrem a operao.
So eles:
& AND
| OR
^ XOR
<< deslocamento esquerda
>> deslocamento direita
~ complemento de um (unrio)
A operao "OU-EXCLUSVO" (ou "XOR") representada pelo smbolo "^", exige que ou
um ou outro dos operandos seja verdadeiro para que sua sada seja verdadeira, nunca todos
ao mesmo tempo.
A operao de "deslocamento esquerda" de bits literalmente desloca os bits de um
nmero binrio esquerda, um determinado nmero de vezes (indicado direita do operador).
sto equivale a multiplicar um nmero binrio por dois (2). Os espaos criados no
deslocamento so preenchidos com 0's.
A operao de "deslocamento direita" de bits literalmente desloca os bits de um
nmero binrio direita, um determinado nmero de vezes (indicado direita do operador).
sto equivale a dividir um nmero binrio por dois (2). Os espaos criados no deslocamento
so preenchidos com 0's.
A operao de "complemento de um" inverte todos os bits do nmero binrio. Os que so "0"
passam a ser "1" e vice-versa.

operando1 operando
2
XOR
falso falso falso
falso verdadeiro verdadeiro
verdadeiro falso verdadeiro
verdadeiro verdadeiro falso
Ex:
Expresso Em binrios Tem o vaIor
1 | 2 0000.0001 | 0000.0010 0000.0011 = 3
0xFF & 0x0F 1111.1111 & 0000.1111 0000.1111 = 0x0F
0x0D << 2 0000.1101 << 2 00110100 = 0x34
0x1C >> 1 0001.1100 >> 1 0000.1110 = 0x0E
~0x03 compl(0000.0011) 1111.1100 = 0xFC
3 ^ 2 0000.0011 ^ 0000.0010 0000.0001 = 1
Operador de Atribuio - Em C, o sinal de igual no tem a interpretao dada em
matemtica. O que acontece que o resultado ou valor do operando do lado direito copiado,
atribudo para a varivel ou endereo, o operando do lado esquerdo. O operador de atribuio
:
= gual a
Ex:
Expresso Operao Tem o vaIor
i = 3 coloca o valor 3 em i 3
i = 3 + 4 coloca o valor 7 em i 7
i = (k=4) coloca o valor 4 em k e depois de k para i 4
i =(k=4) + 3 coloca o valor 4 em k,a adio feita e
o valor 7 e colocado em i 7
3 = i operao invlida! a varivel deve estar do lado esquerdo
Operadores de Atribuio Reduzida - Compactam operaes quaisquer seguidas de
operao de atribuio e tornam o cdigo mais rpido pois a varivel utilizada s procurada
uma vez na memria.
Formato:
operao =
Ex:
Expresso equivaIente a
a += 2 a = a+2
j <<= 3 j = j << 3
q/= 7 + 2 q = q / (7+2)
Operadores Pr e Ps-Fixados - Realizam incremento ou decremento do valor de uma
varivel antes de seu valor ser utilizado, no caso de operador pr-fixado, ou depois de seu
valor ser utilizado, no caso de operador ps-fixado. A vantagem de se utilizar estes
operadores, e no o tradicional "varivel = varivel + 1;" que alm da praticidade e da
compactao do cdigo, torna o programa muito mais rpido.
++ incrementa de 1 seu operando
-- decrementa de 1 seu operando
Ex: Suponhamos a varivel i = 5:
Expresso VaIor expresso VaIor de i depois
5 + i++ = 10 6
5 + i-- = 10 4
--i + 5 = 9 4
++i + 5 = 11 6
Operadores Condicionais - Substituem com vantagens o loop: "Se expresso1
verdadeira Entao expresso2 Seno expresso3". Sua sintaxe :
exp1 ? exp2 : exp3
Ex:
Expresso VaIor
5? 1 : 2 1
i? i+j : k+j valor de i+j, se i no zero e k+j, caso
contrrio
(m>7)? 3:4 3, se m maior que 7 e 4, caso contrrio
(a>b)? a: b o maior entre a e b
(a>b)? ((a>c)? a:c): ((b>c)? b:c)) o maior entre a, b e c
ExempIos:
/*************************************************/
/**** E/EMPLO .C Pro$rama que m"stura t"#os "nt e c*ar **/
/************************************************/
'"nc(ude )std"o+*,
o"d ma"n4o"d6
8 c*ar c 9 2a27
c*ar ans7
#r"nt%4=O a(or de cIL 9 Dc=5 c I L67
ans 9 c D L7
#r"nt%4 2EnEnO a(or de ans 9 DdEn=5 ans67
F
/**************************************************/
/*** E/EMPLO 0C Pro$rama so-re o o#erador ar"tmYt"co D */
/**************************************************/
'"nc(ude )std"o+*,
o"d ma"n4o"d6
8 #r"nt%4 =En.L resto L 9 Dd=5 .L D L67
#r"nt%4=EnX.L resto L 9 Dd=5 X.L D L67
#r"nt%4=En.L resto XL 9 Dd=5 .L D XL67
#r"nt%4=EnX.L resto XL 9 Dd=5 X.L D XL67
F
/****************************************************/
/**** E/EMPLO LC Pro$rama #ara demonstrar o#eradores ****/
/**** re(ac"ona"s X NZmeros #r"mos ****/
/****************************************************/
'"nc(ude )std"o+*,
'"nc(ude )mat*+*,
o"d $eraR#r"mos4"nt ("m"te67
o"d ma"n4o"d6
8 "nt ma:"mo7
#r"nt%4=En Gerar numeros #r"mos ate N=67
scan%4 =Dd=5 <ma:"mo67
$eraR#r"mos 4ma:"mo67
#r"nt%4=En=67
F
o"d $eraR#r"mos 4"nt ("m"te6
8 "nt d""sor7
"nt cand"dato7
"nt r9.7
"% 4("m"te ,9U6
8 "% 4("m"te/0 99 16 /* O ("m"te su#er"or Y #ar */
("m"teXX7
%or4cand"dato 9 L7 cand"dato )9 ("m"te7 cand"dato I906
8 d""sor 9 L7
[*"(e 4d""sor )9 sqrt4cand"dato6 << 4r9cand"dato D d""sor6>9 16
d""sor I907
"% 4r >916
#r"nt%4=DVd=5 cand"dato67 /* numeros #r"mos */
F
F
F
/*****************************************************/
/****** E/EMPLO PC Pro$rama #ara e:"-"r o #adrao de -"ts de um */
/***** "nte"ro sem s"na( */
/****************************************************/
'"nc(ude )std"o+*,
o"d mostraR-"ts4 uns"$ned es#ec"men67
o"d ma"n4o"d6
8 uns"$ned a(or7
mostraR-"ts 4167
mostraR-"ts 4K67
mostraR-"ts 4.L67
mostraR-"ts 4..U67
mostraR-"ts 4.L067
#r"nt%4=EnEn Entre um numeroC =67
scan%4=EDu=5 <a(or67
"%4a(or ,9 16
#r"nt%4=En=67
mostraR-"ts4a(or67
F
o"d mostraR-"ts4uns"$ned es#ec"men6
8 const "nt #osRma: 9 .K7
"nt #os"caoR-"t7
#r"nt%4=EnE- #adrao de -"ts #ara DdEn=5 es#ec"men67
%or 4#os"caoR-"t 9 #osRma:7 #os"caoR-"t ,917 #os"caoR-"tXX6
#r"nt%4=Dd=5 es#ec"men ,, #os"caoR-"t < .67
F
5 - CONVERSES DE TIPOS
Apesar do tipo de cada varivel e constante ser definido no incio das funes,
eventualmente uma varivel ou constante precisar ser convertida para outro tipo, no meio do
programa.
Uma converso pode ocorrer porque definimos um operando como sendo de um tipo e
depois precisamos compar-lo ou realizar alguma operao aritmtica com este e outro
operando de outro tipo. Ou ento porque o tipo do operando no foi suficiente para armazen-
lo durante todo o correr do programa. O fato que converses de tipos de variveis e
constantes acontecem e podem ser:
Converso Automtica - Ocorre quando tipos diferentes aparecem numa mesma
expresso. A regra geral converter o tipo "menor" para o tipo "maior".
Ex:
" "nt :9K7
%(oat ; 9 0+P7
+++ soma 9 : I ;7 /* Nesta linha o inteiro x convertido para o valor real 5.0 */ "

Converso Forada - Tambm conhecida como converso "cast". Ocorre quando um
tipo especfico for necessrio e o operando no foi definido como tal. A sintaxe :
(tipo) expresso
onde tipo o tipo para o qual ser convertida o operando e expresso uma expresso
que contm a varivel ou constante a ser convertida.
Ex:
" %(oat r 9 L+K7
"nt "7
++++ " 9 4"nt6 r7 /* Nesta linha o valor 3 (truncamento do real r) foi atribudo a i
*/"
Converses de tipos so perigosas, pois alm de poderem gerar um cdigo no-porttil
(pois o tamanho dos tipos varia de mquina para mquina), podem criar problemas de
armazenamento dos operandos. Por exemplo, quando um nmero real muito grande, cuja
representao da parte inteira exceda 16 bits (por exemplo 3.24e14), for convertido para
inteiro, o resultado ser imprevisvel, pois no se pode determinar o que ser feito com a parte
inteira que no couber nos 16 bits de um int.
As regras para converses automticas so:
Tipo Char e Short - So convertidos automaticamente para Int. Utiliza-se o cdigo
ASC do caractere. Se o caractere contm o bit MSB em 1, o inteiro resultante poder ser
negativo, ou no, dependendo da mquina. Se o caractere for unsigned, o inteiro ser
positivo e os bits de maior ordem sero preenchidos com zeros.
Tipo FIoat - convertido para DoubIe.
Converso de Operandos Aritmticos - o tipo "maior", dentre os tipos da expresso ser
o do resultado. A regra : double > long > unsigned > int.
Converso de Operandos de Atribuio - o lado direito ser convertido para o tipo do
lado esquerdo. A regra :
Operando esquerda (expresso) Operando direita Converso
Double Float com arredondamento
Float nt trunca parte frac., se o
nmero no
couber em
int:resultado indeterm.
Long nt elimina os bits MSB
nt Char elimina os bits MSB
ExempIos:
Exemplo 1:
" c*ar c*7
"nt "7
%(oat %7
dou-(e d7
resu(t 9 4 c* / " 6 I 4 % * d6 X 4 % I "67
"nt dou-(e dou-(e dou-(e
"nt dou-(e dou-(e
dou-(e
dou-(e
dou-(e =
Exemplo 2:
" #"nc(ude )std"o+*,
o"d ma"n46
8 "nt "7
%or 4" 9 .7 " )9 .117 II"6
#r"nt%4=Dd/L YC D%=5 "5 4%(oat6 "/L67
F
"
Exemplo 3:
A expresso: 4%(oat6 :/0 , converte x e, por consequncia, o 2 para float
J a expresso: 4%(oat6 4:/06 , converte o resultado inteiro de x/2 para float
6 - PRECEDNCIA
Os operadores obedecem uma certa ordem de precedncia. sto : operaes de maior
precedncia so realizadas antes das de menor precedncia. O operador de mais alta
precedncia o abre e fecha-parnteses ("()"), portanto, tudo que estiver entre eles ser
realizado primeiro. Por exemplo:
#r"me"ro *9 se$undo )9 terce"ro
Primeiramente o segundo operando comparado ao terceiro e depois a atribuio ao
primeiro feita, porque o operador "<=" tem uma precedncia maior que o "*=". Esta
expresso equivalente a:
#r"me"ro *9 4se$undo )9 terce"ro 6
Observe que a expresso (segundo <= terceiro) tem valor zero ou um.
No caso da expresso:
#r"me"ro 9 se$undo X9 terce"ro
os operadores "=" e "-=" tm igual precedncia, mas o segundo operando avaliado
antes do primeiro porque os compiladores C costumam avaliar expresses condicionais e de
atribuio da direita para a esquerda.
Existem 15 classes de precedncia, ou seja, todos os operadores pertencentes mesma
classe tm igual precedncia. Neste caso, valem as regras de associatividade, para
determinar-se quais operaes sero realizadas primeiro.
A tabela abaixo mostra as classes de precedncia dos operadores, em ordem
decrescente:
Operador Nome do Operador Preced
ncia
Associatividad
e
( ) Chamada de funo 1 esq. p/ dir.
[ ] Elemento Matriz " "
-> Ponteiro para Membro Estrutura " "
. Membro de Estrutura " "
! Negao Lgica 2 dir. p/ esq.
~ Complemento de um " "
++ ncremento " "
-- Decremento " "
- Menos unrio " "
(tipo) Cast " "
* Ponteiro " "
& Endereo " "
sizeof Tamanho do Objeto " "
* Multiplicao 3 esq. p/ dir.
/ Diviso " "
% Resto da Diviso " "
+ Adio 4 esq. p/ dir.
- Subtrao " "
<< Deslocamento Esquerda 5 esq. p/ dir.
>> Deslocamento Direita " "
< Menor Que 6 esq. p/ dir.
<= Menor ou gual a " "
> Maior Que " "
>= Maior ou gual a " "
== gualdade 7 esq. p/ dir.
!= Desigualdade " "
& AND, Bit a Bit 8 esq. p/ dir.
^ XOR, Bit a Bit 9 esq. p/ dir.
| OR, Bit a Bit 10 esq. p/ dir.
&& AND Lgico 11 esq. p/ dir.
|| OR Lgico 12 esq. p/ dir.
?: Condicional 13 dir. p/ esq.
= Atribuio 14 dir. p/ esq.
op= Atribuio Reduzida " "
, Vrgula 15 esq. p/ dir.
7 - ORDEM DE AVALIAO
A ordem de avaliao de uma expresso indica se a operao ser avaliada da direita
pra esquerda ou o contrrio.
Os operadores "&&", "||", e "," sempre so avaliados da esquerda para a direita. Fora
este caso, a ordem de avaliao depender do compilador.
Ex:
" "nt "9K7
+++ ; 9 4II"6 I 4XX"67 +++=
Neste caso, y poder receber o valor 5+4= 9 ou 6+5 = 11!
8 - COMANDOS DE CONTROLE DE FLUXO
Considera-se comando vlido em C, qualquer expresso vlida, seguida por um ponto-e-
vrgula (;), ou expresso entre chaves ({}).
Ex:
" a = 5; "
Neste captulo, entretanto, trataremos de comandos de controle de fluxo.
Pode-se dividir os comandos de controle de fluxo do C, em trs categorias: instrues
condicionais (if e switch), comandos de controle de loop (whiIe, for e do-whiIe) e instruo
de desvio incondicional (goto).
8.1 - O COMANDO IF
A forma geral da declarao if :
"%4condi)*o_de_teste6
comando
A interpretao : "Se a condio_de_teste for verdadeira (no-zero), executa
comando". Caso contrrio, a execuo transferida para a instruo seguinte ao comando if.
Ex:
" "% 4:99K6 ;9L7 "
Se comando contiver mais de uma instruo, o bloco deve ser colocado entre chaves ( {}
).
8.2 - O COMANDO IF-ELSE
A forma geral da declarao if-eIse :
"%4condi)*o_de_teste6 comando'
e(se comando(
A interpretao : "Se a condio_de_teste for verdadeira (no-zero), executa
comando1, Seno, executa comando2".
Ex:
" "% 4 : ) W6
; 9 .7
e(se
; 9 07 "
Os comandos if e if-eIse podem ser aninhados.
Ex:
" "% 4 " , 06 = "% 4" , 06
"% 4 M 99 L6 diferente de: 8 "%4 M 99 L6
; 9 P7 ; 9 P7
e(se ; 9 K7 = F e(se ; 9 K7 =
No primeiro caso, o else refere-se ao if mais interno e no segundo caso, ao if externo.
Obs:
= "% 4a , -6 c 9 a7
e(se c 9 -7 = equivalente a: = c 9 4 a , - 6 N a C - 7 =
Obs2: Em expresses condio_de_teste no-relacionais deve-se tomar cuidado:
= "% 4" 99 L6 ; 9 K7 = se i for igual a 3, y igual a 5
= "% 4" 9 L6 ; 9 K7 = se i=3 for no zero , y igual a 5 (i=3 TRUE).
Obs3:
" "% 4 " >9 16 ; 9 L7 " equivalente a " "% 4"6 ; 9 L7 "
Exerccio:
Crie um programa de adivinhao, utilizando os comandos if e if-else. O programa pede
um nmero ao usurio, verifica se aquele o nmero mgico e imprime " ** Certo **", caso a
pessoa tenha acertado ou " ** O nmero mgico maior que .... ** " o nmero que a pessoa
digitou, ou ainda " ** O nmero mgico menor que ... ** " o nmero digitado.
ExempIos
/**********************************************************************/
/*** Pro$rama .C E:em#(o de ConersBo Autom!t"ca **/
/**********************************************************************/
'"nc(ude )std"o+*,
o"d ma"n4o"d6
8
c*ar c*7
"nt "7
%(oat %(7
%( 9 " 9 c* 9 2A27 // o caractere 2A2 Y armaJenado
#r"nt%4=c* 9 Dc5 " 9 Dd5 %( 9 D0+0% En=5 c*5 "5 %(67 // como WK 4em "6 e WK+11 4em %(6
c* 9 c* I .7 // conerte c* #ara "nt5 soma . e reconerte
#ara c*ar
" 9 %( I 0 * c*7 // conerte c* #ara "nt5 mu(t"#("ca 05 trans%orma em %(oat5 soma a %( e
//conerte #ara "nt
%( 9 0+1 * c* I "7 // conerte c* em %(oat5 mu(t"#("ca #or 0+15 " Y conert"do em
%(oat e
#r"nt%4=c* 9 Dc5 " 9 Dd5 %( 9 D0+0% En=5 c*5 "5 %(67 //somado a c*5 o resu(tado Y armaJenado em
%(
c* 9 K0.001K+.U7 // o a(or e:cede V -"ts5 #ortanto Y truncado e o
c\d"$o
#r"nt% 4=A$ora c* 9 DcEn=5 c*67 //A3CII Y armaJenado em c*
F
/**********************************************************************/
/*** Pro$rama 0C Demonstrar ConersBo @orAada de Dados 4Cast6 ******/
/**********************************************************************/
'"nc(ude )std"o+*,
o"d ma"n4o"d6
8
"nt a(or.5 a(or07
a(or. 9 .+W I .+U7
a(or0 9 4"nt6 .+W I 4"nt6 .+U7
#r"nt%4=a(or. 9 DdEn=5 a(or.67
#r"nt%4=a(or0 9 DdEn=5 a(or067
F
/**********************************************************************/
/*** Pro$rama LC Demonstrar Estrutura I@ X EL3E ****/
/**********************************************************************/
/* Este #ro$rama (oca("Ja a #ercenta$em de d"as a-a":o $e(ados>> */
'"nc(ude )std"o+*,
'de%"ne E3CALA =ce(s"us=
'de%"ne GELANDO 1
"nt ma"n4o"d6
8
%(oat tem#eratura7
"nt $e(ando 9 17
"nt d"as 917

#r"nt%4=Entre com a re(acao das tem#eratura dos d"as $e(ados+En=67
#r"nt%4=Use esca(a Ds5 e entre s #ara sa"r+En=5 E3CALA67
[*"(e 4scan%4=D%=5 <tem#eratura6 99 .6
8 d"asII7
"%4tem#eratura ) GELANDO6
$e(andoII7
F
"% 4d"as>916
#r"nt%4=Do tota( de Dd d"asC D+.%DD %oram a-a":o de Jero+En=5 d"as5 .11+1*4%(oat6 $e(ando/d"as67
e(se
#r"nt%4=Nao %o" %ornec"do nen*um dado>En=67
return 17
F
8.3 - O COMANDO WHILE
A forma geral da declarao !hile :
[*"(e4 express*o_de_teste6
comando7
A interpretao : "Enquanto expresso_de_teste for verdadeira; execute comando". No
momento em que expresso_de_teste deixa de ser no-zero, a execuo continua na linha de
comando seguinte ao lao while.
Ex:
" "917
+++ [*"(e4" ) .16
8 a 9 - * 07
c*amaR%unABo467
"II7
F =
importante salientar que se a expresso_de_teste no for verdadeira j no primeiro
teste do lao este no ser executado nenhuma vez e que o comando while mais apropriado
para laos onde o nmero de interaes no conhecido de antemo. Por exemplo, como
saber quantas vezes o usurio vai digitar caracteres para um nmero ou uma string de
entrada?
Ex:
= '"nc(ude )std"o+*,
'"nc(ude )con"o+*,
ma"n46
8 "nt cont917
#r"nt%4=D"$"te uma %raseC En=67
[*"(e4$etc*e46>9 .L6 /* O caractere com A3CII "$ua( a .L Y a tec(a enter 4return6 */
contII7
#r"nt%4=EnO numero de caracteres Y Dd=5 cont67 F =
Ex2:
= " 9 17 = " 9 K7
+++ [*"(e 4")K6 equivalente a +++ [*"(e 4"6
"II7 +++ = i--; ..."
8.4 - O COMANDO DO-WHILE
A forma geral da declarao do-!hile :
do
comando7
[*"(e4express*o_de_teste67

A interpretao : "Faa comando enquanto expresso_de_teste for verdadeira".O
comando do-!hile faz quase o mesmo que o !hile, com a diferena que no primeiro, o loop
executado pelo menos uma vez, j que o teste da expresso feito no final da interao. Ou
seja, se expresso_de_teste for falsa j na primeira interao, comando executado uma vez
e em seguida a execuo continua fora do loop, na prxima linha de comando. Caso
expresso_de_teste seja verdadeira, comando ser executado at que esta se torne falsa.
Ex: Uma forma de evitar:
= M 9 P7 = M 9 P7
" 9 W7 fazer do
[*"(e4 " , K6 " 9 MXX7
" 9 MXX7 = [*"(e4" , K67 =
8.5 - O COMANDO FOR
A forma geral da declarao for :
%or4iniciali+a)*o7teste7incremento6
comando7
Em sua forma mais simples, iniciali"ao uma instruo de atribuio (p.e.: i = 0) e
sempre executada uma nica vez antes do lao ser inicializado.
O teste uma instruo condicional que controla o lao. #omando ser executado at
que teste seja falso.
A expresso de incremento (ou decremento) define a maneira como a varivel de
controle do lao ser alterada a cada interao.
Ex:
" %or4 " 9 17 " ) K7 "II6 Para " de 1 atY PC
MII7 = "ncrementa M a cada "nteraABo e "ncrementa "
= %or4" 9 K7 " , 17 "XX6 Para " de K atY 1C
M 9 M * 07 = noo a(or de M Y M * 0 e decrementa "
= %or4776 7 = Loo# eterno
= %or4" 9 17 ") K7 "II6 ] equ"a(ente a =%or 4" 9 17 ") K7 MII5 "II67=
MII7 =

Exerccios
1 - Faa um programa que imprima os nmeros de 1 a 10, utilizando:
a) comando while,
b) comando do-while,
c) comando for.
2 - Faa um programa que imprima os nmeros de 0 a 9, de 2 em 2, utilizando o
comando for.
3 - Faa um programa que imprima o fatorial de um nmero solicitado ao usurio,
utilizando o comando while.
8.6 - O COMANDO CONTINUE
Esta instruo interrompe a execuo do corpo de um comando e inicia diretamente um
novo ciclo. A forma geral da declarao continue :
cont"nue7
O comando continue deve ser evitado em programao estruturada, pois pode causar
dificuldades de leitura e confuso no programa.
Ex:
= M 9 17 Ao trmino da execuo deste bloco i ser igual a 20
%or 4" 9 17 " ) 017 "II6 e j igual a 4, pois quando i=4, o comando continue
8 "% 4" , L6 obriga a execuo a pular a linha "j++".
cont"nue7
MII7 F =
8.7 - O COMANDO BREAK
Esta instruo interrompe a execuo do corpo de um comando sem iniciar novo ciclo. A
forma geral da declarao break :
-rea?7
O comando break tambm deve ser evitado em programao estruturada, a no ser
quando for utilizado em conjunto com o comando s!itch.
Ex:
" j = 0;
for ( i = 0; i < 20; i++) Na sada, i e j tero o valor 3.
{ if ( j > 2) break;
j++; } "
8.8 - O COMANDO SWITCH
A forma geral da declarao s!itch :
s["tc* 4exp_int6
8 case rot'C
cmd' G
case rot(C
cmd(
+++
de%au(tC
cmdn
F
GX Os comandos cmd1, cmd2, etc e a declarao default so opcionais no bloco.
Este comando testa o valor da expresso inteira exp_int, comparando-a com rot1, rot2,
etc, at encontrar um rtulo que se iguale. Quando encontra, comea a executar de cima para
baixo os comandos cmd1, cmd2, etc, at o final do bloco. Se no encontra, executa o
comando do bloco default, cmdn.
Ex: = s["tc* 4"6
8 case .C M 9 M I K7
case 0C
case LC M 9 M I L7 F =

VaIor de i Comandos executados
1 j = j + 5; e j = j + 3;
2 ou 3 j = j + 3;
qualquer outro nenhum.
Utiliza-se a instruo break para que apenas o comando referente a cada rtulo seja
executado.
Ex: = s["tc* 4 " 6
8 case .C M 9 M I K7
-rea?7
case 0C
case LC M 9 M I L7
-rea?7
de%au(tC M 9 MI .7 F =
VaIor de i Comandos executados
1 j = j + 5;
2 ou 3 j = j + 3;
qualquer outro j = j + 1;
8.9 - O COMANDO GOTO
A forma geral da declarao goto :
$oto rot7
+++
rot C comd7
Este comando altera incondicionalmente o fluxo sequencial do programa. Transfere a
execuo do programa para o comando comd, seguinte ao rtulo rot.
Ex:
" $oto LAG7
+++
LAGC ; 9 L7
Este comando, assim como os comandos break e continue, esto disponveis em C para
fornecer alguma compatibilidade com as linguagens como BASC e FORTRAN. No entanto, a
utilizao destes desaconselhada por no seguirem a filosofia de programao estruturada e
por no serem absolutamente necessrios em C.
Exerccios
/*************************************************************************/
/**** Pro$rama que "m#r"me nZmeros de . a .1 ut"("Jando (aAo [*"(eC
*****/
/************************************************************************/
'"nc(ude )std"o+*,
o"d ma"n4o"d6
8 "nt contador 9 .7
[*"(e 4contador )9 .16
8 #r"nt%4=DdEn=5 contador67
contadorII7
F
F
/*************************************************************************/
/**** Pro$rama que "m#r"me nZmeros de . a .1 ut"("Jando (aAo doX[*"(e
****/
/************************************************************************/
'"nc(ude )std"o+*,
o"d ma"n4o"d6
8 "nt contador 9 .7
do
8 #r"nt%4=DdEn=5 contador67
contadorII7
F
[*"(e 4contador )9 .167
F
/*************************************************************************/
/*** Pro$rama que "m#r"me nZmeros de . a .1 ut"("Jando (aAo %or
*****/
/*************************************************************************/
'"nc(ude )std"o+*,
o"d ma"n4o"d6
8 "nt contador7
%or4 contador 9 .7 contador )9 .17 contadorII6
#r"nt%4=DdEn=5 contador67
F
/*************************************************************************/
/**** Pro$rama que "m#r"me nZmeros de 1 a S5 de 0 em 0
*****/
/************************************************************************/
'"nc(ude )std"o+*,
o"d ma"n4o"d6
8 "nt "7
%or 4 " 9 17 " )9 S7 "I906
#r"nt%4=DdEn=5 "67
F
/*************************************************************************/
/***** Pro$rama que ca(cu(a o %ator"a( de um nZmero
*******/
/************************************************************************/
'"nc(ude )std"o+*,
'"nc(ude )con"o+*,
o"d ma"n4o"d6
8 "nt numero5 M7
c*ar c*7
dou-(e %at9.7
%or4776
8 %at9.7
#r"nt%4=Entre com um nZmero #os"t"oC En=67
scan%4=Dd=5 <numero67
"%4numero99 1 ^^ numero 99 .6
#r"nt%4=O %ator"a( de Dd YC D+1%En=5 numero5 %at67
e(se
8 M 9 numero7
[*"(e4M6
8 %at *9 M7
MXX7
F
#r"nt%4=O %ator"a( de Dd YC D+1%En=5 numero5 %at67
F
F
F
/*************************************************************************/
/*** Pro$rama que $era a ta-uada de 0 a S
******/
/************************************************************************/
'"nc(ude )std"o+*,
o"d ma"n4o"d6
8 "nt "5 M5 ?7
#r"nt%4=En=67
%or 4? 9 17 ? )9 .7 ?II6
8 #r"nt%4=En=67
%or4 " 9 .7 " ) K7 "II6
#r"nt%4=TAGUADA DO DLd =5 "IP*?I.67
#r"nt%4=En=67
%or4 " 9 .7 " )9 S7 "II6
8 %or4 M 9 0 I P *?7 M )9 K I P*?7 MII6
#r"nt%4=DLd : D.d 9 DLdEt=5 M5 "5 M*"67
#r"nt%4=Er=67
F
F
F
/*******************************************************************/
/**** Pro$rama da %e"ra de %rutas ****/
/******************************************************************/
'"nc(ude )std"o+*,
'"nc(ude )con"o+*,
o"d ma"n4o"d6
8 "nt "5 o#cao7
#r"nt%4=En=67
%or4" 9 .7 " )9 KL7 "II6
#r"nt%4=*=67
#r"nt%4=En*****EtEtPROGRAMA DA @EIRA>>EtEt*****En=67
%or4" 9 .7 " )9 KL7 "II6
#r"nt%4=*=67
#r"nt%4=EnEnEtEt Esco(*a sua o#ABoC En=67
#r"nt%4=EnEnEtEt4.6 Ua7 En=67
#r"nt%4=EnEtEt406 MaAa7 En=67
#r"nt%4=EnEtEt4L6 Ganana7 En=67
#r"nt%4=EnEtEt4P6 LaranMa7 En=67
scan%4=Dd=5<o#cao67
s["tc*4o#cao6
8 case .C #r"nt%4=O cac*o de uas custa R_.+11=67
-rea?7
case 0C #r"nt%4=A un"dade de maAas custa R_1+K1=67
-rea?7
case LC #r"nt%4=O ?"(o de -ananas custa R_1+U1=67
-rea?7
case PC #r"nt%4=A duJ"a de (aranMas custa R_1+S1=67
-rea?7
de%au(tC #r"nt%4=Descu(#e5 mas nBo temos esta %ruta>>=67
F
F
Exerccios
1 - Faa um programa-calculadora de 4 funes, ou seja, o usurio entra com dois
nmeros e estes so somados, subtrados, multiplicados ou divididos.
9 -- FUNES
Uma funo uma unidade de cdigo de programa autnoma projetada para cumprir
uma tarefa particular. Funes permitem grandes tarefas de computao em tarefas menores
e permitem s pessoas trabalharem sobre o que outras j fizeram, ao invs de partir do nada.
A linguagem C em si, no possui funes pr-definidas. Todas as funes utilizadas em
C foram projetadas pelos prprios usurios e algumas mais usadas j foram incorporadas s
bibliotecas de alguns compiladores. Um exemplo de funo em C printf(), que realiza sadas
dos programas sem que o usurio precise preocupar-se como isto feito, pois algum j fez
isto e vendeu sua idia aos outros usurios.
A principal razo da existncia de funes impedir que o programador tenha de
escrever o mesmo cdigo repetidas vezes.
As funes em C so utilizadas como fun$es (retornam valores; podem ser chamadas
de dentro de uma expresso e no recebem parmetros) e subrotinas ( no retornam valores;
so chamadas por um comando CALL e recebem parmetros) das outras linguagens. No
entanto, no pode haver aninhamento de uma funo dentro de outras funes. Cada bloco de
um programa em C uma e somente uma funo.
Sintaxe:

tipo nome_da_fun)*o4par,metros formais6
declara)*o de par,metros formais
8 declara)*o de vari-veis
comandos
F
Onde:
tipo - tipo do valor de retorno da funo. Se uma funo no retornar nenhum valor
deve-se usar o tipo "void". Ex: =o"d ma"n46=.
nome_da_fun)*o - nome da funo. Como qualquer identificador em C, o nome no pode
ser uma palavra reservada da linguagem (a no ser no caso da funo main()), pode ser
composto por letras, nmeros e o caractere de sublinhado ("_"), mas deve iniciar com uma
letra.
par,metros formais - parmetros que a funo recebe. Se a funo no receber nenhum
parmetro, em alguns compiladores exige-se a utilizao de "void", em outros, basta a
omisso. Os nomes dos parmetros devem ser separados por vrgulas. Ex: " int sqrt(x, y)".
declara)*o de par,metros formais - neste campo, os parmetros da funo devem ser
declarados. Se for omitida a declarao, os parmetros sero assumidos como inteiros.
Obs: Em alguns compiladores os campos de parmetros formais e declarao dos
mesmos podem ser condensados em um s, da seguinte forma:
tipo nome_da_fun)*o4declara)*o de par,metros formais"6
8 declara)*o de vari-veis
...
em alguns compiladores (como o caso do Turbo C), a declarao das variveis
utilizadas na funo deve, obrigatoriamente, preceder quaisquer comandos da funo. Deve
vir logo depois do caractere de abre-chaves ("{"). Existem outros compiladores que aceitam
esta declarao em qualquer linha da funo, desde que precedendo a utilizao das mesmas.
comandos - Alm dos comandos do corpo da funo, este bloco pode conter o comando
return que finaliza a execuo da funo e retorna o valor para a expresso que a chamou.
Caso no haja "return", este ser assumido quando o compilador encontrar o caractere de
fecha-chaves ("}") e o valor retornado ser indefinido.
Ex:
" somaum 4numentra6
"nt numentra7
8 "nt numsa"7
numsa" 9 numentra I .7
return numsa"7
F "
9.1 - CHAMADA DA FUNO
Vimos at agora, como a sintaxe da execuo do corpo de uma funo chamada em
um expresso. Mas qual a sintaxe da chamada de uma funo? Seja numa expresso, ou
no, a sintaxe :
nome_da_fun)*o4ar.umentos67
Na chamada de funo em C no utiliza-se CALL. Note que o que diferencia a chamada
de uma funo, da declarao da mesma a utilizao do ponto-e-vrgula (";"). Os ar.umentos
so valores passados para a funo. Quando no houver argumentos a serem passados,
deixa-se este espao em branco.
Ex:
" somaum4K6 " Retorna o valor 6
" ma"or 9 ac*aRnumRma"or4P5U505K67 " Retorna o valor 7 para a varivel
maior.
9.2 - PARMETROS E ARGUMENTOS
Argumento o valor passado para uma funo.
Parmetro (Formal) a varivel que recebe valor do argumento.
Ex:
" o"d ma"n4o"d6
8 "nt a5 -7
#r"nt%4= O a(or da mu(t"#("caABo de Dd #or Dd Y DdEn=5 a5 -5 mu(t4a5-667
argumentos
F
mu(t4:5;6 parmetros formais
"nt :5 ;7
8 "nt resu(tado7
resu(tado 9 : * ;7
return resu(tado7
F =

Normalmente, C utiliza passagem de parmetros "por vaIor", para funes. sto , os
argumentos recebem cpias dos valores das variveis na expresso. Temos isto ilustrado no
exemplo acima. Quando a funo mult(), recebe os argumentos a e b, na verdade apenas uma
cpia dos valores de a e b so enviado para a funo mult()% Em resumo, as variveis a e b
no tem seus valores modificados aps terem sido utilizadas como argumentos de uma
funo.
Se deseja-se que a prpria varivel seja passada para a funo que vai modificar seu
valor utilizamos a passagem "por referncia". Neste caso, o argumento recebe o endereo de
memria da varivel e a funo chamada modifica o contedo deste endereo diretamente.
Para passar valores por referncia, utiliza-se os operadores "&" e "*":
& - " o endereo de " - endereo da varivel
* - " no endereo de" - o que est contido no endereo da varivel.
Ex:
" "nt sa"da 9 K7
+++
"ncrementa4<sa"da67
+++
"ncrementa4numentra6 /* numentra contYm o endereAo e nBo o a(or de sa"da */
"nt *numentra7 /* conteZdo do endereAo numentra Y do t"#o "nt */
8 4* numentra6II7 /* "ncrementa o conteZdo de numentra */
return7
F No final da funo incrementa(), saida tem o valor 6
Os argumentos argc e argv de main()
Algumas vezes til passar informaes para um programa ao execut-lo. sto pode ser
feito atravs dos argumentos argc e argv da funo main(), que so argumentos de Iinha de
comando. Um exemplo de argumento de linha de comando muito utilizado o nome do
programa que queremos carregar ao mesmo tempo em que abrimos um determinado software
(editor de textos, por exemplo):
Ex:
CCE, tc nomeR#ro$rama
Com a linha de comando acima, indicamos ao Turbo C que este deve ser carregado
com o programa nome_programa ao mesmo tempo em que aberto.
Em C, o argumento argc indica funo main() o nmero de argumentos na linha de
comando, e um inteiro. O nome do programa contado como um argumento, portanto, argc
ser sempre maior ou igual a 1.
J o argumento argv um ponteiro para uma matriz de ponteiros para caracteres. Ou
seja, cada ponteiro da matriz aponta para um argumento da linha de comando (uma string).
Ex:
/*** Pro$rama nome+c ***/
ma"n4 ar$c5 ar$6
"nt ar$c7
c*ar *ar$`a7
8
"% 4ar$c >9 06
8 #r"nt% 4=oce esqueceu de d"$"tar seu nome>>En=67
e:"t4167
F
#r"nt%4=a(b Ds=5 ar$`.a67
F
O programa acima ilustra a utilidade de argc e argv: se digitarmos, na linha de comando:
CCE, nome @ernanda
O programa "nome.exe" ser executado e ser passado o valor 2 para argc (os
argumentos so o nome do programa e o nome da pessoa) e o programa imprimir o segundo
elemento da matriz de strings: Fernanda!
a(b @ernanda
Vale salientar que argc e argv so os nicos argumentos que podem ser passados para
a funo main() e devem ser declarados como apresentado acima.

9.3 - VALORES DE RETORNO
Quando o tipo de valor de retorno da funo no especificado, por default a funo vai
retornar um valor inteiro.
Quando a funo deve retornar um tipo que no o int, necessrio declarar-se o
mesmo.
Quando a funo no retorna nada, no caso de compiladores C ANS, o tipo deve ser
void.
9.4 - ESCOPO DE VARIVEIS
Um programa em C um conjunto de uma ou mais funes, sendo que uma destas
funes a principal (main()), que ser a primeira a ser executada. Como saber a que funo
pertence determinada varivel, como seu valor muda de funo para funo e em qual(is)
funo(es) ela existe?
Variveis Locais ou Automticas
So todas as variveis declaradas dentro de uma funo. Como s existem enquanto a
funo estiver sendo executada, so criadas quando tal funo chamada e destrudas
quando termina a execuo desta. Parmetros formais so variveis locais.
Somente podem ser referenciadas pela funo onde foram declaradas e seus valores se
perdem entre chamadas da funo.
Ex:
" %unc.46
8 "nt :7
: 9 .17
F O x da func1() e o x da func2() so duas variveis diferentes,
armaze-
%unc046 nadas em posies de memria diferentes, com contedos
diferentes,
8 "nt :7 apesar do mesmo nome.
: 9 X.SS7
F "
Uma varivel local deve ser declarada no incio da funo (antes de qualquer comando),
por motivos de clareza e organizao do cdigo e porque alguns compiladores assim o
exigem. Existem compiladores, no entanto, que permitem que a declarao seja feita em
qualquer ponto do corpo da funo, desde que antes da utilizao da varivel.
Variveis GIobais
So variveis declaradas e/ou definidas fora de qualquer funo do programa. Podem
ser acessadas por qualquer funo do arquivo e seus valores existem durante toda a execuo
do programa. Tambm por motivos de clareza convenciona-se declar-las no incio do
programa, aps os comandos do pr-processador e das declaraes de prottipos de funes.
Ex:
" +++
"nt count7 /* count Y $(o-a( */
o"d ma"n4o"d6
8 count 9 mu(4.15.0L67
+++ F
%unc.46
8 "nt tem#7
tem# 9 count7
+++ F
%unc046
8 "nt count7
count 9 .17 /* esta count Y (oca( */
+++ F "
Variveis externas

Um programa em C pode ser composto por um ou mais arquivos-fonte, compilados
separadamente e posteriormente linkados, gerando um arquivo executvel. Como as vrias
funes do programa estaro distribudas pelos arquivos-fonte, variveis globais de um
arquivo no sero reconhecidas por outro, a menos que estas variveis sejam declaradas
como externas. A varivel externa deve ser definida em somente um dos arquivos-fonte e em
quaisquer outros arquivos deve ser referenciada mediante a declarao com a seguinte
sintaxe:
e:tern tipo_var nome_var7
onde tipo_var o tipo da varivel e nome_var, o nome desta.
Ex:
Arquivo 1 Arquivo 2
= "nt :5 ;7 = e:tern "nt :5 ;7
c*ar c*7 e:tern c*ar c*7
o"d ma"n4o"d6 %unc0L46
8 +++ F 8 : 9 ;/.17
%unc.46 F
8 : 9 .0L7 %unc0P46
+++ F = 8 ; 9 .17 F =
Variveis Estticas
So variveis reconhecidas e permanentes apenas dentro dos arquivos-fonte ou funes
onde foram declaradas. Uma varivel esttica mantm seus valores entre chamadas da
funo o que muito til quando se quer escrever funes generalizadas (sem o uso de
variveis globais) e biblioteca de funes. A sintaxe :
stat"c tipo_var nome_var7
onde tipo_var o tipo da varivel e nome_var, o nome desta.
Ex:
" rand46
8 stat"c "nt semente 9 .7
semente 9 4semente * 0K.ULI .LVPS6DWKKLW7 /* %ormu(a ma$"ca */
return 4semente67
F
+++
ma"n46
8 "nt c7
%or4c9.7 c)9K7 cII6
#r"nt%4=NZmero randbm"coC Dd En=5 rand4667
F
A sada deste programa ser:
Nmero randmico: -26514
Nmero randmico: -4449
Nmero randmico: 20196
Nmero randmico: -20531
Nmero randmico: 3882
Variveis Registradores
Uma varivel declarada com o modificador register indica ao compilador para utilizar
um registrador da CPU, ao invs de alocar memria para a varivel. Variveis armazenadas
em registradores so acessadas muito mais rpido que as armazenadas em memria, o que
aumenta muito a velocidade de processamento. Se o nmero de variveis designadas como
register exceder o nmero disponvel de registradores da mquina, ento o excesso ser
tratado como variveis automticas.
Variveis registradores no podem ser globais e geralmente aplicam-se aos tipos int e
char.
Obs: Existem programadores que costumam colocar variveis contadoras em
registradores, para tornar o processamento o mais rpido possvel.
Ex:
/************************************************/
// Este #ro$rama mostra a d"%erenAa que uma ar"!e( re$"ster
// #ode %aJer na e(oc"dade de e:ecucao de um #ro$rama
/************************************************/
'"nc(ude )std"o+*,
'"nc(ude )t"me+*,
uns"$ned "nt "7 // ar"!e( nBoXre$"ster
uns"$ned "nt de(a;7
o"d ma"n4o"d6
8 re$"ster uns"$ned "nt M7
(on$ t7
t 9 t"me42E1267
%or4de(a; 9 17de(a; ) .17 de(a;II6
%or4" 9 17 ") WP1117 "II67
#r"nt%4=tem#o de (oo# nBo re$"sterC Dd En=5 t"me42E126Xt67
t 9 t"me42E1267
%or4de(a; 9 17 de(a; ) .17 de(a;II6
%or4M917 M) WP1117 MII67
#r"nt%4=tem#o do (oo# re$"sterC Dd En=5 t"me42E126Xt67
F
10. MATRIZES
So grupos (de uma ou mais dimenses) de variveis indexadas, do mesmo tipo.
Matrizes unidimensionais so mais conhecidas por vetores ou "arra&s".
Sintaxe:
tipo nome`tamanhoa 9 8 e(em15 e(em.5 +++ 5 e(emnF 7
onde,
tipo: tipo dos elementos da matriz;
nome: nome da matriz;
tamanho: nmero de elementos da matriz;
9 8 F : termo opcional. Representa a definio de uma matriz, j na declarao. Caso a
matriz seja definida na declarao desnecessrio especificar-se o tamanho desta.
elemx: elemento da matriz de ndice x.
Todas as matrizes e vetores em C iniciam pelo eIemento de ndice 0 (zero). Elementos
no-inicializados recebem o valor 0 (zero) por default.
Os elementos da matriz so referenciados individualmente pela especificao do nome
da matriz, seguido do ndice do elemento entre chaves:
nome`%ndicea
Ex:
Matriz que armazena as notas das 4 provas de um aluno:
" stat"c %(oat notas`Pa 9 8S+K5 K+15 .15 W+VF7
+++
notas`1a 9 S+K7
notas`0a 9 .17
+++ "
ou
" stat"c %(oat notas`Pa7
+++
notas`1a 9 S+K7
+++
notas`La 9 W+V7 "
ou
" stat"c %(oat notas`a 9 8 S+K5 K+15 .15 W+VF7
+++
notas `1a 9 S+K7
+++ "

10.1 - STRINGS
Uma string em C equivale a um vetor de caracteres sempre terminado pelo caractere
NULL ('\0').
Para inicializar-se um vetor de caracteres pode-se faz-lo individualmente, elemento a
elemento, ou no. Mesmo que se esquea de incluir o caractere NULL, este ser acrescentado
string. Alm disto, deve-se sempre lembrar de dimensionar o tamanho da string como o
nmero de caracteres da expresso + 1 (para o caractere NULL).
Exs:
" stat"c c*ar matcar`a 9 =AGCD=7 "
onde:
matcar[0] = 'A';
matcar[1] = 'B';
matcar[2] = 'C';
matcar[3] = 'D';
matcar[4] = '\0';
ou
" stat"c c*ar matcar`Ka 9 8 2A25 2G25 2C25 2D25 2E12F7 "
se:
" stat"c c*ar matcar`.1a 9 =AGCDE=7 "
temos:
matcar[0] = 'A';
matcar[1] = 'B';
...
matcar[4] = 'E';
matcar[5] = '\0';
matcar[6] = '0';
matcar[7] = '0';
matcar[8] = '0';
matcar[9] = '0'
A string nula ("") : { '\0'}.
10.2 - MATRIZES MULTIDIMENSIONAIS
Para representar, por exemplo, a matriz bidimensional "Mat", abaixo:

2 4 6 8
Mat = 1 2 3 4
7 8 9 0
utilizamos a sintaxe:
tipo nome ` n/mero_linhas a `n/mero_colunas a7
ou seja, no primeiro par de colchetes indicamos o nmero de linhas da matriz e no
segundo par, o nmero de colunas. O tamanho da matriz ser:
n/mero_linhas X n/mero_colunas
No caso de matrizes multidimensionais, a sintaxe :
tipo nome ` taman*o. a `taman*o0 a +++ ` taman*ona7
onde tamanhox o nmero de elementos da x-sima dimenso.
Ex:
" "nt mat `La `Pa 9 8 8 05 P5 W5 V F5
8 .5 05 L5 P F5
8 U5 V5 S5 1 F F 7 "
onde:
elemento mat [0] [0] = 2;
elemento mat [2] [3] = 0;
elemento mat [1] [2] = 3;
etc.
10.3 - MATRIZES PASSADAS PARA FUNES
Na linguagem C, o nome de uma matriz equivalente ao endereo do primeiro
eIemento da matriz! sto significa que quando queremos passar uma matriz como argumento
("por referncia") a uma funo, basta utilizar o nome da matriz, sem os colchetes e ndices.
Se apenas um elemento da matriz deve ser modificado, ento utiliza-se seus ndices em
colchetes.
Ex:
"/********************************************/
/*** Pro$rama que conerte uma str"n$ #ara ma"Zscu(a ***/
/********************************************/
'"nc(ude)ct;#e+*,
'"nc(ude )std"o+*,
o"d "m#r"meRma"us4c*ar`V1a67
o"d ma"n4o"d6
8 c*ar s`V1a7
$ets4s67
"m#r"meRma"us4s67
F
o"d "m#r"meRma"us4str"n$6
c*ar str"n$`a7
8 re$"ster "nt t7
%or4t917str"n$`ta7 tII6
8 str"n$`ta 9 tou##er4str"n$`ta67
#r"nt%4=Dc=5 str"n$`ta67
F
F =
" /************************************/
/*** MATRIc DO dOGO DA &ELTA ***/
/*************************************/
'"nc(ude )std"o+*,
o"d #e$aRmoRMo$ador4o"d67
o"d #e$aRmoRcom#utador4o"d67
o"d e:"-"rRmatr"J4o"d67
"nt c*ec?4o"d67
c*ar matr"J`La`La 9 8 2 25 2 25 2 25
2 25 2 25 2 25
2 25 2 25 2 2F7
o"d ma"n4o"d6
8 c*ar %e"to7
#r"nt%4= ** Este e2 o Mo$o da e(*a>> ***En=67
#r"nt%4= &oce a" Mo$ar contra o com#utador En=67
%e"to 9 2 2 7
do
8 e:"-"rRmatr"J467
#e$aRmoRMo$ador467
%e"to 9 c*ec?467 // er"%"ca quem $an*ou
"%4%e"to >9 2 2 6
-rea?7
#e$aRmoRcom#utador467
%e"to 9 c*ec?467 // er"%"ca quem $an*ou
F[*"(e 4%e"to 99 2 2 67
"% 4%e"to99 2/2 6 #r"nt%4= &oce enceu>*** En=67
e(se #r"nt%4= Eu $an*e">>En=67
e:"-"rRmatr"J467 // mostra #os"coes %"na"s
F
o"d #e$aRmoRMo$ador4o"d6
8 "nt :5 ;7
"nt o? 9 17
#r"nt%4= D"$"te as coordenadas #ara o seu /C = 67
do
8 scan%4= Dd Dd=5 <:5 <;67
:XX7 ;XX7
"% 4matr"J`:a`;a >9 2 26
#r"nt%4= Mo"mento "na("do5 EnTente de noo+En=67
e(se
matr"J`:a`;a 9 2/27
o? 9 .7
F[*"(e4>o?67
F
o"d #e$aRmoRcom#utador4o"d6
8 re$"ster "nt t5 "7
// #rocura (u$ar nao usado a"nda
%or4t917t)L7tII6
%or4"917")L7"II6
"%4matr"J`ta`"a 99 2 26
"%4t*"99S6
8 #r"nt%4= Em#ate>> En=67
e:"t4167 // term"nar o #ro$rama
Fe(se
8matr"J`ta`"a 9 2O27
t9L7 "9L7
F
F
o"d e:"-"rRmatr"J4o"d6
8 "nt t7
%or4t917t)L7tII6
8 #r"nt%4= Dc ^ Dc ^ Dc = 5 matr"J`ta`1a5 matr"J`ta`.a5 matr"J`ta`0a67
"%4t>906 #r"nt%4=EnXXX^XXX^XXXEn=67
F
#r"nt%4=En=67
F
// er"%"ca se e:"ste um $an*ador7 caso contrar"o5 retorna 2 2
"nt c*ec?4o"d6
8 "nt t7
%or4t917t)L7 tII6
"%4matr"J`ta`1a99matr"J`ta`.a << matr"J`ta`.a99matr"J`ta`0a6
return matr"J`ta`1a7
%or4t917t)L7tII6
"%4matr"J`1a`ta99matr"J`.a`ta << matr"J`.a`ta99matr"J`0a`ta6
return matr"J`1a`ta7
"%4matr"J`1a`1a99matr"J`.a`.a << matr"J`.a`.a99matr"J`0a`0a6
return matr"J`1a`1a7
"%4matr"J`1a`0a99matr"J`.a`.a << matr"J`.a`.a99matr"J`0a`1a6
return matr"J`1a`0a7
return 2 27
F
10.4 - ORGANIZAO DE MATRIZES NA MEMRIA
Como j foi dito, o nome de uma matriz contm o endereo do primeiro elemento da
matriz (ou seja, um ponteiro para o primeiro elemento) . Alm disto, os elementos so
armazenados um em seguida do outro, em endereos consecutivos. Ou seja, numa matriz de
caracteres (variveis de 1 byte), se o endereo do primeiro elemento (ndice 0) for 1500, por
exemplo, o endereo do segundo (ndice 1) ser 1501 e assim por diante.
Quando utilizamos o nome de uma matriz como parmetro para uma funo, no
estaremos passando a matriz, mas na verdade apenas o endereo do primeiro elemento
desta, e por consequncia, os outros.
Ex:
" c*ar a(%a`0Ua7
+++
a(%a`1a 9 2A27
a(%a`.a 9 2G27
+++
a(%a`0Ka 9 2c27
+++
escree4a(%a67
+++ "
Note que, apesar de termos reservado 27 bytes para a matriz 'alfa', utilizamos apenas
26. Como trata-se de uma string, o ltimo lugar reservado para o caractere NULL ('\0').
Na memria, a representao desta matriz seria (suponha o endereo de 'alfa' como
sendo 1491 e do primeiro elemento, alfa[0] como sendo 1500):
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499
/ / a(%a / / / / / / /
/ / .K11 / / / / / / /
1500 1501 1502 1503 1504 1505 1506 1507 1508 1509
a(%a`1a a(%a`.a a(%a`0a a(%a`La a(%a`P
a
a(%a`Ka +++ +++ +++ +++
WK WW WU WV WS U1 +++ +++ +++ +++
...
1520 1521 1522 1523 1524 1525 1526 1527 1528 1529
+++ +++ +++ +++ a(%a`0Pa a(%a`0Ka a(%a`0Wa / / /
+++ +++ +++ +++ VS S1 11 / / /
onde o valor 65 o cdigo ASC do caractere 'A' , 90 o cdigo do caractere 'Z' e 00
o cdigo do caractere NULL.
Observao Importante sobre Matrizes:
A linguagem C no verifica se alguma matriz tomar espao de memria que no devia.
Por exemplo:
" "nt notas`L1a7
+++
%or4"917 ")P17 "II6
scan%4=Dd=5 notas I "67 E "
No exemplo acima, declaramos a matriz notas como tendo 30 elementos e depois, por
descuido provavelmente, atribumos 41 valores a esta. Neste caso, 11 espaos de memria
seguintes ao espao ocupado pela matriz, sero apagados e recebero valores de notas. sto
pode danificar dados importantes do programa, ao apagar os valores de variaveis ou
constantes, ou mesmo partes do cdigo. No se pode prever o que aconteceria.
A responsabilidade do programador redobra, portanto, ao lidar com matrizes e vetores e
preciso muita ateno.
Outro erro que poderia ocorrer no exemplo acima, seria pedir a entrada de valores tipo
float (usando "%f", por exemplo) em scanf() para elementos de uma matriz de inteiros. Como o
tipo float maior que o tipo int, cada elemento no caberia no espao reservado para si e
tomaria memria do elemento seguinte.
GX Note que utilizamos aqui a expresso = scan%4=Dd=5 notas I "67 =5 ao invs de
"scan%4=Dd=5 <notas`"a67" ou mesmo "scan%4=Dd=5 notas`"a67" . Porque? Todas estas expresses
so aceitas? Qual a diferena entre elas???
11 - PONTEIROS
Uma das caractersticas mas poderosas oferecidas pela linguagem C o uso de
ponteiros. Mas tambm visto como um do tpicos mais complexos da linguagem. sto ocorre
principalmente porque os conceitos embutidos em ponteiros podem ser novos para muitos
programadores (tendo-se em vista que poucas linguagens utilizam ponteiros), mas tambm
porque os smbolos usados para notao de ponteiros em C no so to claros; por exemplo, o
mesmo smbolo ("*") usado para duas diferentes finalidades.
Mas, o que so ponteiros?
Ponteiros proporcionam um modo de acesso a variveis sem referenci-las diretamente,
atravs do seu endereo. Basicamente, um ponteiro uma representao simblica de um
endereo.
Para declarar uma varivel como ponteiro, a sintaxe :
t"#o * nome_da_vari-vel"
onde tipo o tipo de varivel para qual o ponteiro vai apontar e nome_da_vari'vel o
nome do ponteiro. Ou seja, a varivel ponteiro nome_da_vari'vel vai conter o endereo de
uma outra varivel do tipo tipo. Alm disto, quando quisermos definir o ponteiro, utilizaremos o
operador "&" para atribuir "o endereo de" uma varivel ao ponteiro.
Ex:
" "nt * #ontR" 7 // #ontR" Y uma ar"!e( #onte"ro #ara ar"!e"s int
%(oat * #ontR%7 // #ontR% Y uma ar"!e( #onte"ro #ara ar"!e"s float
"nt "9K7
+++
#ontR" 9 <"7 // coloca o endereo de i em pont_i "
A varivel pont_i agora "aponta para i". Caso precisemos acessar o contedo do
endereo apontado por pont_i, ou seja, o contedo de i, utilizaremos o operador "*", que neste
caso significa "vaIor no endereo de":
" *#ontR" 9 K7 // co(oca o a(or K no endereAo a#ontado #or #ontR" 4%aJ " 9 K6 "
Os ponteiros podem ser inicializados j na declarao, como qualquer varivel:
" "nt *#" 9 <"7 "
Alm disto, os ponteiros podem ser utilizados na maioria das expresses vlidas em C.
Ponteiros so usados em situaes em que a passagem de valores difcil ou
indesejvel. Algumas razes para o uso de ponteiros so:
1 - fornecem maneiras com as quais as funes podem realmente modificar os
argumentos que recebem;
2 - para passar matrizes e strings mais convenientemente de uma funo para
outra;
3 - para manipular matrizes mais facilmente atravs da movimentao de
ponteiros para elas;
4 - para criar estruturas de dados complexas, como listas encadeadas e
rvores binrias, onde uma estrutura de dados deve conter referncias sobre outra;
5 - para comunicar informaes sobre memria, como na funo malloc() que
retorna a localizao de memria livre atravs do uso de ponteiro;
6 - a notao de ponteiros compila muito mais rapidamente, tornando o cdigo
mais eficiente.
Outra coisa muito importante, lembrar que podemos passar vrios valores como
argumentos para uma funo, porm apenas sabemos como retornar um nico valor (atravs
do comando "return"). Mas como fazer para que uma funo altere mais de um valor para a
funo chamadora? Visto que no h mecanismos prprios para isto, devemos contar com o
uso de ponteiros.
Ex:
" '"nc(ude )std"o+*,
o"d ma"n4o"d6
8 "nt :9P5 ;9U7
"nt *#:5 *#;7
#r"nt%4=: YC Dd5 ; YC Dd+ En=5 :5 ;67
#: 9 <:7
#; 9 <;7
#r"nt%4= O endereAo de : YC Dd5 e o de ; YC Dd En=5 #:5 #;67
*#: 9 *#: I .17 // #odeXse usar *#: I9 .17
*#; 9 *#; I .17 // e tam-Ym 4*#; 6 I9.1
#r"nt%4= A$ora : YC Dd e ; YC Dd En=5 :5 ;67
#r"nt%4= +++ e a$ora #: a#onta #araC Dd5 e #; #araC DdEn=5 II#:5 II#;67
#r"nt%4= +++ que contYm os a(oresC Dd5 Dd En=5 *#:5 *#;67
F =

Um operador "&" pode ser aplicado somente a variveis e elementos de matrizes.
Construes tais com "&(x+1)" e "&(3)" so ilegais.
Ponteiros so sempre inicializados com o valor 0 (NULL) que no um endereo vlido,
obrigando portanto, que inicializemos sempre nossos ponteiros antes de utiliz-los.
11.1 - PONTEIROS E MATRIZES
Existe uma correspondncia muito grande entre ponteiros e matrizes. O nome de uma
matriz equivalente ao endereo do primeiro elemento na matriz. Como isto imutvel,
podemos chamar o nome de uma matriz de "ponteiro constante". J um ponteiro comum tem
contedo varivel, pode conter qualquer endereo, sendo porisso chamado de "ponteiro
variveI". Pode-se fazer, portanto:
" "nt "mat`Ka 9 8K5U5L.5.V500F7
"nt *"#7
+++
"# 9 "mat7 // OU "#9<"mat`1a7 "
e teramos, por exemplo, "*(ip+n)" como sendo o vaIor do n-simo eIemento da
matriz imat. sto porque o significado da adio ou subtrao de um inteiro com um ponteiro
adicionar ou subtrair o tamanho de memria do tipo da varivel ( sizeof) para o qual o ponteiro
foi declarado. Em outras palavras, ip no vai ser incrementado de n b&tes de memria, mas de
2 b&tes * n, pois o tipo int ocupa 2 bytes. A disposio na memria, por exemplo, seria:
VariveI Endereo VaIor
imat 567 630
imat[0] 630 5
imat[1] 632 7
imat[2] 634 31
imat[3] 636 18
imat[4] 638 22
ip 802 630
ento:
Expresso VaIor ExpIicao
ip 630 endereo de imat[0]
*ip 5 valor em 630
ip + 1 632 endereo de imat[1]
*(ip+1) 7 valor em 632
*ip + 1 6 valor em 630 mais 1
imat[0] 5
*(imat) 5
imat[1] 7
*(imat+1) 7
Com strings a mesma coisa:
" c*ar *#c9=AGC=7 "
define um ponteiro para a srie de caracteres "ABC" (terminada com "\0"). O ponteiro pc
tem portanto, como valor, o endereo do primeiro elemento da srie, o caractere 'A'.
Pode-se ter, tambm, matrizes de ponteiros:
" stat"c c*ar *c#`La 9 8=/Qc=5 =eR3=5 =HLM=F7 "
por exemplo, declara cp como sendo uma matriz de 3 ponteiros para caracteres e j
inicializa-os, fazendo-os apontar para as trs sequencias de caracteres.
Na memria isto ficaria:
VariveI Endereo VaIor
constante 731 'X'
constante 732 'Y'
constante 733 'Z'
constante 734 '\0'
constante 735 'Q'
constante 736 'R'
constante 737 'S'
constante 738 '\0'
constante 739 'K'
constante 740 'L'
constante 741 'M'
constante 742 '\0'
cp[0] 900 731
cp[1] 902 735
cp[2] 904 739
11.2 - ARITMTICA DE PONTEIROS
Existem poucas operaes que devem ou podem ser efetuadas com o valor dos
ponteiros. Essas operaes so a atribuio de valores a outros ponteiros, soma e subtrao
de inteiros, e comparao de igualdade com outro valor de ponteiro. Ponteiros podem ser
adicionados e subtrados de outros ponteiros, quando estes ponteiros apontam para elementos
diferentes de uma mesma matriz. Por exemplo:
" stat"c "nt "mat`.1a7
"nt *"#9 <"mat`1a7
"nt *"q9 <"mat`Pa7
+++
d"stanc"a 9 "q X "#7 // d"stanc"a9 P e s"$n"%"ca o nZmero de e(ementos "nt entre "q e " p "

Os operadores unrios utilizados em ponteiros so "++" e "--". Supondo um ponteiro para
ponto flutuante p1, com valor atual de 2000. Aps a operao:
" #.II7 "
o contedo de p1 ser 2008 e no 2001. Para cada incremento de p1, este apontar
para o fIoat seguinte, que na maioria dos computadores tem 8 bytes de comprimento.
O mesmo vale para decrscimos:
" #.XX7 "
far com que p1 tenha o valor 1992.
Pode-se comparar ponteiros, atravs dos testes relacionais ">=, <=, < e >". Deve-se, no
entanto, tomar cuidado para no comparar ponteiros que apontam para tipos diferentes de
variveis, pois os resultados sero sem sentido.
No se pode multiplicar, dividir, deslocar os bits, somar ou subtrair fIoats e doubIe aos
ponteiros.
11.3 - PONTEIROS PARA MATRIZES USANDO FUNES
Vamos analisar como uma funo pode usar ponteiros para acessar elementos de uma
matriz cujo endereo passado para a funo como argumento.
Como exemplo, vamos ver a funo adcon1(), que adiciona uma constante a todos os
elementos de uma matriz.
" '"nc(ude )std"o+*,
'de%"ne TAM K
o"d ma"n4o"d6
8 stat"c "nt matr"J`TAMa 9 8 L5W5U5S5..F7
"nt c9.17
"nt M7
adcon.4matr"J5 TAM5 c67
%or4M917 M)TAM7 MII6
#r"nt%4=Dd=5 *4matr"JIM667
// adcon.46
// ad"c"ona constante a cada e(emento da matr"J
adcon.4#tr5num5con6
"nt *#tr7
"nt num7
"nt con7
8 "nt ?7
%or4?917 ?)num7 ?II6
*4#tr6 9 *4#trII6 I con7
F "
A sada ser:
13 15 17 19 21
Na definio da funo adcon1(), a declarao " int *ptr; " equivalente a " int ptr[]; ".
Em outras palavras, a primeira declarao cria um ponteiro varivel, enquanto a segunda, um
ponteiro constante.
Exerccios
1 - "Os ponteiros permitem a passagem de valores por referncia para uma funo".
Demonstre esta propriedade atravs de um programa.

2 - Faa um programa que calcule a mdia aritmtica de um nmero arbitrrio de notas
de provas, usando matrizes.
3 - Repita o programa acima, agora utilizando ponteiros.
ExempIos
/******************************************************************************/
/***** Pro$rama que #rocura um caractere em uma =str"n$=
**************/
/******************************************************************************/
'"nc(ude )std"o+*,
'"nc(ude )con"o+*,
c*ar *#rocstr4c*ar *5 c*ar67
o"d ma"n4o"d6
8
c*ar *#tr7
c*ar c*5 ("n`V.a7
#uts4=D"$"te uma %raseC =67
$ets4("n67
#r"nt%4=D"$"te o caractere a ser #rocuradoC =67
c* 9 $etc*e467
#tr 9 #rocstr4("n5 c*67
#r"nt%4=En A str"n$ comeca no endereAo Du+En=5("n67
"%4#tr6
8 #r"nt%4=Pr"me"ra ocorrenc"a do caractereC Du+En=5 #tr67
#r"nt%4=E a #os"ABoC Dd=5 #trX("n67
F
e(se #r"nt%4=En caractere nao e:"ste+ En=67
$etc*e467
F
c*ar *#rocstr4c*ar *("n*a5c*ar c6
8 [*"(e4*("n*a >9 c << *("n*a >9 2E126
("n*aII7
"%4*("n*a >9 2E126
return4("n*aI .67
e(se
return4167
F
12 - TIPOS DE DADOS COMPLEXOS E ESTRUTURADOS
A linguagem C permite que o usurio "crie" seus prprios tipos complexos de variveis.
Enumeraes, unies, estruturas e definio de tipos sero os tpicos estudados neste
captulo.
12.1 - ENUMERAES
Enumeraes so classes, conjuntos de valores relacionados, criados para melhorar a
legibilidade do cdigo-fonte. Uma varivel de um tipo enumerao somente pode receber
valores que foram declarados para aquele tipo. A sintaxe da declarao de um tipo enum :
enum r#tulo 8enum' enum( ... enumnF7
onde r(tulo uma identificao para esta enumerao e enum1) enum2) %%%) enumn so
os valores possveis para r(tulo.
A sintaxe para a definio de uma varivel como sendo de um tipo r(tulo :
enum r#tulo nome_vari-vel7
onde nome_vari'vel o nome da varivel que vai assumir algum valor dentre os valores
possveis da enumerao r(tulo.
Como qualquer tipo em C, a definio de uma varivel como sendo de um certo tipo
enumerao r(tulo, pode ser feita na prpria declarao do tipo.
enum r#tulo 8enum' enum( ... enumnF nome_vari-vel7
Ex:
enum d"as 8 se$5 ter5 qua5 qu"5 se:5 sa-5 domF7 (1)
+++
enum d"as *oMe5 d"aRsemana7 (2)
ou
enum d"as 8 se$5 ter5 qua5 qu"5 se:5 sa-5 domF *oMe5 d"aRsemana7 (3)
Neste exemplo, definimos uma enumerao dias (1), que pode ter os valores seg) ter)
*ua) *ui) sex) sab) dom. Logo abaixo, (2), declaramos as variveis ho+e e dia_semana, como
sendo do tipo dias. Pode-se fazer os dois passos ao mesmo tempo, como na linha (3) do
exemplo.
A definio da varivel ser feita com a seguinte sintaxe:
nome_vari-vel 9 enumx7
onde enumx qualquer um dos n valores contidos na enumerao.
Ex:
d"aRsemana 9 ter7
Cada valor possvel na enumerao recebe um valor inteiro com o qual pode ser
representado. Caso no seja explicitado, o primeiro valor vai receber o inteiro 0, o segundo, o
inteiro 1 e assim por diante. sto feito para que se possa comparar cada valor da
enumerao. Por exemplo, na enumerao dias:
Identificador VaIor
seg 0
ter 1
quar 2
qui 3
sex 4
sab 5
dom 6
se fizermos:
Expresso VaIor
dia_semana == seg 1 se dia_semana for seg, 0 caso contrrio
hoje > sex 1 se hoje for sab ou dom, 0 caso contrrio
ter > quar 0 (falso)
Alguns compiladores permitem que se altere o inteiro atrbuido a cada valor da
enumerao.
Exs:
enum estaAfes 8 #r"maera 9 .5 erBo 9 05 outono 9 L5 "nerno 9 PF estaABo7
enum %"mRdeRsemana 8 sa- 9 W5 dom 67

No exemplo acima, dom ter automaticamente, o valor 7.
12.2 - ESTRUTURAS
Estrutura um grupo de variveis, cujo formato definido pelo programador e ao
contrrio das matrizes, pode ser composto por tipos diferentes. Em outras linguagens, por
exemplo Pascal, estruturas so conhecidas como registros.
O exemplo tradicional de uma estrutura o registro de uma folha de pagamento: um
funcionrio descrito por um conjunto de atributos tais como nome (uma "string"), o n,mero
do seu departamento (um inteiro), sal'rio (um float) e assim por diante. Como provavelmente
existiro vrios funcionrios, pode-se criar uma matriz desta estrutura como sendo o banco de
dados completo de pagamentos.
Definio
A definio de uma estrutura feita da seguinte forma:
struct r#tulo
8 declara)*o da vari-vel'"
declara)*o da vari-vel("
...
declara)*o da vari-veln"
F7
onde r(tulo uma identificao para esta estrutura e como veremos mais tarde,
opcional. As linhas de comando declarao da vari'vel so declaraes de variveis de tipos
convencionais (int, float, char) que vo compor os campos da estrutura.
DecIarao de uma variveI do tipo estrutura:
A declarao de uma varivel como sendo do tipo estrutura r(tulo feita com a seguinte
sintaxe:
struct r#tulo nome_vari-vel7
O exemplo acima declara a varivel nome_vari'vel como sendo uma estrutura do tipo
r(tulo. A declarao da varivel pode ser feita j na definio do tipo estrutura:
struct r#tulo
8 declara)*o da vari-vel'"
declara)*o da vari-vel("
...
declara)*o da vari-veln"
F nome_vari-vel7
como usualmente feito.
Ex:
struct re$"stro
8 c*ar nome`01a7
"nt de#artamento7
%(oat sa(!r"o7
F
struct re$"stro meuRre$"stro7
+++
struct re$"stro %o(*aR#a$amento`K1a7
Neste exemplo, definimos a estrutura registro que contm dados sobre um determinado
empregado, como nome, nmero de departamento e sal'rio. Declaramos tambm, a varivel
meu_registro como sendo do tipo registro, ou seja, uma estrutura de dados.
Matriz de estruturas:
A seguir, no exemplo acima, declaramos a matriz de estruturas folha_pagamento,
como tendo 50 elementos. sto significa que a folha de pagamento da empresa conter 50
registros, cada qual com o nome, nmero de departamento e salrio do empregado.
A sintaxe para a declarao de uma matriz de estruturas :
struct r#tulo nome_mat_estrut`dimens*oa7
onde nome_mat_estrut o nome da matriz de estruturas e dimenso o nmero de
elementos da matriz.
RtuIo da estrutura:
O r(tulo de um tipo estrutura opcional quando declaramos uma estrutura na prpria
definio do seu tipo. Caso faamos a declarao da varivel em linha de comando
subsequente ou queiramos declarar outras estruturas como sendo daquele tipo deve-se utilizar
o r(tulo.
IniciaIizao da estrutura:
A inicializao de estruturas assemelha-se a inicializao de matrizes:
stat"c struct re$"stro meuRre$"stro 9 8 =@ernanda Marques=5 0.5 .1111F7
ou
stat"c struct re$"stro meuRre$"stro 9 8 8 2@25 2e25 2r25 2n25 2a25 2n25 2d25 2a2 5 2 25 2M25 2a25 2r25 2q25
2u25 2e25 2s25 2E12F5 0.5 .1111F7
ou
stat"c struct re$"stro meuRre$"stro 9 8 2@25 2e25 2r25 2n25 2a25 2n25 2d25 2a2 5 2 25 2M25 2a25 2r25 2q25 2u25
2e25 2s25 2E125 15 15 15 0.5 .1111F7
Na memria, os campos de uma estrutura so armazenados um ao lado do outro.
Portanto, o endereo da estrutura o endereo do primeiro byte do primeiro campo desta.
Os 3 zeros (entre o caractere nulo, '\0', e o valor do segundo campo, 21) na inicializao da
estrutura meu_registro acima, foram justamente acrescentados para completar o espao de
memria alocado na declarao do campo nome (string de 20 bytes).
Acessando membros da estrutura:
Para acessar individualmente cada campo de uma estrutura, utilizamos o operador de
seleo ".". A sintaxe :
estrutura+cam#o 9 a(or7
onde campo cada varivel declarada na estrutura estrutura.
Exs:
meuRre$"stro+nome 9 =@ernanda Marques=7
meuRre$"stro+nome`1a 9 2@27
Atribuies entre estruturas:
Na maioria dos compiladores mais modernos possvel igualar-se duas estruturas do
mesmo tipo da seguinte forma:
estrutura. 9 estrutura07
Note que no foi preciso igualar cada campo individualmente!
Endereo da estrutura:
A sintaxe do endereo de uma estrutura, como um todo, :
<nome_estrutura
Passando e devoIvendo estruturas para funes:
Para passar (por valor) uma estrutura como argumento para uma funo simplesmente
passamos o nome da estrutura:
= +++
struct :;J 8 /* t"#o estrutura :;J5 com do"s cam#osC a 4"nte"ro6 e - 4caractere6
*/
"nt a7
c*ar -7
F estr.5 estrL467 /* dec(araABo da ar"!e( $(o-a( estr. e %unABo estrL46 como t"#o :;J
*/ +++
ma"n46
8 struct :;J estr07 /* dec(araABo da ar"!e( (oca( estr0 como t"#o :;J */
+++
estr.+a 9 0LP7 /* atr"-u"ABo ao cam#o a da ar"!e( estr.
estr.+- 9 2d27 /* atr"-u"ABo ao cam#o - da ar"!e( estr.
estr0 9 estrL4estr.67 /* atr"-u"ABo do a(or retornado #e(a %unABo estrL g ar"!e(
estr0+++
+++ /* +++ 4am-os os cam#os6+ O ar$umento Y uma c\#"a de estr.
F
struct :;J estrL4struct :;J estr6 /* %unABo estrL X rece-e 4estr6 e retorna 4estr(oca(6 ars :;J */
8 struct :;J estr(oca(7 /* dec(araABo da ar"!e( (oca( estr(oca( */
estr(oca(+a 9 estr+a I .7 /* atr"-u"ABo ao cam#o a da ar"!e( estr(oca( */
estr(oca(+- 9 estr+- I 07 /* atr"-u"ABo ao cam#o - da ar"!e( estr(oca( */
+++
return4estr(oca(67 /* retorna a(or atua("Jado de estr(oca( */
F =
O algoritmo acima no trivial e devemos fazer algumas consideraes sobre o
mesmo:
1) Note que o tipo estrutura x&" foi definido como global;
2) A varivel global estr1 e a funo estr3() foram definidas como sendo do tipo
x&";
3) Dentro da funo main() foi declarada uma varivel local, str2, do tipo x&";
4) Os campos a e b da varivel estrutura estr1 recebem valores em main();
5) A varivel estr2 vai receber o valor retornado pela funo estr3(), que por sua
vez recebeu o valor de estr1 como argumento;
6) Na declarao da funo, deve-se colocar "struct x&" estr3(argumentos)-, para
que o programa saiba que o tipo retornado pela funo tambm uma estrutura;
7) Tambm na lista de argumentos, "(struct x&" estr)", deve-se especificar que o
tipo recebido pela funo uma estrutura x&";
8) Dentro da funo estr3() foi declarada uma varivel local, estrlocal, do tipo x&";
9) Os campos a e b da varivel estrutura estrlocal recebem valores (no caso, o
inteiro 235 e o caractere 'L') em estr3();
10) No final, a funo estr3() retorna a estrutura estrlocal para a expresso
chamadora.
Estruturas aninhadas:
Assim como podemos ter matrizes de matrizes (vrias dimenses), podemos
tambm ter estruturas que contm outras estruturas.
Ex:
=
/************************************************************************/
/* Pro$rama #ara -"-("oteca que se#ara ("ros em do"s $ru#osC D"c"onar"o e L"teratura
*/
/* mostra o uso de estruturas an"n*adas
*/
/************************************************************************/
+++
struct ("ro 8
c*ar t"tu(o`L1a7
"nt re$num7
F7
struct $ru#o 8
struct ("ro d"c"onar"o7
struct ("ro ("teratura7
F7
struct $ru#o $ru#o. 9 8 8=AurY("o=5 .LPF5
8=Iracema=5 L0.F F7
ma"n46
8
#r"nt%4=EnD"c"onar"oC En=67
#r"nt%4= T"tu(oC Ds En=5 $ru#o.+d"c"onar"o+t"tu(o67
#r"nt%4= No+ do re$"stroC D1LdEn=5 $ru#o.+d"c"onar"o+re$num67
#r"nt%4= EnL"teraturaC En=67
#r"nt%4= T"tu(oC DsEn=5 $ru#o.+("teratura+t"tu(o67
#r"nt%4= No+ do re$"stroC D1LdEn=5 $ru#o.+("teratura+re$num67
F
Consideraes:
1) Quando uma matriz de vrias dimenses inicializada, usamos chaves dentro
de chaves; do mesmo modo inicializamos estruturas dentro de estruturas;
2) Para acessar um elemento da estrutura que parte de outra estrutura
utilizamos:
$ru#o+d"c"onar"o+t"tu(o
No exemplo acima temos o elemento titulo da estrutura dicionario) que por sua vez
um elemento da estrutura grupo;
Para compor um banco de dados completo, vamos utilizar tudo o que aprendemos at
agora: matrizes de estruturas, passagem de estruturas para funes, estruturas aninhadas,
etc. Seguindo o exemplo da livraria, temos:
"
/*************************************************************************/
/*** PROGRAMA LI&RARIA X Demonstra como cr"ar -ancos de dados em C5 ut"("Jando */
/*** estruturas
*/
/************************************************************************/
'"nc(ude )std("-+*, /* #ara a %unABo ato%465 que trans%orma uma str"n$ em %(oat */
'"nc(ude )std"o+*,
'"nc(ude )con"o+*,
o"d noonome4o"d67
o"d ("statot4o"d67
struct ("sta
8 c*ar t"tu(o`L1a7
c*ar autor`L1a7
"nt re$num7
dou-(e #reco7
F7
struct ("sta ("ro`K1a7 /* dec(ara uma matr"J com K1 ("ros 4estruturas do t"#o ("sta6 */
"nt n917
o"d ma"n 4o"d6
8 c*ar c*7
%or47c* >9 2s276
8 #r"nt%4=EnD"$"teC 2e2 #ara ad"c"onar um ("roEn=67
#r"nt%4=Et2( 2 #ara ("star os ("rosEn=67
#r"nt%4=Et2s2 #ara sa"rCEn=67
c* 9 $etc*e467
#r"nt%4=En=67
s["tc*4c*6
8 case 2e2 C noonome467 -rea?7
case 2(2 C ("statot467 -rea?7
case 2s2 C #r"nt%4=@"m do #ro$rama=67 -rea?7
de%au(t C #uts4=EnD"$"te somente o#Afes !("dasC =67
F
F
F
/***** @UNO NO&ONOME X ad"c"ona um noo ("ro ao arqu"o ***/
o"d noonome4o"d6
8 c*ar numstr`V.a7
#r"nt%4=En Re$"stro Dd+ EnD"$"te t"tu(oC =5 nI.67
$ets 4("ro`na+t"tu(o67
#r"nt%4=D"$"te autorC =67
$ets4("ro`na+autor67
#r"nt%4=D"$"te o nZmero do ("ro 4L d"$"tos6C =67
$ets4numstr67
("ro`na+re$num 9 ato"4numstr67 /* %unABo ato"46 conerte uma str"n$ #ara "nte"ro */
#r"nt%4=D"$"te #reAoC=67
$ets4numstr67
("ro`nIIa+#reco 9 ato%4numstr67
#r"nt%4=EnRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRREn=67
F
/***** @UNO LI3TATOT X ("sta os dados de todos os ("ros *****/
o"d ("statot4o"d6
8
"nt "7
"%4 >n6
#r"nt%4=EnEnL"sta aJ"a>>En=67
e(se
%or4 "917 ")n7 "II6
8 #r"nt%4=En Re$"stro Dd+En=5 "I.67
#r"nt%4=T"tu(oC Ds+ En=5 ("ro`"a+t"tu(o67
#r"nt%4=AutorC Ds+En=5 ("ro`"a+autor67
#r"nt%4=Numero do re$"stroC DLd+=5 ("ro`"a+re$num67
#r"nt%4=PreAoC DP+0%+ EnEn=5 ("ro`"a+#reco67
F
#r"nt%4=EnRRRRRRRRRRRRRRRRRRRRRRREn=67
F
"
Note que para acessarmos cada elemento da matriz de estruturas utilizamos
"livro.2/%titulo", por exemplo. sto mostra que o ndice da matriz atribudo livro e no ao
campo, t0tulo. Se tivssemos a construo "livro.2/%titulo.3/", por exemplo, estaramos
referindo-nos ao quarto elemento (caractere) da string titulo, da terceira estrutura de livros.
Campos de bits
Uma estrutura pode conter campos de bits, em vez de bytes. Estes campos so
normalmente utilizados para acessar valores dependentes da mquina (como registradores,
por exemplo). Campos de bits so uma alternativa utilizao dos operadores bit a bit no
acesso individual de bits dentro de um inteiro.
A sintaxe :
struct8
uns"$ned "nt ar.C numR-"ts.7
uns"$ned "nt ar0C numR-"ts07
+++
uns"$ned "nt arnC numR-"tsn7
F arRestrut7
onde unsigned int o tipo de todos os campos da estrutura; var1) var2)%%%) varn so os
campos da estrutura; num_bits o nmero de bits que cada campo tem e var_estrut a
varivel declarada como estrutura de campos de bits. Um campo no pode ser ultrapassar o
tamanho de um int. Se isto ocorrer, o campo ser alinhado no prximo inteiro.
Um exemplo de uma declarao para campos de bits :
" struct 8
uns"$ned "nt #rontoC .7
uns"$ned "nt des("$adoC 07
uns"$ned "nt outrosC K7
F modem7 "
sto declara modem como sendo uma estrutura de 8 bits com os membros:
Membro Referncia
modem.pronto primeiro bit
modem.desligado prximos dois bits
modem.outros prximos cinco bits
Estas expresses podem ser utilizadas em qualquer lugar onde um inteiro unsigned
possa ser utilizado. modem ter a distribuio de memria mostrada no diagrama abaixo
(assumindo que ints so obrigatoriamente alinhados em bytes pares e que bits, em nossa
mquina-exemplo, so atribudos da esquerda para a direita, j que isto depende do
computador):
0 1 2 3 4 5 6 7 8 ...
pronto
desligado outros
Bit
O operador de endereo (&) no pode ser utilizado com campos.
Ponteiros para Estruturas:
Existem diversos motivos para se usar ponteiros para estruturas. Assim como ponteiros
so mais rpidos e fceis de manipular que matrizes, tambm os ponteiros para estruturas so
melhores que matrizes de estruturas. Vrias representaes de dados que parecem fantsticas
so constitudas de estruturas contendo ponteiros para outras estruturas.
A sintaxe da declarao de um ponteiro para estrutura :
struct r#tulo *nome_ponteiro7
onde rtulo o identificador para o tipo de estrutura e nome_ponteiro o nome do
ponteiro que aponta para tipos estrutura. Na verdade, a sintaxe a mesma de qualquer
declarao de ponteiro.
Ex:
struct ("sta *#tr(7
declara o ponteiro ptrl que pode apontar para qualquer estrutura do tipo lista.
A sintaxe da definio de um ponteiro para estrutura :
nome_ponteiro 9 <estrutura7
onde estrutura uma estrutura qualquer do tipo que o ponteiro nome_ponteiro pode
apontar.
Ex:
#tr( 9 <("ro`1a7
define o contedo de ptrl como sendo o endereo do primeiro elemento da matriz de
estruturas livro.
Sabemos que se conhecemos o nome de uma dada varivel estrutura, podemos acessar
seus campos usando seu nome acompanhado do operador ponto.
Para acessar os campos de uma estrutura atravs do ponteiro no teria sentido utilizar-
se a construo "ptrl%preco", por exemplo, porque ptrl um ponteiro e no um nome de
estrutura.
Temos duas formas de acessar os campos:
1) Utilizando a construo:
4*#tr(6+#reco
que indica "o campo preco da estrutura apontada por ptrl ". sto equivalente a
"livro.1/%preco", se ptrl 22 3 livro.1/ !
ou
2) Utilizando o operador "->" (sinal de "menos" seguido pelo sinal "maior que"):
#tr( X, #reco
Este o mtodo mais comum e tem o mesmo significado da primeira opo: ptrl um
ponteiro para estrutura, mas "ptrl -4 preco" uma varivel double.
12.3 - LISTAS ENCADEADAS
A lista encadeada ou "lista ligada" uma estrutura de dados abstrata que pode ser
criada em C, utilizando-se o mecanismo de ponteiros para estruturas. Uma lista encadeada
assemelha-se a uma corrente em que as estruturas esto penduradas sequencialmente. sto ,
a corrente acessada atravs de um ponteiro para a primeira estrutura, chamado "cabea", e
cada estrutura contm um ponteiro para a sua sucessora. O ponteiro da ltima estrutura tem
valor NULL ("\0"), indicando o fim da lista.
Normalmente uma lista encadeada criada dinamicamente na memria. O diagrama
abaixo ilustra a grosso modo como ficaria uma lista encadeada na memria:
estrA
estrB
estrC
estrD
X X
X
X
X X X
X
X
X X X X X
X X X
X
X X X
X X
...
...
... ...
...
... ... ... ... ... ... ... ...
onde cada flecha um ponteiro apontando para a prxima estrutura da lista. Esta
"flecha" um campo da estrutura, criado como tipo ponteiro, que conter o endereo da
estrutura seguinte.
Abaixo temos o exemplo "Livraria", utilizando-se listas ligadas, ao invs de matrizes de
estruturas:
"
/*************************************************************************/
/*** PROGRAMA LI&RARIA 0 X Demonstra como cr"ar -ancos de dados em C5 ut"("Jando */
/*** estruturas e ("stas ("$adas
*/
/************************************************************************/
'"nc(ude )std("-+*, /* #ara a %unABo ato%465 que trans%orma uma str"n$ em %(oat */
'"nc(ude )std"o+*,
'"nc(ude )con"o+*,
'de%"ne TRUE .
o"d noonome4o"d67
o"d ("statot4o"d67
struct #rs /* estrutura -!s"ca #ara ("stas ("$adas */
8 c*ar t"tu(o`L1a7
c*ar autor`L1a7
"nt re$num7
dou-(e #reco7
struct #rs *#tr#ro:7
F7
struct #rs *#tr#r"m5 *#tratua(5 *#trnoo7 /* dec(ara estruturas t"#o prs #ara montar a ("sta encadeada
*/
o"d ma"n 4o"d6
8 c*ar c*7

#tr#r"m 9 4struct #rs *6 NULL7 /* sem dados a"nda */
%or47c* >9 2s276
8 #r"nt%4=EnD"$"teC 2e2 #ara ad"c"onar um ("roEn=67
#r"nt%4=Et2( 2 #ara ("star os ("rosEn=67
#r"nt%4=Et2s2 #ara sa"rCEn=67
c* 9 $etc*e467
#r"nt%4=En=67
s["tc*4c*6
8 case 2e2 C noonome467 -rea?7
case 2(2 C ("statot467 -rea?7
case 2s2 C #r"nt%4=@"m do #ro$rama=67 -rea?7
de%au(t C #uts4=EnD"$"te somente o#Afes !("dasC =67
F
F
F
/***** @UNO NO&ONOME X ad"c"ona um noo ("ro ao arqu"o ***/
o"d noonome4o"d6
8 c*ar numstr`V.a7
#trnoo 9 4struct #rs *6 ma((oc 4s"Jeo%4struct #rs667 /* noo #onte"ro #/ estrut+ da ("sta
*/
/* resera es#aAo na mem\r"a 4ma((oc6 #ara armaJenar estrutura do taman*o 4s"Jeo%6 de prs */
"% 4#tr#r"m 99 4struct #rs *6 NULL6 /* se o .o+ #onte"ro da ("sta tem conteudo NULL
*/
#tr#r"m 9 #tratua( 9 #trnoo7 /* ("sta a"nda nBo tem dados */
e(se
8 #tratua( 9 #tr#r"m7
[*"(e4#tratua( X, #tr#ro: >9 4struct #rs *6 NULL6 /* #rocura noo "tem */
#tratua( 9 #tratua( X, #tr#ro:7
#tratua( X, #tr#ro: 9 #trnoo7
#tratua( 9 #trnoo7
F
#r"nt%4= D"$"te t"tu(oC =67
$ets 4#tratua( X, t"tu(o67
#r"nt%4= D"$"te autorC =67
$ets4#tratua( X, autor67
#r"nt%4= D"$"te o nZmero do ("ro 4L d"$"tos6C =67
$ets4numstr67
#tratua( X, re$num 9 ato"4numstr67 /* %unABo ato"46 conerte uma str"n$ #ara
"nte"ro */
#r"nt%4= D"$"te #reAoC=67
$ets4numstr67
#tratua( X, #reco 9 ato%4numstr67
#r"nt%4=EnRRRRRRRRRRRRRRRRRRRRRRRRRRRRRRREn=67
#tratua( X, #tr#ro: 9 4struct #rs *6 NULL7 /* Z(t"mo */
F
/***** @UNO LI3TATOT X ("sta os dados de todos os ("ros *****/
o"d ("statot4o"d6
8
"%4#tr#r"m 99 4struct #rs *6 NULL6
8 #r"nt%4=EnEnL"sta aJ"a>>En=67
return7
F
#tratua( 9 #tr#r"m7
do
8 #r"nt%4=T"tu(oC Ds+ En=5 #tratua( X, t"tu(o67
#r"nt%4=AutorC Ds+En=5 #tratua( X, autor67
#r"nt%4=Numero do re$"stroC DLd+=5 #tratua( X, re$num67
#r"nt%4=PreAoC DP+0%+ EnEn=5 #tratua( X, #reco67
#tratua( 9 #tratua( X, #tr#ro:7
F [*"(e4#tratua( >9 4struct #rs *6 NULL67
#r"nt%4=EnRRRRRRRRRRRRRRRRRRRRRRREn=67
F =
A grande vantagem neste ltimo programa "Livraria", que utiliza listas ligadas, que a
memria necessria para armazenar as estruturas alocada medida que a lista aumenta. No
primeiro programa "Livraria", foi necessrio alocar 50 espaos de memria, cada um do
tamanho de uma estrutura, o que representa um enorme disperdcio se entramos com apenas
3 registros, por exemplo, ou que pode ser insuficiente (e tomar espaos indevidos na
memria), se um desavisado resolve entrar com 100 registros!
A funo maIIoc()
Note que no programa acima utilizamos a funo maIIoc(), para alocar memria e
armazenar as estruturas criadas dinamicamente. sto significa que s alocamos memria,
quando for realmente necessrio! A funo malloc() toma como argumento um inteiro sem
sinal que representa a quantidade de bytes de memria requerida. A funo retorna um
ponteiro para o primeiro byte do bloco de memria disponvel que foi alocado. Se no houver
memria suficiente para alocar, malloc() devolver um ponteiro NULL.
A funo sizeof()
O operador unrio sizeof() devolve o tamanho, em bytes, do argumento que recebe.
Utilizamos no programa acima o operador sizeof() para determinar o tamanho da
estrutura prs e poder alocar memria para armazen-la.
12.4 - UNIES
Unies so localizaes de memria usadas para agrupar um nmero de variveis de
tipos diferentes juntas, tal como as estruturas. Porm, enquanto os membros (campos) de uma
estrutura so armazenados em espaos diferentes de memria, numa unio os membros
compartilham da mesma localizao de memria. Ou seja, a unio uma forma de tratamento
de uma rea de memria contendo um tipo de varivel numa ocasio e um outro tipo de
varivel noutra ocasio.
A sintaxe de definio e a de uso de uma unio a mesma que a de uma estrutura:
un"on r#tulo
8 declara)*o'7
declara)*o(7
...
declara)*on7
F var_uni*o7
onde r(tulo uma identificao para a unio e declaraox uma declarao de
varivel, um membro da unio. A varivel var_unio declarada, na sintaxe acima, como
sendo uma unio do tipo r(tulo. O tamanho de uma unio ser o tamanho do maior de seus
membros.
Ex:
" un"on demo
8 c*ar "n"c"a(7
"nt "dade7
%(oat sa(ar"o7
F
+++
un"on demo #essoa(7 =
declara uma varivel de nome pessoal do tipo union demo e para esta varivel foram
reservados 4 bytes de memria tendo em vista que o maior de seus membros do tipo float.
Para acessar um membro da unio, utilizamos o operador ponto (.), como em
estruturas:
arRun"Bo+mem-ro
onde membro qualquer membro declarado na unio var_unio.
Ex:
" #essoa(+"dade "
Uma das razes para se utilizar unies a possibilidade de se usar um nico nome para
dados de tipos diferentes. Por exemplo, se queremos utilizar um mesmo dado em funes
diferentes, que aceitam argumentos de tipos diferentes, declaramos este dado como unio dos
dois tipos passados como argumentos para as funes.
APNDICE A - ROTINAS DE ENTRADA E SADA (I/O)
Geralmente os programas desenvolvidos tm alguma forma de entrada e sada de
dados. Por exemplo, num programa que calcula o fatorial de um nmero fornecido pelo
usurio, o dado de entrada seria este nmero e a sada, o fatorial deste.
As funes de entrada e sada mais utilizadas so, respectivamente, scanf() e printf().
Neste apndice veremos com detalhes a utilizao destas e outras funes de /O importantes
da linguagem C.
Obs: Como cada compilador possui conjuntos de comandos de /0 diferentes, convm
procurar-se no Help de cada um quais as funes mais convenientes para cada caso. No
Turbo C, deve-se teclar no menu "5elp- (ou digital Alt-h), depois no submenu "6ndex- (ou Alt-i)
e por ltimo no boto "7earch- (ou Alt-s). No quadro de texto deve-se digitar scanf, printf, gets,
getchar, etc, que a busca ser feita automaticamente. Quando o tpico procurado for
encontrado, clica-se em "7ho! 8opics " e finalmente "9oto".
A funo printf()
A funo printf(), assim como scanf(), uma funo formatada de /O, no caso, entrada
de dados. A sintaxe :
#r"nt%4=express*o_de_controle=5 lista_de_ar.umentos67
A expresso de controle consiste de dois tipos de itens. O primeiro tipo ser feito de
caracteres que sero impressos na tela. O segundo tipo contm comandos de formatao que
definem a maneira como os argumentos subsequentes so apresentados. Deve existir o
mesmo nmero de comandos de formatao que o nmero de argumentos e os comandos de
formatao e os argumentos so combinados em ordem. Por exemplo:
= #r"nt%4=O"5 Dc Dd Ds En=5 2c25 .15 =a(unos>=67
apresenta na tela:
= O"5 c .1 a(unos> =
Os cdigos de formatao da funo printf() (que valem tambm para scanf()) so:
Cdigo Funo
%c um nico caractere
%d um inteiro decimal
%e um nmero em notao cientfica
%f um nmero em ponto flutuante
%o um inteiro octal
%s uma srie de caracteres (string)
%x um nmero hexadecimal
%u um decimal sem sinal
%l um inteiro longo
Obs1: Os cdigos de controle podero ter modificadores que especifiquem a largura do
campo, o nmero de casas decimais e um indicador de alinhamento esquerda. Um inteiro
colocado entre o sinal "%" e o comando de formatao atua como um especificador de
largura-de-campo m0nimo, o que preenche a sada com brancos ou zeros para assegurar que
tenha ao menos um comprimento mnimo. Caso uma srie ou um nmero sejam maiores que
o mnimo, sero completamente impressos. O preenchimento normal feito com espaos.
Caso queira-se preencher com zeros, basta colocar um zero antes do especificador de largura-
de-campo. Por exemplo, "%05d" vai preencher um nmero com menos de 5 dgitos com 0's.
Obs2: Para especificar o nmero de casas decimais impressas para um nmero em
ponto flutuante, coloque um ponto decimal seguido do nmero de casas decimais que se quer
apresentar. Por exemplo, "%10.4f" apresenta um nmero com pelo menos 10 caracteres de
comprimento, com 4 casas decimais. No caso de strings, "%5.7s" apresenta uma srie com
pelo menos cinco caracteres, mas no excedendo sete (o resto truncado).
Obs3: Como condio normal, toda sada alinhada pela direita do campo. Para forar-
se o alinhamento pela esquerda, coloca-se um sinal de menos ("-") logo aps o "%". Por
exemplo, "%-10.2f" forar um alinhamento esquerda de um nmero em ponto flutuante,
com duas casas decimais e um campo de 10 caracteres de largura.
Exemplos de formatao da sada printf()
DecIarao print() sada
4=DXK+0%=5 .0L+0LP6 ^.0L+0L ^
4=DK+0%=5 .0L+0LP6 ^ .0L+0L^
4=D.1s=5 =*e((o=6 ^ *e((o^
4=DX.1s=5 =*e((o=6 ^*e((o ^
4=DK+Us=5 =.0LPKWUVS=6 ^ .0LPKWU^
4=D1.1d=5 .0LP6 ^111111.0LP^
A funo scanf()
A funo scanf() realiza a operao de formatao nas entradas a partir da entrada
padro (teclado). Existem inmeras funes da famlia scanf() que permitem a leitura de
dados formatados de outras entradas. Por exemplo, fscanf() l os dados em um arquivo, e no
do teclado. A sintaxe :
scan%4 =express*o_de_controle=5 lista_de_ar.umentos6
A expresso_de_controle contm cdigos de formatao, precedidos por um sinal "%",
indicando qual o tipo de dado ser lido. Se aps o sinal "%" colocarmos um sinal "*" indica que
o dado ser lido mas no ser atribudo a varivel nenhuma, neste caso a lista de argumentos
no existe. sto til quando se tem um conjunto de entradas mas somente uma parte da
entrada ser lida pelo programa.
A lista de argumentos contm um endereo de varivel para cada dado lido e formatado
pela expresso_de_controle. Se a varivel simples, e no um nome de matriz, ou um
ponteiro (que j tem endereos associados ao seu prprio contedo), necessrio
acrescentar-se o operador "&" ("endereo de"), para especificarmos o endereo de cada
varivel.
Por exemplo:
scan%4=D%=5 <anos67
indica que ser lido um dado do tipo float e atribudo varivel anos.
Ex2:
scan%4=DLd/D0d=5<"ntRar$.5 <"ntRar$067
Neste caso, se for digitado "345/67" e :nter, int_arg1 receber o valor 345 e int_arg2 o
valor 67.
Obs1: O modificador de m'xima largura de campo pode ser aplicado aos cdigos de
formatao. Por exemplo, se deseja-se ler um mximo de 20 caracteres para a string address,
escreve-se:
=scan%4=D01s=5 address67 =
Obs2: Espaos, tabulaes e caracteres de linha-nova apenas so utilizados como
separadores de campo, quando no se estiver lendo caracteres simples. Neste caso, sero
lidos como caracteres mesmo, e no como separadores. Por exemplo, com uma lista de
entrada "x y":
=scan%4=DcDcDc=5 <a5 <-5 <c67 =
voltar com o caractere "x" em a, um espao em b e o caractere "y" em c.
Obs3: Qualquer outro caractere na expresso de controle (inclusive espaos,
tabulaes e caracteres de linha-nova) ser usado para comparar caracteres da lista de
entrada. Caso sejam iguais, sero descartados. Por exemplo, dada a lista de entrada
"abcdttttttefg":
=scan%4=DsttttttDs=5 <name.5 <name067=
colocar os caracteres "abcd" em name1 e os caracteres "efg" em name2.
Entradas e Sadas No-Formatadas:
As funes getchar() e putchar()
So as funes mais simples de /O em C. A funo getchar() l um caractere da
entrada padro (normalmente o teclado). Quando o programa encontra esta instruo, a
execuo pra e aguarda at o pressionamento de uma tecla, para em seguida devolver seu
valor. Normalmente getchar() ecoa o caractere digitado para o vdeo. A sintaxe :
$etc*ar46
J a funo putchar() escreve um argumento de caractere no vdeo do computador, se o
argumento for parte do conjunto de caracteres que o computador pode apresentar. A sintaxe :
#utc*ar46
O exemplo abaixo ilustra a utilizao das duas funes, lendo caracteres pelo teclado e
imprimindo-os em modo reverso: maisculas em minsculas e vice-versa. O programa pra
ao se digitar um ponto:
" '"nc(ude )std"o+*,
'"nc(ude)ct;#e+*,
o"d ma"n4o"d6
8 c*ar c*7
do
8 c* 9 $etc*ar467
"%4 "s(o[er4c*66 #utc*ar4 tou##er4c*667
e(se #utc*ar4to(o[er4c*667
F [*"(e4c* >9 2+267 /* use #onto #ara #arar */
F "
As funes gets() e puts()
Estas funes permitem que se leia e escreva sries de caracteres (strings).
A funo gets() retorna uma srie terminada por nulo em seu argumento de vetor de
caracteres ("nome_string"). sto significa que quando utiliza-se gets() pode-se digitar caracteres
no teclado at a operao de retorno de carro (Enter). O retorno de carro coloca um terminado
nulo no fim da srie e gets() retorna. A sintaxe :
$ets4nome_strin.6
A funo puts() escreve uma srie no vdeo. Esta funo reconhece os mesmos cdigos
de se*uncias de escape ("\n", "\t", etc) que printf(). Apesar de ser pouco utilizado por no
permitir formatao da sada, converses de formato, nem colocao de nmeros, a funo
puts() muito mais rpida e simples que printf(), quando trata-se de apenas imprimir strings
simples. A sintaxe :
#uts4strin.6
onde string pode ser uma sequencia de caracteres propriamente dita (delimitada por ""),
ou o nome de uma.
Ex:
" '"nc(ude )std"o+*,
'"nc(ude )std("-+*,
'de%"ne "sRd"$"t4:6 44: ,9 212 << : )9 2S26 N .C1 6

num-er4c*ar *s6

8 "nt t7
%or4t 9 17 s`ta7 IIt6
"% 4>"sRd"$"t4s`ta66
return 17
return .7
F
$etnum46
8 c*ar num`V1a5 n7
do
8
$ets4num67
"%4>num-er4num66
8 #uts4=Dee ser numero+En=67
n 9 17
F e(se n9.7
F [*"(e4>n67
return4ato"4num667
F

o"d ma"n4o"d6
8 #uts4=Entre com um numeroEn=67
#r"nt%4=Dd=5$etnum4667
F "
APNDICE B - PROGRAMA-EXEMPLO PARA ROTINAS GRFICAS
/***********************************************************/
// ThINDOh+C X Teste #ara as %uncoes de Mane(a no modo te:to
/***********************************************************/
'"nc(ude )std"o+*,
'"nc(ude )std("-+*,
'"nc(ude )con"o+*,
'"nc(ude )$ra#*"cs+*,
'de%"ne TRLINE 2E:CP2 /* A3CII estend"do da IGM */
'de%"ne &RLINE 2E:GL2
'de%"ne DTRLINE 2E:CD2
'de%"ne D&RLINE 2E:GA2
'de%"ne TLC 2E:DA2 /* caractere #ara canto su#er"or esquerdo5 etc */
'de%"ne TRC 2E:G@2
'de%"ne GLC 2E:C12
'de%"ne GRC 2E:DS2
'de%"ne DTLC 2E:CS2
'de%"ne DTRC 2E:GG2
'de%"ne DGLC 2E:CV2
'de%"ne DGRC 2E:GC2
'de%"ne 3INGLERGORDER .
'de%"ne ThINRGORDER 0
'de%"ne UNDERLINE te:tco(or4QELLOh67 te:t-ac?$round4GLACH67
/* a(ternat"a #ara under("ne46 */
struct te:tR"n%o m;te:t7
// $(o-a(C %ornece o status da Mane(a5atr"-utos5 etc
// as %uncoes a se$u"r mostram como os atr"-utos #ara te:to "n
// ter#retam aque(es usados #ara a se(ecao de cor
o"d ma$enta4o"d6
8 te:tco(or4MAGENTA67
te:t-ac?$round4GLACH67
F
o"d $reen4o"d6
8 te:tco(or4GREEN67
te:t-ac?$round4GLACH67
F
o"d under("ne4o"d6
8 te:tco(or4GLUE67
te:t-ac?$round4GLACH67
F
o"d reerse"deo4o"d6
8 te:tco(or4GLACH67
te:t-ac?$round4hTITE67
F
o"d *"de4o"d6
8 te:tco(or4GLACH67
te:t-ac?$round4GLACH67
F
/** 3omente #ara modo te:to **********/
/* MQRTLINE46 desen*a uma ("n*a *or"Jonta( com o caractere se
(ec"onado de 4start:5 start;6 a 4end:5 start;6+ Retorna com
o numero de caracteres desen*ados+ start: #ode ser ma"or
que end:+ O cursor %"car! na #os"cao "med"atamente se$u"nte
ao u(t"mo caractere e:"-"do+ As coordenadas sao re(at"as
a Mane(a at"a+ */
"nt m;R*("ne4"nt start:5 "nt start;5 "nt end:5 c*ar ("neRc*ar6
8
"nt "7
$oto:;4start:5 start;67
"%4start: 99 end:6 return 4167
"%4start: ) end:6
8 %or 4 " 9 start:7 " )9 end:7 "II6
#utc*4("neRc*ar67
return4" X start:67
F
$oto:;4end:5 start;67
%or4 " 9 end:7 " )9 start:7 "II6
#utc*4("neRc*ar67
return4"X end:67
F
/**** 3omente #ara modo te:to *********/
/* MQR&LINE46 desen*a uma ("n*a ert"ca( de 4start:5 start;6 a
4start:5 end;6+ start; #ode ser ma"or que end;+ ("neRca*r Y o
s"m-o(o se(ec"onado #ara a ("n*a+ As coordenadas sBo re(at"as
a Mane(a at"a */
"nt m;R("ne4"nt start:5 "nt start;5 "nt end;5 c*ar ("neRc*ar6
8
"nt "7
// nao e2 necessar"o o $oto:; aqu"
"%4start; 99 end;6 return 4167
"%4start; ) end;6
8 %or4"9start;7 ")9end;7 "II6
8 $oto:;4start:5 "67
#utc*4("neRc*ar67
F
return 4"Xstart;67
F
%or4 " 9 end;7 " )9 start;7 "II6
8 $oto:;4start:5 "67
#utc*4("neRc*ar67
F
return 4end;X"67
F
/**** 3omente #ara o modo te:to ******/
/** MQRRECT46 desen*a um retan$u(o com coordenadas 4t(:5 t(;6
#ara o canto su#er"or esquerdo e 4-r:5 -r;6 #ara o canto
"n%er"or d"re"to+ st;(e9. %ornece uma -orda s"m#(es5 st;(e 90
%ornece uma -orda du#(a */
"nt m;Rrect4"nt t(:5 "nt t(;5 "nt -r:5 "nt -r;5 "nt st;(e6
8
"nt [5 *7
c*ar *("neRc*5 ("neRc*5 t(c5 trc5 -rc5 -(c7
s["tc*4st;(e6
8 case .C
case 1C
*("neRc* 9 TRLINE7
("neRc* 9 &RLINE7
t(c 9 TLC7 trc 9 TRC7
-rc 9 GRC7 -(c 9 GLC7
-rea?7
case 0C
*("neRc* 9 DTRLINE7
("neRc* 9 D&RLINE7
t(c 9 DTLC7 trc 9 DTRC7
-rc 9 DGRC7 -(c 9 DGLC7
-rea?7
de%au(tC
return4167
F
$oto:;4t(:5 t(;67
#utc*4t(c67
[ 9 m;R*("ne4t(:I.5 t(;5 -r:X.5 *("neRc*67
#utc*4trc67
* 9 m;R("ne4-r:5 t(;I.5 -r;X.5("neRc*67
$oto:;4-r:5 -r;67
#utc*4-rc67
m;R*("ne4-r:X.5-r;5 t(: I.5 *("neRc*67
$oto:;4t(:5 -r;67
#utc*4-(c67
m;R("ne4t(:5 -r;X.5 t(;I.5 ("neRc*67
return4[**67 /* area de("m"tada */
F
o"d ma"n4o"d6
8 "nt $ra#*mode7
"nt $ra#*dr"er7
"nt *"mode5 (omode7
c*ar sae["n.`L11a5 sae["n0`L11a7
d"rect"deo 9 .7
// 9 1 s"$n"%"ca que usa as c*amadas a ROM GIO37 9 . usa o
// acesso d"reto ao "deo
/****** detect$ra#*4<$ra#*dr"er5 <$ra#*mode67*****/
// er"%"ca o *ard[are do "deo XX encontra o modo de ma"or
// reso(ucao
// $etmoderan$e4$ra#*dr"er5 <(omode5 <*"mode67
te:tmode4CPLK167
// aMusta #ara co(or"do &GA em V1:0K X somente te:to X sem
// $ra%"co
$ette:t"n%o4<m;te:t67
// #e$a o modo te:to atua( e a #os"cao da Mane(a
c(rscr467
ma$enta467
m;Rrect4S5U5PS50K53INGLERGORDER67
$reen467
m;Rrect4.15V5PV5.L5ThINRGORDER67
["ndo[4..5S5PU5.067
$oto:;405.67 /* coordenadas re(at"as */
norm"deo467
// reerse"deo467
c#r"nt%4=dr"er 9 Dd5ma"or modo 9 Dd=5 $ra#*dr"er5 $ra#*mode67
$ette:t4.05S5PU5..5 sae["n.67
// sa(a a Mane(a de te:to no arra; sae["n.
norm"deo467
["ndo[4.5.5V150K67
m;Rrect4.15.P5PV5.S5ThINRGORDER67
["ndo[4..5.K5PU5.V67
$oto:;405.67 /* 9.05.K em coordenadas a-so(utas */
// under("ne46 ou MACRO
UNDERLINE
c#r"nt%4=T:tModo 9Dd5 h"n(e%t 9Dd5 h"nto# 9Dd=5m;te:t+currmode5
m;te:t+["n(e%t5 m;te:t+["nto#67
$oto:;405067 /* 9 .05.W em coordenadas a-so(utas */
norm"deo467
c#r"nt%4=Modo -a":o9 Dd5 Modo a(to 9 Dd=5 (omode5 *"mode67
$ette:t4.05.K5PU5.U5 sae["n067
// sa(a uma determ"nada area de te:to no arra; sae["n0
under("ne467
*"$*"deo467
c#uts4=)cr,+=67 $etc*467
// #ausa de tem#o X ate2 #ress"onar uma tec(a
$oto:;4.5.67
c(rscr467 // ("m#a a Mane(a de te:to 0
#utte:t4.05.K5PU5.U5sae["n.67
// troca a Mane(a . #ara a Mane(a 0
["ndo[4.5.5V150K67
["ndo[4..5S5PU5.067
$oto:;4.5.67
c(rscr467
#utte:t4.05S5PU5..5sae["n067
// troca a Mane(a 0 #ara a Mane(a .
c(ose$ra#*467
F
Apndice C - DIRETIVAS DO PR-PROCESSADOR
possvel incluir vrias instrues para o compilador no cdigo-fonte de um programa
em C. Essas instrues so chamadas diretivas do pr-processador e embora no sejam
realmente parte da linguagem C, ampliam o escopo do ambiente de programao C.
Este apndice contm uma lista de diretivas e detalhes sobre as mais utilizadas.
De acordo com o padro ANS, o pr-processador contm as seguintes diretivas:
#define
#else
#elif
#endif
#error
#if
#ifdef
#ifndef
#include
#line
#pragma
#undef
O comando #define
Utiliza-se #define para definir um identificador e um valor (ou string). O compilador
substituir o identificador pelo valor cada vez que aquele for encontrado no arquivo-fonte. O
padro ANS proposto refere-se ao identificador como nome de macro e ao processo de
substituio como substituio de macro% A sintaxe :
'de%"ne identificador valor
Note que este comando no contm ponto e vrgula, encerrando-se portanto, com o final
da linha.
Ex:
'de%"ne &ERDADEIRO .
+++
#r"nt%4=Dd =5 &ERDADEIRO67
O que causar a impresso da constante 1, no comando printf().
Por conveno, escreve-se as macros em letras maisculas, o que ajuda a distingui-las
dentro do cdigo-fonte, normalmente escrito em minsculas.
Ex2:
'de%"ne :;J ="sto Y um teste=
+++
#r"nt%4:;J67
Neste exemplo, ser impressa a string "isto ; um teste", no comando printf()%
Pode-se utilizar a diretiva #define para pequenas funes:
Ex3:
'de%"ne m"n4a5-6 44a ) -6N aC- 6
Ou seja, toda vez que o programa encontrar a macro min(x, y), vai devolver o valor
mnimo entre x e y.
O comando #incIude
Esta diretiva instrui o compilador para incluir um arquivo-fonte ao arquivo que contm o
#include.
A sintaxe :
'"nc(ude =arqu"o= ou '"nc(ude )arqu"o,
onde ar*uivo o arquivo-fonte a ser includo. Se forem utilizadas as aspas, o compilador
procurar o arquivo primeiro no diretrio de trabalho atual, depois nos diretrios especificados
na linha de comando e por ltimo nos diretrios padres. Se forem utilizados os sinais de
"maior e menor que" o compilador procurar o arquivo primeiro nos diretrios especificados na
linha de comando do compilador, depois nos diretrios padres e por ltimo, no diretrio de
trabalho atual.
Esta diretiva muito utilizada para acessar-se as funes j incorporadas aos
compiladores tradicionais (como Turbo C, Borland C) e facilitar a vida do programador que no
precisar recriar funes, como por exemplo, de entrada e sada (printf(), scanf(), puts(),
gets(), etc). Estas funes encontram-se em arquivos que convencionou-se chamar de
"5eader" (porisso a extenso ".h") e o contedo de cada arquivo varia de compilador para
compilador.
Comandos de compiIao condicionaI (#if, #eIse, #eIif, #endif)
Estas diretivas permitem que se compile de forma seletiva partes do cdigo-fonte do
programa.
Na diretiva #if, se a expresso constante que vem depois de #if for verdadeira, ento o
processador compilar o cdigo entre esse comando e a diretiva #endif. A sintaxe :
'"% e:#ressBoRconstante
sequinc"a de comandos
'end"%
A diretiva #else funciona como um "seno" do C diretiva #if e a diretiva #elif, como um
"seno se".
Os comandos #ifdef e #ifndef (ou #if defined #if !defined)
Estas diretivas, que podem tomar os formatos acima, dependendo do compilador,
selecionam o que ser compilado "se algo foi definido" ou "se algo no foi definido".
Ex:
'"% de%"ned4 Rh"ndo[s 6
'error GGI $ra#*"cs not su##orted under h"ndo[s
'end"%
Ou seja, se (_Windows) foi definido, a diretiva #error (que obriga o compilador a parar a
compilao e apresentar a mensagem de erro " BG graphics not supported under Windows")
executada. Caso contrrio, o compilador no entra no bloco #ifdef.
BIBLIOGRAFIA - LINGUAGEM C
MZRAH, VCTORNE V. - 8reinamento em <inguagem # - =(dulos 1 e 2 - , McGraw-
Hill, So Paulo, 1990.
KELLY-BOOTLE, STAN - >ominando o 8urbo # - 2a. ed. - Ed. Cincia Moderna, Rio de
Janeiro , 1989.
PUGH, KENNETH - ?rogramando em <inguagem # - McGraw-Hill, So Paulo, 1990.
SCHLDT, HERBERT - 8urbo #@ 9uia do Asu'rio - 2a. ed. revisada - McGraw-Hill, So
Paulo, 1988.
PAPPAS, CHRS H. & MURRAY, WLLAM H. - 8urbo #BB@ #ompleto e 8otal -
McGraw-Hill, So Paulo, 1991.
SCHLDT, HERBERT - <inguagem #@ 9uia do Asu'rio - McGraw-Hill, So Paulo, 1986.
RTCHE, DENNS M. & KERNGHAN, BRAN W. - #) a linguagem de programao -
Ed. Campus, Rio de Janeiro; Edisa, Porto Alegre; 1986.
WENER, RCHARD S. - 8urbo #) passo a passo - Ed. Campus, Rio de Janeiro, 1991.