Quase todo algoritmo terá, em algum momento, interação com o usuário. Esta interação se dará normalmente por meio da impressão de dados na tela e da leitura de dados a partir do teclado. Assim, é de fundamental importância entender de fato como utilizar corretamente as instruções de entrada e saída de dados.
Instrução de saída
A instrução de saída é utilizada sempre que desejamos apresentar alguma informação para o usuário, por isso instrução de saída. Alguma informação está saindo do computador, sendo impressa na tela, para que o usuário tome conhecimento.
Na linguagem de programação C a instrução de saída que veremos é a instrução printf(), apresentada no trecho de código a seguir:
#include <stdio.h>
#include <stdlib.h>
void main() {
printf("Esta mensagem será impressa na tela.\n");
}
Tudo que está entre as aspas duplas é entendido como texto e será impresso na tela. O “n” após o ponto final é um marcador especial para saltar uma linha. Dessa forma, a instrução printf() pode ser utilizada para a impressão de menus, como apresentado a seguir:
#include <stdio.h>
#include <stdlib.h>
void main() {
printf("\t=================================\n");
printf("\t1 - Somar 2 - Subtrair 0 - Sair\n");
printf("\t=================================\n");
printf("\n\n");
printf("\t=================================\n\t1 - Somar 2 - Subtrair 0 - Sair\n\t=================================\n");
}
Perceba que as três primeiras instruções printf() são utilizadas em conjunto, imprimindo um menu entre duas linhas tracejadas, enquanto a última instrução printf() produz o mesmo resultado fazendo uso de apenas uma instrução printf() e os marcadores “n” para saltar uma linha e “t” para tabulação (espaço a esquerda).
O resultado final é apresentado na figura a seguir.
Comandos de saída também são úteis quando desejamos imprimir na tela o valor de variáveis. Para isso devemos utilizar marcadores especial na posição em que desejamos que o valor da variável seja impresso. A seguir listamos os marcadores para os principais tipos de dados:
%c → char // caracteres %d → int // números inteiros %f → float // números reais %lf → double // números reais com dupla precisão %llf → long double // números reais longos
Para imprimir os valores de variáveis, além de utilizar o marcador de tipo, também é necessário acrescentar o nome da variável dentro da instrução printf(), como apresentado no código a seguir. Perceba que podem ser utilizados várias instruções printf() ou apenas uma, juntando todas as informações.
#include <stdio.h>
#include <stdlib.h>
void main() {
char letra = 'W';
short num1 = 5;
int num2 = 10;
float num3 = 3.1415;
double num4 = 5.47;
long double num5 = 10.43875;
printf("Letra %c\n", letra);
printf("Valor num1: %d\n", num1);
printf("Valor num2: %d\n", num2);
printf("Valor num3: %f\n", num3);
printf("Valor num4: %lf\n", num4);
printf("Valor num5: %llf\n", num5);
printf("\n");
printf("Letra %c\nValor num1: %d\nValor num2: %d\nValor num3: %f\nValor num4: %lf\nValor num5: %llf\n", letra, num1, num2, num3, num4, num5);
}
O resultado é apresentado na figura a seguir:
Observe que as variáveis foram inicializadas com valores diretamente no código. Caso queiramos que o usuário digite as informações por meio do teclado, precisamos então fazer uso de um comando de entrada. Comando de entrada, pois dados serão digitados no teclado e “entrarão” no computador a fim de serem processados.
Lendo caracteres
Apesar da maioria das vezes a instrução de entrada scanf() ser utilizada, vale ressaltar que existem outras. No trecho de código a seguir apresentamos três formas diferentes para realizar a leitura de caracteres.
1 – getchar()
Ao pressionar qualquer tecla do teclado, o caractere correspondente é armazenado em uma região especial de memória chamada de buffer do teclado. Quando a tecla ENTER é pressionada, a função getchar() retorna o primeiro caractere presente no buffer do teclado. A variável à esquerda receberá então este caractere.
Contudo, a tecla ENTER também é um caractere, por isso precisamos remover ele do buffer do teclado para ler um segundo caractere corretamente. Por isso fazemos a leitura de um segundo caractere na linha 11 e não atribuímos a nenhuma variável. Na verdade, o caractere que está sendo lido é o caractere que representa a tecla ENTER, limpando assim o buffer do teclado.
2 – getc()
Assim como a anterior, esta função lê e retorna um caractere. A diferença é que ela recebe um parâmetro que diz para a função de onde deve ser lido esse caractere. Como queremos ler do buffer do teclado, então utilizamos como parâmetro a palavra reservada “stdin” que faz referência ao teclado do computador.
Assim como no caso anterior, a variável que estiver à esquerda receberá o caractere lido e o buffer do teclado pode ser limpo lendo outro caractere, como feito na linha 16, removendo assim o caractere referente a tecla ENTER.
3 – scanf()
Esta é a instrução de entrada mais utilizada devido sua flexibilidade. Ela não é uma função, logo não retorna nenhum valor. Recebe como parâmetro dois elementos: o primeiro, dentro de aspas duplas, representa o tipo de dado que será lido, neste caso %c, pois iremos ler um caractere; o segundo é o endereço de memória onde deve salvar o caractere lido. Na linguagem C podemos obter o endereço de memória de uma variável utilizando o & (e comercial) antes de seu nome, como feito na linha 19.
Assim como nos casos anteriores, podemos utilizar scanf() também para remover o ENTER do buffer do teclado, como feito na linha 21. O asterisco significa que deve ser removido do buffer o próximo caractere, independente de qual seja.
#include <stdio.h>
#include <stdlib.h>
void main() {
char letra1, letra2, letra3;
printf("Digite uma letra: ");
letra1 = getchar();
printf("Letra digitada: %c\n", letra1);
getchar();
printf("\nDigite uma segunda letra: ");
letra2 = getc(stdin);
printf("Letra digitada: %c\n", letra2);
getc(stdin);
printf("\nDigite uma terceira letra: ");
scanf("%c", &letra3);
printf("Letra digitada: %c\n", letra3);
scanf("%*c");
}
Lendo números
Devido sua flexibilidade, a instrução scanf() é utilizada para a leitura de números em geral, bastando informar corretamente qual o tipo de número será lido, como apresentado no trecho de código a seguir.
#include <stdio.h>
#include <stdlib.h>
void main() {
short num1;
int num2;
float num3;
double num4;
printf("Digite um valor pequeno: ");
scanf("%d", &num1);
printf("Valor lido: %d\n\n", num1);
printf("Digite um valor inteiro: ");
scanf("%d", &num2);
printf("Valor lido: %d\n\n", num2);
printf("Digite um valor real: ");
scanf("%f", &num3);
printf("Valor lido: %f\n\n", num3);
printf("Digite um valor real longo: ");
scanf("%lf", &num4);
printf("Valor lido: %lf\n\n", num4);
}
A instrução scanf() também suporta a leitura de vários dados de uma única vez, como apresentado no trecho de código a seguir.
#include <stdio.h>
#include <stdlib.h>
void main() {
short num1;
int num2;
float num3;
double num4;
printf("Digite um short, um int, um float e um double: ");
scanf("%d%d%f%lf", &num1, &num2, &num3, &num4);
printf("Valores digitados:\nshort: %d\nint: %d\nfloat: %f\ndouble: %lf\n\n", num1, num2, num3, num4);
}
Se ficou alguma dúvida, compartilhe nos comentários que faremos o possível para esclarecer. Um grande abraço, bons estudos e até o próximo.
