Impressão Formatada de Dados

A função printf (print formated) é uma função da biblioteca de entrada e saída padrão utilizada para escrever valores numéricos, caracteres e strings. Ela pode receber diversos parâmetros, sendo que o primeiro deverá ser uma string, chamada string de controle. Somente será exibido o que for solicitado dentro desta string. A string de controle deve aparecer entre aspas duplas e nela podem existir dois tipos de informações: caracteres comuns e especificadores de formato. Tudo o que aparecer nesta string que não for um especificador de formato será impresso literalmente, ou seja, do jeito que estiver escrito. Justamente por isso, esta função é dita de saída formatada, uma vez que os dados de saída podem ser formatados da maneira que desejarmos (alinhados, intercalados com símbolos, etc). Cada especificador de formato encontrado nesta string será substituído pelo parâmetro seguinte pertencente à lista de argumentos da função, na ordem que aparecerem. A estrutura básica da função printf() é dada a seguir:

printf (“string de controle”, lista de argumentos);

Os especificadores de formato que podem fazer parte da string de controle são simbolos, representados por um % mais um outro caracter, que indicam que um valor vai ser escrito pela função, na posição correspondente da string de controle. Eles indicam, também,

o tipo e/ou a base numérica do dado a ser escrito.

Cada valor a ser impresso pelo printf deve ter um especificador de formato correspondente dentro da string de controle. Se faltarem especificadores, os últimos valores não serão exibidos. Se sobrarem especificadores, serão exibidos valores indeterminados (lixo de memória). A Tabela 12. apresenta os principais especificadores de formato utilizados com a função printf. Por exemplo, para exibir um valor inteiro, usa-se o %d. Da mesma forma, para exibir um valor em ponto flutuante, pode-se usar %f.

Tabela 12 – Especificadores de Formato para a Função printf()

Vamos dar uma olhada em uma série de exemplos:

printf(“Olá, Mundo!“);

Saída: Olá, Mundo!

printf(“linha 1 \nlinha 2 “);

Saída: linha 1 linha 2

Observe que na primeira instrução, a saída é exatamente igual à string de controle. Já na segunda instrução, a impressão se deu em duas linhas. Isto se deve ao \n que representa o código ASCII para quebra de linha. Vamos dar exemplos, agora, de saída formatada e os respectivos resultados.

printf(“Tenho %d anos de vida”,idade);

Saída: Tenho 18 anos de vida.

Veja que o especificador de formato %d (que indica um valor inteiro em formato decimal) é substituído pelo conteúdo da variável idade, na posição em que o especificador aparece.

printf (“Teste %% %%”);

Saída: Teste % %

O símbolo de porcentagem (%) é reservado para especificar o tipo a ser impresso. Logo, se desejamos imprimir o próprio símbolo temos de usar %% (vide Tabela 12)

printf (“%f”,40.34534);

Saída: 40.34534

Para imprimir valores de ponto flutuante usamos o %f. O default dele é imprimir números com até seis casas decimais.

printf (“Um caractere %c e um inteiro %d”,’D’,120);

Saída: Um caractere D e um inteiro 120

printf (“%s e um exemplo”,”Este”)

Saída: Este e um exemplo

printf (“%s%d%%”,”Juros de “,10)

Saída: Juros de 10%

printf(“A letra ‚ %c\n”, ‘A’); ou printf(“A letra ‚ %c\n”, 65);

Saída: A letra A

Os dois comandos acima imprimiriam a letra A. O especificador de formato %c indica que deve ser impresso um caractere. Se um número é passado, ele pega o caractere correspondente ao número na tabela ASCII. No caso o valor da letra A na tabela ASCII é 65.

Saída: O valor decimal 107 em Hexadecimal: 6B e em Octal: 153

%d imprime o número na notação decimal convencional, %X imprime o número usando a notação hexadecimal e %o usando a notação octal.

Suponha que pi=3.14159 e raio=2.0031, ambas variáveis do tipo

float.

printf(“A area do circulo e %e\n”, 2 * pi * raio);

