Unicamp LPCap03 TiposBasicos Texto

2/3/2011 11:12 Copyright@2005-2009 Arnaldo V. Moura, Daniel F.
Ferber
2
compilador sabe quanta memria deve ser reservada para uma determinada varivel
(quantas clulas de memria so necessrias para armazenar o contedo da varivel).
A declarao informa o nome da varivel, o seu tipo e, opcionalmente, seu valor inicial.
Com esta informao, o compilador destina automaticamente um nmero suficiente de
clulas de memria, ou bytes, para armazenar esta varivel.

A declarao de uma varivel segue um dos dois modelos abaixo:

tipo nome = valor;
ou:
tipo nome;

O primeiro caso a forma preferida para declarao de variveis. Ela informa, em uma
nica declarao, as trs caractersticas da varivel: rtulo (nome), tipo (domnio de
valores) e valor (contedo).
A segunda declarao menos especfica. Ela cria uma varivel apenas com um nome e um
tipo, mas sem um valor definido. Evidentemente, antes que o algoritmo utilize esta varivel
em algum clculo, o programador dever atribuir um valor mesma em algum ponto
anterior do cdigo fonte.
Exemplo
Um programa deve calcular a mdia de um aluno em duas provas e em uma avaliao de
laboratrio. O programa precisar declarar as variveis de forma semelhante ao exemplo a
seguir:

float nota_prova_a = 8.0;
float nota_prova_b = 6.0;
float nota_laboratorio = 10.0;
float media;

So declaradas quatro variveis: nota_prova_a, nota_prova_b, nota_laboratrio e
media. Todas elas so declaradas como sendo do tipo float, que ser estudado neste
captulo. Somente as primeiras trs recebem um valor na sua declarao. A varivel media
declarada com valor indefinido, j que seu valor depender dos valores das trs variveis
anteriores. O programa deve ser construdo de maneira que, mais tarde, atribua um valor
para a varivel media.
Valor inicial das variveis
Se a declarao j apresenta um valor inicial para a varivel, o compilador o atribui
varivel antes de iniciar a execuo do algoritmo. Caso contrrio, a varivel conter um
valor arbitrrio, impossvel de se prever qual ser, quando a execuo do programa inicia.
No existe um valor padro na linguagem C para variveis que no recebem um valor
inicial j na sua declarao.

2/3/2011 11:12 Copyright@2005-2009 Arnaldo V. Moura, Daniel F. Ferber
3
interessante entender o que acontece no computador como conseqncia da declarao de
uma varivel. Durante a execuo do programa, a varivel estar associada com posies
reais de memria, que so um recurso compartilhado entre todos os programas em
execuo no computador.
Quando declaramos uma varivel em um programa, ela ser associada com uma (ou mais)
clula de memria disponvel logo antes de iniciar a execuo do programa, i.e., a varivel
no est associada a nenhum outro dado de nenhum outro programa que esteja executando
no momento. Durante toda a execuo do nosso programa, o computador garante que
apenas nosso programa pode acessar e modificar o contedo dessa clula de memria.
Porm, provavelmente em algum momento antes do incio do nosso programa, esta clula
foi utilizada por um outro programa que j terminou sua execuo e deixou l armazenado
um valor qualquer. Note que, se a varivel for declarada sem atribuio de valor inicial, a
clula correspondente mantm o valor que j estava na memria quando nosso programa
inicia sua execuo, e que pode ser qualquer valor, imprevisvel, deixado pelo outro
programa. Se esquecermos de atribuir um valor uma varivel antes de usar seu contedo
pela primeira vez no programa, ento o valor l encontrado ser algo que certamente no
desejamos usar em nosso algoritmo. Se usarmos esse valor arbitrrio certo que
produziremos resultados errneos. Esquecer de atribuir um valor s variveis antes de
usar seu contedo pela primeira vez uma causa comum de erros obscuros em C.

Declarao mltipla
Caso desejemos declarar vrias variveis, todas do mesmo tipo, podemos list-las em uma
mesma linha, separando os nomes por vrgulas.

tipo nome1, nome2, nome3, ...;

Isso economiza alguns toques de digitao. Mesmo declarando em uma mesma linha,
(algumas) variveis podem ser inicializadas com valores.

tipo nome1 = valor, nome2, nome3 = valor3, ...;

Exemplo
O exemplo anterior poderia ser declarado assim:
float nota_prova_a = 8.0, nota_prova_b = 6.0;
float nota_laboratorio = 10.0;
float media;
A forma de declarao de variveis totalmente livre, e o programador deve utilizar aquela
que deixe seu cdigo mais legvel.

4
Identificadores
Existem regras especficas que devem ser seguidas ao se escolher o nome de variveis. Em
C, os nomes (ou rtulos) das variveis so denominados identificadores. As seguintes
regras devem ser observadas ao se escolher um identificador para nomear uma varivel:
O identificador deve ser formado por uma seqncia de caracteres, os quais podem
ser as letras maisculas ou minsculas do alfabeto (a-z, A-Z), os dgitos numricos
(0-9), ou smbolo de sublinhado ( _ ).
Letras acentuadas no so permitidas.
O identificador no pode comear com um dgito numrico.
O identificador no pode ser uma das palavras reservadas da linguagem C (listadas
mais adiante).
Exemplos
Identificadores que podem ser utilizados como nome de variveis:
contador, resto_divisao, media, nota1, nota2, PESO
Maisculas/Minsculas
O compilador distingue letras maisculas de minsculas. Se dois identificadores
diferenciam-se apenas pelo uso de maisculas e minsculas, ento o compilador C os
tratar como duas variveis diferentes. Por exemplo, media e Media so identificadores
distintos. Esta uma causa freqente de erros.
Comprimento
No existe limite para o comprimento mximo de um identificador. No entanto, a
linguagem C padro utiliza apenas os primeiros 31 smbolos para diferenciar os
identificadores. Atualmente, a maioria dos compiladores modernos so mais flexveis. Por
exemplo, o compilador C da Microsoft trabalha com identificadores de at 247 smbolos.
Palavras reservadas da linguagem C (no padro ANSI)
Algumas palavras no podem ser utilizadas como identificadores, pois so prprias da
linguagem C. So elas:
auto, break, case, char, const, continue, default, do, double, else, enum, extern,
float, for, goto, if, inline, int, long, register, restrict, return, short, signed,
sizeof, static, struct, switch, typedef, union, unsigned, void, volatile, while,
_Bool, _Complex, _Imaginary

No necessrio decor-las. Normalmente, um editor de cdigo C apresenta as palavras
reservadas em cor diferente, de forma que podemos saber imediatamente, por inspeo, se
uma palavra reservada ou se um identificador.
Palavras reservadas na linguagem C (padro Microsoft)
Alm das palavras reservadas pela linguagem C (padro ANSI), o compilador C da
Microsoft reserva os seguintes identificadores:

5
__asm, __based, __cdecl, __declspec, dllexport, dllimport, __except,
__fastcall, __finally, __inline, __int16, __int32, __int64, __int8, __leave,
naked, __stdcall, thread, __try

