Comandos padrão de entrada e saida de dados.

Recebendo entradas do teclado

A linguagem C é enxuta, não possui dentro de si os comandos para receber e

enviar dados. Requer o uso de bibliotecas para poder usar comandos de
entrada e saída de dados.
A biblioteca mais usada para este fim na linguagem C < stdio.h >, porém é
comum usar também < conio.h > e < stdlib.h > .

Apresentamos um resumo dos passos básicos que um programa executa para

conduzir um diálogo de entrada:

1. mostrar uma mensagem na tela solicitando entrada de dados. printf

("texto")
2. uso de uma das funções de entrada [scanf, gets, getch( ), getche( ) ].
3. armazenar o valor de entrada em uma variável (parte não visível).

scanf() da biblioteca stdio.h

A função scanf lê entradas numéricas do teclado.

Sintaxe:

scanf("formato", &variável);

formato é o tipo de valor que scanf espera ler do teclado.

Tipos básicos de formato:

%d entrada de números inteiros.

%f entrada de ponto flutuante.
%c entrada de caractere
%s entrada de string de caracteres

O símbolo & colocado imediatamente antes do nome da variável significa que

scanf envia o valor ao endereço da memória do computador alocado à
variável. Este procedimento permite acelerar os trabalhos de computo.
Cuidado: se você deixa um espaço entre o simbolo & e o nome da variável
ocorrerá um erro.

scanfpode ler também uma string, mas ela é projetada para ler dado valor de
string somente até o primeiro espaço na string. Por este motivo é aconselhavel
usar a função gets para receber frases que contenham espaços.
Exemplo:
/*ex09.c exemplo do uso de scanf()*/
#include < stdio.h > /* diretiva */
#define DIMENSAO 0.15 /* diretiva */

float rey, dens, vel, visc; /* variáveis globais */

main() /* função principal */

{
char parada; /* variável local */
clrscr();
printf ("Qual é a densidade?"); scanf ("%f", &dens);
printf ("Qual é a viscosidade?"); scanf ("%f", &visc);
printf ("Qual é a velocidade?"); scanf ("%f", &vel);
rey=(dens*vel*DIMENSAO)/visc;
printf ("Numero de Reynolds: %10.2f\n", rey);
parada = getche();
}

gets()da biblioteca stdio.h

Sintaxe:

gets(variável);

A função gets aceita espaços como parte de uma string e considera o fim de
uma entrada quando pressionamos ENTER . Após a entrada, gets anexa
automaticamente um caracter nulo (\0) no final da string.

Exemplo:
printf ("Caracteristicas reologicas do produto.\n\n");
printf ("Qual e a densidade?")
gets (densid);

A função gets pode ler e confirmar entradas numéricas. Ele armazena o valor
em uma variável string. Depois temos que converter o valor da string em
número. Para essa conversão usamos as funções atof e atoi.

atof( ) e atoi ( )

Convertem strings em números.

atof converte uma string de dígitos em um valor numérico de tipo double.

atoi converte em um valor numérico de tipo int.

Sintaxe:
atof(string); "ascii to float"
atoi(string); "ascii to integer"
Ambas se não conseguirem converter a string retornan um valor zero.

Combinando estes comandos podemos criar uma função para entrada e

conversão dos dados:

Exemplo:
/* ex39.c conversão de strings em números*/
#include < stdio.h > /* diretivas */
#include < stdlib.h >

main() /* função principal *

{
char *s1 = "3.45"; /* atribuições */
char *s2 = "1234";
char *s3 = "3ghk.45";

printf ("%lf\n", atof (s1) );

printf ("%i\n", atoi(s2) );
printf ("%lf", atof(s3) );
}

Resultados:
3.450000
1234
3.000000

Exemplo: função definida pelo usuário infloat() para receber valores

numéricos pelo teclado.
float infloat (char prompt[ ])
{
char instrval[STRLENGTH]; /* entrada em formato string */
float inval; /* entrada em formato numérico */

do
{
printf (prompt);
gets (instrval); /* a função atof devolve um valor zero */
/* se instrval não pôde ser convertido */
inval = atof(instrval);
}
while (inval < = 0.0);
return (inval);
} /* final de infloat */

Observação:
O argumento prompt (printf (prompt)) faz com que apareça na tela o sinal de
interrogação.

getchar( ) ( < stdio.h > ), getche( ) e getch( ) ( < conio.h > ).

