Você está na página 1de 65

1Fundamentos da Linguagem C

Neste capitulo sero vistos os fundamentos da linguagem C. O conceito de linguagem de


programao, linguagens de alto e baixo nvel, linguagens genricas e especificas. Ser visto um
pouco do ist!rico da criao da linguagem e a descrio das caractersticas mais importantes da
linguagem C. "inalmente, ser visto o aspecto geral de um c!digo fonte escrito em C.
1.1 - Linguagens de Programao
#m programa de computador um con$unto instru%es &ue representam um algoritmo para a
resoluo de algum problema. 'stas instru%es so escritas atravs de um con$unto de c!digos
(smbolos e palavras). 'ste con$unto de c!digos possui regras de estruturao l!gica e sinttica
pr!pria. *i+emos &ue este con$unto de smbolos e regras formam uma linguagem de programao.
1.1.1 - Exemplos de cdigos.
'xistem muitas linguagens de programao. ,odemos escrever um algoritmo para resoluo de um
problema por intermdio de &ual&uer linguagem. - seguir mostramos alguns exemplos de trecos
de c!digos escritos em algumas linguagens de programao.
Exemplo. treco de um algoritmo escrito em Pseudo-linguagem &ue recebe um n/mero num e escreve
a tabuada de 0 a 01 para este valor.
leia (num);
para n de 1 at 10 passo 1 faa
tab num * n;
imprime tab;
fim-para
Exemplo. treco do mesmo programa escrito em linguagem C.
scanf(&num);
for(n = 1; n <= 10; n++)
{ tab = num * n;
printf(\n %d, tab);
}
Exemplo. treco do mesmo programa escrito em linguagem Basic.
10 input num
20 for n = 1 to 10 step 1
30 let tab = num * n
40 print chr$ (tab)
50 next n
1.1.2 - Linguagens de baixo e alto nvel.
,odemos dividir, genericamente, as linguagens de programao em dois grandes grupos. as linguagens de
baixo nvel e as de alto nvel.
Linguagens de baixo nvel: So linguagens voltadas para a m&uina, isto , so escritas usando as
instru%es do microprocessador do computador. So genericamente camadas de linguagens Assembly.
Vantagens. ,rogramas so executados com maior velocidade de processamento. Os programas ocupam
menos espao na mem!ria.
Desvantagens. 'm geral, programas em -ssembl2 tem pouca portabilidade, isto , um c!digo gerado
para um tipo de processador no serve para outro. C!digos -ssembl2 no so estruturados, tornando a
programao mais difcil.
Linguagens de alto nvel: So linguagens voltadas para o ser umano. 'm geral utili+am sintaxe
estruturada tornando seu c!digo mais legvel. Necessitam de compiladores ou interpretadores para gerar
instru%es do microprocessador. 3nterpretadores fa+em a interpretao de cada instruo do programa
fonte executando4a dentro de um ambiente de programao, Basic e AutoL!P por exemplo.
Compiladores fa+em a traduo de todas as instru%es do programa fonte gerando um programa
executvel. 'stes programas executveis (*.exe) podem ser executados fora dos ambientes de
0
programao, C e Pascal por exemplo. -s linguagens de alto nvel podem se distinguir &uanto a sua
aplicao em genricas como C, Pascal e Basic ou especficas como "o#t#an (clculo matemtico),
$P!! (simulao), L!P (intelig5ncia artificial) ou CLPPE% (banco de dados).
Vantagens: ,or serem compiladas ou interpretadas, tem maior portabilidade podendo ser executados em
varias plataformas com pou&ussimas modifica%es. 'm geral, a programao torna4se mais fcil por
causa do maior ou menor grau de estruturao de suas linguagens.
Desvantagens: 'm geral, as rotinas geradas (em linguagem de ma&uina) so mais genricas e portanto mais
complexas e por isso so mais lentas e ocupam mais mem!ria.
1.2 - Linguagem C
- linguagem C uma linguagem de alto nvel, genrica. "oi desenvolvida por programadores para
programadores tendo como meta caractersticas de flexibilidade e portabilidade. O C uma linguagem &ue
nasceu $untamente com o advento da teoria de linguagem estruturada e do computador pessoal. -ssim
tornou4se rapidamente uma linguagem 6popular7 entre os programadores. O C foi usado para desenvolver o
sistema operacional &'(, e o$e esta sendo usada para desenvolver novas linguagens, entre elas a
linguagem C)) e *ava.
1.2.1 - Ca#acte#sticas do C
'ntre as principais caractersticas do C, podemos citar.
O C uma linguagem de alto nvel com uma sintaxe bastante estruturada e flexvel tornando sua
programao bastante simplificada.
,rogramas em C so compilados, gerando programas executveis.
O C compartila recursos tanto de alto &uanto de baixo nvel, pois permite acesso e programao
direta do microprocessador. Com isto, rotinas cu$a depend5ncia do tempo crtica, podem ser
facilmente implementadas usando instru%es em -ssembl2. ,or esta ra+o o C a linguagem
preferida dos programadores de aplicativos.
O C uma linguagem estruturalmente simples e de grande portabilidade. O compilador C gera
c!digos mais enxutos e velo+es do &ue muitas outras linguagens.
'mbora estruturalmente simples (poucas fun%es intrnsecas) o C no perde funcionalidade pois
permite a incluso de uma farta &uantidade de rotinas do usurio. Os fabricantes de compiladores
fornecem uma ampla variedade de rotinas pr4compiladas em bibliotecas.
1.2.2 - +ist#ico
1,-.: Denis Ritcie desena uma linguagem a partir do BCPL nos laborat!rios da !ell
"elepones, #nc. Cama a linguagem de B.
1,-/: !rian $erningam $unta4se a Ritcie para aprimorar a linguagem. - nova verso cama4se
C. ,elas suas caractersticas de portabilidade e estruturao $ se torna popular entre os
programadores.
01,/.: - linguagem padroni+ada pelo American %ational &tandard #nstitute. surge o A'! C.
81,,.: - !orland #nternational 'o, fabricante de compiladores profissionais escole o C e o Pascal
como linguagens de trabalo para o seu #ntegrated Development (nviroment (-mbiente
3ntegrado de *esenvolvimento). surge o 1u#bo C.
01,,2: O C se torna ponto de concord9ncia entre te!ricos do desenvolvimento da teoria de )b*ect
)riented +rogramming (programao orientada a ob$etos). surge o C)).
1.3 - Estrutura de um programa em C
#m programa em C constitudo de.
um cabealo contendo as di#etivas de compilado# onde se definem o valor de constantes simb!licas,
declarao de variveis, incluso de bibliotecas, declarao de rotinas, etc.
um bloco de instru%es p#incipal e outros blocos de #otinas.
documentao do programa. comentrios.
P#og#ama Exemplo: O ar&uivo e0101.cpp contm um programa para calcular a rai+ &uadrada de um
n/mero real positivo.
/* *******************************************************************
:
Programa: e0101.cpp
Proposito: Calcula a raiz quadrada de um numero real positivo maior
que 1.0 com precisao PREC (0.00001).
******************************************************************* */
#define MAX 100 // numero mximo de iteraes
#define PREC 0.000001 // preciso da raiz
void main(){ // inicia programa principal...
float num // numero do qual se quer saber a raiz quadrada
float raiz; // aproximao para raiz de num
float inf, sup; // intervalo que contem a raiz procurada
do
{ printf("\n\nDigite um numero real positivo: ");
scanf("%f",&num;
}
while(num <= 1.0); // aceita somente positivo maior que 1.0!
inf = 0.0; // inicializa intervalo inicial de busca
sup = num;
i = 0; // inicializa contador
do // faca...
{ i = i + 1; // incrementa contador
raiz = 0.5 * (inf + sup); // faz estimativa de raiz
if(raiz*raiz > num) // se chute foi alto...
{ sup = raiz; // baixa limite superior
}
else // ...seno...
{ inf = raiz; // sobe limite inferior
}
}
while( (sup-inf) > PREC && i < MAX); // enquanto intervalo grande
raiz = 0.5 * (inf + sup); // estima a raiz
printf("Raiz: %f +- %f",raizPREC); // imprime o valor da raiz
} // fim do programa
1.2.1 - Con3unto de ca#acte#es
#m programa fonte em C um texto n4o 5o#matado escrito em um editor de textos usando um o con$unto
padro de caracteres -SC33. - seguir esto os caracteres utili+ados em C.
Ca#acte#es v6lidos:
a b c d e f g h i j k l m n o p q r s t u v w x y z
A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
1 2 3 4 5 6 7 8 9 0
+ - * / \ = | & ! ? # % ( ) { } [ ] _ ` . , : < >
Ca#acte#es n4o v6lidos:
@ $
Os caracteres acima so vlidos apenas em strings. 7e3a se84o 2.1.9.
1.2.2 - Coment6#ios
'm C, comentrios podem ser escritos em &ual&uer lugar do texto para facilitar a interpretao do algoritmo.
,ara &ue o comentrio se$a identificado como tal, ele deve ter um /* antes e um */ depois. Observe &ue no
exemplo e0101.cpp todo o cabealo esta dentro de um comentrio.
Exemplo:
/* esta uma linha de comentrio em C */
O C;; permite &ue comentrios se$am escritos de outra forma. colocando um // em uma lina, o
compilador entender &ue tudo &ue estiver a direita do smbolo um comentrio. Observe no programa
exemplo e0101.cpp as linas de comentrios colocadas a direita dos comandos.
Exemplo:
// este um comentrio valido apenas em C++
<
1.2.2 - :i#etivas de Compila84o
'm C, existem comandos &ue so processados durante a compila84o do programa. 'stes comandos so
genericamente camados de diretivas de compilao. 'stes comandos informam ao compilador do C
basicamente &uais so as constantes simblicas usadas no programa e &uais bibliotecas devem ser anexadas
ao programa executvel. - diretiva #include di+ ao compilador para incluir na compilao do programa
outros ar&uivos. =eralmente estes ar&uivos contem bibliotecas de fun%es ou rotinas do usurio. >oltaremos
a trabalas esta diretiva com mais detale no captulo ?. - diretiva #define di+ ao compilador &uais so
as constantes simb!licas usadas no programa. >eremos sobre esta diretiva no capitulo :.
1.2.9 - :ecla#a84o de va#i6veis
'm C, como na maioria das linguagens, as variveis devem ser declaradas no inicio do programa. 'stas
variveis podem ser de vrios tipos. int (inteiro), float (real de simples preciso) e outras &ue sero
vistas no capitulo :. No exemplo e1010.cpp num, raiz, inf e sup so declaradas como variveis reais,
en&uanto i declarada como uma varivel inteira.
1.2.; - Ent#ada e sada de dados
'm C existem varias maneiras de fa+er a leitura e escrita de informa%es. 'stas opera%es so camadas de
opera%es de entrada e sadia. >eremos no capitulo < algumas fun%es de entrada e sadia de informa%es via
teclado e tela. Outras fun%es de leitura e escrita em ar&uivos, sadia grfica, fun%es de manipulao de
mouse, entrada e sadia de informa%es via portas serial e paralela sero vistas em captulos posteriores. No
exemplo acima printf uma funo de escrita na tela, scanf uma funo de leitura de teclado.
1.2.< - Est#utu#as de Cont#ole
- linguagem C permite uma ampla variedade de estruturas de controle de fluxo de processamento. 'stas
estruturas sero vistas em detales nos captulos @ e ?. *uas estruturas das estruturas bsicas (deciso e
repetio) so muito semelantes as estruturas usadas nas ,seudo4linguagem algortmicas.
Est#utu#a de :ecis4o: ,ermite direcionar o fluxo l!gico para dois blocos distintos de instru%es
conforme uma condio de controle.
pseudo-linguagem
se condio
ento bloco 1;
seno bloco 2;
fim-se
Linguagem C
if (condio)
{ bloco 1; }
else
{ bloco 2; }
Est#utu#a de %epeti84o: ,ermite executar repetidamente um bloco de instru%es ate &ue uma condio
de controle se$a satisfeita.
pseudo-linguagem
enquanto (condio) faa
bloco 1;
bloco n;
fim-enquanto
Linguagem C
while (condio)
{ bloco 1;
bloco n;
}
2Constantes e 7a#i6veis
Neste capitulo veremos como os dados constantes e variveis so manipulados pela linguagem C. O &ue so
constantes inteiras, reais, caracteres e strings. Auais so as regras de atribuio de nomes a variveis e &uais
so os tipos de dados &ue O C pode manipular. >eremos tambm como so declaradas as variveis e as
constantes simb!licas usadas em um programa.
@
2.1 - Constantes
O C possui &uatro tipos bsicos de constantes. intei#as, de ponto 5lutuante, ca#acte#es e strings. Constantes
inteiras e de ponto flutuante representam n/meros de um modo geral. Caracteres e strings representam letras
e agrupamentos de letras (palavras).
2.1.1 - Constantes intei#as
#ma constante inteira um n/mero de valor inteiro. *e uma forma geral, constantes inteiras so se&B5ncias
de dgitos &ue representam n/meros inteiros. N/meros inteiros podem ser escritos no formato decimal (base
01), =exadecimal (base 0C) ou octal (base D).
#ma constante inteira decimal formada por uma se&B5ncia de dgitos decimais. 0, 1, 2, 3, , !, ",
#, $, %. Se a constante tiver dois ou mais dgitos, o primeiro n4o pode ser 0. Na verdade, pode ser 0 mas o
compilador considerar esta constante como octal e no decimal.
Exemplo: - seguir so mostradas alguns valores de constantes inteiras decimais vlidas.
0 3 -45 26338 -7575 1010
Exemplo: -lgumas constantes inteiras decimais invlidas.
1. (ponto)
1,2 (vrgula)
045 (primeiro dgito 0: no constante decimal)
212-22-33 (caracter ilegal: -)
#ma constante inteira =exadecimal formada por uma se&B5ncia de dgitos decimais. 0, 1, 2, 3, ,
!, ", #, $, %, &, ', (, ), *, + (ou a, ,, c, d, e). #ma constante exadecimal deve
comear por 0x. Neste caso, os dgitos exadecimais podem ser min/sculos ou mai/sculos.
Exemplo: - seguir so mostrados algumas constantes inteiras exadecimais v6lidas.
0x0 0x3 0x4f5a 0x2FFE OxABCD 0xAaFf
Exemplo: -lgumas constantes inteiras exadecimais inv6lidas.
0x3. (ponto)
0x1,e (vrgula)
0x ff (espao)
FFEE (no comea com 0x: no constante hexadecimal)
0Xfg34 (caracter ilegal: g)
#ma constante inteira octal formada por uma se&B5ncia de dgitos octais. 0, 1, 2, 3, , !, ", #. -
constante octal deve ter o primeiro digito 0 para &ue o compilador a identifi&ue como tal
Exemplo: - seguir so mostrados algumas constantes octais v6lidas.
00 -03 045 02633 07575 -0101
Exemplo: -lgumas constantes inteiras octais inv6lidas.
010. (ponto)
01,2 (vrgula)
0 4 (espao)
45 (primeiro digito no 0: no constante octal)
01784 (caracter ilegal: 8)
2.1.2 - Constantes de ponto 5lutuante
N/meros #eais (no inteiros) so representados em base 01, por n/meros com um ponto decimal e
(opcionalmente) um expoente. #m n/mero ponto flutuante deve ter um ponto decimal &ue no pode ser
substitudo por uma vrgula. #m n/mero de ponto flutuante pode ser escrito em notao cientfica. Neste
caso o x10 substitudo por e ou *. O n/mero 1.23e representa 1.23 x 10

ou 12300.
Exemplo: N/meros de ponto flutuante vlidos.
0.234 125.65 .93 1.23e-9 -1.e2 10.6e18 -.853E+67
- forma de representao de um n/mero real em C bastante flexvel.
Exemplo: O n/mero <0@ pode ser representado por &ual&uer uma das seguintes formas.
314. 3.14e2 +3.14e+2 31.4e1 .314E+3 314e0
2.1.2 - Constantes ca#acte#es
#ma constante caracter uma letra ou smbolo colocado entre aspas simples.
Exemplo: -baixo esto representados algumas constantes caracteres.
?
'a' 'b' 'X' '&' '{' ' '
'mbora se$am visuali>ados como letras e smbolos as constantes caracteres so arma+enadas internamente
pelo computador como um n/mero intei#o entre 1 e :??. O caracter -&- por exemplo, tem valor "!. Os
valores numricos dos caracteres esto padroni+ados em uma tabela camada de American &tandard 'ode
for #nformation #ntercange "able ou simplesmente tabela A&'##. 7e3a ap?ndice B.
Certos c!digos de controle da tabela -SC33 (como o line feed) ou caracteres especiais (como .) possuem
representao especial no C. 'sta representao cama4se se@A?ncia de escape representada por uma
barra invertida (/) e um caracter. Se&B5ncias de escape so interpretadas como caracteres simples.
-baixo segue uma lista das principais se&uencias de escape usadas no C.
Controle/Caracter Sequencia de escape Valor
ASCII
nulo (null) \0 00
campainha (bell) \a 07
retrocesso (backspace) \b 08
tabulacao horizontal \t 09
nova linha (new line) \n 10
tabulacao vertical \v 11
alimentacao de folha (form feed) \f 12
retorno de carro (carriage return) \r 13
aspas (") \" 34
apostrofo (') \' 39
interrogacao (?) \? 63
barra invertida (\) \\ 92
2.1.9 - Constantes st#ings
#ma constante string consiste de um con$unto de caracteres colocados entre aspas duplas. 'mbora as
instru%es do C usem apenas os caracteres do con$unto padro -SC33, as constantes caracter e string podem
conter caracteres do con$unto estendido -SC33. 0, 1, 2, 3, ...
Exemplo: -baixo seguem algumas constantes strings vlidas.
Oba!
Caxias do Sul
A resposta :
Joo Carlos da Silveira
'a'
isto uma string
2.2 -Identificadores
3dentificadores so os nomes das variveis e fun%es usadas no programa. ,or exemplo raiz e 4&5 so
nomes de variveis utili+adas no programa e0101.cpp.
2.2.1 - %eg#as de sintaxe
Os identificadores devem seguir as seguintes regras de construo.
Os identificadores devem comear por uma letra (a 6 z , & 6 7) ou um underscore ( 8 ).
O resto do identificador deve conter apenas letras, underscores ou dgitos (0 6 %). '4o pode conter
outros caracteres. 'm C, os identificadores podem ter at <: caracteres.
'm C, letras mai/sculas so di5e#entes de letras min/sculas. ,or exemplo. 4&5, max, 4ax so nomes
diferentes para o compilador. 'sta propriedade camada de case sensibility.
Exemplo: os nomes abaixo so vlidos.
abc, y24, VetorPontosMovimentoRobo, nota_1, TAM_MAX.
Exemplo: os nomes abaixo no so vlidos.
3dia, vetor1, pao&leite, iterao.
C
2.2.2 - Palav#as #ese#vadas
'xistem certos nomes &ue n4o podem ser usados como identificadores. So camadas as palavras
reservadas e so de uso restrito da linguagem C (comandos, estruturas, declara%es, etc.). O con$unto de
palavras reservadas usadas em C o seguinte.
asm auto break case cdecl char
class const continue _cs default delete
do double _ds else enum _es
extern _export far _fastcall float for
friend goto huge if inline int
interrupt _loadds long near new operator
pascal private protected public register return
_saveregs _seg short signed sizeof _ss
static struct switch template this typedef
union unsigned virtual void volatile while
Exemplo: No possvel declarar estes con$unto de variveis.
do, re, mi, fa, sol, la, si,
old, new
*o con$unto acima, do e new so palavras reservadas.
2.3 - ipos de dados
'm C, como na maioria das linguagens, os dados so divididos tipos. inteiro, real, caracter, etc. 'sta diviso
se deve basicamente ao n/mero de bytes reservados para cada dado. Cada tipo de dado possui um intervalo
de valores permitidos.
2.2.1 - 1ipos b6sicos
-baixo segue uma lista dos tipos bsicos de dados permitidos em C. Os tipos c9ar e int so inteiros e os
tipos float e dou,le so de ponto flutuante.
Tipo Tamanho Intervalo Uso
char 1 byte -128 a 127 nBme#o muito pe@ueno e ca#acte# A!C
int 2 bytes -32768 a 32767 contado#C cont#ole de la8o
float 4 bytes 3.4e-38 a 3.4e38 #eal Dp#ecis4o de - dgitosE
double 8 bytes 1.7e-308 a 1.7e308 cient5ico Dp#ecis4o de 1; dgitosE
2.2.2 - :ecla#a84o de va#i6veis
,ara &ue se possa usar uma varivel em um programa, F necess6#io fa+er uma declarao de vari,vel antes.
- declarao de variveis simplesmente informa ao processador &uais so os nomes utili+ados para
arma+enar dados variveis e &uais so os tipos usados. *este modo o processador pode alocar (reservar) o
espao necessrio na mem!ria para a manipulao destas variveis. E possvel declarar mais de uma varivel
ao mesmo tempo, basta separ4las por vrgulas (,).
!intaxe: - sintaxe para declarao de variveis a seguinte.
tipo variavel_1 [, variavel_2, ...] ;
Onde tipo o tipo de dado e variavel_1 o nome da varivel a ser declarada. Se ouver mais de uma
varivel, seus nomes so separados por vrgulas.
Exemplo: *eclarao das variveis.
int i;
int x,y,z;
char letra;
float nota_1,nota_2,media;
double num;
No exemplo acima, i, x, : e z foram declaradas variveis inteiras. -ssim elas podem arma+enar valores
inteiros de 4<:FCD at <:FCF. *o mesmo modo letra foi declarada como varivel caracter podendo receber
F
valores de 40:D at 0:F ou caracteres do con$unto padro -SC33. -s variveis nota81, nota82 e media
foram declaradas como ponto flutuante tipo float e num como ponto flutuante tipo double.
- declarao de variveis feita, em geral, dent#o de uma rotina. ,or exemplo, a rotina principal main().
*este modo se di+ &ue est se fa+endo uma declarao de variveis locais. >ariveis locais podem ser
referenciadas apenas dentro da rotina dentro da &ual foi declarada, neste caso a rotina main().
Exemplo: Observe o uso da declarao de variveis no treco de programa abaixo.
void main()
{ float raio, area; // declarao de variveis
raio = 2.5;
rea = 3.14 * raio * raio;
}
No exemplo acima, as variveis ;rea e raio foram declaradas como variveis locais tipo float. -ssim
o processador fa+ a alocao de dois espaos (endereos) de @ b2tes cada para arma+enar as informa%es, um
para cada varivel. Na terceira lina, o processador coloca no endereo alocado para raio o valor 2.!.
*epois, na &uarta lina, o processador coloca o resultado da conta (1%."2!) no endereo de ;rea.
E possvel fa+er a declarao de variveis 5o#a de uma rotina. Neste caso di+4se &ue se fe+ a declarao de
variveis globais. O uso de variveis globais explicado nos captulos seguintes.
2.2.2 - 1ipos modi5icados
-lm dos tipos de dados citados acima existem outros tipos de dados ditos modi5icados. 'm C existem dois
modificadores. o modificador lon< e o modificador unsi<ned. Gipicamente o modificador lon< aumenta
o n/mero de b2tes usados para o registro do n/mero. ,or conse&B5ncia o intervalo de validade do n/mero
fica aumentado significativamente. O modificador unsi<ned, usado somente em inteiros, permite &ue um
bit usado para guardar o sinal do n/mero se$a usado para guardar o valor do n/mero. 'm conse&B5ncia disto
o intervalo do n/mero fica dobrado, porm somente permite o uso de n/meros positivos.
Tipo Tamanho (bytes) Intervalo
unsigned char 1 0 a 255
unsigned int 2 0 a 65.535
long int 4 -2.147.483.648 a 2.147.483.647
unsigned long int 4 0 a 4.294.967.295
long double 10 3,4e-4932 a 1,1e4932
2.2.9 - !t#ings
#ma string um con$unto ordenado de caracteres &ue pode ser arma+enado sob forma de um vetor ou um
ponteiro. 'stas estruturas de dados sero vistas em detale nos capitulo F e D. ,or en&uanto, nos basta saber
como declarar e arma+enar um con$unto caracter em uma varivel.
!intaxe: ,ara declararmos uma varivel para receber um con$unto caracter devemos escrever.
char* var;
Exemplo: No exemplo seguinte a varivel nome foi declarada como con$unto caracter e em seguida
recebe uma constante string.
char* nome;
nome = "Joo Carlos de Oliveira Andrade";
2.2.; - niciali>a84o de va#i6veis.
Auando se fa+ a decla#a84o de uma varivel est se determinando &ue tipo de dado ela vai receber. E
possvel, em C, declarar uma varivel e $ arma+enar nela um valor inicial. Camamos este procedimento de
iniciali>a84o de uma varivel.
!intaxe: - sintaxe para a iniciali+ao de variveis .
tipo var_1 = valor_1 [, var_2 = valor_2, ...] ;
Onde tipo o tipo de dado, var_1 o nome da varivel a ser iniciali+ada e valor_1 o valor inicial da
varivel.
Exemplo: 3niciali+ao de variveis.
int i = 0, j = 100;
float num = 13.5;
D
char* titulo = " Programa Teste ";
No exemplo acima, i e = foram declaradas variveis tipo int. O valor inicial de i 0 e o de = 100. *o
mesmo modo num foi declarada como varivel float com valor inicial de 13.!. Gambm a varivel
titulo foi declarada como um con$unto caracter e recebeu como conte/do inicial a string > ?ro<rama
@este >.
2.2.< - Conve#s4o de tipo DCastingE
-lgumas ve+es &ueremos, momentaneamente, modificar o tipo de dado representado por uma varivel, isto
, &ueremos &ue o dado se$a apresentado em um tipo diferente do &ual a varivel foi inicialmente declarada.
,or exemplo. declaramos uma varivel como int e &ueremos, momentaneamente, &ue seu conte/do se$a
apresentado como float. 'ste procedimento camado de conve#s4o de tipo ou casting (moldagem, em
ingl5s).
!intaxe: - sintaxe da instruo de converso de tipo .
(tipo) varivel
onde tipo o nome do tipo ao &ual &ueremos converter o dado arma+enado em Aari;Ael.
Exemplo: observe a converso de tipo feita no exemplo abaixo.
int num;
float valor = 13.0;
num = (int)valor % 2;
No exemplo acima a varivel Aalor foi declarada inicialmente como sendo do tipo float recebendo o
valor inicial 13.0. Hogo em seguida o conte/do de valor convertido para o tipo int para reali+ar a
operao m!dulo (B) com o inteiro :. -&ui a converso necessria pois a operao m!dulo somente pode
ser feita com inteiros. E importante salientar &ue a converso de tipo feita com o dado arma+enado em uma
varivel mas a va#i6vel continua tendo o seu tipo original. No exemplo acima a varivel Aalor e os dados
nela arma+enados continuam sendo do tipo float ap!s a converso.
>eremos na se84o 2.1 uma explicao mais detalada do uso da converso de tipos.
2.! - Constantes "im#$%icas
Iuitas ve+es identificamos uma constante numrica por um smbolo. ,i J <,0@0?K por exemplo. ,odemos
definir um nome simb!lico para esta constante, isto , podemos definir uma constante simblica &ue
represente valor.
2.9.1 - Constantes de5inidas pelo p#og#amado#
O programador pode definir constantes simb!licas em &ual&uer programa.
!intaxe: - sintaxe da instruo de definio de uma constante simb!lica .
#define nome valor
Onde #define uma diretiva de compilao &ue di+ ao compilador para trocar as ocorr5ncias do texto
nome por valor. Observe &ue n4o =6 ; no final da instruo pois trata4se de um comando para o
compilador e no para o processador. - instruo #define deve ser escrita antes da instruo de
declarao da rotina principal.
Exemplo: a seguir definimos algumas constantes simb!licas.
#define PI 3.14159
#define ON 1
#define OFF 0
#define ENDERECO 0x378
void main(){
...
No exemplo acima, definimos ?C como 3.11!%. 3sto significa &ue todas as ocorr5ncias do texto ?C ser
trocado por 3.11!%. -ssim se escrevemos uma instruo.
rea = PI * raio * raio;
o compilador vai interpretar esta instruo como se fosse escrita assim.
rea = 3.14159 * raio * raio;
,oderamos escrever estas instru%es assim.
float pi = 3.14159;
K
rea = pi * rea * rea;
porm este tipo de instruo tem duas desvantagens. ,rimeiro, reserva @ b2tes de mem!ria
desnecessariamente. Segundo, esta instruo executada mais lentamente pois o processador precisa acessar
a mem!ria para verificar &ual o valor de pi.
Observe tambm &ue no exemplo definimos os nomes simb!licos com letras mai/sculas. 3sto n4o F
necess6#io, podemos perfeitamente definir nomes simb!licos usando letras min/sculas, porm fa+ parte do
$argo dos programadores C usar letras mai/sculas para definir constantes simb!licas.
O uso da diretiva #define no se restringe apenas ao apresentado acima, podemos us4la para definir
mac#o inst#u8Ges. No veremos o uso de macros neste texto, procure mais detales na bibliografia
recomendada.
2.9.2 - Constantes p#F-de5inidas
'm alguns compiladores C, algumas constantes simb!licas $ esto pr4definidas. 'stas constantes em geral
definam alguns valores matemticos (, L:, e, etc.), limites de tipos etc. - seguir segue uma tabela contendo
algumas (existem muitas outras) constantes simb!licas pr4definidas no compilador Gurbo C;; da Morland.
Biblioteca Constante Valor Significado
math.h M_PI 3.14159...
math.h M_PI_2 1.57079... /2
math.h M_PI_4 0,78539... /4
math.h M_1_PI 0,31830... 1/
math.h M_SQRT2 1,41421... 2
conio.h BLACK 0 valor da cor (preto)
conio.h BLUE 1 valor da cor (azul)
conio.h GREEN 2 valor da cor (verde)
conio.h CYAN 3 valor da cor (cyan)
conio.h RED 4 valor da cor (vermelho)
conio.h MAGENTA 5 valor da cor (magenta)
limits.h INT_MAX 32767 limite superior do tipo int
limits.h INT_MIN -32768 limite inferior do tipo int
Cada uma das constantes acima esta definida em uma biblioteca. #ma biblioteca, em C, um ar&uivo pr4
compilado camado ar&uivo eader (cabealo, em ingl5s). 'm cada biblioteca esto agrupadas constantes e
fun%es semelantes (ve$a seo <.F.:). ,or exemplo, constantes e fun%es matemticas esto guardadas na
biblioteca mat9.9 (matematical functions), constantes e fun%es de manipulao teclado e monitor esto
guardadas na biblioteca conio.9 (console input and output). ,ara &ue se possa usar a constante simb!lica
em um programa preciso inclui# a biblioteca na compilao do programa.
!intaxe: - sintaxe de incluso de bibliotecas a seguinte.
#include <nome_bib>
onde nome_bib o nome da biblioteca &ue se dese$a incluir. 'sta instruo deve ser escrita antes do
programa principal.
Exemplo: O programa abaixo usa a constante predefinida IN,3 para calcular a rea de um disco circular.
#include <math.h>
void main()
{ float area, raio = 5.0;
rea = M_PI * raio * raio;
}
2Hpe#ado#esC Exp#essGes e "un8Ges
#m programa tem como caracterstica fundamental a capacidade de processar dados. ,rocessar dados
significa reali+ar opera%es com estes dados. -s opera%es a serem reali+adas com os dados podem ser
determinadas por ope#ado#es ou 5un8Ges. Os operadores podem ser de atribuio, aritmticos, de atribuio
aritmtica, incrementais, relacionais, l!gicos e condicionais.
Exemplo: o smbolo D um operador &ue representa a operao aritmtica de adio. O identificador
sqrt() uma funo &ue representa a operao de extrair a rai+ &uadrada de um n/mero.
01
#ma exp#ess4o um arran$o de operadores e operandos. - cada expresso vlida atribudo um valor
numrico.
Exemplo: D " uma expresso cu$o valor 10. - expresso sqrt(9.0) tem valor 3.0.
3.1 - &perador de 'tri#uio
- operao de atribuio a operao mais simples do C. Consiste de atribuir valor de uma exp#ess4o a uma
va#i6vel.
!intaxe: - sintaxe da operao de atribuio a seguinte.
identificador = expresso;
onde identificador o nome de uma varivel e expresso uma expresso vlida (ou outro
identificador).
Exemplo: - seguir so mostradas algumas atribui%es vlidas.
a = 1;
delta = b * b - 4. * a * c;
i = j;
Observe &ue o smbolo de atribuio = n4o tem o mesmo significado &ue o usual da matemtica &ue
representa a igualdade de valores. 'ste smbolo, em C, representa a atribuio do valor calculado em
expresso a varivel identificador. 'm pseudo4linguagem o operador de atribuio representado
como . Gambm no se pode confundir o operador de atribuio = com o operador relacional de igualdade
== &ue ser visto na seo <.?.0.
Observe4se tambm &ue o operando es&uerdo deve se# um identificador de varivel, isto , n4o pode ser
uma constante ou expresso.
Exemplo: - seguir so mostradas algumas atribui%es invlidas.
1 = a; // constante!
b + 1 = a; // expresso!
2.1.1 - Conve#s4o de tipo.
Se os dois operandos de uma atribuio n4o s4o do mesmo tipo, o valor da expresso ou operador da direita
se#6 conve#tido para o tipo do identificador da es&uerda.
Exemplo: -lgumas atribui%es com converso de tipo.
int i;
float r;
i = 5; // valor de i: 5
r = i ; // valor de r: 5.0
- varivel i foi iniciali+ada com o valor !. -o final da terceira instruo, r recebe o valor !.0.

Nestas convers%es podem ocorrer altera%es dos valores convertidos se o operando da es&uerda for de um
tipo &ue utili+e meno# nume#o de b2tes &ue o operando da direita.
Exemplo: -lgumas atribui%es com converso de tipo e perda de informao.
int i;
float r = 654.321;
i = r; // truncamento!

-p!s a execuo deste treco de programa o valor da varivel i ser "! pois seu valor foi truncado
durante a converso.
,ode4se di+er &ue as convers%es potencialmente perigosas (onde possibilidade de perda de informao)
so.
char int float double
Observe &ue o compilador C ao encontrar esta operao n4o ge#a nenum aviso de ateno para o
programador. -ssim este detale pode gerar um erro de programao (bug) &ue passe desapercebido ao
programador inexperiente. E possvel di+er &ue a linguagem C possui tipos 6macios7 (soft types) pois a
00
operao com variveis de tipos diferentes perfeitamente possvel. 'sta caracterstica do C se contrap%e a
algumas linguagens em &ue isto no possvel ("ortran, por exemplo). 'stas linguagens possuem tipos
6duros7 (ard types).
2.1.2 - Limites do inte#valo do tipo de dado.
Gambm importante observar &ue os tipos em C tem intervalos bem definidos e os resultados das opera%es
devem respeitar estes intervalos. Se a uma varivel for atribudo um valor &ue este$a fora dos seus limites
ento este valor ser alterado.
Exemplo: Observe as express%es abaixo, assuma &ue i se$a uma varivel do tipo int.
i = 4999; // o valor de i 4999
i = 4999 + 1; // o valor de i 5000
i = 5000 + 30000; // o valor de i -30536

O valor de 3!000 ultrapassou o limite superior do tipo int (32#"#).
E importante observar &ue em C, ao contrrio de outras linguagens, a ultrapassagem do limite de um tipo
n4o F inte#p#etado como e##o. 3sto pode acarretar resultados inesperados para o programador desatento.
2.1.2 - At#ibui84o mBltipla.
E possvel atribuir um valor a muitas variveis em uma /nica instruo. - esta operao d4se o nome de
at#ibui84o mBltipla.
!intaxe: - sintaxe da atribuio m/ltipla seguinte.
var_1 = [var_2 = ... ] expresso;
onde var_1, var_2, ... so os identificadores de variveis e expresso uma expresso vlida.
Observe &ue na atribuio m/ltipla as opera%es ocorrem da di#eita para a es@ue#da, isto , inicialmente o
valor de expresso atribudo a var_2 e depois o valor de var_2 atribudo a var_1. *eve4se tomar
cuidado com as convers%es de tipo e limites de intervalo para atribui%es de tipos diferentes.
Exemplo: Observe a instruo de atribuio m/ltipla abaixo. as variveis inteiras i, = e E so todas
iniciali+adas com o valor 1. ' as variveis de dupla preciso max e min so iniciali+adas com o valor
0.0.
int i, j, k;
double max, min;
i = j = k = 1;
max = min = 0.0;
P#og#ama Exemplo: O ar&uivo e0301.cpp tra+ um programa para visuali+ar alguns aspectos
relacionados com o operador de atribuio. 'xecute o programa passo4a4passo e observe o valor das
variveis.
/************************************
Programa: e0301.cpp
Propsito: Operadores de atribuio.
Ultima Reviso: 22/07/97
***********************************/
void main()
{ // declarao de variveis
char c;
int i,j,k;
float f,g,h;
double d;
// Atribuies validas
c = 'A';
i = 7;
f = 10.0;
d = 4.32464869714159;
// atribuies invalidas
// 12 = i; // constante
// f + d = d + f; // expresso
// Converso de tipo sem perda de informao
i = c; // valor ASCII de 'A' e' 65
0:
f = i;
d = f;
// Converso de tipo com perda de informao
d = 74.5461836294756;
f = d;
i = f;
i = 2.999999; //Truncamento!
// Estouro dos limites de um tipo
i = 30000;
i = i + 1000;
i = i + 1000;
i = i + 1000; // Passou do limite!
// Atribuio mltipla
i = j = k = 4;
f = g = h = 6.8;
// Atribuio mltipla sem perda de informao
d = f = i = 20;
// Atribuio mltipla com perda de informao
i = f = d = 3.09571648723667;
}
3.2 - &peradores 'ritm(ticos
'xistem cinco operadores aritmticos em C. Cada operador aritmticos est relacionado ao uma operao
aritmtica elementar. adio, subtrao, multiplicao e diviso. 'xiste ainda um operador (%) camado
operador de mdulo cu$o significado o resto da diviso inteira. Os smbolos dos operadores aritmticos
so.
Operador Operao
+ adi84o.
- subt#a84o.
* multiplica84o
/ divis4o
% mdulo D#esto da divis4o intei#aE
!intaxe: - sintaxe de uma expresso aritmtica .
operando operador operando
onde operador um dos ca#acte#es mostrados acima e operando uma constante ou um identificador
de va#i6vel.
Exemplo: -lgumas express%es aritmticas.
1+2 a-4.0 b*c valor_1/taxa num%2
No existe em C, como existe em outras linguagens, um operador especfico para a operao de potenciao
(a
,
). 'xiste, porm, uma funo de biblioteca (pow()) &ue reali+a esta operao. >e$a a seo <.F adiante.
'mbora as opera%es do C se$am semelantes as opera%es aritmticas usuais da matemtica, alguns detales
so especficos da linguagem, e devem ser observados.
2.2.1 - %est#i8Ges de ope#andos
Os operandos dos operadores aritmticos devem ser constantes numricas ou identificadores de variveis
numricas. Os operadores D, 6, *, / podem operar n/meros de todos os tipos (inteiros ou reais) porm
o operador % somente aceita operandos intei#os.
Exemplo: 'xpress%es vlidas
Expresso Valor
6.4 + 2.1 8.5
7 - 2 5
2.0 * 2.0 4.0
6 / 3 2
0<
47 % 2 1
#ma restrio ao operador de diviso (/) &ue o denominador deve ser diferente de +ero. Se alguma
operao de diviso por +ero for reali+ada o correra um e##o de execu84o do programa (run-time error), o
programa ser abortado e a mensagem diAide error ser exibida.
Exemplo: - expresso abaixo invlida pois o primeiro operando no um numero inteiro.
Expresso Valor
6.4 % 3 invalido!
,odemos contornar o problema do operador inteiro da operao modulo usando o artifcio da converso de
tipo (casting) mostrada na seo :.<.@.
Exemplo: Observe o treco de programa abaixo.
int num;
float valor = 13.0;
num = valor % 2; // invlido!
num = (int)valor % 2; // vlido!
Observe &ue usamos a converso de tipo para &ue o dado arma+enado em Aalor fosse transformado no tipo
int assim a operao m!dulo pode ser efetuada.
2.2.2 - Conve#s4o de tipo.
O resultado de uma operao aritmtica depende dos tipos dos operandos. Se os operandos so do mesmo
tipo o resultado ser do mesmo tipo. Se os operando forem de tipos di5e#entes ento aver uma conve#s4o
de tipo tal &ue o tipo &ue ocupa menos espao de mem!ria ser convertido para o tipo &ue ocupa mais
espao de mem!ria e o resultado ser deste tipo. 'm geral.
char int float double
'sta uma regra geral, alguns compiladores podem ter outras regras de converso.
Exemplo: Observe as convers%es de tipo abaixo.
Expresso Valor Converso
6 + 2.0 8.0 int float
7.000000 - 2.0000000000000 5.000000000000000 float double
2 * 3.000000000000000 6.000000000000000 int double
Observe &ue estas convers%es podem gerar resultados surpreendentes para o programador desatento.
Exemplo: Observe as express%es abaixo. -ssuma &ue as variveis num8i, num8f, den8i e den8f
so iniciali+adas como.
int num_i = 7 , den_i = 2 ;
float num_f = 7.0, den_f = 2.0;
Expresso Valor Operandos Resultado
num_f / den_f 3.5 float / float float
num_f / den_i 3.5 float / int float
num_i / den_f 3.5 int / float float
num_i / den_i 3 int / int int

Observe &ue no exemplo acima o valor da /ltima expresso 3 e no 3.5. 3sto ocorre por&ue como os dois
operandos so tipo int o resultado e convertido para o tipo int e ocorre o truncamento. O truncamento da
diviso inteira feito de modo a obter o menor valor absoluto.
'm C caracteres so arma+enados na mem!ria como n/meros inteiros e por isso opera%es aritmticas so
permitidas com tipos c9ar. Os valores usados so os correspondentes da tabela -SC33.
Exemplo: Observe as express%es abaixo.
Expresso Valor Converso
'A' + 1 'B' 65 + 1 66
'A' + 'B' '' 65 + 66 131
'A' + 32 'a' 65 + 32 97
0@
2.2.9 - P#eced?ncia de ope#ado#es.
Auando mais de um operador se encontram em uma expresso aritmtica as opera%es so efetuadas uma de
cada ve+ respeitando algumas regras de preced5ncia. 'stas regras de preced5ncia so as mesmas da
matemtica elementar.

Os operadores de multiplicao (*), diviso (/) e m!dulo (B) tem preced5ncia sobre os operadores de adio
(D) e subtrao (6). 'ntre operadores de mesma preced5ncia as opera%es so efetuadas da es@ue#da para a
di#eita. >e$a a tabela <.0.
Exemplo: Observe, nas express%es abaixo, o seu valor e a ordem das opera%es efetuadas.
Expresso Valor Ordem
1 + 2 - 3 0 + -
24 - 3 * 5 9 * -
4 - 2 * 6 / 4 + 1 2 * / - +
6 / 2 + 11 % 3 * 4 11 / % * +
- ordem de preced5ncia dos operadores pode ser &uebrada usando4se par5nteses. ( ). Os par5nteses so, na
verdade, operadores de mais alta preced5ncia e so executados primeiro. ,ar5nteses internos so executados
primeiro &ue par5nteses externos.
Exemplo: Observe, nas express%es abaixo, o seu valor e a ordem das opera%es efetuadas.
Expresso Valor Ordem
1 + (2 - 3) 0 - +
(24 - 3) * 5 105 - *
(4 - 2 * 6) / 4 + 1 -1 * - / +
6 / ((2 + 11) % 3) * 4 24 + % / *

Observe &ue os operadores e os operandos deste exemplo so os mesmos do exemplo anterior. Os valores,
porm, so diferentes pois a ordem de execuo das opera%es foi modificada pelo uso dos par5nteses.
P#og#ama Exemplo: O ar&uivo e0302.cpp tra+ um programa para visuali+ar alguns aspectos
relacionados com os operadores aritmticos. 'xecute o programa passo4a4passo e observe o valor das
variveis.
/***************************************
Programa: e0302.cpp
Propsito: Operadores Aritmticos
Ultima Reviso: 18/05/2000
************************************* */
void main()
{ char c1, c2;
int i1, i2;
float f1, f2, f3;
// Expresses validas
i1 = 10 + 50 - 2;
i2 = i1 % 3;
f1 = 3.8 * 2.1;
f2 = 53.5 / f1;
// Expresso invalida
// i1 = f1 % 2; // O operador % s aceita inteiros!
f1 = f1 / 0.0; // O divisor zero!
// Casting
i1 = (int)f1 % 2; // Observe que f1 continua sendo float
// somente o valor foi convertido.
// Converso de tipo
i1 = 17;
i2 = 4;
f1 = 17.0;
f2 = 4.0; // operandos resultado
f3 = f1 / f2; // float / float float
0?
f3 = f1 / i2; // float / int float
f3 = i1 / f2; // int / float float
f3 = i1 / i2; // int / int int Resultado truncado!
f3 = (float)i1 / (float)i2; // Resultado correto!
// Operando caracter
c1 = 65; // valor ASCII
c2 = 'M';
c1 = c1 + 1;
c2 = c2 + 32;
// Precedncia de operadores: Verifique o resultado
i1 = 3 - 5 * 7 % 2;
i2 = 40 / 2 / 2 / 2;
f1 = 4.0 * 3.0 - 6.0 / 2.0 + 2.0;
}
3.3 - &peradores de 'tri#uio 'ritm(tica
Iuitas ve+es &ueremos alterar o valor de uma varivel reali+ando alguma operao aritmtica com ela.
Como por exemplo. i F i D 1 ou Aal F Aal * 2. 'mbora se$a perfeitamente possvel escrever
estas instru%es, foi desenvolvido na linguagem C uma instru%es otimi>adas com o uso de operadores ditos
ope#ado#es de at#ibui84o a#itmFtica. Os smbolos usado so (DF, 6F, *F, /F , BF). *este modo
as instru%es acima podem ser rescritas como. i DF 1 e Aal *F 2, respectivamente.
!intaxe: - sintaxe da atribuio aritmtica a seguinte.
var += exp;
var -= exp;
var *= exp;
var /= exp;
var %= exp;
onde var o identificador da varivel e exp uma expresso vlida. 'stas instru%es so e&uivalentes
as seguintes.
var = var + exp;
var = var - exp;
var = var * exp;
var = var / exp;
var = var % exp;
Exemplo: Observe as atribui%es aritmticas abaixo e suas instru%es e&uivalentes.
Atribuio aritmtica Instruo equivalente
i += 1; i = i + 1;
j -= val; j = j - val;
num *= 1 + k; num = num * (1 + k);
troco /= 10; troco = troco / 10;
resto %= 2; resto = resto % 2;
O operador de atribuio aritmtica tem preced5ncia menor &ue os outros operadores at a&ui discutidos.
P#og#ama Exemplo: O ar&uivo e0303.cpp tra+ um programa para visuali+ar alguns aspectos
relacionados com os operadores de atribuio aritmtica. 'xecute o programa passo4a4passo e observe o
valor das variveis.
/* *******************************************************************
Programa: e0303.cpp
Propsito: Operadores de atribuio aritmtica
Ultima Reviso: 18/05/2000
******************************************************************* */
void main()
{ char c;
int i,j;
float r,s;
i = 0;
j = 100;
0C
r = -3.47;
s = 546.764;
c = 'A';
// Operadores aritmticos
c += 2; // c = c + 2
i -= 4; // i = i - 4
j %= 7; // j = j % 7
r *= 7.9; // r = r * 7.9
s /= r - 1.5; // s = s / (r - 1.5)
}
3.! - &peradores Incrementais
'm programao existem instru%es muito comuns camadas de inc#emento e dec#emento. #ma instruo
de incremento adiciona uma unidade ao conte/do de uma varivel. #ma instruo de decremento subt#ai
uma unidade do conte/do de uma varivel.
'xistem, em C, operadores especficos para reali+ar as opera%es de incremento (DD) e decremento (66).
'les so genericamente camados de ope#ado#es inc#ementais.
!intaxe: - sintaxe dos operadores incrementais a seguinte.
instruo equivalente
++ var var = var + 1
var ++ var = var + 1
-- var var = var - 1
var -- var = var - 1
onde var o nome da varivel da &ual se &uer incrementar ou decrementar um unidade.
Observe &ue existe duas sintaxes possveis para os operadores. pode4se colocar o operador I es@ue#da ou 6
di#eita da varivel. Nos dois casos o valor da varivel ser incrementado (ou decrementado) de uma unidade.
,orm se o operador for colocado 6 es@ue#da da varivel, o valor da varivel ser incrementado (ou
decrementado) antes &ue a varivel se$a usada em alguma outra operao. Caso o operador se$a colocado I
di#eita da varivel, o valor da varivel ser incrementado (ou decrementado) depois &ue a varivel for usada
em alguma outra operao.
Exemplo: Observe o fragmento de c!digo abaixo e note o valor &ue as variveis recebem aps a execuo
da instruo.
valor das variveis
int a, b, c, i = 3; // a: ? b: ? c: ? i: 3
a = i++; // a: 3 b: ? c: ? i: 4
b = ++i; // a: 3 b: 5 c: ? i: 5
c = --i; // a: 3 b: 5 c: 4 i: 4
Os operadores incrementais so bastante usados para o controle de laos de repetio, &ue sero vistos
adiante. E importante &ue se conea exatamente o efeito sutil da colocao do operador, pois isto pode
enganar o programador inexperiente.
Os operadores incrementais tem a mais alta preced5ncia entre todos, sendo superados apenas pelos
par5nteses &ue tem preced5ncia ainda maior. >e$a a tabela <.0.
P#og#ama Exemplo: O ar&uivo e030.cpp tra+ um programa para visuali+ar alguns aspectos
relacionados com os operadores incrementais. 'xecute o programa passo4a4passo e observe o valor das
variveis.
/* *******************************************************************
Programa: e0304.cpp
Proposito: Operadores incrementais
Ultima Reviso: 22/07/97
******************************************************************* */
void main(){
int i = 0, j = 10;
float f = -5.0;
char c = 'Z';
// Incremento
0F
do{
i++;
j--;
f++;
c--;
}while(i < 10);
// Posio do operador:
// Observe que...
i = 0;
j = i++; // atribui e depois incrementa
// ... e' diferente de:
i = 0;
j = ++i; // incrementa e depois atribui
// Precedncia:
i = j++ * 3;
j = 4 % --i;
}
3.) - &peradores *e%acionais e L$gicos
- cave para a flexibilidade de um algoritmo a tomada de decis%es atravs da avaliao de condi%es de
controle. #ma condi%es de controle uma exp#ess4o lgica &ue avaliadas como ve#dadei#a ou 5alsa.
#ma expresso l!gica construda com ope#ado#es #elacionais e lgicos.
2.;.1 - Hpe#ado#es #elacionais
Operadores relacionais verificam a relao de magnitude e igualdade entre dois valores. So seis os
operadores relacionais em C.
Operador Significado
> maior que
< menor que
>= maior ou igual a (no menor que)
<= menor ou igual a (no maior que)
== igual a
!= no igual a (diferente de)
!intaxe: - sintaxe das express%es l!gicas .
expresso_1 operador expresso_2
onde expresso_1 e expresso_2 so duas express%es numricas &uais&uer, e operador um dos
operadores relacionais.
-o contrrio de outras linguagens, em C n4o existem tipos l!gicos, portanto o #esultado de uma expresso
l!gica um valo# numF#ico. uma expresso avaliada ve#dadei#a recebe o valor 1, uma expresso l!gica
avaliada 5alsa recebe o valor 0.
Se os operandos forem de tipos di5e#entes aver uma converso de tipo antes da avaliao da expresso.
'sta converso de tipo feita de acordo com a regra mostrada na seo <.:.:.
Exemplo: Observe as express%es l!gicas abaixo e verifi&ue o resultado de sua avaliao. -dmita &ue i e =
so variveis int cu$os valores so ! e 63, respectivamente. -s variveis r e s so float com valores
#.3 e 1.#, respectivamente.
Expresso Valor
i == 7 0
r != s 1
i > r 0
6 >= i 1
i < j 0
s <= 5.9 1
0D
Os operadores relacionais de igualdade (FF e GF) tem preced5ncia meno# &ue os de magnitude (H, I, HF e
IF). 'stes, por sua ve+, tem preced5ncia meno# &ue os operadores aritmticos. Operadores relacionais de
mesma preced5ncia so avaliados da es&uerda para a direita. >e$a a tabela <.0.
Exemplo: Observe as express%es l!gicas abaixo e verifi&ue o resultado de sua avaliao. -dmita &ue m e n
so variveis tipo int com valores e 1, respectivamente.
Expresso Valor Ordem de Operao
m + n == 5 1 + ==
m != 2 * n > m 1 * > !=
6 >= n < 3 - m 0 - >= <
m == n <= m > m 0 <= > !=
2.;.2 - Hpe#ado#es lgicos
So tr5s os operadores l!gicos de C. &&, JJ e G. 'stes operadores tem a mesma significao dos
operadores l!gicos Mooleanos -N*, OO e NOG.
!intaxe: - sintaxe de uso dos operadores l!gicos.
expr_1 && expr_2
expr_1 || expr_2
!expr
onde expr_1 , expr_2 e expr so express%es &uais&uer.
Observe &ue os operadores l!gicos atuam sobre express%es de &uais&uer valores. ,ara estes operadores todo
valor numrico diferente de 0 considerado 1.
Exemplo: - seguir mostrado o valor l!gico de uma expresso &ual&uer.
Expresso alor l!"ico
0 0
1 1
1.0 1
0.4 1
-5.2 1
onde expr_1 , expr_2 e expr so express%es &uais&uer.
O resultado da operao l!gica && ser 1 somente se os dois operandos forem 1, caso contrrio o resultado
0. O resultado da operao l!gica JJ ser 0 somente se os dois operandos forem 0, caso contrrio o
resultado 1. O resultado da operao l!gica G ser 0 se o operandos for 1, e 1 se o operando for 0.
-baixo mostra4se o resultado das possveis combina%es entre os operandos para cada operador l!gico.
Kperador && L op1 op2 Res
op1 && op2 1 1 1
1 0 0
0 1 0
0 0 0
Kperador || L op1 op2 Res
op1 || op2 1 1 1
1 0 1
0 1 1
0 0 0
Kperador !L op Res
!op 1 0
0 1
O operador && tem preced5ncia sobre o operador JJ. 'stes dois t5m preced5ncia menor &ue os operadores
relacionais. O operador P tem a mesma preced5ncia &ue os operadores incrementais. >e$a a tabela <.0.
Exemplo: Observe as express%es l!gicas abaixo e verifi&ue o resultado de sua avaliao. -dmita &ue a, , e
c so variveis tipo int com valores 0, 1 e 2, respectivamente.
Expresso Valor Ordem de Operao
a && b 0
c > b || a < c 1 > < ||
a + b && !c - b 1 ! + - &&
!b && c || a 0 ! && ||
0K
P#og#ama Exemplo: O ar&uivo e030!.cpp tra+ um programa para visuali+ar alguns aspectos
relacionados com os operadores l!gicos e relacionais. 'xecute o programa passo4a4passo e observe o valor
das variveis.
/* *******************************************************************
Programa: e0305.cpp
Propsito: Operadores Relacionais e Lgicos
Ultima Reviso: 18/05/2000
******************************************************************* */
void main()
{ char c,d;
int i,j;
float r,s;
int valor_logico;
// Operadores Relacionais
i = 5;
j = 6;
r = 2.3;
s = 6.1;
c = 'A';
d = 'a';
// Tipos iguais
valor_logico = (i == j);
valor_logico = (r != s);
valor_logico = (i > 3);
valor_logico = (c < d); // obs: 'A' = 65 'a' = 97
valor_logico = (4 >= j);
valor_logico = (i-5 > j*3);
valor_logico = (2.6 != 4.8);
valor_logico = (c == 'w'); // Obs.: 'w' = 119
// Tipos diferentes
valor_logico = (r <= i);
valor_logico = (j == 2.3);
// Operadores Lgicos
valor_logico = r==s && c<d;
valor_logico = i>45 || r!=s;
valor_logico = !(c != d);
// Quando termina a repetio abaixo?
i = 0;
r = 1.0;
do
{ r /= 2.0;
}
while( r > 1e-8 && i++ < 50);
}
3.+ - &perador Condiciona%
O operador condicional (ML) usado em express%es condicionais. #ma expresso condicional pode ter dois
valores diferentes dependendo de uma condio de controle.
!intaxe: - sintaxe de uma expresso condicional .
condio ? expresso_1 : expresso_2
onde expresso_1 e expresso_2 so duas express%es &uais&uer, e condio uma expresso
l!gica &ue ser avaliada primeiro. Se o valor de condio for 1, isto , verdadeiro, ento a expresso
condicional assumir o valor de expresso_1. Caso contrario assumir o valor de expresso_2. #ma
expresso condicional e&uivalente a uma estrutura de deciso simples.
se condio
ento expressao_1
seno expressao_2
:1
fim se
Exemplo: Observe as express%es condicionais abaixo e verifi&ue o resultado de sua avaliao. -dmita &ue
i, = e E so variveis tipo int com valores 1, 2 e 3, respectivamente.
Expresso Valor
i ? j : k 2
j > i ? ++k : --k 4
k == i && k != j ? i + j : i - j -1
i > k ? i : k 3
O operador condicional tem baixa preced5ncia, precedendo, apenas, aos operadores de atribuio. >e$a a
tabela <.0.
P#og#ama Exemplo: O ar&uivo e030".cpp tra+ um programa para visuali+ar alguns aspectos
relacionados com o operador condicional. 'xecute o programa passo4a4passo e observe o valor das variveis.
/* *******************************************************************
Programa: e0306.cpp
Propsito: Operadores Condicionais
Ultima Reviso: 18/05/2000
******************************************************************* */
void main(){
int i,j,max1,max2;
float r,s;
// A seguinte atribuio...
r = (i==j) ? 34.9 : 88.4;
// equivalente a...
if(i==j){
s = 34.9;
}else{
s = 88.4;
};
// Aplicao simples
// Para no escrever...
if(i > j)
{ max1 = i;
}
else
{ max1 = j;
}
// pode-se escrever...
max2 = (i > j) ? i : j;
}
3., - -un.es de #i#%ioteca
#ma funo um sub-p#og#ama (tambm camado de rotina). 'sta funo recebe informa%es, as processa
e retorna outra informao. ,or exemplo, podemos ter uma funo &ue receba um valor numrico, calcule
seu logaritmo decimal e retorne o valor obtido. 'xistem dois tipos de fun%es. fun.es de biblioteca e
fun.es de usu,rio. "un%es de biblioteca so fun%es escritas pelos fabricantes do compilador e $ esto
pr4compiladas, isto , $ esto escritas em c!digo de m&uina. "un%es de usurio so fun%es escritas pelo
programador. Nesta seo trataremos somente das fun%es de biblioteca, fun%es de usurio sero vistas no
captulo Q.
2.-.1 - H uso de 5un8Ges
-ntes de usar uma funo preciso saber como a funo esta declarada, isto , &uais so os par9metros &ue a
funo recebe e &uais so os para metros &ue a funo retorna. 'stas informa%es esto contidas no manual
do usurio do compilador ou em sua documentao on-line.
!intaxe: - sintaxe de declarao de uma funo .
tipo_ret nome(tipo_1, tipo_2, ...)
:0
onde nome o nome da funo, tipo_1, tipo_2, ... so os tipos (e &uantidade) de par9metros de entrada
da funo e tipo_ret o tipo de dado de retorno da funo. -lm dos tipos usuais vistos na seo :.<,
existe ainda o tipo Aoid (va+io, em ingl5s) &ue significa &ue a&uele par9metro inexistente.
Exemplo: - funo cos() da biblioteca mat9.9 declarada como.
double cos(double);
3sto significa &ue a funo tem um par9metro de entrada e um par9metro de sada, ambos so do tipo
dou,le.
Exemplo: - funo <etc9() da biblioteca conio.9 declarada como.
int getch(void);
3sto significa &ue a funo no tem par9metros de entrada e tem um par9metro int de sada.
,ara podermos usar um funo de biblioteca devemos inclui# a biblioteca na compilao do programa. 'sta
incluso feita com o uso da diretiva #include colocada antes do programa principal, como visto na seo
:.@.:.
Exemplo: -ssim podemos usar a funo no seguinte treco de programa.
#include <math.h> // incluso de biblioteca
void main() // inicio do programa principal
{ double h = 5.0; // hipotenusa
double co; // cateto oposto
double alfa = M_PI_4; // angulo: /4
co = h * cos(alfa); // calculo: uso da funo cos()
} // fim do programa
-s fun%es tem alta preced5ncia, sendo mais baixa apenas &ue os par5nteses. - tabela <.0 mostra as
preced5ncias de todos os operadores estudados neste captulo.
2.-.2 - As bibliotecas disponveis e algumas 5un8Ges inte#essantes
- seguir segue uma lista de todas as bibliotecas disponveis no compilador "urbo '// 0.1 !orland. -o
longo do texto veremos o uso de muitas fun%es cobrindo uma boa parte destas bibliotecas, porm o leitor
&ue dese$ar tornar4se RfluenteR na linguagem C pode (e deve) estud4las com profundidade.
alloc.h assert.h bcd.h bios.h complex.h
conio.h ctype.h dir.h dirent.h dos.h
errno.h fcntl.h float.h fstream.h generic.h
graphics.h io.h iomanip.h iostream.h limits.h
locale.h malloc.h math.h mem.h process.h
setjmp.h share.h signal.h stdarg.h stddef.h
stdio.h stdiostr.h stdlib.h stream.h string.h
strstrea.h sys\stat.h sys\timeb.h sys\types.h time.h
values.h
>e$amos algumas fun%es disponveis nas bibliotecas C.
Biblioteca mat=.=
int abs(int i);
dou,le fabs(dou,le d);
Calcula o valor absoluto do inteiro i e do real d, respectivamente.
double sin(double arco);
double cos(double arco);
double tan(double arco);
double asin(double arco);
double acos(double arco);
double atan(double arco);
"un%es trigonomtricas do 9ngulo arco, em radianos.
double ceil(double n#m);
double floor(double n#m);
"un%es de arredondamento para inteiro.
ceil() a##edonda pa#a cima. Ex. ceil(3.2) == 3.0;
floor() a##edonda pa#a baixo. Ex. floor(3.2) == 4.0;
::
double log(double n#m);
double log10(double n#m);
"un%es logartmicas. lo<() logaritmo natural (base e), lo<10() logaritmo decimal (base 01).
double pow(double base, double exp);
,otenciao. poN(3.2,!.") J <.:
?.C
.
double sqrt(double n#m);
Oai+ &uadrada. sOrt(%.0) F 3.0.
Biblioteca stdlib.=
int random(int n#m);
=era um n/mero inteiro aleat!rio entre 0 e num 6 1.
Biblioteca st#ing.=
strlen(s);
Oetorna um n/mero inteiro de acordo com o n/mero de caracteres de s.
'x. tamanho = strlen(nome)S
strcpy(s1, s2);
Copia o conte/do da varivel s: para a varivel s0.
'x: strcpy(nomemaior, nome);
strcmp(s1, s2);
Oetorna um n/mero inteiro de acordo a comparao entre o conte/do de s1 e s2 da seguinte forma.
-1 se o valor de s1 for menor &ue o valor de s2,
. se o valor de s1 for igual ao valor de s2C
1 se o valor de s1 for maior &ue o valor de s2.
*xL i<ual F strcmp(nome1, nome2)
N9ile (strcmp(nome, PfimQ) GF 0)
P#og#ama Exemplo: O ar&uivo e030#.cpp tra+ um programa para visuali+ar alguns aspectos
relacionados com fun%es de biblioteca. 'xecute o programa passo4a4passo e observe o valor das variveis.
/* *******************************************************************
Programa: e0307.cpp
Proposito: Funes de Biblioteca
Ultima Reviso: 20/05/2000
******************************************************************* */
// Exerccio: O programa abaixo foi escrito usando varias funes
// disponveis do C. Procure, na ajuda on-line, informaes sobre as
// funes usadas...
#include <conio.h> // incluso das bibliotecas
#include <stdio.h>
#include <string.h>
#include <ctype.h>
#include <dos.h>
#include <stdlib.h>
#include <math.h>
void main()
{ char* titulo = "* * * P r o g r a m a E x e m p l o * * *";
char tecla; // tecla pressionada pelo usurio
int tam; // tamanho do titulo
int col; // coluna inicial de impresso do titulo
int cont; // flag de continuao do lao
float num; // numero aleatrio
float val; // valor calculado
do{ // inicia lao repetitivo...
:<
// *********************
// 1 Titulo Centralizado
// *********************
clrscr(); // limpa a tela
tam = strlen(titulo); // calcula o tamanho do titulo.
col = 40 - tam / 2; // calcula a coluna de inicio
gotoxy(col,1); // posiciona o cursor
printf(titulo); // imprime o titulo
// ******************
// 2 Numero aleatrio
// ******************
randomize(); // inicia gerador aleatrio
num = (float)random(1000) / 100.0; // gera numero
printf("\n\n Numero: %f",num); // imprime escolha
getch(); // pausa
// ********************
// 3 Faz algumas contas
// ********************
val = sin(num); // seno
printf("\n sin( %f ) = %f",num,val); // imprime
getch(); // pausa
val = ceil(num); // arredonda para cima
printf("\n ceil( %f ) = %f",num,val); // imprime
getch(); // pausa
val = floor(num); // arredonda para baixo
printf("\n floor( %f ) = %f",num,val); // imprime
getch(); // pausa
val = log(num); // logaritmo natural
printf("\n ln( %f ) = %f",num,val); // imprime
getch();
// pausa
val = sqrt(num); // raiz quadrada
printf("\n sqrt( %f ) = %f",num,val); // imprime
getch(); // pausa
// ***********
// 4 Continua?
// ***********
printf("\n Continua ? "); // imprime mensagem
tecla = getch(); // recebe caracter do teclado
tecla = toupper(tecla); // transforma em maisculo
cont = (tecla == 'S') ? 1 : 0; // se for 'S' continua
}while(cont); // ... fim do lao de repetio
// *******
// 5 Sadia
// *******
clrscr(); // limpa tela
sound(440); // emite um som de 300 Hz...
delay(100); // ... por 100 ms...
nosound(); // ... e para.
printf("\n Volte Sempre!"); // mensagem
} // fim do programa
:@
3./ - Preced0ncia entre os operadores do C
- tabela <.0 mostra a ordem de preced5ncia de todos os operadores estudados neste captulo. Os operadores
de maior preced5ncia so os pa#?nteses e as camadas de 5un8Ges. Os operadores de menor preced5ncia so
os o operadores de at#ibui84o.
Catego#ia Hpe#ado#es P#io#idade
pa#?nteses
( )
inte#no exte#no
5un84o
nome()
E :
inc#ementalC lgico
++ -- !
E :
a#itmFtico
* / %
E :
a#itmFtico
+ -
E :
#elacional
< > <= >=
E :
#elacional
== !=
E :
lgico
&&
E :
lgico
||
E :
condicional
?:
E :
at#ibui84o
= += -= *= /= %=
E :
a#e%a 3.1: +reced2ncia dos operadores. 3aior preced2ncia no topo, menor preced2ncia na base.
9Ent#ada e !ada
,ara &ue um programa torne4se minimamente funcional preciso &ue ele receba dados do meio externo
(teclado, mouse, portas de comunicao, drives de disco, etc.) e emita o resultado de seu processamento de
volta para o meio externo (monitor, impressora, alto4falante, portas de comunicao, drives de disco, etc.).
*e outro modo. um programa deve trocar informa%es com o meio externo. 'm C, existem muitas fun%es
pr4definidas &ue tratam desta troca de informa%es. So as fun%es de ent#ada e sada do C. Nos exemplos
mostrados nos captulos anteriores foram vistas algumas fun%es de entrada (scanf(), <etc9()) e
algumas fun%es de sada (printf()). Neste captulo veremos, em detale, estas e outras fun%es de modo
a permitir escrever um programa completo em C.
Iostraremos, nas duas se%es iniciais as mais importantes fun%es de entrada e sada de dados em C. as
fun%es printf() e scanf(). - partir do estudo destas fun%es possvel escrever um programa
propriamente dito com entrada, processamento e sada de dados.
!.1 - "a1da formatada2 printf()
Biblioteca: stdio.9
:ecla#a84o: int printf (const c9ar* st_contr R, lista_argS);
P#opsito: - funo printf() (print formated) imprime dados da lista de argumentos lista_arg
formatados de acordo com a string de controle st_contr. 'sta funo retorna um valor inteiro
representando o n/mero de caracteres impressos.
'sta funo imprime dados numricos, caracteres e strings. 'stafuno dita de sada formatada
pois os dados de sada podem ser formatados (alinados, com n/mero de dgitos variveis, etc.).
!intaxe: - string de controle uma mscara &ue especifica (formata) o &ue ser impresso e de &ue maneira
ser impresso.
Exemplo: Observe no exemplo abaixo as instru.es de sada formatada e os respectivos resultados.
Instruo Sada
:?
printf(Ol, Mundo!); Ol, Mundo!
printf(linha 1 \nlinha 2 ); linha 1
linha 2
Observe &ue na primeira instruo, a sada exatamente igual a string de controle. T na segunda instruo a
impresso se deu em duas linas. 3sto se deve ao /n &ue representa o c!digo -SC33 para &uebra de lina
(ve$a seo :.0.<).
Nesta mascara possvel reservar espao para o valo# de alguma varivel usando especificadores de
formato. #m especificador de formato marca o luga# e o 5o#mato de impresso das variveis contidas na
lista va#i6veis. *eve aver um especificador de formato para cada varivel a ser impressa. Godos os
especificadores de formato comeam com um B.
Exemplo: Observe no exemplo abaixo as instru.es de sada formatada e os respectivos resultados. -dmita
&ue idade se$a uma varivel int contendo o valor 2% e &ue tot e din se$am variveis float cu$o
valores so, respectivamente, 12.3 e 1!.0.
Instruo:
printf(Tenho %d anos de vida,idade);
Sada:
Tenho 29 anos de vida
Instruo:
printf(Total: %f.2 \nDinheiro: %f.2 \nTroco: %f.2,tot,din,din-tot);
Sada:
Total: 12.30
Dinheiro: 15.00
Troco: 2.70

*epois do sinal B, seguem4se alguns modificadores, cu$a sintaxe a seguinte.
B [flag] [tamanho] [.preciso] tipo
[fla"]
3usti5ica84o de sada: DHpcionalE
-
3usti5ica84o I es@ue#da.
+
conve#s4o de sinal Dsada semp#e com sinal: ) ou -E
<espao>
conve#s4o de sinal Dsadas negativas com sinalC positivas sem sinalE
[taman$o]
especi5ica84o de taman=o DHpcionalE
n
pelo menos n dgitos se#4o imp#essos Ddgitos 5altantes se#4o completados po#
b#ancosE.
0n
pelo menos n dgitos se#4o imp#essos Ddgitos 5altantes se#4o completados po#
>e#osE.
[.preciso]
especi5icado# de p#ecis4oC dgitos a di#eita do ponto decimal. DHpcionalE
(nada)
pad#4o: < dgitos pa#a #eais.
.0
nen=um digito decimal.
.n
s4o imp#essos n dgitos decimais.
Tipo
ca#acte# de conve#s4o de tipo D%e@ue#idoE
d
intei#o decimal
o
intei#o octal
x
intei#o =exadecimal
f
ponto 5lutuante: [-]dddd.dddd.
e
ponto 5lutuante com expoente: [-]d.dddde[+/-]ddd
c
ca#acte# simples
s
st#ing
P#og#ama Exemplo: O ar&uivo e001.cpp contm um programa &ue ilustra o uso da funo printf()
usando vrias combina%es de strings de controle e especificadores de formato. 'xecute o programa passo4a4
passo e verifi&ue a sada dos dados.
/* *******************************************************************
Programa: e0401.cpp
Propsito: Uso da funo printf()
:C
Ultima Reviso: 20/05/2000
******************************************************************* */
#include <stdio.h> // biblioteca da funo printf()
#include <conio.h> // biblioteca da funo clrscr()
void main()
{ int i = 12;
int j = -35;
int k = 9386;
float r = 5.83;
float s = -82.3;
float t = 5467.75;
char letra = 'a';
char* nome = "Teste";
clrscr(); // limpa tela
// somente texto
printf("Texto Exemplo"); // sem quebra de linha
printf("Texto Exemplo");
printf("\nTexto Exemplo"); // com quebra de linha
printf("\nTexto Exemplo");
// formato caracter
printf("\n%c",letra);
printf("\n%c",'b');
// formato string
printf("\n%s",nome);
// texto e numero sem formatacao
printf("\nJoaozinho tem %d amiguinhos!",i);
printf("\nConsumo Medio: %f kWh",r);
// Uso dos modificadores de formato
printf("\n\nJustificacao a direita");
printf("\n %6d %12f",i,r);
printf("\n %6d %12f",j,s);
printf("\n %6d %12f",k,t);
printf("\n\nJustificacao a esquerda");
printf("\n %-6d %-12f",i,r);
printf("\n %-6d %-12f",j,s);
printf("\n %-6d %-12f",k,t);
printf("\n\nCom sinal");
printf("\n %+6d %+12f",i,r);
printf("\n %+6d %+12f",j,s);
printf("\n %+6d %+12f",k,t);
printf("\n\nCom zeros");
printf("\n %06d %012f",i,r);
printf("\n %06d %012f",j,s);
printf("\n %06d %012f",k,t);
printf("\n\nSem decimais, Com 3 decimais");
printf("\n %6.0f %8.3f", r,r);
printf("\n %6.0f %8.3f", s,s);
printf("\n %6.0f %8.3f", t,t);
printf("\n\nDecimal, Hexa, Octal");
printf("\n %6d %6X %6o",i,i,i);
printf("\n %6d %6X %6o",k,k,k);
printf("\n %6d %6X %6o",k+1,k+1,k+1);
:F
printf("\n\nPadrao, Cientifico");
printf("\n %11f %e", r,r);
printf("\n %11f %e", s,s);
printf("\n %11f %e", t,t);
}
!.2 - Leitura formatada2 scanf()
Biblioteca: stdio.9
:ecla#a84o: int scanf(const c9ar* st_contr R, end_var, ...S);
P#opsito: - funo scanf() (scan formated) permite a entrada de dados numricos, caracteres e UstringsU
e sua respectiva atribuio a variveis cu$os endereos so end_var. 'sta funo dita de entrada
formatada pois os dados de entrada so formatados pela string de controle st_contr. a um determinado
tipo de varivel (int, float, c9ar, ...).
!intaxe: O uso da funo scanf() semelante ao da funo printf(). - funo l5 da entrada padro
(em geral, teclado) uma lista de valores &ue sero formatados pela string de controle e arma+enados nos
endereos das variveis da lista. - string de controle formada por um con$unto de especificadores de
formato, cu$a sintaxe a seguinte.
B R*S RtamanhoS tipo
*
indicado# de sup#ess4o DHpcionalE
<presente>
!e o indicado# de sup#ess4o estive# p#esente o campo n4o F lido. Este sup#esso#
F Btil @uando n4o @ue#emos le# um campo de dado a#ma>enado em a#@uivo.
<ausente>
H campo F lido no#malmente.
Tamanho
especi5icado# de taman=oDHpcionalE
n
Especi5ica n como o nume#o m6ximo de ca#acte#es pa#a leitu#a do campo.
<ausente>
Campo de @ual@ue# taman=o.
Tipo
de5ine o tipo de dado a se# lido D%e@ue#idoE
d
intei#o decimal DintE
f
ponto 5lutuante DfloatE
o
intei#o octal DintE
x
intei#o =exadecimal DintE
i
intei#o decimal de @ual@ue# 5o#matoDintE
u
intei#o decimal sem sinal Dunsigned intE
s
st#ing Dchar*)
c
ca#acte# DcharE
- lista de variveis o con$unto de (endereos) de variveis para os &uais sero passados os dados lidos.
>ariveis simples devem ser precedidos pelo caracter &. >e$a mais sobre endereos na seo D. >ariveis
string e vetores no so precedidos pelo caracter &. >e$a mais sobre strings e vetores na seo F.
P#og#ama Exemplo: O ar&uivo e002.cpp contm um programa &ue ilustra o uso da funo scanf() na
leitura de dados. 'xecute o programa passo4a4passo e verifi&ue a sada dos dados.
/* *******************************************************************
Programa: e0402.cpp
Propsito: Uso da funo scanf()
Ultima Reviso: 08/08/97
******************************************************************* */
#include <stdio.h> // biblioteca das funes scanf() e printf()
void main(){
{ char* nome;
int cod;
float preco;
int dia,mes,ano;

// leitura individual
printf("\nDigite o nome do item: "); // texto de aviso (prompt)
scanf("%s",nome); // leitura do dado
printf("Digite o cdigo do item: ");
:D
scanf("%d",&cod);
printf("Digite o preo do item: ");
scanf("%f",&preco);
// leitura conjunta
printf("\nDigite o nome, cdigo e preo do item: ");
scanf("%s %d %f",nome,&cod,&preco);
// leitura conjunta com supresso
printf("\nDigite o nome, cdigo e preo do item: ");
scanf("%s %d %*f",nome,&cod,&preco); // aps leitura, preo no alterado
// leitura segmentada
printf("\nDigite sua data de nascimento (ddmmaa): ");
scanf("%2d %2d %2d",&dia,&mes,&ano);
printf("\nVoc nasceu em %d de %d de 19%d!",dia,mes,ano);
}
!.3 - Entrada no formatada2 cin 33
Biblioteca: iostream.9
:ecla#a84o: cin HH Aar;
P#opsito: - funo cin HH l5 um caracter individual ou um valor numrico da entrada padro (em geral, o
teclado). E uma funo muito simples. No possibilita controle de leitura.
!.! 4 "a1da no formatada2 cout 55
Biblioteca: iostream.9
:ecla#a84o: cout II Aar;
P#opsito: - funo cout II escreve um ou mais caracteres individuais ou um valor numrico na tela. E
uma funo muito simples. ,ara cada informao necessrio um par de VV.
!.) - Entrada de caracter individua%2 "etc$ar()
Biblioteca: stdio.9
:ecla#a84o: int <etc9ar(Aoid);
P#opsito: - funo <etc9ar() (get caracter) l5 um caracter individual da entrada padro (em geral, o
teclado). Se ocorrer um erro ou uma condio de U fim-de-ar4uivoU durante a leitura, a funo retorna o valor
da constante simb!lica *K+ (end of file) definida na biblioteca stdio.9. 'sta funo permite uma forma
eficiente de deteco de finais de ar&uivos.
'sta funo dita line buffered, isto , no retorna valores at &ue o caracter de controle line feed (/n) se$a
lido. 'ste caracter, normalmente, enviado pelo teclado &uando a tecla RenterS pressionada. Se forem
digitados vrios caracteres, estes ficaro arma+enados no buffer de entrada at &ue a tecla RenterS se$a
pressionada. 'nto, cada camada da funo <etc9ar() ler um caracter arma+enado no buffer.
!.+ - "a1da de caracter individua%2 p#tc$ar()
Biblioteca: stdio.9
:ecla#a84o: int putc9ar(int c);
P#opsito: 'sta funo putc9ar() (put caracter) imprime um caracter individual c na sada padro
(em geral o monitor de vdeo).
P#og#ama Exemplo: O programa e003.cpp mostra o uso das fun%es <etc9ar() e putc9ar() em
um programa &ue l5 caracteres do teclado e os reimprime convertidos para mai/sculos.
!., - Leitura de tec%ado2 "etc$(), "etc$e()
Biblioteca: conio.9
:K
:ecla#a84o: int <etc9(Aoid);
int <etc9e(Aoid);
P#opsito: 'stas fun%es fa+em a leitura dos c!digos de teclado. 'stes c!digos podem representar tecla s de
caracteres (&, :, *, $, etc.), teclas de comandos ( WenterX, WdeleteX, W?a<e TpX, W+1X, etc.) ou
combinao de teclas (W&ltX ; W&X, WU9iftX ; W+1X, W(trlX ; W?a<e )oNnS, etc.).
-o ser executada, a funo <etc9() (get caracter) aguarda &ue uma tecla (ou combinao de teclas) se$a
pressionada, recebe do teclado o c!digo correspondente e retorna este valor. - funo <etc9e()(get
caracter and ecoe) tambm escreve na tela, &uando possvel, o caracter correspondente.
Cdigo A!C. ao ser pressionada uma tecla correspondente a um caracter -SC33, o teclado envia um
c!digo ao UbufferU de entrada do computador e este c!digo lido. ,or exemplo, se a tecla & for pressionada o
c!digo "! ser arma+enado no buffer e lido pela funo.
Cdigo Especial. ao serem pressionadas certas teclas (ou combinao de teclas) &ue no correspondem a um
caracter -SC33, o teclado envia ao UbufferU do computador dois c!digos, sendo o primeiro semp#e 1. ,or
exemplo, se a tecla W+1X for pressionada os valores 0 e !% sero arma+enados e a funo deve ser camada
duas ve>es para ler os dois c!digos.
!./ - Escrita formatada em cores2 cprintf()
Biblioteca: conio.9
:ecla#a84o: int cprintf (const c9ar* st_contr R, lista_argS);
P#opsito: 'sta funo cprintf() (color print formated) permite a sada de dados numricos, caracteres e
strings usando cores. O uso da funo cprintf() semelante a printf()porm permite &ue a sada
se$a a cores. ,ara &ue a sada se$a colorida necessrio definir as cores de fundo e de letra para a impresso
antes do uso da funo.
Cores (Modo Texto)
Cor Constante Valor Fundo Letra
Preto BLACK 0 ok ok
Azul BLUE 1 ok ok
Verde GREEN 2 ok ok
Cian CYAN 3 ok ok
Vermelho RED 4 ok ok
Magenta MAGENTA 5 ok ok
Marrom BROWN 6 ok ok
Cinza Claro LIGHTGRAY 7 ok ok
Cinza Escuro DARKGRAY 8 -- ok
Azul Claro LIGHTBLUE 9 -- ok
Verde Claro LIGHTGREEN 10 -- ok
Cian Claro LIGHTCYAN 11 -- ok
Vermelho Claro LIGHTRED 12 -- ok
Magenta Claro LIGHTMAGENTA 13 -- ok
Amarelo YELLOW 14 -- ok
Branco WHITE 15 -- ok
Piscante BLINK 128 -- ok
'stas defini%es so feitas pelas fun%es texcolor() e text,acE<round() cu$a sintaxe .
textcolor(cor_de_letra);
textbackground(cor_de_f#ndo);
onde cor_de_letra e cor_de_fundo so n/meros inteiros referentes as cores da paleta padro (0C
cores, modo texto). 'stes valores de cor so representadas por constantes simb!licas definidas na biblioteca
conio.9. ,ara se usar uma letra piscante deve4se adicionar o valor 12$ ao valor da cor de letra. -lguns
valores de cor no podem ser usados como cor de fundo. - relao acima mostra as cores, suas constantes
simb!licas e onde podem ser usadas.
Exemplo: O treco de programa abaixo imprime uma mensagem de alerta em amarelo piscante sobre fundo
vermelo.
#include <conio.h>
<1
...
textbackground(RED);
textcolor(YELLOW + BLINK);
cprintif( Alerta: Vrus Detectado! );
...
P#og#ama Exemplo: O programa do ar&uivo e00".cpp mostra todas as combina%es possveis de
impresso colorida em modo texto.
/* *******************************************************************
Programa: e0406.cpp
Proposito: Uso das funcoes cprintf(), textbackground() e textcolor()
Ultima Reviso: 08/08/97
******************************************************************* */
#include <conio.h>
void main(){
int cl; // cor de letra
int cf; // cor de fundo
clrscr(); // limpa tela
cf = BLACK; // cor de fundo preta
do{ // faz...
textbackground(cf); // ativa cor de fundo
cl = BLACK; // cor de letra preta
do{ // faz...
textcolor(cl); // ativa cor de texto
cprintf(" Teste "); // imprime teste de cor
}while(++cl <= WHITE); // enquanto ano e' ultima cor de letra
}while(++cf <= LIGHTGRAY); // enquanto ano e' ultima cor de fundo
cf = BLACK;
do{
textbackground(cf);
cl = BLACK;
do{
textcolor(cl + BLINK); // ativa letra piscante
cprintf(" Teste ");
}while(++cl <= WHITE);
}while(++cf <= LIGHTGRAY);
textbackground(BLACK); // ativa fundo padro
textcolor(LIGHTGRAY); // ativa letra padro
}
!.6 - "a1da sonora2 sound789 de%a:789 nosound78
Biblioteca: dos.9
:ecla#a8Ges: Aoid sound(unsi<ned freq);
Aoid dela:(unsi<ned tempo);
Aoid nosound(Aoid);
P#opsito: - funo sound() ativa o alto4falante do ,C com uma fre&B5ncia freq (Y+). - funo
dela:() reali+a uma pausa (aguarda intervalo de tempo) de durao tempo (milisegundos). - funo
nosound() desativa o alto4falante.
P#og#ama Exemplo: O uso destas fun%es muito simples mas produ+ resultados interessantes. No ar&uivo
e00#.cpp temos um exemplo do uso de sons em programas.
/* *******************************************************************
Programa: e0407.cpp
Proposito: Uso das funcoes sound(), delay() e nosound()
Ultima Reviso: 11/08/97
******************************************************************* */
#include <dos.h>
#include <conio.h>
#include <stdio.h>
#define T 250
void main(){
clrscr();
<0
textbackground(BLUE);
textcolor(WHITE + BLINK);
cprintf("Hino do Grmio");
printf("\nAteno pois nos iremos,...");
sound(660);delay(2*T);
sound(550);delay(T);
sound(495);delay(T);
sound(440);delay(2*T);
sound(495);delay(T);
sound(550);delay(T);
sound(495);delay(2*T);
sound(330);delay(6*T);
printf("\b\b\b para o que der e vier.");
sound(660);delay(2*T);
sound(550);delay(T);
sound(495);delay(T);
sound(440);delay(2*T);
sound(495);delay(T);
sound(550);delay(T);
sound(495);delay(6*T);
printf("\nMas o certo, que ns estaremos...");
sound(550);delay(T);
sound(594);delay(T);
sound(660);delay(2*T);
sound(634);delay(T);
sound(660);delay(T);
sound(704);delay(2*T);
sound(660);delay(T);
sound(704);delay(T);
sound(844);delay(2*T);
sound(734);delay(4*T);
printf("\b\b\b com o Grmio, onde o Grmio estiver!");
sound(550);delay(T);
sound(594);delay(T);
sound(660);delay(2*T);
sound(734);delay(T);
sound(660);delay(T);
sound(495);delay(2*T);
sound(594);delay(T);
sound(550);delay(T);
sound(440);delay(4*T);
nosound();
}
!.1; - Limpe<a de te%a2 clrscr(), clreol()
Biblioteca: conio.9
:ecla#a8Ges: Aoid clrscr(Aoid);
Aoid clreol(Aoid);
P#opsito: - funo clrscr() (clear screen) limpa a $anela de tela e posiciona o cursor na primeira lina
e primeira coluna da $anela (canto superior es&uerdo da $anela). - funo clreol() (clear to end of line)
limpa uma lina desde a posio do cursor at o final da lina mas no modifica a posio do cursor. -mbas
fun%es preencem a tela com a cor de fundo definida pela funo text,ac<round().
!.11 - Posicionamento do cursor2 "otox%()
Biblioteca: conio.9
:ecla#a8Ges: Aoid <otox:(int pos_x, int pos_);
<:
P#opsito: 'm modo texto padro, a tela dividida em uma $anela de :? linas e D1 colunas. - funo
<otox:() permite posicionarmos o cursor em &ual&uer posio (pos8x,pos8:) da tela. Sendo &ue a
posio (0,0) corresponde ao canto superior es&uerdo da tela e a posio (D1,:?) corresponde ao canto
inferior direito. Como as fun%es printf() e cprintf() escrevem a partir da posio do cursor,
podemos escrever em &ual&uer posio da tela.
!.12 - *edimencionamento de =ane%a2 &indo&()
Biblioteca: conio.9
:ecla#a8Ges: Aoid NindoN(int esq, int sup, int dir, int inf);
P#opsito: 'sta funo permite redefinir a $anela de texto. -s coordenadas esO e sup definem o canto
superior es&uerdo da nova $anela, en&uanto as coordenadas inf e dir definem o canto inferior direito da
nova $anela. ,ara reativar a $anela padro escreve4se a instruo NindoN(1,1,$0,2!). Auando uma
$anela definida, o texto &ue ficar fora da $anela fica congelado at &ue se redefina a $anela original.
!.13 - >onitorao de tec%ado2 'b$it()
Biblioteca: conio.9
:ecla#a8Ges: int E,9it(Aoid);
P#opsito: 'sta funo (5eyboard itting) permite verificar se uma tecla foi pressionada ou no. 'sta funo
verifica se existe algum c!digo no buffer de teclado. Se ouver algum valor, ela retorna um n/mero no nulo
e o valor arma+enado no buffer pode ser lido com as fun%es <etc9() ou <etc9e(). Caso nenuma tecla
se$a pressionada a funo retorna 1. Observe &ue, ao contrrio de <etc9(), esta funo n4o agua#da &ue
uma tecla se$a pressionada.
P#og#ama Exemplo: O ar&uivo e1@1D.cpp contm um programa para exemplificar o uso das fun%es
clrscr(), clreol(), <otox:(), NindoN(), E,9it().
/* *******************************************************************
Programa: e0408.cpp
Proposito: Uso das funcoes clrscr(), clreol(), gotoxy(), window()
e kbhit()
Ultima Reviso: 11/08/97
******************************************************************* */
#include <conio.h>
#include <string.h>
#include <stdlib.h>
#include <dos.h>
void main(){
int esq,sup,dir,inf; // bordas
char* tit = "Teste de video: Blocos coloridos"; // titulo
char* rpe = "Pressione alguma tecla para terminar"; // rodap
clrscr(); // limpa tela
textbackground(BLUE); // seleciona cor de fundo de linha
textcolor(WHITE); // cor de letra
gotoxy(1,1); // posiciona cursor no canto esquerdo
clreol(); // desenha fundo de linha
gotoxy(40 - strlen(tit)/2, 1); // posiciona cursor
cprintf("%s",tit); // escreve titulo centralizado
gotoxy(1,25); // posiciona cursor no canto esquerdo
clreol(); // desenha fundo de linha
gotoxy(40 - strlen(rpe)/2, 25); // posiciona cursor
cprintf("%s",rpe); // escreve rodap centralizado
do{
delay(100); // pausa pra ano ficar muito ligeiro
esq = 1 + random(80); // esq <- [1 , 80]
dir = esq + random(81-esq); // dir <- [esq, 80]
<<
sup = 2 + random(23); // sup <- [ 2, 24]
inf = sup + random(25-sup); // inf <- [sup, 24]
window(esq,sup,dir,inf); // define janela
textbackground(random(8)); // seleciona cor de fundo aleatria
clrscr(); // preenche janela com cor
}while(!kbhit());
window(1,1,80,25); // restaura janela
textbackground(BLACK); // restaura cor de fundo
clrscr(); // limpa tela
}
<@
;Est#utu#as de Cont#ole
'struturas de controle permitem controlar a se&B5ncia das a%es l!gicas de um programa. Masicamente,
existem dois tipos de estruturas de controle. estruturas de #epeti84o e estruturas de decis4o. - estrutura de
repetio permite &ue um bloco de instru%es se$a executado repetidamente uma &uantidade controlada de
ve+es. - estrutura de deciso permite executar um entre dois ou mais blocos de instru%es. Neste captulo
estudaremos em detale as instru%es do C &ue permitem implementar estas estruturas.
).1 - Condio de contro%e
'm todas as estruturas, existe pelo menos uma expresso &ue fa+ o controle de @ual bloco de instru%es ser
executado ou @uantas ve>es ele ser executado. o &ue camamos de condi84o de cont#ole. #ma condio
de controle uma expresso l!gica ou aritmtica cu$o resultado pode ser considerado verdadeiro ou falso.
Conforme vimos na seo <.?, a linguagem C no possui, entretanto, variveis ou constantes l!gicas, possui
somente express%es numricas, assim &uando uma exp#ess4o numF#ica se encontra em uma condi84o de
cont#ole, ela ser considerada 5alsa se seu valor for igual a >e#o, e ve#dadei#a se seu valor for di5e#ente de
>e#o.
Exemplo: Observe nas condi%es abaixo, seu valor numrico e seu significado l!gico. Considere as
variveis int i F 0, = F 3;
condio valor numrico significado lgico
(i == 0) 1 verdadeiro
(i > j) 0 falso
(i) 0 falso
(j) 3 verdadeiro
'ste fato deve ficar claro pois, nas estruturas &ue estudaremos neste captulo, &uando for dito &ue uma
condio 5alsa ou ve#dadei#a &uer se di+er &ue seu valor e igual a +ero ou di5e#ente de +ero.
).2 - Estrutura do...&$ile
'sta uma estrutura bsica de repetio condicional. ,ermite a execuo
de um bloco de instru%es repetidamente. Sua sintaxe a seguinte.
!intaxe:
do {
bloco
}while(condio);
onde. condio uma expresso l!gica ou numrica.
bloco um con$unto de instru%es.
'sta estrutura fa+ com &ue o bloco de instru%es se$a executado pelo
menos uma ve+. -p!s a execuo do bloco, a condio avaliada. Se a
condio ve#dadei#a o bloco executado outra ve+, caso contrrio a
repetio terminada. O fluxograma desta estrutura mostrada na figura
?.0.
Exemplo: No treco abaixo, a leitura de um n/mero feita dentro de um
lao de repetio condicional. - leitura repetida caso o n/mero lido
se$a negativo.
do
{ puts("Digite um nmero positivo:");
scanf("%f",&num);
}while(num <= 0.0);
).3 - Estrutura &$ile
- estrutura de repetio condicional N9ile semelante a estrutura
do...N9ile. Sua sintaxe a seguinte.
!intaxe:
while(condio)
<?
bloco
condio?
V
F
-igura ).22 6luxograma da estrutura
!hile.
bloco
condio? V
F
-igura ).12 6luxograma da estrutura
do...!hile.
{ bloco
}
onde. condio uma expresso l!gica ou numrica.
bloco um con$unto de instru%es.
'sta estrutura fa+ com &ue a condio se$a avaliada em primeiro lugar. Se a condio ve#dadei#a o bloco
executado uma ve+ e a condio avaliada novamente. Caso a condio se$a 5alsa a repetio terminada
sem a execuo do bloco. Observe &ue nesta estrutura, ao contrrio da estrutura do...N9ile, o bloco de
instru%es pode no ser executado nenuma ve+, basta &ue a condio se$a inicialmente falsa. O fluxograma
desta estrutura mostrada na figura ?.:.
Exemplo: No treco abaixo, calcula4se a preciso () do processador aritmtico do ,C. - varivel eps tem
seu valor dividido por 2 en&uanto o processador conseguir distinguir entre 0 e 0;. -p!s a execuo do lao,
o valor de eps contm a preciso da m&uina.
eps = 1.0;
while(1.0 + eps > 1.0)
{ eps /= 2.0;
}
).! - Estrutura for
- estrutura for muito semelante as estruturas de repetio vistas anteriormente, entretanto costuma ser
utili+ada &uando se &uer um n/mero determinado de ciclos. - contagem dos ciclos feita por uma varivel
camada de contado#. - estrutura for , as ve+es, camada de estrutura de #epeti84o com contado#. Sua
sintaxe a seguinte.
!intaxe:
for(iniciali(ao; condio) incremento)
{ bloco
}
onde. iniciali"ao uma expresso de iniciali+ao do contador.
condio uma expresso l!gica de controle de repetio.
incremento uma expresso de incremento do contador.
bloco um con$unto de instru%es a ser executado.
'sta estrutura executa um n/mero determinado de repeti%es usando um contador de itera%es. O contador
iniciali+ado na expresso de iniciali"ao antes da primeira iterao. ,or exemplo. i F 0; ou
cont F 20;. 'nto o bloco executado e depois de cada iterao, o contador incrementado de acordo
com a expresso de incremento. ,or exemplo. iDD ou cont 6F 2. 'nto a expresso de condio
avaliada. se a condio for verdadeira, o bloco executado novamente e o ciclo recomea, se a condio
falsa termina4se o lao. 'sta condio , em geral, uma expresso l!gica &ue determina o ultimo valor do
contador. ,or exemplo. i IF 100 ou cont H 0.
Exemplo: No treco abaixo, o contador i iniciali+ado com o valor 1. O bloco repetido en&uanto a
condio i IF 10 for verdadeira. O contador incrementado com a instruo iDD. 'sta estrutura, deste
modo, imprime os n/meros 1, 2, ..., %, 10.
for(i=1; i<=10; i++)
{ printf(" %d",i);
}
E interessante notar &ue a mesma estrutura l!gica pode ser implementada usando as estruturas for ou
do...N9ile.
Exemplo: -s seguintes instru%es so plenamente e&uivalentes.
i = 0; for(i = 0; i <= 100; i++)
do { bloco
{ bloco }
i++;
}while(i <= 100);
,odem existir mais de uma expresso de iniciali"ao e de incremento na estrutura for. 'stas
express%es devem ser separadas por vrgula (,). Ias n4o pode aver mais de uma expresso de condio.
,or exemplo. for(iF0, =F10; iI10; iDD, =66)V...W
<C
).) - Estrutura de deciso if...else
- estrutura if...else a mais simples estrutura de controle do C. 'sta estrutura permite executar um
entre vrios blocos de instru%es. O controle de &ual bloco ser executado ser dado por uma condio
(expresso l!gica ou numrica). 'sta estrutura pode se apresentar de modos ligeiramente diferentes. Nesta
seo vamos apresentar separadamente cada uma das possibilidades de sintaxe.
;.;.1 :ecis4o de um bloco (if...)
- estrutura de deciso de um bloco permite &ue se execute (ou
no) um bloco de instru%es conforme o valor de uma condio
se$a verdadeiro ou falso. O fluxograma desta estrutura mostrada
na figura ?.<.
!intaxe: *eciso com um bloco.
if(condio){
bloco
}
onde. condio uma expresso l!gica ou numrica.
bloco um con$unto de instru%es.
Se a condio ve#dadei#a, o bloco executado. Caso contrrio,
o bloco no executado.
Exemplo: No treco abaixo, se o valor lido for maior &ue 01, ento o seu valor redefinido como 01.
Observe &ue o bloco constitui4se de um /nica instruo.
printf("Digite o nmero de repeties: (mximo 10)";
scanf("%d",&iter);
if(iter > 10){
iter = 10;
}
P#og#ama Exemplo: O ar&uivo e0!0.cpp mostra um programa &ue utili+a a estrutura if... para
emitir um sinal sonoro ao imprimir um n/mero m/ltiplo de @.
/*******************************************************************
Programa: e0504.cpp
Propsito: Uso da estrutura if...
Ultima Reviso: 26/08/97
*******************************************************************/
#include <dos.h> // incluso de bibliotecas
#include <conio.h>
#include <stdio.h>
void main()
{ int i; // contador
clrscr();
puts("Jogo do Pim!");
for(i = 1; i <= 20; i++) // para i de 1 a 20...
{ printf("\n%2d...",i); // imprime numero
if(i%4 == 0) // se mltiplo de 4...
{ sound(600); // Pim!
delay(50); //
nosound(); //
} // fim se
delay(500); // espera
}
puts("Oba! Ganhei o prmio!");
}
;.;.2 - :ecis4o de dois blocos (if...else)
Gambm possvel escrever uma estrutura &ue execute um entre dois
blocos de instru%es. - figura ?.@ mostra o fluxograma
correspondente a esta estrutura de deciso.
!intaxe. *eciso de dois blocos.
if(condio)
<F
condio
bloco
V
F
-igura ).32 6luxograma da estrutura de deciso
if...
condio?
bloco 1 bloco 2
-igura ).!2 6luxograma da estrutura de
deciso if...else
{ bloco1;
}
else
{ bloco2;
}
onde. condio uma expresso l!gica ou numrica.
bloco1 e bloco2 so con$untos de instru%es.
Se a condi21o for ve#dadei#a o bloco1 executado. Caso contrrio, o bloco2 executado.
Exemplo: No treco abaixo, se o valor de raiz*raiz for maior &ue num o valor de raiz ser
atribudo a max, caso contrario, ser atribudo a min.
if(raiz*raiz > num)
{ max = raiz; }
else
{ min = raiz; }
P#og#ama Exemplo: O ar&uivo e0!0!.cpp mostra um programa &ue utili+a a estrutura if...else
para determinar o tipo de ra+es de uma e&uao de segundo grau.
/* *******************************************************************
Programa: e0505.cpp
Proposito: Uso da estrutura if...else
Ultima Reviso: 26/08/97
******************************************************************* */
#include <stdio.h>
void main(){
float a,b,c; // parmetros de ax^2+bx+c=0
float delta; // discriminante: b^2-4ac
puts("\nBaskara");
puts("Digite valores para a, b, c: ");
scanf("%f %f %f",&a,&b,&c); // leitura dos parmetros
delta = b * b - 4. * a * c; // calculo do discriminante
printf("Discriminante: %f", delta);
if(delta >= 0.0) // se delta e' positivo...
{ puts(" Razes Reais"); // razes reais
}
else // ...seno...
{ puts(" Razes Complexas"); // razes complexas
}
}
;.;.2 - :ecis4o de mBltiplos blocos (if...else if...)
Gambm possvel escrever uma estrutura &ue execute um entre m/ltiplos blocos de instru%es. - figura ?.?
mostra o fluxograma correspondente a esta estrutura de deciso.
<D
Condio
1?
bloco 1
Condio
2?
bloco 2
Condio
3?
bloco 3
. . .
. . .
V
F
V
F
V
F
-igura ).)2 6luxograma da estrutura de deciso if...else if.
!intaxe. *eciso de m/ltiplos blocos.
if(condio 1){
bloco 1;
...
}else if(condio *){
bloco *;
}else{
bloco +
}
onde. condio 1# condio 2# ... so express%es l!gicas ou numricas.
bloco 1 # bloco 2#... so con$untos de instru%es.
Se a condio 0 for ve#dadei#a o bloco 1 executado. Caso contrario, a condio : avaliada. Se a
condio : for ve#dadei#a o bloco 2 executado. Caso contrario, a condio < avaliada e assim
sucessivamente. Se nenuma condio ve#dadei#a bloco $ executado. Observe &ue apenas um dos
blocos executado.
Exemplo: No treco abaixo, uma determinada ao executada se o valor de num for positivo, negativo ou
nulo.
if(num > 0){
a = b;
}else if(num < 0){
a = b + 1;
}else{
a = b - 1;
}
P#og#ama Exemplo: O ar&uivo e0!0".cpp mostra um programa &ue utili+a a estrutura if...else if
para determinar se um n/mero maior, menor ou igual a outro.
/* *******************************************************************
Programa: e0506.cpp
Proposito: Uso da estrutura if...else if
<K
Ultima Reviso: 26/08/97
******************************************************************* */
#include <stdio.h>
#include <stdlib.h>
#include <math.h>
void main()
{ int palpite; // palpite do usurio
int numero; // numero do computador
randomize(); // inicializador do gerador aleatrio
numero = random(10); // escolhe numero aleatrio
puts("\nEscolhi um nmero. Adivinha qual ?\n");
scanf("%d",&palpite); // leitura do palpite
if(palpite > numero){ // se chute alto...
puts("Chute alto!"); // mensagem
}else if(palpite < numero){ // ...senao se chute baixo...
puts("Chute baixo!"); // mensagem
}else{ // senao acertou
puts("Acertou!"); // mensagem
}
}
).+ - Estrutura s&itc$...case
- estrutura sNitc9...case uma estrutura de deciso &ue permite a execuo de um con$unto de
instru%es a partir pontos diferentes conforme o resultado de uma expresso inteira de controle. O resultado
deste expresso comparado ao valor de cada um dos r!tulos, e as instru%es so executadas a partir desde
r!tulo. - figura ?.C mostra o fluxograma l!gico desta estrutura.
!intaxe. 'sta estrutura possui a seguinte sintaxe.
switch(expresso){
case r!t#lo_1:
con,#nto_1
case r!t#lo_2:
con,#nto_2
.
.
.
case r!t#lo_n:
con,#nto n
default:
con,#nto_d
}
onde.
expresso uma expresso inteira.
r%tulo_1# r%tulo_2# r%tulo_n e r%tulo_d so constantes inteiras.
con&unto 1# con&unto 2# ...# con&unto_n e con&unto_d so con$untos de
instru%es.
@1
O valor de expresso avaliado e o fluxo l!gico ser
desviado para o con$unto cu$o r%tulo igual ao resultado
da expresso e todas as instru%es abaixo deste r!tulo sero
executadas. Caso o resultado da expresso for diferente de
todos os valores dos r!tulos ento con&unto d
executado. Os r!tulos devem ser express%es constantes
inteiras di5e#entes entre si. O r!tulo default opcional.
'sta estrutura particularmente /til &uando se tem um
con$unto de instru%es &ue se deve executar em ordem,
porm se pode comear em pontos diferentes.
Exemplo: O treco abaixo ilustra o uso da instruo
sNitc9 em um menu de seleo. Neste exemplo, o
programa iniciar o processo de usinagem de uma pea em
um ponto &ual&uer dependendo do valor lido.
int seleo;
puts("Digite estagio de usinagem:");
scanf("%d",&selecao);
switch(seleo){
case 1:
// desbaste grosso...
case 2:
// desbaste fino...
case 3:
// acabamento...
case 4:
// polimento...
}
)., - Interrupo e desvio2 #rea?9 continue9 goto9 e@it78
-s instru%es vistas anteriormente podem sofrer desvios e inte##up8Ges em sua se&B5ncia l!gica normal
atravs do uso certas instru%es. -s instru%es &ue veremos a seguir devem ser usadas com muita
parcimZnia, pois fogem da l!gica estruturada tem a tend5ncia de tornar um programa incompreensvel.
;.-.1 - A inst#u84o break
'sta instruo serve para terminar a execuo das instru%es de um lao de repetio ( for,
do...N9ile, N9ile) ou para terminar um con$unto sNitc9...case.
Auando em um lao de repetio, esta instruo fora a interrupo do lao independentemente da condio
de controle.
Exemplo: No treco abaixo um lao de repetio l5 valores para o clculo de uma mdia. O lao possui uma
condio de controle sempre verdadeira o &ue, a principio, um erro. lao infinito. ,orm, a sada do lao se
d pela instruo ,reaE &ue executada &uando um valor negativo lido.
puts("digite valores:");
do{
puts("valor:");
scanf("%f",&val);
if(val < 0.0){
break; // sada do lao
}
num++;
soma += val;
}while(1); // sempre verdadeiro
printf("mdia: %f",soma/num);
Exemplo: No exemplo acima, o uso da instruo ,reaE poderia ter sido evitado, como segue.
puts("digite valores:");
do{
@0
conjunto 1
conjunto N
conjunto 2
conjunto D
...
expresso
rotulo 1
rotulo N
rotulo D
rotulo 2

-igura ).+2 6luxograma da estrutura
s!itch...case.
puts("valor:");
scanf("%f",&val);
if(val >= 0.0){
num++;
soma += val;
}
}while(val >= 0.0);
printf("mdia: %f",soma/num);
O outro uso da instruo ,reaE, em estruturas sNitc9...case, serve para separar os con$untos de
instru%es em cada case.
Exemplo: 'strutura sNitc9...case com a instruo ,reaE.
int tipo;
puts("Selecione o sabor de sua pizza:");
puts("Muzzarela Calabreza Alho&Oleo:");
tipo = getch();
switch(tipo){
case M:
// prepara pizza muzzarela...
case C:
// prepara pizza calabreza...
case A:
// prepara pizza Alho&Oleo...
default:
puts("Opcao incorreta");
}
;.-.2 A inst#u84o continue.
'sta instruo opera de modo semelante a instruo ,reaE dentro de um lao de repetio. Auando
executada, ela pula as instru%es de um lao de repetio sem sair do lao. 3sto , a instruo fora a
avaliao da condio de conttrole do lao.
Exemplo: No treco abaixo revemos um lao de repetio l5 valores para o clculo de uma mdia. Se (Aal
I 0.0) ento o programa salta diretamente para a condio de controle, sem executar o resto das
instru%es.
puts("digite valores:");
do{
puts("valor:");
scanf("%f",&val);
if(val < 0.0){ // se val negativo...
continue; // ...salta para...
}
num++; // se (val < 0.0) estas instrues
soma += val; // no so executadas!
}while(val >= 0.0); // ...fim do lao
printf("mdia: %f",soma/num);
;.-.2 - A inst#u84o goto
'sta instruo camada de desvio de fluxo. - instruo desvia o programa para um r!tulo (posio
identificada) no programa. So raros os casos onde a instruo goto necessria, no entanto, certas
circunst9ncias, onde usada com prud5ncia, ela pode ser /til.
!intaxe: - sintaxe da instruo goto a seguinte.
goto r!t#lo;
...
r!t#lo:
...
onde r%tulo um identificador vlido.
Exemplo: No treco abaixo revemos um lao de repetio l5 valores para o clculo de uma mdia. "oram
usadas duas instru%es <oto.
puts("digite valores:");
inicio: // rtulo
puts("valor:");
@:
scanf("%f",&val);
if(val < 0.0){ // se val negativo...
goto fim; // ...salta para fim
}
num++; // se (val < 0.0) estas instrues
soma += val; // no so executadas!
goto inicio; // salta para inicio
fim: // rtulo
printf("mdia: %f",soma/num);
;.-.9 - A 5un84o exit().
'sta funo (no instruo) exit() , da biblioteca stdli,.9, uma funo &ue termina a execuo de
um programa. Normalmente um programa terminado &uando se executa a /ltima sua instruo, porm
pode4se terminar a execuo do programa a &ual&uer momento com o uso desta funo.
- funo exit() tem a seguinte declarao. Aoid exit(int status). Onde o argumento da funo
um valor inteiro &ue ser passado para o Sistema Operacional. (varivel de sistema errorleAel no
*OS).
Exemplo: No treco abaixo revemos um lao de repetio l5 valores para o clculo de uma mdia. "oi usado
a funo exit para terminar a execuo do programa.
puts("digite valores:");
do{
puts("valor:");
scanf("%f",&val);
if(val < 0.0){ // se val negativo...
printf("mdia: %f",soma/num); // imprime resultado
exit(0); // termina programa
}
num++; soma += val;
}while(1);
<"un8Ges
"un%es (tambm camadas de #otinas, ou sub-p#og#amas) so a ess5ncia da programao estruturada.
"un%es so segmentos de programa &ue executam uma determinada tarefa especfica. T vimos o uso de
fun%es nos captulos anteriores. fun%es $ providenciadas pelas bibliotecas4padro do C (como sOrt(),
toupper(), <etc9() ou putc9ar()).
E possvel ao programador, alem disso, escrever suas pr!prias rotinas. So as camadas de 5un8Ges de
usu6#io ou rotinas de usurio. *este modo pode4se segmentar um programa grande em vrios programas
menores. 'sta segmentao camada de modula#i>a84o e permite &ue cada segmento se$a escrito, testado
e revisado individualmente sem alterar o funcionamento do programa como um todo. ,ermite ainda &ue um
programa se$a escrito por vrios programadores ao mesmo tempo, cada um escrevendo um segmento
separado. Neste captulo, veremos como escrever fun%es de usurio em C.
+.1 - Estrutura das fun.es de usuArio
- estrutura de uma funo de usurio muito semelante a estrutura dos programas &ue escrevemos at
agora. #ma funo de usurio constitui4se de um bloco de inst#u8Ges &ue definem os procedimentos
efetuados pela funo, um nome pelo &ual a camamos e uma lista de a#gumentos passados a funo.
Camamos este con$unto de elementos de de5ini84o da 5un84o.
Exemplo: o c!digo mostrado abaixo uma funo definida pelo usurio para calcular a mdia aritmtica de
dois n/meros reais.
float media2(float a, float b){
float med;
med = (a + b) / 2.0;
return(med);
}
@<
No exemplo acima definimos uma funo camada media2 &ue recebe dois argumentos tipo float. a e
,. - mdia destes dois valores calculada e arma+enada na varivel med declarada internamente. - funo
retorna, para o programa &ue a camou, um valor tambm do tipo float. o valor da varivel med. 'ste
retorno de valor feito pela funo return()&ue termina a execuo da funo e retorna o valor de med
para o programa &ue a camou.
*epois de definimos um funo, podemos us4la dentro de um programa &ual&uer. *i+emos &ue estamos
fa+endo uma c=amada a funo.
Exemplo: No exemplo abaixo camamos a funo media2() dentro de um programa principal.
void main()
{ float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2); // chamada a funo
printf(\nA media destes nmeros e %f, med);
}
+.2 - Definio de fun.es
*e modo formal, a sintaxe de uma funo a seguinte.
tipo_de_retorno nome_da_f#no(tipo_1 ar"_1, tipo_2 ar"_2, ...)
- [bloco de instr#.es da f#no]
}
- primeira lina da funo contm a decla#a84o da funo. Na declarao de uma funo se define o nome
da funo, seu tipo de #eto#no e a lista de a#gumentos &ue recebe. 'm seguida, dentro de caves VW,
definimos o bloco de instru%es da funo.
O tipo de #eto#no da funo especifica &ual o tipo de dado retornado pela funo, podendo ser &ual&uer tipo
de dado mostrado na seo :.<. int, float, etc. Se a funo no retorna nenum valor para o programa
&ue a camou devemos definir o retorno como Aoid, ou se$a um retorno ausente. Se nenum tipo de retorno
for especificado o compilador entender &ue o retorno ser tipo int.
>ale notar &ue existe apenas um valor de retorno para fun%es em C. '4o podemos fa+er o retorno de dois
ou mais valores como em algumas linguagens (no IatHab. Rmedia,desAioS F estat(a, ,, c,
d, e)). ,orm isto no um limitao sria pois o uso de ponteiros (cap. Q) contorna o problema.
,or ser um identificador, o nome da 5un84o segue as mesmas regras de definio de identificadores (ve$a
seo :.:).
- lista de a#gumentos da funo especifica &uais so os valores &ue a funo recebe. -s variveis da lista
de argumentos so manipuladas normalmente no corpo da funo (ve$a seo C.? adiante).
- camada de uma funo termina com a instruo return() &ue transfere o controle para o programa
camador da funo. 'sta instruo tem duas finalidades. determina o 5im lgico da rotina e o valo# de
#eto#no da funo. O argumento de return() ser retornado como valor da funo.
+.3 - Loca%i<ao das fun.es
'xistem basicamente duas posi%es possveis para escrevermos o corpo de uma funo. ou antes ou depois
do programa principal. ,odemos ainda escrever uma funo no mesmo a#@uivo do programa principal ou
em a#@uivo sepa#ado.
<.2.1 - Co#po da 5un84o antes do p#og#ama p#incipal Dno mesmo a#@uivoE
Auando escrevemos a definio de uma funo antes do programa principal e no mesmo ar&uivo deste,
nenuma outra instruo necessria. - sintaxe geral para isto a seguinte.
!intaxe: #ma funo escrita antes do programa principal.
tipo nomef(...) // definio da funo
@@
{ [corpo de f#no]
}
void main() // programa principal
{ ...
var = nomef(...) // chamada da funo
...
}
Exemplo: "uno media2() escrita antes do programa principal.
float media2(float a, float b) // funo
{ float med;
med = (a + b) / 2.0;
return(med);
}
void main() // programa principal
{ float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2); // chamada da funo
printf(\nA media destes nmeros e %f, med);
}
P#og#ama exemplo: No ar&uivo e0"01.cpp existe um programa &ue calcula o maior valor entre dois
n/meros digitados. 'ste programa fa+ uso da funo max()escrita pelo usurio.
/*****************************************************************
Programa: e0601.cpp
Propsito: Funo de usurio escrita antes de programa principal
Ultima Reviso: 29/09/97
*****************************************************************/
#include <conio.h>
#include <stdio.h>
float max(float a, float b) // funcao max()
{ if(a > b)
{ return(a);
}
else
{ return(b);
}
}
void main() // programa principal
{ float num1,num2,m;
clrscr();
puts("*** Valor maximo de dois reais ***");
puts("Digite dois numeros:");
scanf("%f %f",&num1,&num2);
m = max(num1,num2); // chamada da funcao
printf("O maior valor e': %f",m);
getch();
}
<.2.2 - Co#po da 5un84o depois do p#og#ama p#incipal Dno mesmo a#@uivoE
Auando escrevemos a definio de uma funo depois do programa principal e no mesmo ar&uivo deste,
devemos incluir um p#ottipo da funo camada. #m prot!tipo uma instruo &ue define o nome da
funo, seu tipo de retorno e a &uantidade e o tipo dos argumentos da funo. O prot!tipo de uma funo
indica ao compilador &uais so as fun%es usadas no programa principal os tipo. - sintaxe geral para isto a
seguinte.
!intaxe: #ma funo escrita depois do programa principal.
void main(){ // programa principal
tipo nomef(...); // prottipo da funo
...
var = nomef(...) // chamada a funo
...
}
@?
tipo nomef(...){ // definio da funo
[corpo de f#no]
}
Exemplo: "uno media2() escrita depois do programa principal.
void main(){ // programa principal
float media2(float,float); // prottipo de media2()
float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2); // chamada a funo
printf(\nA media destes nmeros e %f, med);
}
float media2(float a, float b){ // funo media2()
float med;
med = (a + b) / 2.0;
return(med);
}
Observe &ue o prot!tipo de uma funo nada mais &ue a decla#a84o da funo sem o seu corpo. Observe
ainda &ue na lista de argumentos do prot!tipo podem ser escritos apenas os tipos dos argumentos.
P#og#ama exemplo: No ar&uivo e0"02.cpp existe um programa &ue calcula o maior valor entre dois
n/meros digitados. 'ste programa fa+ uso da funo max()escrita pelo usurio.
/*****************************************************************
Programa: e0602.cpp
Proposito: Funcao de usurio escrita depois de programa principal
Ultima Reviso: 29/09/97
*****************************************************************/
#include <conio.h>
#include <stdio.h>
void main(){ // programa principal
float max(float,float); // prottipo da funcao max()
float num1, num2;
clrscr();
puts("*** Valor maximo de dois reais ***");
puts("Digite dois numeros");
scanf("%f %f",&num1,&num2);
printf("O maior valor e': %f",max(num1,num2)); // chamada a funcao
getch();
}
float max(float a, float b){ // funcao max()
if(a > b){
return(a);
}else{
return(b);
}
}
<.2.2 - Co#po da 5un84o esc#ito em arBuivo separado
'm C, como em muitas outras linguagens, permitido &ue o usurio crie uma funo em um a#@uivo e um
programa &ue a came em outro a#@uivo distinto. 'sta facilidade permite a criao de bibliotecas de
usu6#io. um con$unto de ar&uivos contendo fun%es escritas pelo usurio. 'sta possibilidade uma grande
vantagem utili+ada em larga escala por programadores profissionais.
Auando escrevemos a definio de uma funo em a#@uivo sepa#ado do programa principal devemos
inclui# este ar&uivo no con$unto de ar&uivos de compila84o do programa principal. 'sta incluso feita com
a diretiva #include. 'sta diretiva, vista nas se%es :.@.: e <.F.0, instrui o compilador para incluir na
compilao do programa outros ar&uivos &ue contem a definio das fun%es de usurio e de biblioteca.
!intaxe: - sintaxe de incluso de fun%es de usurio a seguinte.
#include pat$ // incluso da funo
void main(){ // programa principal
@C
...
var = nomef(...) // chamada a funo
...
}
Na diretiva #include, indicamos entre aspas duplas o camino de locali+ao do ar&uivo onde est
definida a funo camada.
Exemplo: - funo media2() est escrita em um ar&uivo separado.
#include c:\tc\userbib\stat.h // incluso da funo
void main(){ // programa principal
float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2); // chamada a funo
printf(\nA media destes nmeros e %f, med);
}
Hbse#va84o: #m ar&uivo pode conter a definio de uma ou mais fun%es. 'm geral, &uando o ar&uivo
possui apenas uma funo ele nomeado com o mesmo nome da funo e extenso *.cpp ou *.c. ,or
exemplo, poderamos definir a funo media() no ar&uivo media.cpp. Auando um ar&uivo possui a
definio de mais de uma funo, ele nomeado com a extenso *.9 ou *.li,. ,or exemplo. poderamos
criar um con$unto de fun%es estatsticas camadas media(), dsApd(), moda(), max(),
min(), etc. definindo4as em um ar&uivo camado stat.9.
+.! - CierarBuia de -un.es
Sempre possvel &ue um programa principal came uma funo &ue por sua ve+ came outra funo... e
assim sucessivamente. Auando isto acontece di+emos &ue a funo camadora tem ierar&uia maior (ou
superior) a funo camada. Ou &ue a funo camadora est em um nvel ierr&uico superior a funo
camada.
Auando isto ocorre, devemos ter o cuidado de definir (ou incluir) as fun%es em ordem crescente de
ierar&uia, isto , uma funo c=amada escrita antes de uma funo c=amado#a. 3sto se deve ao fato de
&ue o compilador deve conecer uma funo antes de &ue camada se$a compilada.
P#og#ama exemplo: No ar&uivo e0"0!.cpp existe um $ogo de 6*ac5pot7 &ue ilustra o uso de vrias
rotinas por um programa principal. Observe tambm &ue estas fun%es camam4se umas as outras.
/*********************************************************
Programa: e0605.cpp
Propsito: Uso de varias funes de usurio.
Ultima Reviso: 29/09/97
*********************************************************/
// 1 incluso de bibliotecas padro C
// **********************************
#include <dos.h>
#include <string.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
// 2 rotina bip()
// **************
void bip(int tipo){
int i; // contador de iterao
switch (tipo){ // seleciona tipo de som...
case 0: // giro da roleta
sound(100);
delay(5);
break;
case 1: // parada da roleta
sound(200);
delay(100);
@F
break;
case 2: // moedas caindo
sound(3000);
delay(20);
}
nosound();
}
// 3 rotina pinta()
// ****************
void pinta(int figura,int status, int linha, int coluna){
switch (figura){ // seleciona figura...
case 1: // happy face
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
}else{
textcolor(YELLOW+BLINK); // cor da figura
}
gotoxy(coluna,linha++); // posiciona cursor
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
break;
case 2: // copa
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
}else{
textcolor(RED); // cor da figura
}
gotoxy(coluna,linha++); // posiciona cursor
cprintf(" ");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
break;
case 3: // ouro
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
@D
}else{
textcolor(BLUE); // cor da figura
}
gotoxy(coluna,linha++); // posiciona cursor
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
break;
case 4: // espada
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
}else{
textcolor(GREEN); // cor da figura
}
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
break;
case 5: // pau
if(status == 0){ // se roleta girando...
textcolor(LIGHTGRAY); // cor normal
}else{
textcolor(CYAN); // cor da figura
}
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf("");
@K
gotoxy(coluna,linha++);
cprintf("");
gotoxy(coluna,linha++);
cprintf(" ");
gotoxy(coluna,linha++);
cprintf(" ");
};
textcolor(LIGHTGRAY); // cor padrao
};
// 4 rotina imprimec()
// *******************
void imprimec(int linha,char* texto){
int col,tam;
textcolor(WHITE); // cor de letra
textbackground(BLUE); // cor de fundo
gotoxy(1,linha); // posiciona o cursor
clreol(); // limpa linha(imprime fundo)
tam = strlen(texto); // calcula o tamanho do texto
col = 40 - tam / 2; // calcula a coluna de inicio
gotoxy(col,linha); // posiciona o cursor
cprintf("%s",texto); // imprime o texto
textcolor(LIGHTGRAY); // cor de letra original
textbackground(BLACK); // cor de fundo original
};
// 5 rotina regras()
// *****************
void regras(){
clrscr();
imprimec(1,"J a c k p o t !");
imprimec(10,"Regras:");
imprimec(11,"- Pressione [enter] para rodar a roleta.");
imprimec(12,"- Pressione [esc] para sair.");
imprimec(13,"- Quanto maior o numero de CARAS FELIZES, maior seu prmio!");
getch();
clrscr();
}
// 6 Rotina Saida()
// ****************
void saida(void){
imprimec(12,"Vencedores no usam drogas!");
delay(2000);
textcolor(LIGHTGRAY);
textbackground(BLACK);
clrscr();
}
// 7 rotina roleta()
// *****************
void roleta(int naipe1,int naipe2,int naipe3,int naipe4,int naipe5){
int volta1=2,volta2=4,volta3=8,volta4=16,volta5=32,tempo=25;
do{
if(volta1 > 1){
pinta(random(4)+2,0,5,6);
bip(0);
volta1--;
}else if(volta1 == 1){
pinta(naipe1,1,5,6);
bip(1);
volta1--;
}
delay(tempo);
?1
if(volta2 > 1){
pinta(random(4)+2,0,5,21);
bip(0);
volta2--;
}else if(volta2 == 1){
pinta(naipe2,1,5,21);
bip(1);
volta2--;
}
delay(tempo);
if(volta3 > 1){
pinta(random(4)+2,0,5,36);
bip(0);
volta3--;
}else if(volta3 == 1){
pinta(naipe3,1,5,36);
bip(1);
volta3--;
}
delay(tempo);
if(volta4 > 1){
pinta(random(4)+2,0,5,51);
bip(0);
volta4--;
}else if(volta4 == 1){
pinta(naipe4,1,5,51);
bip(1);
volta4--;
}
delay(tempo);
if(volta5 > 1){
pinta(random(4)+2,0,5,66);
bip(0);
volta5--;
}else if(volta5 == 1){
pinta(naipe5,1,5,66);
bip(1);
volta5--;
}
delay(tempo);
}while(volta5 > 0);
}
// 8 rotina abertura()
// *******************
void abertura(){
imprimec(1,"J a c k P o t !"); // titulo
roleta(1,1,1,1,1); // caras felizes
imprimec(25,"T e n t e s u a S o r t e !"); // rodap
getch(); // aguarda
}
// 9 rotina simnao()
// *****************
int simnao(){
int tecla,resp;
do{
tecla = getch(); // leitura do teclado
switch (tecla){
case 13: // pressionou [enter]?
resp = 1;
?0
break;
case 27: // pressionou [esc]?
resp = 0;
break;
default: // pressionou qq outra coisa?
printf("\a");
};
}while(tecla != 13 && tecla != 27); // nao sai enquanto tecla != [enter]
ou [esc]
return(resp);
};
// 10 rotina sorte()
// ****************
int sorte(int f1,int f2,int f3,int f4,int f5){
int lucro,cont = 0;
if(f1 == 1){cont++;};
if(f2 == 1){cont++;};
if(f3 == 1){cont++;};
if(f4 == 1){cont++;};
if(f5 == 1){cont++;};
switch (cont) {
case 0:
lucro = 0;
break;
case 1:
lucro = 1;
break;
case 2:
lucro = 5;
break;
case 3:
lucro = 20;
break;
case 4:
lucro = 50;
break;
case 5:
lucro = 250;
};
return(lucro);
};
// 11 rotina plim_plim()
// ********************
int plim_plim(int total,int lucro){
do{
if(lucro > 0){
lucro--;
total++;
bip(2);
delay(50+random(100));
};
gotoxy(1,25);
clreol();
printf("Dinheiro: $ %d",total);
}while(lucro > 0);
textcolor(7);
textbackground(0);
return(total);
};
// 12 programa principal
// ********************
void main(){
?:
int fig1,fig2,fig3,fig4,fig5; // figuras geradas na roleta
int lucro = 0; // valor recebido na roleta
int moedas = 10; // dinheiro disponvel
randomize(); // inicializa gerador aleatrio
regras(); // anuncia regras
abertura(); // abertura do programa
do{ // joga...
fig1 = random(5)+1; // gera figuras da roleta
fig2 = random(5)+1;
fig3 = random(5)+1;
fig4 = random(5)+1;
fig5 = random(5)+1;
roleta(fig1,fig2,fig3,fig4,fig5); // gira a roleta
lucro = sorte(fig1,fig2,fig3,fig4,fig5); // calcula ganho na roleta
moedas = plim_plim((moedas-2),lucro); // despeja moedas
}while(simnao() && moedas); // ... enquanto desejar e tiver moedas
if(moedas <= 0){ // se no tem mais moedas...
imprimec(25,"Sinto muito, mas seu dinheiro acabou!");
getch(); // aguarda
}
saida(); // termina
}
// * * * * f i m d o p r o g r a m a p r i n c p a l ! * * * *
Neste programa exemplo, os nveis ierr&uicos das fun%es podem ser colocados da seguinte maneira.
main()
regras() abertura() sorte() plim_plim() saida() simnao()
imprimec() roleta()
pinta() bip()
No exemplo acima temos um primeiro nvel onde se encontra a funo main() Wo programa principal tambm
uma funoX &ue cama as fun%es x, 2, +. - funo x por sua ve+ camas as fun%es s, r, e t. Observe &ue
neste exemplo os prot!tipos das fun%es esto colocados de modo a &ue as fun%es de menor ierar&uia so
escritas antes das fun%es de maior ierar&uia.
+.) - *egra de escopo para variAveis
- regra de escopo define o Jmbito de validade de variveis. 'm outras palavras define onde as variveis e
fun%es so reconecidas. 'm C, uma varivel s! pode ser usada ap!s ser decla#ada (ver seo :.<.:). 3sto
por &ue o processador deve reservar um local da mem!ria para arma+enar os valores atribudos [ varivel.
,orm o local, do programa, onde uma varivel declarada define ainda seu escopo de validade. #ma
varivel pode ser local, global ou 5o#mal de acordo com o local de declarao.
7a#i6veis Locais: #ma varivel dita local, se for declarada dent#o do bloco de uma funo. #ma varivel
local tem validade apenas dentro do bloco onde declarada, isto significa &ue podem ser apenas acessadas e
modificadas dentro de um bloco. O espao de mem!ria alocado para esta varivel c#iado &uando a
execuo do bloco iniciada e dest#udo &uando encerrado, assim variveis de mesmo nome mas declaradas
em blocos distintos, so para todos os efeitos, variveis distintas.
Exemplo:
float media2(float a, float b){
float med;
med = (a + b) / 2.0;
return(med);
}
void main(){
float num_1, num_2, med;
puts(Digite dois nmeros:);
scanf(%f %f, &num_1, &num_2);
med = media2(num_1, num_2);
?<
printf(\nA media destes nmeros e %f, med);
}
No exemplo acima, med uma varivel local definida pela funo media(). Outra varivel med tambm
definida pela funo main(). ,ara todos os efeitos estas variveis so distintas.
7a#i6veis "o#mais: #ma vari,vel formal uma varivel local declarada na lista de pa#Jmet#os de uma
funo. *este modo, tem validade apenas dentro da funo onde declarada, porm serve de suporte para os
valores passados pelas fun%es. -s variveis formais na decla#a84o da funo e na c=amada da funo
podem ter nomes distintos. - /nica exig5ncia de &ue se$am do mesmo tipo.
,or serem variveis locais, os valores &ue uma funo passa para outra no so alterados pela funo
camada. 'ste tipo de passagem de argumentos camado de passagem po# valo# pois os valores das
variveis do programa camador so copiados para as correspondentes variveis da funo camada.
>eremos no capitulo Q como alterar os valores das variveis do programa camador. Camaremos esta
passagem de passagem po# ende#e8o.
No exemplo acima, a e , so par9metros formais declarados na funo media:(). Observe &ue a funo
camada com os valores de num81 e num82. Iesmo &ue os valores de a e , fossem alterados os valores
de num81 e num82 no seriam alterados.
7a#i6veis $lobais: #ma varivel dita global, se for declarada 5o#a do bloco de uma funo. #ma varivel
global tem validade no escopo de todas as fun%es, isto , pode ser acessadas e modificada por &ual&uer
funo. O espao de mem!ria alocado para esta varivel c#iado no momento de sua declarao e dest#udo
apenas &uando o programa encerrado.
Exemplo: #so de variveis globais.
float a, b, med;
void media2(void){
med = (a + b) / 2.0;
}
void main(){
puts(Digite dois nmeros:);
scanf(%f %f, &a, &b);
media2();
printf(\nA media destes nmeros e %f, med);
}
No exemplo acima, a, ,, med so variveis globais definidas fora dos blocos das fun%es media() e
main(). *este modo ambas as fun%es tem pleno acesso as variveis, podendo ser acessadas e modificadas
por &uais&uer uma das fun%es. -ssim no necessrio a passagem de par9metros para a funo.
+.+ - *ecursividade
- recursividade talve+ se$a a mais importante vantagem das fun%es em C. %ecu#s4o o processo pelo &ual
uma funo cama a si mesma repetidamente um numero finito de ve+es. 'ste recurso muito /til em alguns
tipos de algoritmos camados de algo#itmos #ecu#sivos.
>e$amos um exemplo cl,ssico para esclarecermos o conceito. calculo do 5ato#ial de um n/mero. - definio
de fatorial .
n! = n . (n-1) . (n-2) . ... . 3 . 2 . 1
0! = 1
onde n um numero inteiro positivo. #ma propriedade (facilmente verificvel) dos fatoriais &ue.
n! = n . (n-1)!
'sta propriedade camada de propriedade recursiva. o fatorial de um numero pode ser calculado atravs do
fatorial de seu antecessor. Ora, podemos utili+ar esta propriedade para escrevermos uma rotina recursiva para
o calculo de fatoriais. ,ara criarmos uma rotina recursiva, em C, basta criar uma camada a pr!pria funo
dentro dela mesma, como no exemplo a seguir.
?@
#ma funo recursiva cria a cada camada um novo con$unto de variveis locais. No existe gano de
velocidade ou espao de mem!ria significativo com o uso de fun%es recursivas. Georicamente uma
algoritmo recursivo pode ser escrito de forma iterativa e vice4versa. - principal vantagem destes algoritmos
&ue algumas classes de algoritmos Wde intelig5ncia artificial, simulao numrica, busca e ordenao em
arvore binaria, etc.X so mais facilmente implementadas com o uso de rotinas recursivas. O estudo deste tipo
de algoritmo est, porm, alm do alcance deste texto.
??
-7eto#es
Neste captulo estudaremos o conceito de vetor, sua declarao e uso. Como so usados vetores em
argumentos de fun%es. ', ainda, como trabalar com vetores de mais de uma dimenso.
,.1 - Introduo
'm muitas aplica%es &ueremos trabalar com con$untos de dados &ue so semel=antes em tipo. ,or
exemplo o con$unto das alturas dos alunos de uma turma, ou um con$unto de seus nomes. Nestes casos, seria
conveniente poder colocar estas informa%es sob um mesmo con$unto, e poder referenciar cada dado
individual deste con$unto por um n/mero ndice. 'm programao, este tipo de estrutura de dados camada
de veto# (ou array, em ingl5s) ou, de maneira mais formal est#utu#as de dados =omog?neas.
Exemplo: - maneira mais simples de entender um vetor atravs da visuali+ao de um lista, de elementos
com um nome coletivo e um ndice de refer5ncia aos valores da lista.
n nota
0 8.4
1 6.9
2 4.5
3 4.6
4 7.2
Nesta lista, n representa um n/mero de refer5ncia e nota o nome do con$unto. -ssim podemos di+er &ue a
:
a
nota ".% ou representar notaR1S F ".%
'sta no a /nica maneira de estruturar con$unto de dados. Gambm podemos organi+ar dados sob forma de
tabelas. Neste caso, cada dado referenciado por dois ndices e di+emos &ue se trata de um veto#
bidimensional (ou mat#i>)
0
. >etores de mais de uma dimenso sero vistos na seo F.?.
,.2 - Dec%arao e inicia%i<ao de vetores
-.2.1 - :ecla#a84o de veto#es
'm C, um vetor um con$unto de variveis de um mesmo tipo &ue possuem um nome identificador e um
ndice de refer5ncia.
!intaxe: - sintaxe para a declarao de um vetor a seguinte.
tipo nome[tam];
onde.
tipo o tipo dos elementos do vetor. int, float, dou,le ...
nome o nome identificador do vetor. -s regras de nomenclatura de vetores so as mesmas usadas em
variveis (seo :.:.0).
tam o tamano do vetor, isto , o n/mero de elementos &ue o vetor pode arma+enar.
Exemplo: >e$a as declara%es seguintes.
int idade[100]; // declara um vetor chamado 'idade' do tipo
// 'int' que recebe 100 elementos.
float nota[25]; // declara um vetor chamado 'nota' do tipo
// 'float' que pode armazenar 25 nmeros.
char nome[80]; // declara um vetor chamado 'nome' do tipo
// 'char' que pode armazenar 80 caracteres.
Na declarao de um vetor estamos reservando espao de mem!ria para os elementos de um vetor. -
&uantidade de mem!ria (em bytes) usada para arma+enar um vetor pode ser calculada como.
quantidade de mem%ria ' tamanho do tipo ( tamanho do vetor
0
-lguns autores preferem camar todos os tipos de estruturas omog5neas, no importando o numero de ndices de refer5ncia (ou
dimens%es) de vetores. Outros preferem camar de matri7es. Outros ainda distinguem vetores (uma dimenso) de matri7es (mais de
uma dimenso), etc. No vamos entrar no mrito da &uesto (existem boas $ustificativas para todas as interpreta%es) e, nesta
apostila, vamos usar a primeira nomenclatura. toda estrutura omog5nea de dados ser camada de vetor.
?C
-ssim, no exemplo anterior, a &uantidade de mem!ria utili+ada pelos vetores , respectivamente,
200(2x100), 100(x2!) e $0($0x1) bytes.
-.2.2 - %e5e#?ncia a elementos de veto#
Cada elemento do vetor referenciado pelo nome do vetor seguido de um ndice inteiro. O p#imei#o
elemento do vetor tem ndice 0 e o Bltimo tem ndice tam61. O ndice de um vetor deve ser intei#o.
Exemplo: -lgumas refer5ncias a vetores.
#define MAX 5
int i = 7;
float valor[10]; // declarao de vetor
valor[1] = 6.645;
valor[MAX] = 3.867;
valor[i] = 7.645;
valor[random(MAX)] = 2.768;
valor[sqrt(MAX)] = 2.705; // NO vlido!
-.2.2 - niciali>a84o de veto#es
-ssim como podemos iniciali+ar variveis (por exemplo. int = F 3;), podemos iniciali+ar vetores.
!intaxe: - sintaxe para a iniciali+ao dos elementos de um vetor .
tipo nome[tam] = {lista de valores};
onde.
lista de valores uma lista, separada por vrgulas, dos valores de cada elemento do vetor.
Exemplo: >e$a as iniciali+a%es seguintes. Observe &ue a iniciali+ao de nota gera o vetor do exemplo do
incio desta seo.
int dia[7] = {12,30,14,7,13,15,6};
float nota[5] = {8.4,6.9,4.5,4.6,7.2};
char vogal[5] = {'a', `e', `i', `o', `u'};
Opcionalmente, podemos iniciali+ar os elementos do vetor enumerando4os um a um.
Exemplo: Observe &ue estas duas iniciali+a%es so possveis.
int cor_menu[4] = {BLUE,YELLOW,GREEN,GRAY};
ou
int cor_menu[4];
cor_menu[0] = BLUE;
cor_menu[1] = YELLOW;
cor_menu[2] = GREEN;
cor_menu[3] = GRAY;
P#og#ama Exemplo: O ar&uivo e0#01.cpp contm um programa &ue mostra o uso de vetores.
declarao, iniciali+ao, leitura e escrita de elementos...
/****************************************************
Programa: e0701.cpp
Propsito: Manipula vetores
Ultima Reviso: 20/10/97
****************************************************/
#include <conio.h>
#include <stdio.h>
#include <ctype.h>
void main(){
int total[5] = {0,0,0,0,0}; // inicializao por lista
char letra[80]; // declarao de vetor
char vogal[5]; // declarao de vetor
vogal[0]='a'; // inicializao por elemento
vogal[1]='e';
vogal[2]='i';
vogal[3]='o';
vogal[4]='u';
int i,j; // contadores
clrscr();
puts("Digite uma frase de teste:");
i=0;
do{ // faz a leitura das teclas...
letra[i] = tolower(getche()); // i-esimo elemento de 'letra' recebe tecla
?F
for(j=0; j<=4; j++) // para todas as vogais...
{ if(letra[i] == vogal[j]) // se tecla digitada e' vogal...
{ total[j]++; // incrementa i-esimo contador
}
}
}while(letra[i++] != '\r'); // ... enquanto no for [enter]
puts("\nTotal de vogais digitadas:");
for(i=0; i<=4; i++) // para todas as vogais...
{ printf("%c: %d \n",vogal[i],total[i]); // imprime totais
}
getch(); // pausa
}
,.3 - amanDo de um vetor e segmentao de mem$ria
-.2.1 - Limites
Na linguagem C, devemos ter cuidado com os limites de um vetor. 'mbora na sua declarao, tenamos
definido o tamano de um vetor, o C no fa+ nenum teste de verificao de acesso a um elemento dentro do
vetor ou no.
,or exemplo se declaramos um vetor como int AalorR!S, teoricamente s! tem sentido usarmos os
elementos AalorR0S, ..., AalorRS. ,orm, o C no acusa e##o se usarmos AalorR12S em
algum lugar do programa. 'stes testes de limite devem ser feitos logicamente dentro do programa.
'ste fato se deve a maneira como o C trata vetores. - mem!ria do microcomputador um espao (fsico)
particionado em por%es de 0 byte. Se decla#amos um vetor como int AetR3S, estamos #ese#vando C
bytes (< segmentos de : bytes) de mem!ria para arma+enar os seus elementos. O primeiro segmento ser
reservado para AetR0S, o segundo segmento para AetR1S e o terceiro segmento para AetR2S. O
segmento inicial camado de segmento base, de modo &ue AetR0S ser locali+ado no segmento base.
Auando acessamos o elemento AetRiS, o processador acessa o segmento locali+ado em base)i. Se i for
igual a 2, estamos acessando o segmento base)2 ou AetR2S(o ultimo segmento reservado para o vetor).
,orm, se i for igual a #, estamos a acessando segmento base)- &ue n4o 5oi #ese#vado para os elementos
do vetor e &ue provavelmente est sendo usado por uma outra varivel ou contm informao esp/ria (lixo).
Observe &ue acessar um segmento fora do espao destinado a um vetor pode dest#ui# in5o#ma8Ges
reservadas de outras variveis. 'stes erros so difceis de detectar pois o compilador no gera nenuma
mensagem de erro... - soluo mais ade&uada sempre avaliar os limites de um vetor antes de manipul4lo.
- princpio este fato poderia parecer um defeito da linguagem, mas na verdade trata4se de um recurso muito
poderoso do C. ,oder manipular sem restri%es todos os segmentos de mem!ria uma flexibilidade
apreciada pelos programadores.
-.2.2 - 1aman=o pa#amet#i>ado
Na linguagem C no possvel, usando a sintaxe descrita acima, declarar um vetor com tamano varivel.
Exemplo: O treco de c!digo seguinte fa+ uma declarao e##ada de vetor.
...
int num;
puts("Quantos nmeros?");
scanf("%d, &num);
float valor[num]; // declarao de vetor (errado!)
...
Ias possvel declarar um vetor com tamano pa#amet#i>ado. usando uma constante simblica.
*eclaramos uma constante simb!lica (par9metro) com a diretiva #define no cabealo do programa e
depois declaramos o vetor com esta constante simb!lica como tamano do vetor. *este modo podemos
alterar o n/mero de elementos do vetor antes de &ual&uer compila84o do programa. 'sta uma maneira
simples de administrar o espao de mem!ria usado pelo programa, e tambm testar os limites de um vetor.
?D
P#og#ama Exemplo: O ar&uivo e0#03.cpp contm um programa &ue mostra a declarao de um vetor
com tamano parametri+ado. Iostra tambm o uso deste par9metro como teste de limite do vetor. Compile
este programa com outros valores para o par9metro 4&5 e verifi&ue &ue a execuo do programa alterada
automaticamente.
/*****************************************************************
Programa: e0703.cpp
Propsito: Mostra declarao de vetor com tamanho parametrizado
Ultima Reviso: 17/10/97
*****************************************************************/
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define MAX 5 // definio do parmetro MAX
// Experimente alterar este valor!
void main()
{ int i=3;
int valor[MAX]; // declarao do vetor usando MAX
randomize();
clrscr();
printf("Calculo de %d nmeros aleatrios: ",MAX);
for(i = 0; i <= MAX-1; i++) // somente MAX valores sao calculados
{ valor[i] = 1+random(100);
printf("\n%3d: %d",i+1,valor[i]); // o valor e' impresso
}
getch();
}
,.! - Passando Vetores para -un.es
>etores, assim como variveis, podem ser usados como argumentos de fun%es. >e$amos como se declara
uma funo &ue recebe um vetor e como se passa um vetor para uma funo.
!intaxe: Na passagem de vetores para fun%es usamos a seguinte sintaxe.
nome_da_f#no(nome_do_vetor)
onde.
nome_da_funo o nome da funo &ue se est camando.
nome_do_vetor o nome do vetor &ue &ueremos passar. 3ndicamos apenas o nome do vetor, sem ndices.
!intaxe: Na declarao de fun%es &ue recebem vetores.
tipo_f#no nome_f#no(tipo_vetor nome_vetor[]){
...
}
onde.
tipo_f#no F o tipo de #eto#no da 5un84o.
nome_f#no F o nome da 5un84o.
tipo_vetor F o tipo de elementos do veto#.
nome_vetor F o nome do veto#. Hbse#ve @ue depois do nome do veto# temos um ndice va>io [] para
indicar &ue estamos recebendo um vetor.
Exemplo: Observe o exemplo abaixo.
Na declarao da funo.
float media(float vetor[],float N){ // declarao da funo
...
}
Na camada da funo.
void main(){
float valor[MAX]; // declarao do vetor
...
med = media(valor, n); // passagem do vetor para a funo
...
}
Aten84o: -o contrrio das variveis comuns, o conte/do de um vetor pode se# modi5icado pela funo
camada. 3sto significa &ue podemos passar um vetor para uma funo e alterar os valores de seus elementos.
?K
3sto ocorre por&ue a passagem de veto#es para fun%es feita de modo especial dito +assagem por endereo.
#ma abordagem mais detalada deste procedimento ser feita no captulo Q sobre ponteiros.
,ortanto devemos ter cuidado ao manipularmos os elementos de um vetor dentro de uma funo para no
modifica4los por descuido.
P#og#ama Exemplo: O ar&uivo e0#0!.cpp contm um programa &ue mostra a modificao de um vetor
por uma funo. Neste caso a modificao dese3ada pois &ueremos ordenar os elementos do vetor.
/***********************************************************************
Programa: e0705.cpp
Propsito: Mostra a modificao de elementos de um vetor passado como
argumento de uma funo.
Ultima Reviso: 20/10/97
***********************************************************************/
#include <dos.h>
#include <conio.h>
#include <stdlib.h>
#include <stdio.h>
#define MAX 150
// ********************
// 1 Programa principal
// ********************
void main(){
int i; // contador de iterao
int n; // numero de elementos do vetor
int num[MAX]; // declarao do vetor 'num' de MAX elementos
void ordem(int[],int); // prottipo da funo de ordenamento
randomize(); // inicializa gerador aleatrio
// ********************
// 1.1 Entrada de dados
// ********************
clrscr();
do{
puts("\nDigite a quantidade de numeros a ordenar: ");
scanf("%d",&n);
}while(n < 1 || n > MAX);
// *********************************
// 1.2 Gerao de numeros aleatrios
// *********************************
puts("Gerando lista de numeros aleatorios...");
for(i = 0; i <= n-1; i++){
num[i] = random(100); // gera numero aleatrio
printf("%2d ",num[i]); // imprime vetor gerado
delay(50);
}
// *************************
// 1.3 Ordenao e impresso
// *************************
ordem(num,n); // passagem do vetor idade para a funo
puts("\nValores ordenados:");
for(i=0 ; i<=(n-1) ; i++){
printf("%2d ",num[i]); // imprime vetor ordenado
delay(50);
}
getch();
}
// 2 rotina ordem()
// **************************************************************************
// Mtodo: Ordenao Bolha.
C1
// Referencia: MANZANO,J.A.N.G.,OLIVEIRA,J.F., Algoritmos: Lgica para desen-
// volvimento de programao, So Paulo. Erica, 1996 [p.121]
// "O mais simples e mais ineficiente algoritmo desenvolvido pela humanidade"
// **************************************************************************
void ordem(int valor[],int num){ // declarao da funo
int t; // contador de trocas
int temp; // armazenador temporrio para troca
int i; // contador de iterao
do{ // ordena...
t = 0; // nenhuma troca ainda
for(i = 0; i <= num-2; i++){ // para todos os elementos do vetor...
if(valor[i] > valor[i+1]){ // se fora de ordem...
temp = valor[i]; // troca...
valor[i] = valor[i+1];
valor[i+1] = temp;
t++; //conta troca
}
}
}while(t); // ...enquanto houver trocas
}
,.) - Vetores >u%tidimensionais
>etores podem ter mais de uma dimenso, isto , mais de um ndice de refer5ncia. ,odemos ter vetores de
duas, tr5s, ou mais dimens%es. ,odemos entender um vetor de duas dimens%es (por exemplo) associando4o
aos dados de um tabela.
Exemplo: #m vetor bidimensional pode ser visuali+ado atravs de uma tabela.
nota 0 1 2
0 8.4 7.4 5.7
1 6.9 2.7 4.9
2 4.5 6.4 8.6
3 4.6 8.9 6.3
4 7.2 3.6 7.7
Nesta tabela representamos as notas de ? alunos em < provas diferentes (matemtica, fsica e &umica, por
exemplo). O nome nota o nome do con$unto, assim podemos di+er &ue a nota do <
o
aluno na :
a
prova
". ou representar notaR2,1S F ".
-.;.1 - :ecla#a84o e iniciali>a84o
- declarao e iniciali+ao de vetores de mais de uma dimenso feita de modo semelante aos vetores
unidimensionais.
!intaxe: - sintaxe para declarao de vetores multidimensionais .
tipo nome[tam_1][tam_2]...[tam_N]={{lista},{lista},...{lista}};
onde.
tipo o tipo dos elementos do vetor.
nome o nome do vetor.
Rtam81SRtam82S...Rtam8XS o tamano de cada dimenso do vetor.
VVlistaW,VlistaW,...VlistaWW so as listas de elementos.
Exemplo: ve$a algumas declara%es e iniciali+a%es de vetores de mais de uma dimenso. Observe &ue a
iniciali+ao de nota gera a tabela do exemplo do incio desta seo.
float nota[5][3] = {{8.4,7.4,5.7},
{6.9,2.7,4.9},
{4.5,6.4,8.6},
{4.6,8.9,6.3},
{7.2,3.6,7.7}};
int tabela[2][3][2] = {{{10,15}, {20,25}, {30,35}},
{{40,45}, {50,55}, {60,65}};
Neste exemplo, nota um vetor duas dimens%es (RSRS). 'ste vetor composto de ? vetores de <
elementos cada. ta,ela vetor de tr5s dimens%es (RSRSRS). 'ste vetor composto de : vetores de <
sub4vetores de : elementos cada.
C0
-.;.2 - Passagem de veto#es multidimensionais pa#a 5un8Ges
- sintaxe para passagem de vetores multidimensionais para fun%es semelante a passagem de vetores
unidimensionais. camamos a funo e passamos o nome do vetor, sem ndices. - /nica mudana ocorre na
declarao de fun%es &ue recebem vetores.
!intaxe: Na declarao de fun%es &ue recebem vetores.
tipo_f f#no(tipo_v vetor[tam_1][tam_2]...[tam_n]){
...
}
Observe &ue depois do nome do vetor temos os ndices com contendo os tamanos de cada dimenso do
vetor.
Exemplo: Observe o exemplo abaixo.
Na declarao da funo.
int max(int vetor[5][7],int N, int M){ // declarao da funo
...
}
Na camada da funo.
void main(){
int valor[5][7]; // declarao do vetor
...
med = media(valor, n); // passagem do vetor para a funo
...
}
P#og#ama Exemplo: O ar&uivo e0#0".cpp contm um programa &ue mostra a manipulao de vetores
bidimensionais. leitura de elementos, escrita, passagem para fun%es, etc.
/**********************************************************************
Programa: e0706.cpp
Propsito: Mostra a manipulao de vetores de 2 dimenses.
Ultima Reviso: 20/10/97
**********************************************************************/
#include <conio.h>
#include <stdio.h>
#define MAX 5
// 1 Programa principal
// ********************
void main(){
int a[MAX][MAX]; // vetor bidimensional!!
int n,m; // numero de linhas(n) e colunas(m) da matriz
int c,l; // contadores de iterao
void impmtz(int[MAX][MAX],int,int); // funo de impresso de matriz
void transp(int[MAX][MAX],int,int); // funo de transposio de matriz
// titulo
clrscr();
puts("Transposicao de Matrizes");
// leitura da ordem da matriz
do{
puts("Digite o numero de LINHAS da matriz:");
scanf("%d",&n);
}while(n < 1 || n > MAX);
do{
puts("Digite o numero de COLUNAS da matriz:");
scanf("%d",&m);
}while(m < 1 || m > MAX);
// leitura dos elementos da matriz
puts("Digite os elementos (INTEIROS) da matriz:");
for(l = 0 ; l <= n-1 ; l++){
for(c = 0 ; c <= m-1 ; c++){
printf("\na[%d][%d]: ",l+1,c+1);
scanf("%d",&a[l][c]); // A > elemento do vetor
}
C:
}
// impresso da matriz original
clrscr();
puts("Matriz original:");
impmtz(a,n,m);
// transposicao
transp(a,n,m);
// impresso da matriz transposta
puts("Matriz Transposta:");
impmtz(a,m,n);
getch(); // pausa
}
// 2 rotina impmtz()
// *****************
void impmtz(int matriz[MAX][MAX], int max_lin,int max_col){
int i,j;
for(i = 0 ; i <= max_lin-1 ; i++){ // para todas as linhas...
puts("\n"); // quebra linha
for(j = 0 ; j <= max_col-1 ; j++){ // para todas as colunas...
printf("%3d ",matriz[i][j]); // imprime elemento
}
}
puts("\n");
}
// *****************
// 3 rotina transp()
// *****************
void transp(int matriz[MAX][MAX], int max_lin,int max_col){
int i,j,temp;
for(i = 0 ; i <= max_lin-1 ; i++){ // para todas as linhas...
for(j = i ; j <= max_col-1 ; j++){ // para todas as colunas j >= i
temp = matriz[i][j]; // troca: m[i][j] <-> m[j][i]
matriz[i][j] = matriz[j][i];
matriz[j][i] = temp;
}
}
}
Hbse#va8Ges: -lgumas observa%es a respeito de vetores multidimensionais podem ser feitas.
*o mesmo modo &ue vetores unidimensionais, os vetores multidimensionais podem ter seus
elementos modificados pela funo camada.
Os ndices dos vetores multidimensionais, tambm comeam em 0. ,or exemplo. AetR0SR0S,
o primeiro elemento do vetor.
'mbora uma tabela no se$a a /nica maneira de visuali+ar um vetor bidimensional, podemos
entender o p#imei#o ndice do vetor como o ndice de lin=as da tabela e o segundo ndice do
vetor como ndice das colunas.
C<
0 4 "#N*-I'NGOS *- H3N=#-='I C.................................................................................................................0
0.0 4 H3N=#-='NS *' ,OO=O-I-\]O.......................................................................................................................0
8.8.8 - (xemplos de c9digos.................................................................................................................................8
8.8.: - ;inguagens de baixo e alto nvel...............................................................................................................8
0.: 4 H3N=#-='I C....................................................................................................................................................:
8.:.8 - 'aractersticas do '..................................................................................................................................:
8.:.: - <ist9rico....................................................................................................................................................:
0.< 4 'SGO#G#O- *' #I ,OO=O-I- 'I C................................................................................................................:
8.0.8 - 'on*unto de caracteres..............................................................................................................................0
8.0.: - 'oment,rios..............................................................................................................................................0
8.0.0 - Diretivas de 'ompilao...........................................................................................................................0
8.0.= - Declarao de vari,veis............................................................................................................................=
8.0.> - (ntrada e sada de dados..........................................................................................................................=
8.0.? - (struturas de 'ontrole..............................................................................................................................=
: 4 CONSG-NG'S ' >-O3^>'3S................................................................................................................................@
:.0 4 CONSG-NG'S......................................................................................................................................................@
:.8.8 - 'onstantes inteiras....................................................................................................................................>
:.8.: - 'onstantes de ponto flutuante...................................................................................................................>
:.8.0 - 'onstantes caracteres................................................................................................................................>
:.8.= - 'onstantes strings.....................................................................................................................................?
:.: 43*'NG3"3C-*OO'S................................................................................................................................................C
:.:.8 - Regras de sintaxe.......................................................................................................................................?
:.:.: - +alavras reservadas..................................................................................................................................?
:.< 4 G3,OS *' *-*OS.................................................................................................................................................F
:.0.8 - "ipos b,sicos.............................................................................................................................................@
:.0.: - Declarao de vari,veis............................................................................................................................@
:.0.0 - "ipos modificados......................................................................................................................................A
:.0.= - &trings........................................................................................................................................................A
:.0.> - #niciali7ao de vari,veis..........................................................................................................................A
:.0.? - 'onverso de tipo B'astingC......................................................................................................................D
:.@ 4 CONSG-NG'S S3IM_H3C-S.................................................................................................................................K
:.=.8 - 'onstantes definidas pelo programador...................................................................................................D
:.=.: - 'onstantes pr-definidas.........................................................................................................................81
< 4 O,'O-*OO'S, '`,O'SSa'S ' "#N\a'S......................................................................................................01
<.0 4 O,'O-*OO *' -GO3M#3\]O.............................................................................................................................00
0.8.8 - 'onverso de tipo....................................................................................................................................88
0.8.: - ;imites do intervalo do tipo de dado.......................................................................................................8:
0.8.0 - Atribuio mEltipla..................................................................................................................................8:
<.: 4 O,'O-*OO'S -O3GIEG3COS.............................................................................................................................0<
0.:.8 - Restri.es de operandos..........................................................................................................................80
0.:.: - 'onverso de tipo....................................................................................................................................8=
0.:.= - +reced2ncia de operadores.....................................................................................................................8=
<.< 4 O,'O-*OO'S *' -GO3M#3\]O -O3GIEG3C-....................................................................................................0C
<.@ 4 O,'O-*OO'S 3NCO'I'NG-3S...........................................................................................................................0F
<.? 4 O,'O-*OO'S O'H-C3ON-3S ' H_=3COS...........................................................................................................0D
0.>.8 - )peradores relacionais...........................................................................................................................8A
0.>.: - )peradores l9gicos..................................................................................................................................8D
<.C 4 O,'O-*OO CON*3C3ON-H................................................................................................................................:1
<.F 4 "#N\a'S *' M3MH3OG'C-.................................................................................................................................:0
0.@.8 - ) uso de fun.es......................................................................................................................................:8
0.@.: - As bibliotecas disponveis e algumas fun.es interessantes...................................................................::
<.D 4 ,O'C'*bNC3- 'NGO' OS O,'O-*OO'S *O C...................................................................................................:@
@ 4 'NGO-*- ' S-c*-..............................................................................................................................................:?
@.0 4 S-c*- "OOI-G-*-. ?YCX@+()........................................................................................................................:?
@.: 4 H'3G#O- "OOI-G-*-. U(&X+()......................................................................................................................:F
@.< 4 'NGO-*- N]O "OOI-G-*-. C3N dd................................................................................................................:K
@.@ e S-c*- N]O "OOI-G-*-. CO#G VV.................................................................................................................:K
@.? 4 'NGO-*- *' C-O-CG'O 3N*3>3*#-H. Z*@([&Y()..........................................................................................:K
C@
@.C 4 S-c*- *' C-O-CG'O 3N*3>3*#-H. ?T@([&Y()...............................................................................................:K
@.F 4 H'3G#O- *' G'CH-*O. Z*@([(), Z*@([*()................................................................................................:K
@.D 4 'SCO3G- "OOI-G-*- 'I COO'S. (?YCX@+()................................................................................................<1
@.K 4 S-c*- SONOO-. SO#N*(), *'H-f(), NOSO#N*()..............................................................................................<0
@.01 4 H3I,'g- *' G'H-. (\YU(Y(), (\Y*K\()..................................................................................................<:
@.00 4 ,OS3C3ON-I'NGO *O C#OSOO. ZK@K5]()...................................................................................................<:
@.0: 4 O'*3I'NC3ON-I'NGO *' T-N'H-. ^CX)K^().............................................................................................<:
@.0< 4 ION3GOO-\]O *' G'CH-*O. _'[C@()........................................................................................................<<
? 4 'SGO#G#O-S *' CONGOOH'...........................................................................................................................<@
?.0 4 CON*3\]O *' CONGOOH'.................................................................................................................................<@
?.: 4 'SGO#G#O- )K...^[C\*................................................................................................................................<@
?.< 4 'SGO#G#O- ^[C\*..........................................................................................................................................<@
?.@ 4 'SGO#G#O- +KY..............................................................................................................................................<?
?.? 4 'SGO#G#O- *' *'C3S]O C+...*\U*..............................................................................................................<C
>.>.8 Deciso de um bloco )if...*...........................................................................................................0?
>.>.: - Deciso de dois blocos )if...else*.................................................................................................0?
>.>.0 - Deciso de mEltiplos blocos )if...else if...*..........................................................................0@
?.C 4 'SGO#G#O- U^C@([...(&U*...........................................................................................................................<K
?.F 4 3NG'OO#,\]O ' *'S>3O. MO'-h, CONG3N#', =OGO, '`3G().............................................................................@1
>.@.8 - A instruo brea+..................................................................................................................................=1
>.@.: A instruo continue.......................................................................................................................=8
>.@.0 - A instruo goto....................................................................................................................................=8
>.@.= - A funo exit)*....................................................................................................................................=:
C 4 "#N\a'S...............................................................................................................................................................@:
C.0 4 'SGO#G#O- *-S "#N\a'S *' #S#^O3O..........................................................................................................@:
C.: 4 *'"3N3\]O *' "#N\a'S...................................................................................................................................@<
C.< 4 HOC-H3g-\]O *-S "#N\a'S...........................................................................................................................@<
?.0.8 - 'orpo da funo antes do programa principal Bno mesmo ar4uivoC......................................................=0
?.0.: - 'orpo da funo depois do programa principal Bno mesmo ar4uivoC....................................................==
?.0.0 - 'orpo da funo escrito em ar4uivo separado.......................................................................................=>
C.@ 4 Y3'O-OA#3- *' "#N\a'S................................................................................................................................@C
C.? 4 O'=O- *' 'SCO,O ,-O- >-O3^>'3S................................................................................................................?:
C.C 4 O'C#OS3>3*-*'...............................................................................................................................................?<
F 4 >'GOO'S...............................................................................................................................................................?@
F.0 4 3NGOO*#\]O....................................................................................................................................................?@
F.: 4 *'CH-O-\]O ' 3N3C3-H3g-\]O *' >'GOO'S..................................................................................................?@
@.:.8 - Declarao de vetores.............................................................................................................................>=
@.:.: - Refer2ncia a elementos de vetor..............................................................................................................>>
@.:.: - #niciali7ao de vetores...........................................................................................................................>>
F.< 4 G-I-NYO *' #I >'GOO ' S'=I'NG-\]O *' I'I_O3-................................................................................?C
@.0.8 - ;imites.....................................................................................................................................................>?
@.0.: - "amano parametri7ado..........................................................................................................................>?
F.@ 4 ,-SS-N*O >'GOO'S ,-O- "#N\a'S...............................................................................................................?F
F.? 4 >'GOO'S I#HG3*3I'NS3ON-3S........................................................................................................................?K
@.>.8 - Declarao e iniciali7ao......................................................................................................................>D
@.>.: - +assagem de vetores multidimensionais para fun.es............................................................................?1
C?