Módulo 4 – Estudo das Funções PRINTF() e SCANF()
4.1 – Função PRINTF()
Quando é necessário imprimir na tela um dado, um valor, uma string ou mesmo um endereço de memória, usa-se a função printf(). Quando o programa usa a função printf(), as informações que instrui printf() a imprimir são chamadas parâmetros ou argumentos de printf(). A estrutura básica da função printf() é dada a seguir:
printf ("string de controle", lista
de argumentos);
A string de controle contém tanto caracteres para serem impressos na tela como códigos de formato que especificam como apresentar o restante dos argumentos. Quando os programas trabalharem com variáveis, será possível usar printf() para exibir os valores de cada variável. A função printf() suporta mais de um parâmetro. O primeiro parâmetro precisa ser sempre uma string de caracteres. Pode-se fazer os parâmetros que seguem a primeira string de caracteres serem números, expressões, variáveis, ou até outras strings de caracteres. Quando for necessário que printf() exiba um valor ou uma variável, é preciso fornecer informações sobre o tipo da variável dentro do primeiro parâmetro. Além de especificar caracteres dentro do primeiro parâmetro, pode-se incluir especificadores de formato, que instruem printf() como imprimir os outros parâmetros. Esses especificadores de formato têm a forma de um sinal de porcentagem (%) seguido por uma letra. 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. A seguir, uma tabela com os especificadores de formato:
|
Código |
Significado |
|
%c |
Exibe um caractere
|
|
%d |
Exibe um inteiro em formato decimal |
|
%i |
Exibe um inteiro |
|
%e |
Exibe um número em notação científica (com e
minúsculo) |
|
%E |
Exibe um número em notação científica (com E
maiúsculo) |
|
%f |
Exibe um ponto flutuante em formato decimal |
|
%g |
Usa %e ou %f, o que for menor |
|
%G |
O mesmo que %g, só que um E maiúsculo é usado se o
formato %e for escolhido |
|
%o |
Exibe um número em notação octal |
|
%s |
Exibe uma string |
|
%u |
Exibe um decimal sem sinal |
|
%x |
Exibe um número em hexadecimal com letras minúsculas |
|
%X |
Exibe um número em hexadecimal com letras maiúsculas |
|
%% |
Exibe um sinal de % |
|
%p |
Exibe um ponteiro |
4.1.1 – Exibindo Valores do Tipo int Usando Printf()
Para exibir valores do tipo int com printf(), usa-se o especificador de formato %d. O programa a seguir usa o especificador de formato %d para exibir valores e variáveis do tipo int:
|
#include <stdio.h> void main(void) { int idade = 41; int altura = 182; int peso = 80; printf("Idade do usuario: %d
peso: %d altura: %d\n", idade, peso, altura); printf("%d mais %d igual a %d\n", 1, 2, 1 + 2); } |
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.
4.1.2 – Exibindo um Valor Inteiro Octal ou Hexadecimal
Muitas vezes nos programas é preciso exibir um valor inteiro em seu formato octal (base 8) ou hexadecimal (base 16). O especificador de formato %o (letra "o", não zero) instrui printf() a exibir uma valor em octal. Da mesma forma, %x e %X instruem printf() a exibir uma valor em hexadecimal, sendo que no primeiro caso em minúsculo e no segundo imprime os valores em maiúsculo.
Veja a seguir um exemplo que utiliza
estes especificadores de formato:
|
#include <stdio.h> void main(void) { int valor = 255; printf("O valor decimal %d em octal ‚ %o\n",
valor, valor); printf("O valor decimal %d em hexadecimal ‚
%x\n", valor, valor); printf("O valor decimal %d em hexadecimal ‚
%X\n", valor, valor); } |
4.1.3 – Exibindo Valores do Tipo Unsigned Int
Para exibir valores do tipo unsigned int com a função printf(), deve-se usar o especificador de formato %u. Se usar %d em lugar de %u, printf() tratará o valor especificado como tipo int, provavelmente exibindo o valor incorreto. O exemplo a seguir ilustra o uso dos dois especificadores, %d e %u.
|
#include <stdio.h> void main(void) { unsigned int valor =
42000; printf("Exibindo 42000 como unsigned %u\n",
valor); printf("Exibindo 42000 como int %d\n", valor); } |
4.1.4 – Exibindo Valores do
Tipo Long Int
Para exibir valores do tipo long int com a função printf(), deve-se usar o especificador de formato %ld. Se usar %d em lugar de %ld, printf() tratará o valor especificado como tipo int, provavelmente exibindo o valor incorreto.
O exemplo a seguir ilustra o uso dos dois
especificadores, %d e %ld:
|
#include <stdio.h> void main(void) { long int um_milhao = 1000000; printf ("Um milhão é %ld\n", um_milhao); printf ("Um milhão é %d\n", um_milhao); } |
4.1.5 – Exibindo Valores do Tipo Float
Para exibir valores do tipo float com a função printf(), deve-se usar o especificador de formato %f. A seguir um exemplo que usa %f para exibir valores em ponto flutuante.
|
#include <stdio.h> void main(void) { float preco = 525.75; float imposto_vendas = 0.06; printf("O custo do item ‚ %f\n", preco); printf("O imposto sobre a venda do item ‚ %f\n",
preco * imposto_vendas); } |
4.1.6 – Exibindo Valores do
Tipo Char
Para exibir valores do tipo char com a função printf(), deve-se usar o especificador de formato %c. A seguir um exemplo que usa %c para exibir a letra A em sua tela.
|
#include <stdio.h> void main(void) { printf("A letra ‚ %c\n", 'A'); printf("A letra ‚ %c\n", 65); } |
4.1.7 – Exibindo Valores de
Ponto Flutuante em um Formato Exponencial
Para exibir um valor em ponto flutuante em um formato exponencial com a função printf(), deve-se usar o especificador de formato %e ou %E. A diferença entre os dois é que %E instrui printf() a usar uma letra E maiúscula na saída.
|
#include <stdio.h> void main(void) { float pi = 3.14159; float raio = 2.0031; printf("A área do círculo é %e\n", 2 * pi *
raio); printf("A área do círculo é %E\n", 2 * pi * raio); } |
4.1.8 – Exibindo Valores em
Ponto Flutuante
A função printf()
também suporta os especificadores %g e %G para imprimir valores em ponto flutuante. Quando usa-se esses
especificadores de formato, printf() decide se deve usar o formato %f ou %e, dependendo da técnica que exibirá a saída no formato mais
significativo para o usuário.
Veja o exemplo que ilustra o uso do especificador %g:
|
#include <stdio.h> void main(void) { printf("Exibir 0.1234 resulta em %g\n",
0.1234); printf("Exibir 0.00001234 resulta em %g\n",
0.00001234); } |
4.1.9 – Exibindo uma String de Caracteres
Para
exibir uma string de caracteres com a função printf(), deve-se usar o
especificador de formato %s.
A seguir um exemplo que usa %s para exibir uma string de caracteres:
|
#include <stdio.h> void main(void) { char faculdade[255] = "Universidade Estadual
Paulista"; printf("O nome da minha universidade é %s\n",
faculdade); } |
4.1.10 – Exibindo um
Endereço de Ponteiro
Para
exibir um endereço de ponteiro com a função printf(), deve-se usar o
especificador de formato %p.
A seguir um exemplo que usa %p para exibir um endereço de memória.
|
#include <stdio.h> void main(void) { int valor; printf("O endereço da variável valor é %p\n",
&valor); } |
4.1.11 - Precedendo um Valor com um Sinal de Adição ou de Subtração
Em
muitos programas é necessário que printf() exiba o sinal para os valores
positivos e negativos. Para instruir printf() a exibir um sinal de um valor, simplesmente
inclua um sinal de adição imediatamente após o % no especificador de formato. O
exemplo a seguir ilustra o uso do sinal de adição dentro do especificador de
formato.
|
#include <stdio.h> void main(void) { int neg_int = -5; int pos_int = 5; float neg_flt = -100.23; float pos_flt = 100.23; printf("Os valores inteiros são %+d and
%+d\n",neg_int, pos_int); printf("Os valores em ponto flutuante são %+f
%+f\n", neg_flt, pos_flt); } |
4.1.12 – Formatando um Valor
Inteiro
Usando
o especificador de formato %d, será possível instruir printf() a
exibir um número mínimo de caracteres. O dígito que for colocado após o %
especifica o número mínimo de caracteres que printf() usará para exibir um
valor inteiro. Por exemplo, caso seja especificado %5d e o valor
a ser exibido for 10, printf() predecerá o valor com três espaços. Observe que
o valor especifica o número mínimo de caracteres que a saída
consumirá. Se o valor a ser exibido requer mais caracteres do que o
especificado, printf() usará o número de caracteres que printf() requer para
exibir o valor corretamente. Veja um exemplo que ilustra este caso logo a
seguir:
|
#include <stdio.h> void main(void) { int valor = 5; printf ("%1d\n", valor); printf ("%2d\n", valor); printf ("%3d\n", valor); printf ("%4d\n", valor); } |
4.1.13 - Saída de Inteiros
Preenchida com Zeros
No item anterior, foi visto como formatar uma saída instruindo printf() a exibir um determinado número de dígitos. No caso anterior, printf() colocava espaços antes do valor a ser exibido, mas é possível configurá-lo de tal maneira que ele exiba zeros antes do valor ou caracter que é necessário exibir. Esses zeros são chamados de zeros de preenchimento. Para instruir printf() a preencher um valor com zeros, coloca-se um 0 (zero) imediatamente após o % no especificador de formato, antes do número desejado de dígitos. O exemplo abaixo ilustra o uso desta propriedade.
|
#include <stdio.h> void main(void) { int valor = 5; printf ("%01d\n", valor); printf ("%02d\n", valor); printf ("%03d\n", valor); printf ("%04d\n", valor); } |
4.1.14 Exibindo um Prefixo Antes dos Valores Octais ou Decimais
Em muitos programas que apresentam valores octais ou hexadecimais, em muitos casos é necessário que se preceda os valores em octal com um zero (0777, por exemplo), e os hexadecimais com 0x (oxFF, por exemplo). Para instruir printf() a preceder um valor octal ou hexadecimal com o prefixo apropriado, coloca-se um sinal # imediatamente após o % no especificador de formato. Veja o exemplo abaixo que ilustra o uso do sinal #.
|
#include <stdio.h> void main(void) { int valor = 255; printf("O valor decimal %d em octal é %#o\n",
valor, valor); printf("O valor decimal %d em hexadecimal é
%#x\n", valor, valor); printf("O valor decimal %d em hexadecimal é
%#X\n", valor, valor); } |
4.1.15 – Formatando um Valor
em Ponto Flutuante
No item 3.1.11 foi visto como formatar um valor inteiro colocando o número desejado de dígitos imediatamente após o % no especificador de formato %d. Usando uma técnica similar, printf() permite formatar a saída em ponto flutuante. Quando formata-se um valor em ponto flutuante especifica dois valores. O primeiro valor diz a printf() o número mínimo de caracteres a serem exibidos. O segundo valor diz a printf() o número de dígitos a serem exibidos à direita do ponto decimal. O exemplo abaixo ilustra esta técnica.
|
#include <stdio.h> void main(void) { float valor = 1.23456; printf ("%8.1f\n", valor); printf ("%8.3f\n", valor); printf ("%8.5f\n", valor); } |
4.1.16 – Formatando a Saída Exponencial
No item anterior foi visto como usar o especificador de formato %f para formatar valores em ponto flutuante. Usando técnicas de formatação similares, pode-se instruir pintf() a exibir a saída em ponto flutuante em um formato exponencial. Veja o exemplo a seguir que ilustra este caso.
|
#include <stdio.h> void main(void) { float valor = 1.23456; printf ("%12.1e\n", valor); printf ("%12.3e\n", valor); printf ("%12.5e\n", valor); } |
4.1.17 – Justificando à Esquerda a Saída de Printf()
Por padrão, quando for exibido o texto usando os caracteres de formatação, printf() exibirá o texto justificado à direita. Dependendo do programa, algumas vezes é necessário que printf() justifique o texto à esquerda. Para justificar o texto à esquerda, coloque um sinal de subtração (-) imediatamente após o % no especificador de formato. O exemplo a seguir ilustra o uso desta técnica de formatação.
|
#include <stdio.h> void main(void) { int int_valor = 5; float flt_valor = 3.33; printf("Justificado à direita %5d valor\n",
int_valor); printf("Justificado à esquerda %-5d valor\n",
int_valor); printf("Justificado à direita %7.2f valor\n",
flt_valor); printf("Justificado à esquerda %-7.2f valor\n",
flt_valor); } |
4.1.18 – Combinando os Especificadores de Formato de Printf()
Muitas vezes por rapidez e para que o código torne-se mais enxuto pode-se aproveitar dois ou mais especificadores de formato de printf(). Em tais casos, simplesmente coloque cada um dos especificadores logo após o %. Veja um exemplo.
|
#include <stdio.h> void main(void) { int int_valor = 5; printf("Justificado à esquerda com sinal
%-+3d\n", int_valor); } |
4.1.19 – Trabalhando com os Caracteres Escape de Printf()
Quando trabalha-se com string de caracteres, pode-se usar caracteres especiais, tais como tabulação, retorno do carro, ou alimentação de linha. A Linguagem C define vários caracteres de escape (referenciados no Módulo 2 item 2.4.3) para facilitar para você a inclusão de caracteres especiais dentro de uma string. Um exemplo é o uso do caracter de nova linha (\n) para avançar a saída para o início da próxima linha.
|
printf("Linha
1\nLinha2\nLinha 3\n"); |
4.1.20 – Determinando o Número de Caracteres que Printf() Exibiu
Quando usa-se o especificador de formato %n, printf() atribuirá à uma variável (passada por ponteiro) um contador do número de caracteres que printf() exibiu.
|
#include <stdio.h> void main(void) { int primeiro_conta; int segundo_conta; printf("Universidade%n Estadual
Paulista%n\n",&primeiro_conta, &segundo_conta); printf("Primeiro conta %d Segundo conta %d\n",
primeiro_conta, segundo_conta); } |
4.1.21 – Usando o Valor de
Retorno de Printf()
Usar o especificador de formato %n é um modo de garantir que printf() teve sucesso ao exibir sua saída. Além disso, quando printf() termina, ele retorna o número total de caracteres que escreveu. Se printf() encontrar um erro, retornará a constante EOF (que como será visto no módulo sobre sistema de arquivo, indica o fim de um arquivo). O exemplo a seguir, usa o valor de retorno de printf() para garantir que printf() foi bem sucedido.
|
#include <stdio.h> void main(void) { int result; result = printf("Universidade Estadual Paulista\n"); if (result == EOF) fprintf(stderr, "Erro dentro de printf\n"); } |
4.2 – Função SCANF()
A função scanf( ) é uma das funções de entrada de dados da Linguagem C, que pode ser usada para ler virtualmente qualquer tipo de dado inserido por meio do teclado, freqüentemente ela é usada para a entrada de números inteiros ou de ponto flutuante. A forma geral da função scanf( ) é:
scanf (“string de controle”, lista de argumentos);
Os especificadores de formato de entrada são precedidos por um sinal % e dizem à função scanf( ) qual tipo de dado deve ser lido em seguida. Esses códigos são listados na tabela a seguir.
|
Código |
Significado |
|
%c |
Lê um único caractere |
|
%d |
Lê um decimal inteiro |
|
%i |
Lê um decimal inteiro (não pode ser octal ou hexadecimal) |
|
%u |
Lê um decimal sem sinal |
|
%e |
Lê um número em ponto flutuante com sinal opcional |
|
%f |
Lê um número em ponto flutuante com ponto opcional |
|
%g |
Lê um número em ponto flutuante com expoente opcional (double) |
|
%o |
Lê um número em base octal |
|
%s |
Lê uma string |
|
%x |
Lê um número em base hexadecimal |
|
%p |
Lê um ponteiro |
Os caracteres de conversão d, i, o, u e x podem ser precedidos por h para indicarem que um apontador para short ao invés de int aparece na lista de argumentos, ou por l (letra ele) para indicar que um apontador para long aparece na lista de argumentos. Semelhantemente, os caracteres de conversão e, f e g podem ser precedidos por l (letra ele) para indicarem que um apontador para double ao invés de float está na lista de argumentos.
A cadeia de formato geralmente contém especificações de conversão, que são usadas para controlar a conversão da entrada. A cadeia de formato pode conter:
· espaços, tabulações e novas linhas, que serão ignorados;
· caracteres comuns (não %), que devem combinar com o próximo caractere não espaço do fluxo de entrada;
· especificações de conversão, consistindo no caractere %, um caractere * opcional de supressão de atribuição, um número opcional especificando um tamanho máximo do campo, um h ou l opcional indicando o tamanho do destino, e um caractere de conversão.
4.2.1 – Usando Caracteres em
Scanf() que Serão Descartados
Um caractere que não seja um espaço em branco faz com que a função
scanf( ) leia e descarte o caractere correspondente. Por exemplo, “%d,%d”
faz com que a função scanf() leia um inteiro, então, leia uma
vírgula (que será descartada) e, finalmente, leia outro inteiro. Se o caractere
especificado não é encontrado, a função scanf(
) terminará. Pode-se usar
esta técnica para separa os especificadores de formato, tornando o código mais
legível.
|
#include <stdio.h> void main(void) { int a,b; scanf("%d,%d",
&a, &b); } |
4.2.2 - Lendo Valores em
Variáveis
Todas as variáveis usadas para
receber valores por meio da função scanf() deverão ser passadas pelos seus
endereços. Por exemplo, para ler um inteiro em uma variável count, poderia usar a seguinte chamada à função
scanf():
|
#include <stdio.h> void main(void) { int count; scanf("%d ", &count); } |
4.2.3 – Lendo String de
Caracteres
As strings serão lidas em
vetores (cadeias de caracteres) e o nome do vetor é o endereço do primeiro
elemento do vetor. Então, para ler uma string no vetor de caracteres nome,
deve-se usar o seguinte comando:
|
#include <stdio.h> void main(void) { char nome[40]; scanf("%s", nome); } |
Nesse caso, nome já é um endereço e não precisa ser precedido pelo operador &.
4.2.4 – Formatando a Entrada
de Scanf()
Os itens de dados de entrada devem ser separados por espaços, tabulações ou novas linhas. Pontuações como vírgula, ponto-e-vírgula e semelhantes não contam como operadores. Isso significa que scanf(“%d%d”, &r, &c); aceitará uma entrada dos números 10 20, mas falhará com 10,20. Como na função printf( ), os códigos de formato da função scanf( ) devem ser correspondidos na ordem com as variáveis que estão recebendo a entrada na lista de argumento.
Um * colocado depois do % e antes do código de formato lerá um dado de um tipo especificado, mas suprimirá a sua atribuição. Assim, scanf(“%d%*c%d”, &x, &y); dando-se a entrada 10/20, colocará o valor 10 em x descartando o sinal de divisão, e dará a y o valor 20.
Ainda que espaços, tabulações e novas linhas sejam usados como
separadores de campos, quando da leitura de um único caractere, esses últimos
são lidos como qualquer outro caractere. Por exemplo, com uma entrada de “x y”;
scanf(“%c%c%c”, &a, &b, &c); retornará com o caractere “x” em a, um
espaço em b e o caractere “y” em c.
4.2.5 – Determinando o Número
Máximo de Caracteres a ser Lido
Os comandos de formato podem especificar um campo modificador de comprimento máximo. Esse modificador é um número inteiro colocado entre o sinal % e o código de comando de formato, que limita o número de caracteres lidos para qualquer campo. Por exemplo, para ler não mais que 20 caracteres em str, você pode escrever:
|
#include <stdio.h> void main(void) { char str[40]; scanf("%20s", str); } |
Se o apontador de entrada é maior do que 20 caracteres, uma chamada subseqüente para entrada começará onde ela pára. Por exemplo, se for digitado ABCDEFGHIJKLMNOPQRSTUVWXYZ em resposta à chamada scanf( ), nesse exemplo, somente os 20 primeiros caracteres, até o “T”, serão colocados em str por causa do especificador de tamanho máximo. Isso significa que os caracteres restantes “UVWXYZ” não são usados. Se uma outra chamada à função scanf( ) é feita, tal como scanf(“%s”, str); então “UVWXYZ” é colocado em str. A entrada para o campo pode ser terminada, antes que o campo de comprimento máximo seja alcançado, se um caractere de espaço em branco é encontrado. Nesse caso, a função scanf( ) move-se para o próximo campo.
4.2.6 - Lendo Somente
Caracteres Pré-Determinados
A função scanf( ) inclui também
uma característica muito poderosa chamada scanset. Um scanset define uma lista
de caracteres que serão correspondidos por scanf(). A função scanf(
) continuará a ler caracteres enquanto eles estiverem no scanset. Assim
que um caractere entrado não corresponder a qualquer um do scanset, a função scanf(
) segue para o próximo especificador de formato (se existir). Um
scanset é definido colocando-se uma lista de caracteres que quer-se que seja
examinada entre chaves. A chave inicial deve ser prefixada por um sinal de
porcentagem. Por exemplo, este scanset diz à função scanf( ) para ler somente
os dígitos de 0 a 9: %[1234567890].
O
argumento correspondente a scanset deve ser uma variável string.
Após retornar de função scanf( ), a variável conterá uma string terminada com um nulo com os caracteres lidos. Para ver como isso funciona, considere este programa:
|
#include
<stdio.h> #include
<conio.h> void
main() { char s1[80], s2[80]; scanf (“%[1234567890]%s”, s1, s2); printf (“\n%s| |%s”, s1, s2); getch(); } |
Pode-se testar esse programa usando a entrada “123456789abcdefg987654” seguida por um retorno de carro. O programa exibirá, então: 123456789| |abcdefg987654. Uma vez que “a” não faz parte do scanset, a função scanf( ) pára de ler os caracteres em s1 quando ele é encontrado e os caracteres restantes são colocados em s2.
Você pode especificar um intervalo dentro de um scanset usando um hífen. Por exemplo, isto diz à função scanf( ) para aceitar os caracteres de A a Z:
%[A-Z]
Pode-se especificar mais de um intervalo dentro de um scanset. Por exemplo, este programa lê dígitos e letras. Ele também ilustra que pode-se usar o especificador de campo máximo como um scanset.
|
#include
<stdio.h> #include
<conio.h> void
main()
{
char str[80];
printf (“Informe dígitos e letras: ”);
scanf (“%78[a-z0-9]”, str);
printf (“\n%s, str);
getch();
} |
Pode-se especificar um conjunto invertido se o primeiro caractere é um ^. Quando está presente, o ^ instrui a função scanf( ) a aceitar quaisquer caracteres que não estão definidos no scanset.
Um ponto importante a lembrar é que o scanset difere letras minúsculas de maiúsculas. Portanto, se quiser examinar tanto letras maiúsculas como minúsculas, deve especificá-las individualmente.
4.3 - Síntese do
Módulo
É apresentado à seguir, uma síntese do que foi tratado em cada item deste módulo. Com esta síntese você poderá relembrar conceitos vistos durante nosso estudo ou mesmo direcionar seu estudo, caso você já tenha conhecimentos na Linguagem C.
·
4.1 – Função PRINTF(): neste item foi apresentada uma introdução da
função printf(), listando suas características e propriedades bem como sua
estrutura.
·
4.1.1 – Exibindo Valores do Tipo int Usando
Printf(): neste item foi mostrado
como é possível exibir uma saída printf() para valores inteiros, usando-se o
especificador de formato %d.
·
4.1.2 – Exibindo um Valor Inteiro Octal ou
Hexadecimal: foi visto que é possível exibir um valor inteiro em seu
formato octal (base 8) ou hexadecimal (base 16) através dos especificadores de
formato %o, %x e %X.
·
4.1.3 – Exibindo Valores do Tipo Unsigned
Int: neste item foi apresentado como exibir valores do tipo unsigned int
com a função printf(), usando o especificador de formato %u.
·
4.1.4 – Exibindo Valores do Tipo Long Int: foi visto que para exibir valores do
tipo long int com a função printf(), deve-se usar o especificador de formato
%ld.
·
4.1.5 – Exibindo Valores do Tipo Float:
foi visto que para exibir valores do tipo float com a função printf(), deve-se
usar o especificador de formato %f.
·
4.1.6 – Exibindo Valores do Tipo Char: foi
visto que para exibir valores do tipo char com a função printf(), deve-se usar
o especificador de formato %c.
·
4.1.7 – Exibindo Valores de Ponto Flutuante
em um Formato Exponencial: foi visto que para exibir um valor em ponto
flutuante em um formato exponencial com a função printf(), deve-se usar o
especificador de formato %e ou %E.
·
4.1.8 – Exibindo Valores em Ponto
Flutuante: foi visto que a função printf() também suporta os
especificadores %g e %G para imprimir valores em ponto flutuante.
·
4.1.9 – Exibindo uma String de Caracteres: foi visto que para exibir uma string
de caracteres com a função printf(), deve-se usar o especificador de formato
%s.
·
4.1.10 – Exibindo um Endereço de Ponteiro: foi visto que para exibir um endereço
de ponteiro com a função printf(), deve-se usar o especificador de formato %p.
·
4.1.11 – Precedendo um Valor com um Sinal de
Adição ou de Subtração: foi visto
que para instruir printf() a exibir um sinal de um valor, deve-se
incluir um sinal de adição imediatamente após o % no especificador de formato.
·
4.1.12 – Formatando um Valor Inteiro: neste item foi visto como configurar printf()
de tal forma que sua valores a serem exibidos tenha seu formato de saída na
tela especificado pelo programador.
·
4.1.13 – Saída de Inteiros Preenchida com
Zeros: foi visto neste item que é possível configurar printf() de tal
maneira que ele exiba zeros antes do valor ou caracter que é necessário exibir.
·
4.1.14 – Exibindo um Prefixo Antes dos
Valores Octais ou Decimais: foi
visto como preceder os valores em octal com um zero, e os hexadecimais com 0x .
·
4.1.15 – Formatando um Valor em Ponto
Flutuante: foi visto que quando
formata-se um valor em ponto flutuante especifica dois valores. O primeiro
valor diz a printf() o número mínimo de caracteres a serem exibidos. O segundo
valor diz a printf() o número de dígitos a serem exibidos à direita do ponto
decimal. Com isto foi apresentada uma técnica de formatação de printf().
·
4.1.16 – Formatando a Saída Exponencial: foi visto como configurar printf() de tal
forma a exibir a saída em ponto flutuante em um formato exponencial.
·
4.1.17 – Justificando à Esquerda a Saída de
Printf(): foi apresentado que para
justificar o texto à esquerda, coloca-se um sinal de subtração (-)
imediatamente após o % no especificador de formato.
·
4.1.18 – Combinando os Especificadores de
Formato de Printf(): é apresentado
neste item a possibilidade de aproveitar dois ou mais especificadores de
formato de printf() com intuito de deixar o código mais enxuto.
·
4.1.19 – Trabalhando com os Caracteres
Escape de Printf():. Foi visto que a Linguagem C define vários caracteres
de escape (referenciados no Módulo 2 item 2.4.3) para facilitar para você a
inclusão de caracteres especiais dentro de uma string.
·
4.1.20 – Determinando o Número de Caracteres
que Printf() Exibiu: Foi visto que
quando usa-se o especificador de formato %n, printf() atribuirá à uma
variável (passada por ponteiro) um contador do número de caracteres que printf()
exibiu.
·
4.1.21 – Usando o Valor de Retorno de
Printf(): foi mostrado que é
possível utilizar o valor que printf() retorna quando ele finaliza suas
tarefas. Este valor retornado pode ser utilizado de várias formas, variando o
uso de acordo com as características do programa.
·
4.2 – Função SCANF(): foi feita neste item uma introdução à função
scanf(). Foi mostado que a função scanf(
) é uma das funções de entrada de dados da Linguagem C, que pode ser usada
para ler virtualmente qualquer tipo de dado inserido por meio do teclado. Além
da introdução à função foi apresentada
sua estrutura e características.
·
4.2.1 – Usando Caracteres em Scanf() que Serão
Descartados: foi mostrado que é possível inserir dentro da função scanf()
caracteres que não serão lidos. Estes caracteres servem apenas na tornar o
código mais legível e de fácil entendimento.
·
4.2.2 – Lendo Valores em Variáveis: foi visto que é possível utilizar a função
scanf() para obter valores para determinadas variáveis.
·
4.2.3 – Lendo String de Caracteres: foi mostrado como usar a função scanf() para
ler string de caracteres que serão armazenadas em vetores.
·
4.2.4 – Formatando a Entrada de Scanf(): neste item é mostrado como formatar scanf()de
tal forma a atender as especificações de cada programa para entrada de dados.
· 4.2.5 – Determinando o Número Máximo de Caracteres a ser Lido: foi mostrado que é possível especificar o número de caracteres lidos por scanf(), de tal forma a desprezar caracteres que forem digitados a mais, por exemplo.
· 4.2.6 – Lendo Somente Caracteres Pré-Determinados: foi visto que pode-se previamente especificar os caracteres que serão lidos por scanf(), sendo que o caracter que não estiver dentro destes especificados será ignorado.