Recomendaes
A maioria dos programadores costuma seguir algumas convenes ao atribuir nomes s
variveis para tornar o cdigo fonte mais uniforme. Tratam-se de boas prticas que
melhoram substancialmente a legibilidade do cdigo C. Cabe ao programador seguir estas
recomendaes ou no. Sugerimos:
Utilizar sempre substantivos, evitar verbos.
Quando o nome da varivel formado pela juno de duas palavras, usar o smbolo
de sublinhado (_) entre as duas palavras consecutivas.
Evitar identificadores que comeam com o smbolo de sublinhado. Estes nomes so
reservados para o compilador criar suas prprias variveis, quando houver
necessidade.

Tipos Inteiros
O primeiro tipo que vamos estudar na linguagem C
usado para designar nmeros inteiros. Eles
caracterizam, portanto, variveis cujo domnio ser
um intervalo dos nmeros inteiros. Estas variveis
podero conter nmeros positivos ou negativos, desde que obrigatoriamente inteiros. No
possvel armazenar nmeros com dgitos decimais em variveis designadas como sendo do
tipo inteiro. Devemos alertar, desde j, que a linguagem no suporta todos os inteiros. Isto
, vamos ver que existem limites para os valores absolutos que podem ser armazenados nas
variveis de tipos inteiros em C. O programador deve garantir que seu programa no
extravasa esses valores, caso contrario resultados errneos podem ser obtidos pelo
programa.
O tipo inteiro comporta vrias variantes. A diferena entre estas variantes est na
quantidade de memria que reservada para a varivel e, portanto, esto diretamente
relacionadas aos valores mximo e mnimo que elas podero armazenar. A escolha do tipo
para uma varivel envolve um compromisso entre a amplitude dos nmeros que ela poder
armazenar e o quanto de memria desejamos reservar para ela.
Os principais tipos inteiros so:

short short int Nmeros muito pequenos
short int Nmeros pequenos
long int Nmeros grandes
long long int Nmeros muito grandes
Inteiro
int short long long long
Inteiro
int short long long long

Figura 2 - Tipos Inteiros

6

A linguagem C tambm define um tipo, denominado int (note a ausncia de short ou
long) que corresponde ao tipo inteiro que o processador consegue tratar com maior
eficincia. Freqentemente, chamamos int de tipo inteiro padro da arquitetura do
processador.
Exemplos
Declarao de variveis para armazenar nmeros pequenos:
short int numero_pequeno;
short int contador = 4;

Declarao de variveis para armazenar nmeros grandes:
long int quantidade_pecas;
long int numero_repeticoes = 3000000000;

Declarao de variveis para armazenar nmeros de tamanho padro para a arquitetura do
processador:
int contador;
int limite_tentativas = 100;
Intervalos de tipos inteiros
O que um inteiro grande ou um inteiro pequeno? O tamanho do intervalo vlido associado
a cada um desta trs variantes do tipo inteiro depende da arquitetura do computador, e
tambm do compilador. No existe uma padronizao entre os compiladores C para esses
valores.
Para escolher o tipo de nmero inteiro mais adequado para o seu programa, o programador
precisa estudar seu algoritmo para saber qual o valor mnimo e mximo que cada varivel,
designada para conter nmeros inteiros, poder assumir durante a execuo do programa.
Em seguida, necessrio consultar a documentao do compilador, na qual encontra-se
uma tabela com os valores mnimos e mximos de cada um destes tipos. O tipo desta
varivel deve ser aquele que comporta todo o intervalo de valores, do mximo ao mnimo,
que podero ser utilizados ou gerados pelo algoritmo.
A tabela a seguir apresenta os intervalos do domnio de cada um dos tipos de nmeros
inteiros, utilizando como referncia a arquitetura Intel Pentium com compilador C da
Microsoft.

Tipo Descrio Tamanho Intervalo
int
Tamanho padro 4 bytes - 2.147.483.648 at 2.147.483.647
short short int
Nmeros muito pequenos 1 byte -256 at 257
short int
Nmeros pequenos 2 bytes -32.768 at 32.767
long int
Nmeros grandes 4 bytes - 2.147.483.648 at 2.147.483.647
long long int
Nmeros muito grandes 8 bytes - 9,223 10
15
at 9,223 10
15

Observao 1: Esta tabela refere-se ao compilador C da Microsoft e para uma arquitetura
Intel Pentium. Outras implementaes de compiladores C podem utilizar uma conveno
diferente para tamanhos e intervalos definidos por estes tipos!

7
Observao 2: Especificamente para o compilador C da Microsoft, o tipo inteiro padro e
o nmero grande so equivalentes (respectivamente int e long int). Em outras palavras o
nmero grande (long int) justamente o tipo que o processador consegue tratar com
maior eficincia.
Discusso sobre a escolha dos tipos
Para declarar variveis de valor inteiro, a linguagem C dispe de quatro tipos diferentes
(int, short int, long int e long long int). A escolha do tipo mais adequado
envolve um compromisso entre:
O valor mnimo e mximo que a varivel poder representar (short int limita-se
a nmeros pequenos).
A quantidade de memria ocupada (short int ocupa pouca memria e long
long int ocupa mais memria).
A eficincia de processamento (int eficiente enquanto short int e long long
int podero implicar em alguma perda de eficincia).
A necessidade de distinguir entre tantos tipos inteiros fazia muito sentido nos computadores
antigos, que tinham baixa capacidade de processamento e pouca disponibilidade de
memria. Neles, a economia de memria e de processamento era uma questo importante
para tornar vivel a execuo do algoritmo.
Os computadores atuais possuem uma quantidade de memria to grande que, na prtica,
pode ser considerada infinita para a maioria dos programas. A preocupao de se utilizar o
tipo short int para economizar memria perdeu muito de seu sentido prtico.
A tecnologia dos processadores tambm evoluiu a ponto de realizar operaes com a
mesma eficincia para praticamente todos os tipos de nmeros inteiros, independente se
eles so short int, long int ou long long int.
Exceto em aplicaes onde o processamento ou o uso de memria so
requisitos crticos de projeto, recomendamos utilizar sempre o tipo int
para declarar variveis cujo contedo ser um nmero inteiro.
Escrever texto na tela
Escrever texto
Para escrever texto no monitor do computador utilizamos o comando printf. O texto
informado entre aspas duplas e entre parnteses aps o printf, conforme o exemplo
abaixo:

printf("mensagem");

Quando desejamos que a mensagem do prximo printf comece no incio da prxima
linha, a mensagem atual deve terminar com \n:

8
printf("mensagem\n");

Na verdade, a instruo printf no primitiva na linguagem C. Ela um comando mais
complexo cuja descrio bsica est no arquivo stdio.h , e que devemos incluir como
diretiva para o compilador, sempre que nosso programa usar o printf. Programadores
mais experientes j criaram o cdigo para o comando printf e o disponibilizaram para
uso em outros programas escritos em C. Assim, no precisamos nos preocupar com as
idiossincrasias de sada de dados relativas ao computador para o qual estamos escrevendo
nosso cdigo C.
Escrever contedo de variveis
Durante a execuo do programa, a nica forma para se conhecer o valor de uma varivel
escrever seu contedo na tela. Para escrever o contedo das variveis, o comando printf
funciona de forma semelhante. Agora, a mensagem deve conter indicadores a serem
substitudas pelo contedo das variveis, cujos nomes devem ser passadas como os demais
parmetros no comando printf, conforme o exemplo abaixo:

