Especificaes de formato[editar | editar cdigo-fonte]

A documentao mais tcnica os chama de "especificadores de converso", pois o que

ocorre na maioria das vezes , de fato, a converso de um valor numrico em uma
sequncia de caracteres que representa aquele valor. Mas o nome "formato" no deixa de
estar correto, pois eles especificam em que formato (inteiro, real etc.) est o argumento
correspondente.
Cdigo

Converso/Formato do argumento

%d

Nmero decimal inteiro (int). Tambm pode ser usado %i como equivalente a %d.

%u

Nmero decimal natural (unsigned int), ou seja, sem sinal.

%o

Nmero inteiro representado na base octal. Exemplo: 41367 (corresponde ao

decimal 17143).

%x

Nmero inteiro representado na base hexadecimal. Exemplo: 42f7 (corresponde ao

decimal 17143). Se usarmos %X, as letras sero maisculas: 42F7.

%X

Hexadecimal com letras maisculas

Nmero decimal de ponto flutuante. No caso da funo printf, devido s

%f

%e
%E
%g
%p
%c

converses implcitas da linguagem C, serve tanto para float como para double.
No caso da funo scanf, %f serve para float e%lf serve para double.
Nmero em notao cientfica, por exemplo 5.97e-12. Podemos usar %E para
exibir o E maisculo (5.97E-12).
Nmero em notao cientfica com o "e"maisculo
Escolhe automaticamente o mais apropriado entre %f e %e. Novamente, podemos
usar %G para escolher entre %f e %E.
Ponteiro: exibe o endereo de memria do ponteiro em notao hexadecimal.
Caractere: imprime o caractere que tem o cdigo ASCII correspondente ao valor
dado.

%s

Sequncia de caracteres (string, em ingls).

%%

Imprime um %

Observao Se voc quiser imprimir um sinal de porcentagem, use %%. Exemplo:

printf("O lucro para o ltimo ms foi de 20%%.");

Numa sequncia de controle, possvel tambm indicar a largura do campo, o nmero de

casas decimais, o tamanho da varivel e algumas opes adicionais. O formato geral :
%[opes][largura do campo][.preciso][tamanho da varivel]tipo de
dado
A nica parte obrigatria o tipo de dado. Todas as outras podem ser omitidas.
Opes[editar | editar cdigo-fonte]

As opes so parmetros opcionais que alteram a formatao. Voc pode especificar

zero ou mais delas, colocando-as logo aps o sinal de porcentagem:

0: o tamanho do campo deve ser preenchido com zeros esquerda quando

necessrio, se o parmetro correspondente for numrico.

- (hfen): o valor resultante deve ser alinhado esquerda dentro do campo (o

padro alinhar direita).

(espao): no caso de formatos que admitem sinal negativo e positivo, deixa um

espao em branco esquerda de nmeros positivos.

+: o sinal do nmero ser sempre mostrado, mesmo que seja positivo.

' (aspa simples/apstrofe): nmeros decimais devem ser exibidos com separador

de milhares caso as configuraes regionais o especifiquem. Essa opo normalmente

s funciona nos sistemas Unix.
Largura do campo[editar | editar cdigo-fonte]
Como o prprio nome j diz, especifica qual a largura mnima do campo. Se o valor no
ocupar toda a largura do campo, este ser preenchido com espaos ou zeros. Por
exemplo, podemos imprimir um cdigo de at 5 dgitos preenchido com zeros, de maneira
que os valores 1, 27, 409 e 55192 apaream como 00001, 00027, 00409 e 55192.
A largura deve ser especificada logo aps as opes, se presentes, e pode ser um nmero
que especifica a largura ou um asterisco, que diz que a largura ser especificada
pelo prximo argumento (ou seja, o argumento anterior ao valor a ser impresso). Neste
exemplo, o campo ter largura igual ao valor de num e o valor impresso ser 300:
printf ("%*d", num, 300);
O campo impresso de acordo com as seguintes regras:

Se o valor for mais largo que o campo, este ser expandido para poder conter o
valor. O valor nunca ser cortado.

Se o valor for menor que o campo, a largura do campo ser preenchida com
espaos ou zeros. Os zeros so especificados pela opo 0, que precede a largura.

O alinhamento padro direita. Para se alinhar um nmero esquerda usa-se a

opo - (hfen ou sinal de menos) antes da largura do campo.

Por exemplo, compare as trs maneiras de exibir o nmero 15:

printf ("%5d", 15);

printf ("%05d", 15);
printf ("%-5d", 15);

// exibe "
15"
// exibe "00015"
// exibe "15
"

