A maior rede de estudos do Brasil

Grátis
347 pág.
LINGUAGEM C

Pré-visualização | Página 20 de 50

menos esforço de processamento que a 
mesma chamada para a função printf(), uma vez que a primeira pode enviar somente strings, 
enquanto que a segunda, além de strings, pode enviar outros tipos de dados, bem como fazer 
conversão de formatos. Portanto, a função puts() ocupa menos espaço de memória e é 
executada mais rapidamente que a função printf(). 
Observe abaixo um exemplo de sua utilização. 
 
1. #include <stdio.h> 
2. void main(void) 
3. { 
4. char STRING[10]; 
5. puts(“Exemplo de utilização da função puts.\n Entre com uma string:”); 
6. gets(STRING); 
7. puts(“\n A string digitada foi:”); 
8. puts(STRING); 
9. } 
 
 
2.4. RECURSOS AVANÇADOS DA FUNÇÃO PRINTF() 
A função printf() é uma das funções de saída/escrita de dados da linguagem C. Sua 
funcionalidade básica é escrever na saída de vídeo (tela) um conjunto de valores, caracteres e/ou 
sequência de caracteres de acordo com o formato especificado. Porém, essa função permite uma 
variedade muito maior de formatações do que as vistas até então. 
Observe a definição geral da função. A função printf() possui o seguinte protótipo: 
 
int printf(“expressão_de_controle”, lista_de_argumentos) 
 
A função printf() recebe dois parâmetros de entrada: 
 expressão_de_controle  conjunto de caracteres que especifica o formato 
dos dados a serem escritos e/ou o texto a ser escrito; 
 lista_de_argumentos  conjunto de nomes de variáveis, separados por 
vírgula, que serão escritos; 
e retorna: 
 um valor inteiro que representa o número total de caracteres escritos na tela, em 
caso de sucesso; 
 um valor negativo, em caso de erro da função. 
 
77 
 
 
 
O valor de retorno da função printf() permite identificar o funcionamento adequado da 
função. Foi visto que quando se quer escrever dados formatados na tela, usa-se a 
expressão_de_controle para especificar o formato de saída dos dados que serão escritos. E 
que cada expressão de controle é precedida por um sinal de % e um código de controle deve ser 
especificado para cada variável a ser escrita. 
A string da expressão_de_controle permite especificar mais características dos dados 
além do formato. Essas características são opcionais e são: flag, largura, precisão e comprimento. 
A ordem em que essas quatro características devem ser especificadas é a seguinte: 
 
%[flag][largura][.precisão][comprimento]código_de_controle 
 
Note que o campo precisão vem sempre começando com um caractere de ponto (.). 
Como a expressão_de_controle, cada uma dessas características possui um conjunto de 
valores pré-definidos e suportados pela linguagem. Observe nas seções seguintes, todos os valores 
suportados para cada uma das características de formatação possíveis. 
 
2.4.1. Expressão de Controle 
A função printf() pode ser usada para escrever virtualmente qualquer tipo de dado. A 
tabela abaixo mostra todos os tipos de saída suportados pela linguagem C. Observe: 
 
Código Descrição 
%c um caractere 
%d ou %i números inteiros com sinal 
%u números inteiros sem sinal 
%f números reais (float e double) 
%s vários caracteres (string) 
%p endereço de memória (ponteiro) 
%e ou %E números reais em notação científica 
%x números inteiros sem sinal no formato hexadecinmal (minúsculo) 
%X números inteiros sem sinal no formato hexadecinmal (maiúsculo) 
%o números inteiros sem sinal no formato octal 
%g números reais; compilador decide se é melhor usar %f ou %e 
%G números reais; compilador decide se é melhor usar %f ou %E 
%% exibe o caracter “%” 
78 
 
 
 
 
A seguir, são apresentados alguns exemplos de como cada expressão de controle pode ser 
utilizada para escrever determinado dado na tela. 
 
Exibindo os tipos básicos 
A linguagem C possui vários tipos de saída que podem ser utilizados com os tipos básicos, 
ou seja, char (“%c” e “%d”), int (“%d” e “%i”), float e double (“%f”), e por fim array de char 
ou string (“%s”). Note que o tipo char pode ser escrito na tela de saída por meio dos 
operadores “%c” e “%d”. Nesse caso, “%c” irá imprimir o caractere armazenado na variável, 
enquanto “%d” irá imprimir o seu valor na tabela ASCII. Abaixo, tem-se alguns exemplos de escrita 
dos tipos básicos: 
 