printf("mensagem com indicaes", variavel, variavel, ...);

Na mensagem entre aspas duplas, um indicador um cdigo iniciado por % (porcentagem).
Para cada indicador que ocorre na mensagem deve haver a correspondente varivel passada
como parmetro aps a mensagem, e na mesma ordem em que os indicadores aparecem na
mensagem.
Quando h um indicador, o comando printf consulta o valor da varivel correspondente,
formata-o usando a representao apropriada, especificada no indicador, e substitui o
indicador pelo valor formatado ao imprimir a mensagem na tela.
Para cada tipo de varivel (int, short int, long int, etc), existe um cdigo apropriado
para o indicador. Por exemplo, o indicador %d substitudo pelo contedo de uma varivel
de tipo int.
Exemplos
Vamos supor que o programa declarou as seguintes variveis:
int quantidade = 10;
int nota1 = 6;
int nota2 = 7;

Alguns exemplos tpicos de printf poderiam ser:
printf("Nmero de tens comprados: %d\n", quantidade);
printf("Voc comprou %d itens.\n", quantidade);
printf("O aluno tirou %d na primeira prova e %d na segunda.\n", nota1,
nota2);

O resultado na tela seria o seguinte:

9
Nmero de tens comprados: 10
Voc comprou 10 itens.
O aluno tirou 6 na primeira prova e 7 na segunda.

Tabela de indicaes de formatao para escrita de valores inteiros (printf)
necessrio utilizar o indicador correto para cada tipo de varivel. Caso contrrio, o
resultado poder ser diferente do esperado. Todos os indicadores listados a seguir vo
exprimir o contedo da varivel usando a representao decimal, precedida por um sinal de
menos (-) caso o nmero seja negativo. Existem os seguintes indicadores para os tipos
inteiros:
%hd ou %hi para o tipo short int
%d ou %i para o tipo int
%ld ou %li para o tipo long int
%lld ou %lli para o tipo long long int

Controlando a forma da sada
O comando printf permite que se exera algum controle sobre a forma da sada. O
controle indicado por smbolos colocados logo aps o sinal de % nos indicadores de
formatao.
Se nada for colocado, ento o computador usa exatamente tantas posies para escrever o
valor na tela quantas forem necessrias, incluindo uma posio para escrever o sinal de
menos, se o valor for negativo. Por exemplo, o cdigo abaixo
printf("Numero = '%d'", -850);
produziria a sada
Numero = '-850'
Note como foram usadas quatro posies entre as aspas: uma para o sinal e trs para o
valor. Note tambm que o valor a ser impresso pode ser informado como uma constante; no
caso, -850. Como veremos mais adiante, o valor a ser impresso pode ser indicado
tambm como o resultado de uma expresso cujo valor deve ser calculado.
Se colocarmos um nmero inteiro n aps o sinal de % ento o valor correspondente deve
ser escrito em um campo de n posies. Se o valor correspondente ocupar mais do que as n
posies reservadas, o computador ignora o nmero n e usa tantas posies quantas forem
necessrias. Por outro lado, se nmero de posies for maior que o necessrio para escrever
o valor, ento ele escrito ajustado direita. Por exemplo, o cdigo abaixo
printf("Numero = '%8d'", -850);
produziria a sada
Numero = ' -850'
Nesse caso foram usadas oito posies entre as aspas: quatro brancos, uma para o sinal e
trs para o valor. E agora, o cdigo
printf("Numero = '%1d'", -850);
produziria a sada
Numero = '-850'
Como um campo de uma posio muito curto para se escrever o valor pretendido, o
computador ignorou o tamanho do campo e usou as quatro posies necessrias.

10
Um sinal de menos logo aps o sinal de % fora o ajuste pela esquerda, e no pela direita.
O cdigo
printf("Numero = '%-8d'", -850);
produziria a sada
Numero = '-850 '
com oito posies, sendo que as quatro ltimas so brancos.
Com esse tipo de controle, podemos gerar colunas bem alinhadas. O cdigo
printf("Numeros\n");
printf(" %8d\n", -850);
printf(" %8d\n", 12345);
printf(" %8d\n", -4);
printf(" %8d\n", -90876);

produziria a seguinte sada alinhada pela direita
Numeros
-850
12345
-4
-90876
Existe tambm uma maneira de se controlar os tamanhos dos campos dinamicamente,
quando o programa est executando. Para tal, colocamos um asterisco * logo aps o sinal
de %. Nesse caso, o tamanho do campo tambm deve ser informado como um parmetro do
comando printf, aps as aspas duplas e logo antes do valor a ser impresso. Por exemplo,
no comando abaixo
printf("Numeros = %d, %*d", 8, 5, -3);
o primeiro %d refere-se ao valor 8, que ser impresso primeiro. Em seguida, na mensagem
formatada, temos a vrgula e um branco, que so impressos logo aps o valor 8. Depois,
vemos o indicador %*d . Ento, o prximo valor na lista aps o 8, ser usado para
substituir o * nesse indicador, resultando em %5d . Este o indicador que ser usado para
imprimir o prximo, e ltimo, parmetro na lista de valores, qual seja, o -3. Tudo se passa
como se o comando printf acima fosse transformado para
printf("Numeros = '%d, %5d'", 8, -3);
produzindo como sada:
'8 -3'
Ento o primeiro valor ocupou 1 posio (o suficiente para escrever 8) e o segundo valor
ocupou 5 posies, sendo ajustado pela direita. Em geral, podemos associar variveis ao
smbolo * , tal como
printf("Numeros = '%d, %*d'", a, campo, b);
Nesse caso, o programa vai imprimir o valor da varivel a com o nmero justo de posies,
e vai usar o valor armazenado na varivel campo como o tamanho do campo para imprimir
o valor da varivel b. Dependendo do valor armazenado na varivel campo no momento da
execuo, o valor da varivel b ser impresso de uma forma ou de outra.

Leitura do teclado
O comando scanf armazena na posio de memria associada a uma varivel o valor
(contedo) digitado pelo usurio. Neste caso, o primeiro parmetro do comando (escrito

11
entre aspas duplas) formado por indicadores que determinam o tipo das variveis que
sero lidas. Os demais parmetros so os nomes das variveis (precedidos obrigatoriamente
pelo smbolo &) que armazenaro os valores digitados. O comando scanf utilizado
conforme modelo a seguir:
scanf("indicadores", &variavel1, &variavel2, ...);
Os indicadores so semelhantes aos utilizados para a escrita com printf. Para ler um
nmero inteiro e armazenar na varivel v de tipo int:
int v;
scanf("%d", &v);
Para ler trs nmeros separados por espaos e armazen-los, respectivamente, nas variveis
x, y, z, de tipo int:
int x, y, z;
scanf("%d %d %d", &x, &y, &z);
O comando scanf tambm no uma instruo primitiva da linguagem C . Sua descrio
bsica consta no arquivo stdio.h que deve ser includo antes do cdigo do programa,
atravs de uma diretiva #include.
Tabela de indicaes para leitura de valores inteiros (scanf)
Para ler nmeros inteiros, utilize os seguintes indicadores no primeiro parmetro do
comando scanf. i.e., entre as aspas duplas. Todos eles especificam que desejamos ler um
nmero inteiro na representao decimal, podendo ser precedido por um sinal de menos (-)
para nmeros negativos ou um sinal de mais (+), este opcional, para nmeros positivos.
%hd ou %hi para tipos short int
%d ou %i para tipos int
%ld ou %li para tipos long int
%lld ou %lli para tipos long long int (ANSI C)
%I64d ou %I64i para tipos long long int (Microsoft C)