E alguns outros exemplos:

printf ("%-10s", "Jos");
printf ("%10s", "Jos");
printf ("%4s", "Jos");

// exibe "Jos
"
// exibe "
Jos"
// exibe "Jos"

Preciso[editar | editar cdigo-fonte]

A preciso pode ter quatro significados diferentes:

Se a converso solicitada for inteira (d, i, o, u, x, X): o nmero mnimo de dgitos a

exibir (ser preenchido com zeros se necessrio).

Se a converso for real (a, A, e, E, f, F): o nmero de casas decimais a exibir. O

valor ser arredondado se a preciso especificada no formato for menor que a do
argumento.

Se a converso for em notao cientfica (g, G): o nmero de algarismos

significativos. O valor ser arredondado se o nmero de algarismos significativos
pedido for maior que o do argumento.

Se a converso for de uma sequncia de caracteres (s): o nmero mximo de

caracteres a exibir.

Assim como a largura do campo, a preciso pode ser especificada diretamente por um
nmero ou com um asterisco, mas deve ser precedida por um ponto.
Alguns exemplos:
printf
printf
printf
printf

("%.5d",
("%.5f",
("%.5g",
("%.5s",

314);
// exibe "00314"
2.4);
// exibe "2.40000"
23456789012345); // exibe "2.3457e+13"
"Bom dia");
// exibe "Bom d"

claro que podemos combinar a largura com a preciso. Por exemplo, %10.4f indica um
campo de nmero real de comprimento total dez e com 4 casas decimais. Note que, na
largura do campo, o valor inteiro levado em conta, inclusive o ponto decimal, e no
apenas a parte inteira. Por exemplo, essa formatao aplicada ao nmero 3.45 ir resultar
nisto:

"

3.4500"

Tamanho da varivel[editar | editar cdigo-fonte]

importante ressaltar que quando so usados modificadores de tamanho de tipos, a
maneira como os dados so armazenados pode tornar-se diferente. Assim, devemos
informar funo printf() precisamente qual o tipo da varivel cujo valor desejamos exibir.
A funo printf() admite cinco principais modificadores de tamanho de varivel:

hh: indica que a converso inteira corresponde a uma varivel char. Por exemplo,

poderamos usar o formato %hhd para exibir uma varivel do tipo char na base
decimal.

h: indica que a converso inteira corresponde a uma varivel short.

l: indica que a converso inteira corresponde a uma varivel long.

ll: indica que a converso inteira corresponde a uma varivel long long.

L: indica que a converso de nmero real corresponde a uma varivel long

double.

Quando o tipo da varivel no tem modificadores de tamanho (long ou short), no se

usa nenhum modificador de tamanho da varivel na funo printf().

Sequncias de escape[editar | editar cdigo-fonte]

Sequncias de escape so combinaes de caracteres que tm significado especial, e
so sempre iniciadas por uma barra invertida (\). Voc pode us-las em qualquer literal de
caractere ou string. Por exemplo, a string "linha 1\nlinha 2" equivale a:
linha 1
linha 2
pois a sequncia \n indica uma quebra de linha. Como foi citado anteriormente, a
funo printf(), diferentemente de puts(), no imprime automaticamente uma quebra
de linha no final da string. O cdigo abaixo, por exemplo:
printf("string 1");
printf("string 2");
Imprimiria isto:
string 1string 2

Isso pode ser til, pois s vezes desejvel permanecer na mesma linha.
A seguir apresentamos a tabela com as sequncias de escape suportadas pela linguagem
C:
Sequncia

Significado

\n

Quebra de linha (line feed ou LF)

\t

Tabulao horizontal

\b

Retrocede o cursor em um caractere (backspace)

\r

Retorno de carro (carriage return ou CR): volta o cursor para o comeo da linha
sem mudar de linha

\a

Emite um sinal sonoro

\f

Alimentao de formulrio (form feed ou FF)

\v

Tabulao vertical (em impressoras)

\"

Aspa dupla

\'

Aspa simples

\\

Barra invertida

\0

Caractere nulo (caractere de valor zero, usado como terminador de strings)

\N

O caractere cuja representao octal N (dgitos de 0 a 7)

\xN

O caractere cuja representao hexadecimal N (dgitos de 0 a 9 e de A a F)

Representao octal e hexadecimal[editar | editar cdigo-fonte]