getchar( ) lê um caracter do teclado. A função retorna o caracter lido, após
convertê-lo para int. Quando digitado o dado, ele é armazenado em um buffer,
até que seja digitado o retorno.
getche( ) e getch( ) retornan um caracter assim que o mesmo seja digitado, ou
seja não é aguardado até que seja digitado o retorno.
getche( ) lê um caracter do teclado, apresenta-o na tela e o devolve para a
função chamadora.
getch( ) parece com getche( ), exceto por não apresentar o caracter na tela.

Exemplo:
/* ex40.c utilização de getche() e getch() */
#include < stdio.h > /* diretiva */
#include < conio.h >
main () /* função principal */
{
char dado;
printf ("Digite um caracter"); scanf ("%c", &dado);
printf ("Caracter lido = %c\n", dado);
printf ("Digite um caracter"); dado = getch ();
printf ("Caracter lido = %c\n", dado);
}

Exemplo:
/* ex55.c exemplo de getchar */
#include < stdio.h >
main()
{
char c;
int x, y;
clrscr();
printf ("Deslocamento? (a,b,c,d,):");
c = getchar();

switch (c)
{
case 'a' : y ++; break;
case 'b' : y --; break;
case 'c' : x --; break;
case 'd' : x ++; break;
default: printf ("n\resp. incorreta|n"); exit(0);
}
printf ("Posição: %d %d \n",x,y);

printf( ) da biblioteca < stdio.h >

A função printf mostra informação em formato especial. Ela é muito usada.

Sintaxe: printf ("formato", valor1, valor2, valor3,...);

formato string de formato na qual você especifica como quer que apareça a
saída, pode incluir texto e definições de uso de varios tipos de variáveis.
valor1,...,valor3,... valores de dados numéricos ou string que a função printf
mostrará na tela.

A string de formato pode conter três tipos de informação:

1. texto literal
2. especificadores de formato
3. símbolos especiais de controle

Texto literal envia diretamente para a tela como parte da saída;

Especificadores de formato - indicam como os argumentos de valor de dados
correspondentes do comando printf serão mostrados.
Símbolo de controle controlam operações particulares na tela ou impressora -
tais como mudanças de linha, tabulações . Esses símbolos começam com o
caractere barra invertida (\), e podem aparecer em qualquer lugar dentro da
string de formato.

Especificadores de formato para a função printf

Todos especificadores começam com um sinal de porcentagem (%) e

terminam com uma ou duas letras e/ou números que representam um tipo de
dado suportados em C.

Os principais especificadores são:

% i inteiro (int)
% d inteiro decimal (int)
% ld inteiro longo (long)
% f ponto flutuante ou número decimal (float)
% lf ponto flutuante de dupla presição (double)
% c caracter (char)
% s string (matriz de char)
% e número com formato exponencial

Para um tipo de dado numérico, pode incluir largura da imagem e instruções

de ponto decimal no especificador. Essas instruções opcionais aparecem entre
o sinal de porcentagem e o código de tipo.

Exemplo:
%4d - valor de número inteiro correspondente deve ser um campo de
saída de 4 espaços.
%4.2f - valor de número de ponto flutuante num campo de 4 espaços e
com duas decimais.
Justificando um número à esquerda na função printf

Printf normalmente justifica um número inteiro ou número de ponto flutuante

à direita dentro de uma certa largura de saída.

Exemplo:

printf ("Reynolds: %8.0f", rey);

Saída:
Reynolds: 10000

Justificando um número à direita na função printf

Mas algumas vezes você poderia preferir justificar à esquerda dentro do printf
em campo de saída. Para tanto, inclua um sinal menos (-) antes do
especificador de largura

Exemplo:

printf ("Reynolds: -%8.0f", rey);

Saída:
Reynolds: 10000

Usando simbolos de controle especiais na função printf

A função printf não aloca automaticamente a posição de cada texto, por

exemplo, em uma nova linha. Para modificar a posição no printf, devemos
fornecer uma instrução específica na string de formato.

Algumas instruções de controle.

\n mudança de linha.
\t tabulação.
\n\n produz linha em branco.
\a sinal de audio.

Exemplo:
/*ex08.c exemplo do uso de printf()*/
#include < stdio.h > /* diretiva */
#define calc "Numero de Reynolds" /* diretivas */
#define dimen 0.450
#define veloc 1.7
#define dens 1200
#define visc 0.78

main() /* função principal */

{
 char parada; /* variável local */
float rey = (dens*veloc*dimen)/visc ;
clrscr();
printf ("Caracteristicas reologicas\n");
printf ("densidade: %4.2f\n ",dens);
printf ("viscosidade: %2.3f\n", visc);
printf ("Dimensoes caracteristicas do sistema: %2.4f\n",dimen);
printf ("O valor do %s e: %6.2", calc,rey);
parada = getchar();
}

Enviando saída para a impressora com fprintf

C oferece um número de funções de biblioteca que você pode utilizar para

enviar dados a vários destinos. Em complemento, o arquivo de cabeçalho
stdio.h define nomes que representam especificamente a tela e a impressora
como destinos de saída. Esses identificadores - algumas vezes chamados filas
predefinas - são como se segue:

Stdout - dispositivo padrão de saída, normalmente a tela.

Stdprn - impressora padrão . dispositivo identificado como PRN: no DOS.

A função printf sempre envia sua saída para o stdout. Mas outras funções
permitem especificar os destinos dos dados de saída.

fprintf( ) da biblioteca < stdio.h >.

fprintf é usado para enviar dados à impressora. Sua sintaxe é semelhante a de

printf, exceto que um argumento adicional é necessário.

Sintaxe:

fprintf (destino, "formato", valor1, valor2, valor3,...);

Destino especifica para onde você quer que a saída seja enviada.
Formato e valor trabalham como com printf .

Se fornecemos o destino como de stdout fprintf se comporta igual a printf.

Para que avance página na hora da impressão enviamos um caracter de avanço

de página ("Form feed").

fprintf("\f") onde f - representa o caracter de avanço de página.

Exemplo: uma função definida pelo usuário: printcalc.

void printcalc (float vel, float visc, float dens, float dim)
{
fprintf (stdprn, "Densidade: %6.2f\n", dens);
fprintf (stdprn, "Viscosidade: %2.3f\n", visc);
 fprintf (stdprn, "Velocidade: %2.2f\n", vel);
fprintf (stdprn, "Dimensao caracteristica: %1.3f\n", dim);
fprintf (stdprn, "Numero de Reynolds: %6.2f\n", (dens*vel*dim)/visc
);
}

Utilizando funções especiais de controle da tela

gotoxy ( ) da biblioteca < conio.h >.

Durante uma execução de programa, a posição atual do cursor determina onde

um comando subseqüente de saída mostra a informação na tela. Cada posição
na tela tem um endereço numérico de duas partes, consistindo em uma
componente horizontal e uma vertical.

A função gotoxy posiciona o cursor em localização determinada da tela, para

que o comando subseqüente de saída possa aí mostrar informação. Cuidado
para não confundir GOTOXY com GOTO. O segundo é altamente censurável
ao ser usado em uma linguagem estruturada como C.

Sintaxe:

gotoxy (horizontal, vertical);

Observação:
- horizontal varia de 1 até 80,
- vertical varia 1 até 24.

Os argumentos de gotoxy podem ser expressos como números inteiros literais

ou como expressões aritméticas que calculam endereços de tela.

Exemplo:
/*ex15.c mostra código ASCII extendido*/
#include < stdio.h > /* diretivas */
#include < conio.h >
main() /* função principal */
{
char parada; /* variável local */
int i= 0, x = 1, y = 1; /* inicialização de variáveis locais */
clrscr(); /* chamada a função que limpa tela */
do { /*laço de repetição */
gotoxy(x, y);
printf ("%3d %c",i,i);
i++;
y++;
if (y > = 24) {x += 6, y = 1};
}
while ( i < = 255);
gotoxy (60,24);
printf ("Código ASCII");
parada = getchar();
}

putchar ( ) da biblioteca < stdio.h >.

A função putchar mostra um dado caracter na posição atual do cursor.

Sintaxe:

putchar (caracter);

O argumento pode ser um caracter literal ou um número de código ASCII.

Exemplo:
printf ("\nQuer alterar o valor da velocidade? < S ou N > ");
do
yesno = toupper(getch());
while ((yesno == 'S') && (yesno == 'N'));
putchar(yesno);

clrscr ( ) da biblioteca < stdio.h >.

Apaga todos os caracteres que estão na janela de texto e posiciona o cursor

nas coordenadas (1,1) em relação a janela de texto.

Exemplo:
/* EX03: tabela de conversão */
#include < stdio.h > /* diretivas */
main () / b@