Exemplo: Leitura e escrita de dados inteiros
Este programa demonstra diferentes formas de uso dos comandos printf e scanf para
escrever e imprimir variveis do tipo short int e long int.
Cdigo fonte:
#include <stdio.h>
#include <stdlib.h>

int main(int argc, char* argv[]) {
// Declarar variveis
short int pequenoA, pequenoB;
long int grandeA, grandeB;

// Ler um valor de cada vez:
printf("Digite um nmero pequeno: ");
scanf("%hd", &pequenoA);
printf("Digite outro nmero pequeno: ");
scanf("%hd", &pequenoB);

// Ler dois valores em uma nica operao:

12
printf("Digite dois nmeros grandes, separados por espao: ");
scanf("%ld %ld", &grandeA, &grandeB);

// Escrever dois valores em uma nica operao
printf("Numeros: %hd e %hd\n", pequenoA, pequenoB);

// Escrever um valor de cada vez
printf("Numeros: %ld\n", grandeA);
printf("Numeros: %ld\n", grandeB);

return 0;
}
Consulte programas: TiposInteiros\LeituraEscrita\LeituraEscrita
Descrio passo a passo:
#include <stdio.h>
#include <stdlib.h>
As primeiras duas linhas do programa so diretivas de compilador que fazem
referncia s bibliotecas padro do C. Sua incluso garante que os comandos
printf e scanf estejam disponveis para uso no programa.

short int pequenoA, pequenoB;
O programa comea declarando todas as variveis que utilizar. Esta linha define
duas variveis, chamadas pequenoA e pequenoB. Elas armazenaro dois nmeros
pequenos que sero lidos do teclado. As duas so do tipo short int, mas no
possuem um valor inicial. Como as caractersticas dessas variveis so todas iguais,
pode-se declar-las todas na mesma linha, separando seus nomes por vrgulas.
Repare que nenhuma dessas variveis est recebendo um valor inicial. Ento,
quando executar, que valores contero? impossvel prever. Felizmente este
problema ser resolvido quando o contedo das variveis for lido com o comando
scanf.

long int grandeA, grandeB;
A segunda declarao define dois nmeros grandes que sero lidos do teclado.

printf("Digite um nmero pequeno: ");
scanf("%hd", &pequenoA);
printf("Digite outro nmero pequeno: ");
scanf("%hd", &pequenoB);
Para obter o valor das variveis pequenoA e pequenoB, utilizamos duas vezes o
comando scanf para ler o valor de cada uma. Utilizamos o indicador %hd para
informar que desejamos ler um nmero na representao decimal e converter para
uma varivel de tipo short int . Note a existncia do & na frente dos nomes das
variveis para o funcionamento correto do scanf. Essa uma fonte de erros
em C.
Note que a mensagem solicitando que o usurio digite os nmeros gerada pelo
comando printf, no por scanf! Como o comando printf no termina com \n

13
ento o cursor no deslocado para a prxima linha aps a mensagem ser impressa.
Assim, o usurio continua digitando os valores de entrada logo aps a mensagem
solicitando o dado. Porm, como o usurio deve apertar a tecla enter (ou
return) logo aps digitar o primeiro valor (que vai ser armazenado em pequenoA),
o cursor imediatamente deslocado para a prxima linha, preparando o terreno para
que a mensagem do segundo printf comece logo na primeira coluna da nova
linha. Por fim, note que o computador automaticamente imprime na tela os dgitos
que vo sendo teclados, mesmo o programa no tendo solicitado isso
explicitamente. Essa impresso dos dados digitados chamada de eco na tela.

printf("Digite dois nmeros grandes, separados por espao: ");
scanf("%ld %ld", &grandeA, &grandeB);
Para as variveis grandeA e grandeB, utilizamos o comando scanf de uma forma
diferente. As variveis so lidas de uma s vez, ou seja, o usurio precisa escrever
os dois valores na mesma linha e o scanf reconhecer os dois nmeros. Utilizamos
o indicador %ld para informar que desejamos ler um nmero na representao
decimal e armazenar numa varivel de tipo long int. Observe o espao entre os
dois indicadores %ld. Isso indica que os nmeros devem vir separados por um ou
mais espaos em branco (que, para a rotina scanf podem ser tanto o branco
comun, o tab, ou o return). Porm, se colocarmos outros caracteres na
mensagem do comando scanf (que vem entre aspas duplas) entre os dois
indicadores %ld, ento o computador exigir um casamento perfeito entre a entrada
de dados e o formato indicado no comando scanf. Por exemplo, se escrevermos
scanf("%ld A %ld", &grandeA, &grandeB);
ento os dados devero estar separados por um ou mais espaos em branco,
seguidos do caractere A, seguido de um ou mais espaos em branco. Se a forma
de entrada dos dados no seguir a especificao do comando, ento resultados
inesperados podem ocorrer, dependendo de cada compilador. Para segurana,
consulte o manual do seu compilador para ver como o comando scanf l descrito.
Continuamos agora com o programa original.

printf("Numeros: %hd e %hd\n", pequenoA, pequenoB);
A mensagem do comando printf contm dois indicadores %hd, ou seja, ele ir
substituir o primeiro pelo valor da varivel pequenoA e o segundo pelo valor da
varivel pequenoB . Antes de realizar a substituio, ele formata os dois valores
para a representao decimal. O smbolo \n indica que o prximo printf escrever
no incio da linha seguinte.

printf("Numeros: %ld\n", grandeA);
printf("Numeros: %ld\n", grandeB);
Eis uma forma alternativa de escrever nmeros, utilizando um comando printf
para cada varivel. Note que, como as variveis so do tipo long int, necessitamos
do indicador %ld para realizar a substituio e formatao.

14
return 0;
Para terminar o programa, devemos sempre utilizar o comando return 0.
Exemplo de Execuo:
Os valores digitados pelo usurios esto em itlico.
Digite um nmero pequeno: 300
Digite outro nmero pequeno: 200
Digite dois nmeros grandes, separados por espao: 100000 300200
Nmeros: 300 e 200
Nmeros: 100000
Nmeros: 300200
Observaes importantes
Quando a execuo do programa chega ao comando scanf, o programa permanece
suspenso at que o usurio digite todos os valores esperados pelo scanf e pressione a tecla
enter.
Se um comando scanf requer mais de um valor, como no exemplo da leitura de x, y e z
abaixo, isto no implica que o usurio deve digitar os valores na mesma linha. Por
exemplo:
scanf("%d %d %d", &x, &y, &z);
Tanto faz o usurio digitar:
3 4 5
Ou:
3
4
5
Se o usurio digitar mais nmeros que o esperado pelo scanf, os nmeros em excesso
ficaro armazenados na fila de entrada para serem lidos automaticamente pelos prximos
comandos scanf.
O primeiro parmetro do scanf contm somente indicadores. O programa tentar
reconhecer o texto digitado pelo usurio de acordo com o indicador. Para escrever uma
mensagem informando ao usurio o que ele deve digitar, utilize o comando printf antes
do scanf.
printf("Por favor, digite trs nmeros: ");
scanf("%d %d %d", &x, &y, &z);