Tambm possvel trocar uma sequncia de escape pelo seu valor em octal ou
hexadecimal. Voc pode, por exemplo, trocar o caractere "\n" pelo valor octal "\12" ou
hexadecimal "\x0A". Vejamos mais alguns exemplos.
Hexadecimal
\x00
\x0A
\x0D
\x07
\x08
\x0B
scanf()[editar

Octal
\00
\12
\15
\07
\10
\13

Caracter
\0
\n
\r
\a
\b
\v

| editar cdigo-fonte]

A funo scanf() l dados da entrada padro (teclado) e os guarda em variveis do

programa. Assim como para printf(), usamos uma string de formatao para especificar
como sero lidos os dados. A sintaxe de scanf() esta:
scanf ("string de formatao", &arg1, &arg2, ...);

Como voc pode ver, a sintaxe quase igual de printf(), com exceo do E comercial
(&). Voc entender melhor o seu uso nas sees seguintes, mas adiantamos que ele
um operador que retorna o endereo de uma varivel. Isso necessrio pois a funo
scanf() deve modificar as variveis, e quando no usamos o operador de endereo,
passamos apenas o valor de uma varivel para a funo. Isso ser explicado melhor no
captulo sobre ponteiros. O fato de scanf receber endereos de variveis (em vez de seus
valores) tambm explica por que ele precisa ser informado da diferena entre %f (float)
e %lf (double) enquanto que o printf no precisa.
Um exemplo bsico da utilizao de scanf() este:
int a;
scanf ("%d", &a);
O que este exemplo faz declarar uma varivel e aguardar o usurio digitar algo. Os
dados s sero processados quando o usurio apertar Enter. Depois disso, os caracteres
digitados pelo usurio sero convertidos para um valor inteiro e esse inteiro ser guardado
no endereo que corresponde varivel a. Se o valor digitado no puder ser convertido
(porque o usurio no digitou nenhum algarismo vlido), a varivel no ser modificada.
Assim como na funo printf(), podemos receber quantos valores quisermos, bastando
usar vrios especificadores de converso:
int a;
char b;
float c;
scanf ("%d %c %f", &a,&b,&c);
Dessa maneira, se o usurio digitar 120 z 17.63, teremos a igual a 120, b igual ao
caractere 'z' e c igual ao nmero 17,63. Se o usurio tentar digitar mais de um espao
entre os dados ou simplesmente nenhum espao, ainda assim o programa obter os
dados certos. Por exemplo, 120z17.63 tambm dar o mesmo resultado.
Agora uma questo um pouco mais difcil: vamos supor que especificamos um formato
inteiro e o usurio digitou um nmero real, como por exemplo 12.5. O que dever
acontecer?
#include <stdio.h>
int main ()
{
int a;

printf ("Digite um nmero: ");

scanf ("%d", &a);
printf ("\nO nmero digitado foi %d", a);
return (0);
}
Se voc testar com o valor 12.5, vai ver que o programa retornar o nmero 12, pois a
funo scanf() apenas interpreta os caracteres vlidos para aquele formato.
Os especificadores de converso so praticamente os mesmos que os da funo printf(),
com algumas mudanas. A maioria deles pula espaos em branco, exceto dois.

%i no mais sinnimo de %d. O que %i faz interpretar o valor digitado como

hexadecimal, se iniciar-se por 0x ou 0X; como octal, se iniciar-se por 0; ou como

decimal, caso nenhuma dessas condies seja verificada.

%a, %e/%E e %g so sinnimos de %f.

%lf deve ser usado para variveis do tipo double.

%s l uma sequncia de caracteres no-brancos (qualquer caractere exceto

espao, tabulao, quebra de linha etc.), ou seja, uma palavra.

%c l uma sequncia de caracteres, sem ignorar espaos. O padro ler um

caractere, se no for especificada a largura do campo.

%[...] l uma sequncia de caracteres, sem ignorar espaos, especificando

entre colchetes quais caracteres devem ser aceitos, ou, se o primeiro caractere dentro
dos colchetes for um acento circunflexo (^), quais no devem ser aceitos. Alm disso,
se colocarmos um trao entre dois caracteres, todos os caracteres entre os dois sero
includos no padro. Por exemplo, se quisermos incluir qualquer letra minscula,
poderimos escrever %[a-z]; se quisssemos tambm incluir as maisculas,
colocaramos %[a-zA-Z]. A leitura pra quando for encontrado um caractere que no
coincide com o padro especificado.
J os modificadores funcionam de maneira bastante diferente:

O modificador * (asterisco) especifica que o valor atual deve ser lido da maneira
especificada, mas no ser guardado em nenhuma varivel, e portanto no deve
haver um ponteiro correspondente a esse valor. Por exemplo, poderimos ter um
programa que espera ler uma palavra e depois um nmero, mas no importa qual