1. #include <stdio.h> 
2. #include <stdlib.h> 
3. int main() 
4. { 
5. int n=125; 
6. float f=5.25; 
7. double d=10.53; 
8. char letra='a'; 
9. char palavra[10]="programa"; 
10. printf("Valor inteiro: %d\n", n); 
11. printf("Valor inteiro: %i\n", n); 
12. printf("Valor real: %f\n", f); 
13. printf("Valor real: %f\n", d); 
14. printf("Caractere: %c\n", letra); 
15. printf("Valor numérico do caractere: %d\n", letra); 
16. printf("Palavra: %s\n", palavra); 
17. return 0; 
18. } 
 
 
 
 
 
 
 
 
 
Saída: 
Valor inteiro: 125 
Valor inteiro: 125 
Valor real: 5.250000 
Valor real: 10.530000 
Caractere: a 
Valor numérico do caractere: 97 
Palavra: programa 
79 
 
 
 
Exibindo valores no formato octal ou hexadecimal 
O exemplo abaixo mostra como exibir um valor inteiro nos formatos octal (base 8) ou 
hexadecimal (base 16). Para isso, usamos a expressão de controle “%o” (sinal de porcentagem 
mais a letra “o”, não o zero “0”) para que a função printf() exiba o valor em octal, e “%x” para 
hexadecimal com letras minúsculas e “%X” para hexadecimal com letras maiúsculas. Observe: 
 
1. #include <stdio.h> 
2. #include <stdlib.h> 
3. int main() 
4. { 
5. int n=125; 
6. printf("Valor de n: %d\n", n); 
7. printf("Valor em octal: %o\n", n); 
8. printf("Valor em hexadecimal: %x\n", n); 
9. printf("Valor em hexadecimal: %X\n", n); 
10. return 0; 
11. } 
 
 
 
 
 
Exibindo valores como notação científica 
O exemplo abaixo mostra como exibir um valor real (também chamado ponto flutuante) 
no formato de notação científica. Para isso, usamos as expressões de controle “%e” ou “%E”, 
sendo que o primeiro usará a letra E minúscula enquanto o segundo usará ela maiúscula na saída. 
Temos também as expressões de controle “%g” e “%G”. Essas expressões de controle, 
quando utilizadas, deixam para o compilador decidir se é melhor usar “%f” ou “%e” (ou “%E”, se 
for utilizado “%G”). Nesse caso, o compilador usa “%e” (ou “%E”) para que números muito 
grandes ou muito pequenos sejam mostrados na forma de notação científica. 
Observe o exemplo abaixo. 
 
1. #include <stdio.h> 
2. #include <stdlib.h> 
3. int main() 
4. { 
5. float f=0.00000025; 
6. double d=10.53; 
7. printf("Valor real: %e\n", f); 
8. printf("Valor real: %E\n", f); 
9. printf("Valor real: %g\n", d); 
Saída: 
Valor de n: 125 
Valor em octal: 175 
Valor em hexadecimal: 7d 
Valor em hexadecimal: 7D 
80 
 
 
 
10. printf("Valor real: %G\n", f); 
11. return 0; 
12. } 
 
 
 
 
 
 
Exibindo valores inteiros sem sinal e endereços 
Para imprimir valores inteiros sem sinal, devemos utilizar a expressão de controle “%u” e 
evitar o uso do código “%d”. Isso ocorre por que o tipo “%u” trata o número inteiro como 
unsigned (sem sinal), enquanto “%d” o trata como signed (com sinal). 
A primeira vista os dois códigos podem parecer iguais. Se o valor inteiro estiver entre 0 e 
INT_MAX (231 – 1, em sistemas de 32 bits), a saída será idêntica para os dois casos (“%d” e “%u”). 
Porém, se o valor inteiro for negativo (para entradas com sinal, signed) ou estiver entre INT_MAX 
e UINT_MAX (isto é, entre 231 – 1 e 232 – 1, em sistemas de 32 bits), os valores impressos pelos 
tipos “%d” e “%u” serão diferentes. Neste caso, o tipo “%d” irá imprimir um valor negativo, 
enquanto o tipo “%u” irá imprimir um valor positivo. 
Já para imprimir o endereço de memória de uma variável ou