O resultado ser (a parte digitada pelo usurio est em itlico):
Por favor, digite trs nmeros: 3 4 5

O exemplo a seguir est errado:
scanf("Por favor, digite trs nmeros: %d %d %d", &x, &y, &z); (errado!)
Se, por algum motivo, o usurio no digitar texto no formato correto conforme indicado
exatamente pela mensagem entre aspas, com os indicadores substitudos pelos valores a
serem lidos, ento o comando scanf interromper a leitura sem preencher o contedo das
variveis.

15
Introduo aos Operadores
Agora vamos estudar algumas operaes bsicas que podem ser realizadas sobre as
variveis de tipo inteiro.
Atribuio
Aps a declarao de uma varivel, possvel atribuir-lhe um novo valor. Esta operao
indicada pelo operador =.
Note que, em C, o sinal = no significa o mesmo que igualdade matemtica!
Para atribuir um valor a uma varivel, a sintaxe bem simples:
variavel = valor;
Na atribuio, o operador = aparece entre os dois lados da operao. O lado esquerdo deve
ser obrigatoriamente uma varivel. O lado direito deve ser um nmero, uma outra varivel
ou uma expresso matemtica cujo resultado final seja um nmero.
O efeito da atribuio simples. Primeiro, calcula-se o resultado (valor) da expresso
direita. Depois, armazena-se o resultado na varivel esquerda do operador =.
importante garantir que o tipo da varivel esquerda seja compatvel com o gerado pela
expresso direita. Caso contrrio, a atribuio poder ocorrer de forma diferente da
esperada. Este um erro freqente.

Exemplo
Suponha que existam variveis chamadas quantidade, nota1 e nota2, todas declaradas
como int . Vamos atribuir, respectivamente, a cada uma dessas variveis, os novos
valores 10, 6 e 7:
quantidade = 10;
nota1 = 6;
nota2 = 7;

A atribuio pode ser tambm o resultado de uma expresso matemtica:
soma = nota1 + nota2;
contador_novo = contador_velho + 1;
Outros Operadores
Para nmeros inteiros, a linguagem C define um operador para cada uma das quatro
operaes bsicas (adio, subtrao, multiplicao, diviso). No caso da diviso, existe um
operador para se obter o quociente e outro para se obter o resto. Tambm h um operador
para se obter o negativo de um valor.
Expresses envolvendo nmeros inteiros, em C, so muito semelhantes expresses
matemticas tradicionais com as quais j estamos familiarizados.
Os operadores realizam as operaes sobre dois valores, que devem ser resultados da
avaliao de expresses de tipos compatveis.
Para os tipos inteiros, a linguagem C define os seguintes operadores:

16
Soma + (smbolo de adio)
Subtrao - (smbolo de subtrao, ou de negativo)
Multiplicao * (asterisco)
Diviso / (barra)
Resto % (porcento)

Os operadores matemticos normalmente so utilizados em conjunto com o operador de
atribuio para armazenar o resultado em uma varivel, como podemos observar nos
prximos exemplos.
Tambm permitido utilizar parnteses para agrupar operadores de uma expresso,
indicando a ordem na qual as operaes devem ser realizadas. As regras para o uso de
parnteses so as mesmas a que j estamos acostumados na aritmtica.
Exemplos
Soma: operador +:
int parcela1 = 10;
int parcela2 = 16;
int soma;
soma = parcela1 + parcela2;
printf("Soma: %d mais %d %d", parcela1, parcela2, soma);
Imprime:
Soma: 10 mais 16 26
Note que primeiro ser realizada a soma, depois a atribuio.

Subtrao: operador -:
int parcela1 = 10;
int parcela2 = 16;
int subtracao;
subtracao = parcela1 - parcela2;
printf("Subtrao: %d menos %d %d", parcela1, parcela2, subtracao);
Imprime:
Subtrao: 10 menos 16 -6

Multiplicao: operador * (asterisco):
int fator_a = 4;
int fator_b = 6;
int produto;
produto = fator_a * fator_b;
printf("Multipliao: %d vezes %d %d", fator_a, fator_b, produto);
Imprime:
Multiplicao: 4 vezes 6 24

Diviso: operador /(barra):
Quando aplicado a nmeros inteiros, o operador de diviso no realiza a operao exata,
mas gera o quociente da diviso.

17
int dividendo = 46;
int divisor = 6;
int quociente;
quociente = dividendo / divisor;
printf("Diviso: %d dividido por %d %d", dividendo, divisor, quociente);
Imprime:
Diviso: 46 dividido por 6 7

Resto: operador % (porcento):
Cdigo em C:
int dividendo = 46;
int divisor = 6;
int quociente;
int resto;
quociente = dividendo / divisor;
resto = dividendo % divisor;
printf("Diviso: %d dividido por %d %d, resto %d", dividendo, divisor,
quociente, resto);
Imprime:
Diviso: 46 dividido por 6 7, resto 3

Exemplo:
Este programa pergunta o tempo decorrido entre dois eventos, que deve ser dado em
segundos. O programa calcula, ento, quantas horas, minutos e segundos correspondem a
este intervalo de tempo.
Cdigo fonte:
#include <stdio.h>
#include <stdlib.h>

int horas, minutos, segundos;
int total_segundos;

// Pedir ao usurio para escrever intervalo de tempo (em segundos)
printf("Digite o intervalo de tempo (segundos): ");
scanf("%d", &total_segundos);

// Clculos;
horas = (total_segundos / 60) / 60;
minutos = (total_segundos / 60) % 60;
segundos = total_segundos % 60;

// Imprimir resultados
printf("\n");
printf("Total de segundos: %d \n", total_segundos);
printf("Tempo: %d:%d:%d\n", horas, minutos, segundos);

return 0;
}

Consulte: IntroducaoOperadores\Horario01\Horario01.vcproj

18

Descrio passo a passo:
#include <stdio.h>
#include <stdlib.h>
As primeiras duas linhas do programa so diretivas de compilador para que este
inclua as bibliotecas padro da linguagem C. Elas garantiro que os procedimentos
printf e scanf estaro disponveis para serem usados no programa.

int horas, minutos, segundos;
O programa comea declarando todas as variveis que utilizar. Esta linha define
trs variveis, chamadas horas, minutos e segundos. Elas armazenaro o
resultado dos clculos realizados. Todas elas so do tipo int e no possuem um
valor inicial. Como as caractersticas dessas variveis so todas iguais, pode-se
declar-las todas na mesma linha, separando seus nomes com vrgulas.
Como nenhuma dessas variveis est recebendo um valor inicial, devemos
tomar o cuidado de atribuir um valor a elas, antes de utiliz-las para clculos
no programa.

int total_segundos;
A segunda declarao o valor que ser digitado do usurio, que ficar armazenado
na varivel chamada total_segundos.