palavra . Nesse caso usaramos o modificador *: scanf ("%*s %d", &numero). O

programa leria a palavra e guardaria o nmero na varivel numero.

Como na funo printf(), existe o especificador de largura do campo, que deve

aparecer antes do especificador de converso, mas em scanf() ele especifica
a largura mxima. Se a largura mxima foi definida como n, scanf() pular para o
prximo campo se j tiver lido n caracteres. Por exemplo, scanf ("%4d", &num) ler
um nmero de at quatro algarismos. Se o usurio digitar mais, o excedente ser no
ser lido por essa chamada, mas poder ser lido por uma prxima chamada a scanf.

Mais detalhes sobre os especificadores de converso e os modificadores podem ser

encontrados na documentao da biblioteca padro.

Valor de retorno[editar | editar cdigo-fonte]

A funco scanf() retorna o nmero de converses realizadas com sucesso. Isso til
pois, se o valor contido numa varivel aps a chamada de scanf() for igual ao valor
anterior, no possvel saber se o valor digitado foi o mesmo que j havia ou se no foi
feita a converso. Para obter esse nmero de converses realizadas, voc deve guardar o
resultado numa varivel do tipo int. Veja como proceder:
int a, b;
int num;
num = scanf("%d%d", &a, &b);
Este exemplo l dois nmeros inteiros e os guarda nas variveis a e b. O nmero de
converses realizadas guardado na varivel num. Se aps o scanf, num for diferente de
2, sinal de que o usurio digitou algo incompatvel com o formato desejado.
Note que aqui introduzimos um conceito novo: o valor de retorno de uma funo. Ele
pode ser obtido simplesmente associando o valor de uma varivel chamada da funo.
Ele ser detalhado na seoFunes, mas j possvel compreender um pouco sua
utilizao.
gets()

e getchar()[editar | editar cdigo-fonte]

gets() e getchar(), assim como scanf(), lem da entrada padro. Assim

como puts() e putchar(), no suportam formatao. Como o nome

sugere, getchar() l apenas um caractere, e gets() l uma string at o final da linha ou
at que no haja mais dados para ler, e adiciona o terminador de string "\0".
A sintaxe das funes :
gets(ponteiro_para_string);

char c;
c = getchar();
No entanto, existe um problema com a funo gets(). Veja o exemplo a seguir:
#include <stdio.h>
int main()
{
char buffer[10];
printf("Entre com o seu nome: ");
gets(buffer);
printf("O nome : %s", buffer);
return 0;
}
A notao char buffer[10], que ainda no foi introduzida (e ser detalhada na
seo Vetores (arrays)), pede que seja reservado um espao para 10 caracteres para a
string buffer. Portanto, se usurio digitar mais de 9 caracteres (pois o terminador de string
adicionado ao que o usurio digitou), os caracteres excedentes adicionais sero
colocados na rea de memria subsequente ocupada pela varivel, escrevendo uma
regio de memria que no est reservada string. Este efeito conhecido como "estouro
de buffer" e pode causar problemas imprevisveis. Por isso, no se deve usar a funo
gets(); mais tarde introduziremos a funo fgets(), que no apresenta esse problema e
que deve ser usada no lugar de gets().
sprintf()

e sscanf()[editar | editar cdigo-fonte]

sprintf e sscanf so semelhantes a printf e scanf. Porm, ao invs de escreverem

na sada padro ou lerem da entrada padro, escrevem ou lem em uma string. A nica
mudana nos argumentos a necessidade de especificar a string que deve ser lida ou
atribuda no incio. Veja os exemplos para entender melhor.
#include <stdio.h>
int main()
{
int i;
char string1[30];
printf("Entre um valor inteiro: ");
scanf("%d", &i);
sprintf(string1, "Valor de i = %d", i);

puts(string1);
return 0;
}
Nesse exemplo, a mensagem que queramos exibir na tela foi primeiramente salva em
uma string, e depois essa string foi enviada para a tela. Se voc olhar bem, se voc
tivesse alocado um valor menor parastring1, tambm ocorreria um estouro de buffer. Para
evitar esse problema, existe a funo snprintf, que tem mais um argumento: o tamanho
da string (deve ser colocado depois da string onde a mensagem ser gravada).
#include <stdio.h>
int main()
{
int i, j, k;
char string1[] = "10 20 30";
sscanf(string1, "%d %d %d", &i, &j, &k);
printf("Valores lidos: %d, %d, %d", i, j, k);
return 0;
}
Nesse exemplo, usamos a funo sscanf para interpretar os valores contidos na string e
guard-los nas variveis numricas.