Saída: A área do circulo e 1.258584e+001

O %e faz com que o valor de ponto flutuante seja impresso em notação científica. A diferença de %e para %E é apenas na impressão da letra E, que no primeiro caso é minúscula e no segundo maiúscula.

Suponha que troco e pagamento sejam variáveis do tipo float cujos valores são, respectivamente, 12.3 e 15.0.

printf(“Total: %f.2 \nDinheiro: %f.2 \nTroco: %f.2“, tot, din, (din-tot));

Saída: Total: 12.30 Dinheiro: 15.00 Troco: 2.70

O que é esse .2 depois do %f? Ele significa que o número de ponto

flutuante deve ser escrito com duas casas decimais de precisão. Depois do sinal % do especificador de formato e antes do caracter que indica o especificador de formato, podem ser usados alguns modificadores OPCIONAIS cuja sintaxe é a seguinte: % [flag] [tamanho] [.precisão] caracter_do_especificador_de_formato

Onde:

[flag] especifica a formatação da saída - alinhamento à esquerda.

+ conversão de sinal (saída sempre com sinal: + ou - impresso)

[tamanho] especificação de tamanho ou quantidade de dígitos a

serem impressos. Em outras palavras, o tamanho do campo indica quantas posições da saída serão utilizados para exibir o valor correspondente à um especificador de formato. Por exemplo, %5d indica que o valor a ser impresso vai ocupa 5 posições na tela. Por padrão, as posições em excesso são preenchidas com brancos e o valor é alinhado à direita do campo. Sempre que o tamanho do campo for insuficiente para exibir o valor solicitado, este tamanho é ignorado e o número é impresso por completo. Desta forma, um valor nunca é truncado. Valores possíveis:

n pelo menos n dígitos serão impressos (dígitos faltantes serão completados por brancos).

0n pelo menos n dígitos serão impressos (dígitos faltantes serão completados por zeros).

Exemplos:

int valor = 2580; int valor = 2580;

printf(“Valor justificado para dir: %8d\n”, valor ); printf(“Valor justificado para esq: %-8d\n”, ano );

Saída: Valor justificado para dir: 2580 Valor justificado para esq: 2580

No primeiro caso, dizemos que queremos imprimir o valor 2580 como inteiro em oito posições. O alinhamento default da impressão é à direita. Se quisermos imprimir à esquerda, devemos usar o flag – (menos) antes do tamanho do número.

[.precisão] especificador de precisão, ou seja, da quantidade

de dígitos à direita do ponto decimal. É mais usado para configurar valores de ponto flutuante. Valores possíveis:

(nada) padrão: 6 dígitos para reais. .0 nenhum digito decimal.

.n são impressos n dígitos decimais, ou seja, casas depois do ponto decimal.

Por exemplo, o formato %10.2f, exibe o valor em ponto-flutuante

Quando as notações de tamanho e de precisão são aplicadas ao tipo string, elas passam a indicar, respectivamente, o tamanho total de casas a serem ocupadas e o número de caracteres que serão realmente impressos. Por exemplo:

printf(“ %10.3s \n”, “Alo Mundo!”);

Saída: Alo

Foram alocadas 10 casas para imprimir a string (por isso, ela está deslocada para a direita), mas apenas três casas foram realmente impressas. O restante das casas ficou com espaços em branco.

Como mencionado, todos esses modificadores são opcionais (por isso, na sintaxe estão expressos entre colchetes [ ]) e, deles, o mais utilizado é o modificador de precisão, quando desejamos imprimir números de ponto flutuante.

Atenção

Uma observação importante é que muitos compiladores C tratam o especificador de formato %i como idêntico a %d. No entanto, para criar-se novos programas , use o especificador %d, pois %i é um legado do passado, e os compiladores futuros talvez deixem de aceitá-lo.

A função printf retorna um valor inteiro representando o número de caracteres que foram realmente impressos. De repente, você pode em algum programa precisar desse valor. Exemplo:

int retorno = printf(“%10.3s”, “Alo Mundo!”); retornaria 10