printf("Digite o intervalo de tempo (segundos): ");
scanf("%d", &total_segundos);
Para obter o valor da varivel total_segundos, utilizamos o procedimento
scanf para ler seu valor. O indicador %d informa que desejamos ler um nmero na
representao decimal e converter para uma varivel de tipo int.
Note a presena do & na frente do nome da varivel total_segundos para o
funcionamento correto do scanf. Nova fonte de erros.

horas = (total_segundos / 60) / 60;
Esta linha uma atribuio. O lado direito do operador = uma expresso
matemtica que calcula o nmero de horas, dado o valor em segundos. O smbolo /
indica operador de diviso inteira. Note que dividimos duas vezes por 60 (uma vez
para transformar segundos em minutos, e uma segunda vez para transformar
minutos em horas). O valor resultante ser armazenado na varivel horas. O uso
dos parnteses, a rigor, opcional, j que a divises sucessivas so realizadas da
esquerda para direita.

minutos = (total_segundos / 60) % 60;
Estas duas linhas tambm so atribuies. Dividimos o total de segundos por 60,
para obter o nmero de minutos. Depois, calculamos o resto da diviso por 60, para

19
saber o nmero de minutos que excedem as horas. Note que, neste caso, o uso de
parnteses obrigatrio, para garantir que primeiro ser realizada a diviso de
total_segundos por 60, e somente depois ser realizado o clculo do resto.
O nmero de segundos obtido de forma semelhante, calculando o resto da diviso
por 60, para obter o nmero de segundos que excedem os minutos.

printf("\n");
printf("Total de segundos: %d \n", total_segundos);
printf("Tempo: %d:%d:%d\n", horas, minutos, segundos);
Por fim, o programa no seria de utilidade se no informasse o resultado de forma
visvel para o usurio. O primeiro comando printf escreve uma linha em branco,
apenas para tornar a sada do texto mais organizada. O segundo printf escreve
novamente o total de segundos digitado pelo usurio. Note que utilizamos o
indicador %d para informar que ele ser substitudo pela representao decimal do
valor da varivel total_segundos.

return 0;
Para terminar o programa, devemos sempre utilizar return 0.
Exemplo de Execuo:
Digite o intervalo de tempo (segundos): 1085

Total de segundos: 1085
Tempo: 0:18:5
Melhorias no cdigo:
Podemos aplicar uma pequena melhoria no cdigo do clculo das horas, minutos e
segundos. Note que, para determinar tanto o nmero de horas quanto o nmero de minutos
realizamos divises por 60. Para evitar a repetio desta operao, poderamos guardar o
resultado da diviso em uma varivel auxiliar.
int total_minutos;
.
.
.
total_minutos = total_segundos / 60;

minutos = total_minutos % 60;
horas = total_minutos / 60;
Consulte: IntroducaoOperadores\Horario02\Horario02.vcproj
Note como a varivel total_minutos foi reutilizada para armazenar o valor intermedirio
dos minutos. Com isso, economizamos um clculo de diviso.
Este exemplo comprova que no existe uma nica soluo para escrever um algoritmo
correto para uma tarefa dada. No existe um algoritmo mais correto que outro. O
programador deve preferir aquele mais simples de entender.

20
Tipo Caractere
Para realizar processamento de texto e trabalhar com letras do alfabeto e outros caracteres
como, por exemplo, smbolos de pontuao, a linguagem C tambm representa s caracteres
como nmeros inteiros, com algumas facilidades especficas. Desta forma, tudo que
aprendemos para nmeros inteiros pode ser aplicado para caracteres.
As variveis que armazenam um caractere so declaradas como sendo do tipo char. Esse
tipo nada mais que uma outra denominao para o tipo short short int. Uma varivel
desse tipo usa apenas um byte da memria, podendo acomodar valores inteiros desde -256
at +255, como podemos extrair da nossa tabela de valores para inteiros apresentada
anteriormente. No entanto, quando uma varivel declarada como do tipo char o
programador j indica sua inteno de utilizar a varivel para armazenar smbolos.
A correspondncia entre smbolos e nmeros dada pela tabela ASCII (American Standard
Code for Information Interchange). Esta tabela utiliza os nmeros de 0 at 127 para letras
do alfabeto ingls e para os sinais de pontuao mais comuns. Por exemplo, na entrada 65
da tabela ASCII encontramos a letra 'A'. Assim, uma varivel do tipo char cujo contedo
seja 65 representaria tambm a letra 'A'. Infelizmente no existe consenso de como tratar
os caracteres numerados a partir de 128, onde estariam os caracteres acentuados, e isso
causa de incompatibilidades entre programas que compilam e executam em plataformas
diferentes.
Uma das facilidades da linguagem C para manipular caracteres a converso automtica
entre letras e nmeros da tabela ASCII. Assim, para atribuir uma letra a uma varivel do
tipo char, basta escrever a letra entre aspas simples. Por exemplo:
char letra = 'A';
O resultado dessa atribuio que o contedo da varivel letra ser uma seqncia de 8
bits (que o tamanho de um short short int ) que, se interpretada como um nmero
resultar em 65. De forma semelhante, podemos atribuir a mesma letra A varivel
letra diretamente, usando seu respectivo cdigo ASCII que 65:
char letra = 65;
A primeira atribuio, entretanto, bem mais legvel. No precisamos conhecer a tabela
ASCII. Simplesmente escrevemos a letra desejada (entre aspas simples) e deixamos o
compilador realizar a converso.
Uma informao til, entretanto, que as letras a-z tm numerao consecutiva na tabela
ASCII. O mesmo vale para as letras A-Z e para os dgitos 0-9.
Escrita
Para escrever um caractere, utiliza-se o comando printf com um dos seguintes
indicadores:

%c char escreve caractere
%hhd, %hhi char escreve o cdigo ASCII do caractere

21

Exemplo
char letra_a = 'a', letra_W = 'W';
printf("Letra %c tem cdigo %hhd", letra_a, letra_a);
printf("Letra %c tem cdigo %hhd", letra_W, letra_W);
Imprime:
Letra a tem cdigo 97
Letra W tem cdigo 87

Observe como o indicador %c causa a impresso do smbolo correspondente ao valor que
est armazenado na varivel. O compilador faz a converso automaticamente. J o
indicador %hhd causa a impresso do valor numrico e na representao decimal.
Leitura
A leitura de caractere realizada com o comando scanf, usando os seguintes indicadores
de formatao :

%c char l um caractere
%hhd, %hhi char l o cdigo ASCII do caractere
%c (espao em branco na frente)
char l prximo caractere que no caractere de
espaamento

O primeiro indicador (%c) encontrado na mensagem, fora a leitura do prximo caractere,
independente da letra ou pontuao que ele representa. O ltimo indicador (%c com espao
em branco na frente) significa que desejamos ler a prxima letra, ignorando caracteres de
espaamento.
Se desejamos ler uma letra digitada pelo usurio, devemos usar scanf(" %c"), caso
contrrio, o programa vai ler o prximo caractere da entrada, mesmo que ele seja um
espao em branco como, por exemplo, o ltimo return que foi teclado. Note que espaos
em branco tambm correspondem a smbolos (existe uma tecla para eles!) e, assim, eles
tambm tm um ndice na tabela ASCII (usualmente o de nmero 40).
No incio as operaes de leitura e escrita usando caracteres, especialmente as operaes de
leitura, podem parecer confusas. Se tal o caso, tente evit-las enquanto ganha mais
proficincia com a linguagem C. Uma boa forma remover confuses imaginar que tudo
que teclamos (inclusive a tecla espao!) um caractere que colocado numa fila de
entrada. Quando invocamos um comando scanf, o computador acessa essa fila e retira de
l exatamente quantos caracteres sejam necessrios para obter os valores de que precisa. Os
demais caracteres so deixados na fila (inclusive aqueles correspondentes aos return que
digitamos!). Se teclarmos mais, os novos caracteres entram todos na fila, na ordem em que
foram teclados. Se invocarmos novos comandos scanf os caracteres mais no incio da fila
so removidos at satisfazer os comandos scanf. Uma boa maneira de verificar quais
caracteres um comando scanf leu seria imprimir o contedo das variveis onde esses
caracteres foram armazenados, mas agora usando indicadores de formatao %d, que
informam os valores decimais contidos nas variveis.

22

Os caracteres de espaamento correspondem ao branco, ao tab e ao return.
Podemos fazer esses caracteres aparecerem nas mensagens impressas de vrias formas. Eis
duas delas:
1. No comando printf podemos usar o espao, ou o '\t' ou o '\n' para causar a
impresso de cada um deles, respectivamente.
2. Podemos armazenar numa varivel tipo char o seu valor numrico e usar o
indicador %c no comando printf para imprimi-los.

Em resumo, na linguagem C smbolos so, na realidade, tratados como valores inteiros
pequenos. O programador pode manipular o contedo dessas variveis como se fossem
inteiros, inclusive usando todas as operaes sobre inteiros. O compilador, porm, aceita a
sintaxe especial das aspas simples que permite escrever o smbolo diretamente ao invs de
seu valor numrico correspondente. Alm disso, o compilador faz a converso automtica
entre o valor numrico e o smbolo correspondente, e vice-versa.
Voc j tem condies de fazer um programa para descobrir qual o smbolo associado a
qualquer inteiro pequeno. Tente!

Outros Tipos Inteiros
J estudamos como a linguagem C utiliza as palavras short e long para definir tipos de
nmeros inteiros com diferentes intervalos para os possveis valores. A linguagem C
tambm permite informar se a varivel aceita ou no um sinal, ou seja, se ela aceita
nmeros negativos.
Sobre a diversidade de tipos em C
A rigor, atualmente, o programador no precisa se preocupar com o intervalo dos nmeros
usados na maioria dos programas. Todos os tipos numricos so processados com
praticamente a mesma eficincia e a memria disponvel to grande que pode ser
considerada infinita. No faz mais muito sentido optar por declarar uma varivel como
short int apenas para economizar memria ou como int para tornar o programa mais
rpido.
Da mesma forma, para os programas mais comuns no h necessidade em se preocupar se
uma varivel possui ou no sinal. Declarando todas as variveis inteiras como do tipo int,
o programa poder operar tanto com nmeros positivos como com nmeros negativos.
Assim, para contornar a complexidade gerada pelo excesso de tipos de nmeros inteiros,
recomenda-se utilizar somente o tipo int, que o tipo inteiro mais genrico.
No entanto, ainda existe muito cdigo fonte C antigo e necessrio pelo menos conhecer
todos os tipos da linguagem C.

23
Tipos com sinal
At o momento, encontramos os tipos inteiros int, short int, long int e long long
int. O tipo char tambm pode ser utilizado como um caso especial de tipo inteiro que
representa um smbolo. Todos estes tipos representam nmeros inteiros, cujo domnio um
intervalo (quase) simtrico de nmeros negativos e positivos. Por este motivo, estes tipos
so tambm denominados de tipos com sinal. Para ressaltar esta propriedade, a declarao
das variveis pode ser realizada adicionando-se opcionalmente a palavra signed ao nome
do tipo. Normalmente, para deixar o programa mais enxuto e mais fcil de ler, costuma-se
omitir a palavra signed.
Os seguintes tipos so equivalentes (declaram o mesmo tipo de varivel):

Tipo com sinal Tipo equivalente com sinal
char signed char
int signed int
short short int signed short short int
short int signed short int
long int signed long int
long long int signed long long int

Tipos sem sinal
Para cada um destes tipos inteiros, C oferece um tipo correspondente que representa um
nmero no negativo. Ao invs do domnio do tipo conter tanto nmeros inteiros negativos
como positivos, estes tipos representam apenas nmeros positivos. Por este motivo, estes
tipos so tambm denominados de tipos sem sinal. Para ressaltar esta propriedade, a
declarao das variveis deve ser realizada adicionando-se a palavra obrigatria unsigned
ao nome do tipo. Todos os conceitos aprendidos para variveis com sinal tambm so
vlidos para variveis sem sinal.
A tabela a seguir apresenta estes novos tipos.

Tipo com sinal Tipo equivalente com sinal Equivalente sem sinal
char signed char unsigned char
int signed int unsigned int
short short int signed short short int unsigned short short int
short int signed short int unsigned short int
long int signed long int unsigned long int
long long int signed long long int unsigned long long int

A prxima tabela mostra os domnios de cada um dos tipos inteiros para o compilador C da
Microsoft. Repare como os tipos sem sinal comportam valores positivos alm daqueles que
podem ser armazenados em tipos com sinal.

24

Tipo Tamanho Domnio
char ou
signed char
1 byte - 128 at 127
int ou
signed int
4 bytes - 2.147.483.648 at 2.147.483.647
short int ou
signed short int
2 bytes - 32.768 at 32.767
long int ou
signed long int
4 bytes - 2.147.483.648 at 2.147.483.647
long long int ou
signed long long int
8 bytes - 9,223 10
15
at 9,223 10
15

unsigned char 1 byte 0 at 255
unsigned int 4 bytes 0 at 4.294.967.296
unsigned short int 2 bytes 0 at 65.536
unsigned long int 4 bytes 0 at 4.294.967.296
unsigned long long int 8 bytes 0 at 18,446 10
15

Escrita
A tabela a seguir resume todos os indicadores para todos os tipos encontrados, para uso
com o comando printf:

%hhd, %hhi
char ou
signed char
%d, %i
int ou
signed int
%hd, %hi
short int ou
signed short int
%ld, %li
long int ou
signed long int
%lld, %lli, %I64i
long long int ou
%hhu unsigned char
%u unsigned int
%hu unsigned short int
%lu unsigned long int
%llu, %I64u unsigned long long int
Observao: O compilador C da Microsoft no aceita os indicadores %lld, %lli e %llu.
Deve-se utilizar, respectivamente, %I64d, % I64i e %I64u.

25
Leitura
Para o comando scanf, os indicadores disponveis so:

%hhd, %hhi
char ou
signed char
%d, %i
int ou
signed int
%hd, %hi
short int ou
signed short int
%ld, %li
long int ou
signed long int
%lld, %lli, %I64i
long long int ou
%hhu unsigned char
%u unsigned int
%hu unsigned short int
%lu unsigned long int
%llu, %I64u unsigned long long int

Tipos Ponto Flutuante (Fracionrios)
Alm dos nmeros inteiros, a linguagem C define
trs tipos de nmeros cujos domnios so nmeros
fracionrios: so tambmchamados de nmeros de
tipo ponto flutuante.
Os trs tipos de ponto flutuante so:

float Pouca preciso, baixa magnitude
double Muita preciso, alta magnitude
long double Preciso ainda maior, altssima magnitude

Tal como para as variveis inteiras, quanto maior a preciso e magnitude, mais memria
necessria para armazenar o contedo de variveis daquele tipo. No computadores antigos,
as variveis de tipo float eram processadas com maior eficincia. Hoje, no existe um tipo
de ponto flutuante preferido para cada processador. A arquitetura Intel Pentium implementa
as operaes sobre float e double praticamente com a mesma eficincia.
Exemplos
Declarao de variveis de pouca preciso:
float raio = 5.4;
float area = 50040.22;
Declarao de variveis com alta preciso:
Real
float double long double
Real
float double long double

Figura 3 - Tipos de nmeros reais

26
double velocidade = 5.333222567854;

Intervalos de ponto flutuante
Tipo Tamanho Preciso aproximada Magnitude aproximada
float 4 byes 7 dgitos - 3,4 10
38
at 3,4 10
38

double 8 byes 15 dgitos - 1,7 10
308
at 1,7 10
308

long double 10 bytes 19 dgitos - 1,2 10
4932
at 1,2 10
4932

Escrita
Para escrever nmeros de ponto flutuante, utiliza-se o comando printf, de forma muito
semelhante quela vista para valores inteiros. So os seguintes os indicadores de
formatao para lidar com valores fracionrios:

%e double/float usa notao cientfica (ex.: 4.56e-3)
%f double/float usa representao decimal (ex.: 0.00456)
%g double/float escolhe entre notao cientfica e representao decimal,
escolhendo a forma mais compacta.
%Le long double usa notao cientfica (ex.: 4.56e-3)
%Lf long double usa representao decimal (ex.: 0.00456)
%Lg long double escolhe entre notao cientfica e representao decimal,
escolhendo a forma mais compacta.

Exemplo
float numero = 156.40;
printf("O nmero: %f %e %g\n", numero, numero, numero);
numero = 1560000.0;
printf("O nmero: %f %e %g\n", numero, numero, numero);
Produzir:
O nmero: 156.399994 1.564000e+02 156.4
O nmero: 1560000.000000 1.560000e+06 1.56e+06
Ao invs de imprimir 156.4, o programa imprime 156.399994. A explicao est na
prxima observao.

Observao
O tipo ponto flutuante no capaz de representar qualquer nmero real com preciso
absoluta, ele os aproxima para fraes que satisfazem a seguinte expresso:
valor = sinal mantissa 2
expoente
.
E esta aproximao boa o suficiente para praticamente todas as aplicaes. No entanto,
para aplicaes financeiras que requerem apurao rigorosa de valores, no devemos
utilizar variveis de tipo ponto flutuante. Basta multiplicar os valores por 100 e usar
inteiros.

27
Leitura
A leitura de valores em ponto flutuante realizada com o comando scanf, de forma muito
semelhante quela vista para valores inteiros. Utiliza-se os seguintes indicadores de
formatao:

%e float l em notao cientfica
%f float l em representao decimal
%g float l em qualquer uma das duas formas
%le double l em notao cientfica
%lf double l em representao decimal
%lg double l em qualquer uma das duas formas
%Le long double l em notao cientfica
%Lf long double l em representao decimal
%Lg long double l em qualquer uma das duas formas

Exemplo: operaes com nmeros fracionrios
Calcular o permetro e rea de um crculo, cujo raio foi informado pelo usurio.
Cdigo fonte
#include <stdio.h>
#include <stdlib.h>

double pi = 3.141592;
double raio, area, perimetro;

// Pedir ao usurio escrever o raio
printf("Digite o raio: ");
scanf("%lf", &raio);

// Clculos
area = pi * (raio * raio);
perimetro = 2.0 * pi * raio;

// Imprimir resultados
printf("\n");
printf("Raio: %lf \n", raio);
printf("rea: %lf \n", area);
printf("Permetro: %lf \n", perimetro);

return 0;
}
Consulte: TiposPontoFlutuante\Circulo01\Circulo01.vcproj

28
Descrio passo a passo
#include <stdio.h>
#include <stdlib.h>
As primeiras duas linhas do programa so diretivas de compilador para incluir as
bibliotecas padro da linguagem C. Elas garantem que os comandos printf e
scanf estejam disponveis no instante da compilao do programa.

double pi = 3.141592;
O programa comea delcarando todas as variveis que utilizar. Declara-se a
varivel de nome pi, do tipo double, que j armazena o valor 3.141592.

double raio, area, perimetro;
Esta linha outra declarao em C, que define trs variveis, chamadas raio, area
e perimetro. Todas elas so do tipo double e no possuem um valor inicial. Como
as caractersticas dessas variveis so todas iguais, pode-se declar-las todas na
mesma linha, separando seus nomes com vrgula. Como nenhuma dessas variveis
est recebendo um valor inicial, devemos tomar o cuidado de atribuir um valor
a elas antes de utilizar seus valores para clculos no programa.

printf("Digite o raio: ");
scanf("%lf", &raio);
Para obter o valor da varivel raio, utilizamos o comando scanf para ler o seu
valor. Note que utilizamos o indicador %lf para informar que desejamos ler um
nmero na representao decimal e converter para uma varivel de tipo double.
Note a existncia do & na frente da varivel raio para o funcionamento correto
do scanf.

area = pi * (raio * raio);
Essa linha uma atribuio. O lado direito do operador = uma expresso
matemtica que calcula a rea do crculo a partir do raio, usando a frmula que
aprendemos em geometria (
2
R A ! = ). O smbolo * indica o operador de
multiplicao. Como no existe um operador de potncia, multiplicamos duas vezes
pelo raio. O valor resultante ser armazenado na varivel area.

perimetro = 2.0 * pi * raio;
De forma semelhante, esta linha uma atribuio que calcula o valor do permetro e
o armazena na varivel perimetro.

printf("\n");
printf("Raio: %lf \n", raio);
printf("rea: %lf \n", area);
printf("Permetro: %lf \n", perimetro);
Por fim, o programa no seria de utilidade se ele no informasse o resultado de
forma visvel para o usurio. O primeiro printf escreve uma linha em branco,

29
apenas para tornar o texto mais organizado. O segundo printf escreve novamente
o raio digitado pelo usurio. Note que utilizamos o indicador %lf para informar que
ele ser substitudo pela representao decimal do valor da varivel raio, que do
tipo double. O mesmo vale para os demais printfs, que escrevem o valor
calculado para a rea e para o permetro.

return 0;
Para terminar o programa, devemos sempre utilizar return 0.
Exemplo de execuo
Digite o raio: 3.5

Raio: 3.500000
rea: 38.484502
Permetro: 21.991144

Unicamp LPCap03 TiposBasicos Texto

Загружено:

Сведения о документе

Авторское право

Доступные форматы

Поделиться этим документом

Поделиться или встроить документ

Параметры публикации

Этот документ был вам полезен?

Это неприемлемый материал?

Авторское право:

Доступные форматы

Unicamp LPCap03 TiposBasicos Texto

Загружено:

Авторское право:

Доступные форматы

2/3/2011 11:12 Copyright@2005-2009 Arnaldo V. Moura, Daniel F.

Вам также может понравиться