Entrada y salida de datos en C

Todas las funciones de entrada y salida de datos están

contenidas en el archivo de cabecera stdio.h.

Entrada de datos por teclado

Entrada de caracteres
La función getchar() lee un carácter de la entrada estándar. Si
se introducen más caracteres, los restantes se almacenan en
el buffer de entrada.

//lee un carácter y lo imprime en pantalla.

#include <stdio.h>

void main(){
int caracter;
puts("Escriba un caracter: ");

while ((caracter = getchar()) != '\n' && caracter != EOF)

printf("El caracter es: %c\n", caracter);
}

Hay que tener cuidado al solicitar varios caracteres en

distintas instrucciones, porque al introducir un carácter y
oprimir Enter, el carácter salto de línea queda almacenado
en el buffer, y será este carácter el que se asigne en la
siguiente instrucción de entrada. Por esto es muy normal
que antes de leer un carácter de la entrada estándar, se

1
limpie el buffer de caracteres no imprimibles con la función
fflush(stdin).

//lee un carácter y lo imprime en pantalla.

#include <stdio.h>

void main(){
char letra, vocal;

puts("Escriba una letra: ");

letra = getchar();

puts("Escriba una vocal: ");

fflush(stdin);
vocal = getchar();

printf("Letra: %c, vocal: %c\n", letra, vocal);

}

La función getch() también lee un carácter de la entrada

estándar, pero no lo almacena temporalmente, por lo que
apenas se presiona la tecla, de inmediato continúa el flujo de
ejecución (no hay que oprimir Enter). Esta función se suele
usar con Enter (13), Tabulación (9) y Escape (27).

//si se presiona la tecla ESC (código 27), el programa termina.

#include <stdio.h>

void main(){
char tecla;

puts("Presione ESC para salir.");

tecla = getch();

if (tecla == 27)
exit(-1);

puts("continua el programa");
system("pause");
}

Obtención de teclas extendidas

Existen algunas teclas especiales, como las teclas F1 a F10.
Estas a diferencia de las teclas de caracteres regulares,
envían un par de valores a stdin, en vez de uno solo. En cada
par, el primer valor siempre es el carácter nulo, con un valor

2
numérico de 0. El segundo tiene un valor numérico que
identifica la tecla oprimida.

//la función ext_key() permite leer teclas extendidas.

#include <stdio.h>

int ext_key(void);

void main(){
int tecla;

puts("Presione una tecla extendida: ");

while (1){
tecla = ext_key();
if (tecla == 59)
break;
else
printf("tecla presionada: %d\n", tecla);
}
}

//la función solo sale del ciclo while cuando lee el carácter nulo,
//e inmediatamente lee un segundo valor.
int ext_key(void){
int ch;
while ((ch = getch()) != 0)
;
return getch();
}

Leer cadenas de caracteres

La función gets() lee todos los caracteres tecleados hasta
encontrar el primer carácter de nueva línea (generado al
oprimir Enter). La función reemplaza el carácter de nueva
línea por el carácter nulo y guarda la cadena en el puntero
que ha sido pasado como argumento. La función retorna un
puntero a la dirección de memoria donde fue almacenada la
entrada.

#include <stdio.h>

void main(){
char nombre[20];

puts("Escriba su nombre: ");

gets(nombre); //fgets(nombre, 20, stdin);

printf("Su nombre es: %s\n", nombre);

3
 }

El uso de gets() es algo peligroso, ya que la función no conoce

el tamaño del arreglo que se va a pasar por teclado. Así, si
se pasan más caracteres de lo que puede almacenar el
arreglo declarado, se pueden sobreescribir datos o hacer que
la aplicación se comporte de manera inesperada.

Una solución a esto es usar fgets() que es similar a la anterior,

solo que toma tres argumentos. El primero es el puntero
donde se guardará la información, el segundo es la cantidad
máxima de caracteres que recibe y el tercer argumento
especifica el flujo de entrada, que suele ser stdin. Al pasar
más caracteres de los requeridos, estos se almacenan en el
buffer.

Leer cualquier tipo de variable

La función scanf() acepta la entrada desde el teclado de datos
numéricos y cadenas de caracteres. Esta toma dos
argumentos, el primero es un especificador de formato, que
indica la manera de leer la entrada y el segundo argumento
es la dirección de la variable donde se guardará el dato.

En el caso de cadenas, el nombre del arreglo es un puntero,

por lo que no necesita el operador de dirección ( & ).
Además, lee una cadena hasta encontrar un carácter en
blanco (espacio, tabulación o salto de línea).

Especificad Descripción Especificad Descripción

or de or de
formato formato
número
%c carácter %x
hexadecimal
número entero
%s cadena de caracteres %ld
long
%d número entero %f número float
%o número octal %lf número double

4
Se pueden leer varias cadenas al tiempo, cada una separada
por un carácter de espacio en blanco, tabulador o nueva
línea (sin incluirlo). Si se ingresan más cadenas de las
pedidas, las cadenas sobrantes permanecen pendientes
(esperando en el buffer del teclado) y son leídas
posteriormente por cualquier otra función de entrada.

Se puede usar %ns con las cadenas de caracteres, donde n es

un número entero que indica la longitud de la cadena (sin
incluir el carácter nulo). La función lee solo n caracteres o
hasta encontrar un carácter en blanco.

#include <stdio.h>

void main(){
char name[15];
int age;

puts("Ingrese su nombre y edad: ");

scanf("%s %d", name, &age);

printf("Nombre: %s, edad: %d\n", name, age);

}

Limpiar el buffer de entrada

Después de leer cadenas de caracteres se puede utilizar un

ciclo while que lee todos los caracteres del buffer mientras no
sean un salto de línea.

#include <stdio.h>
#define clear_buffer while(getchar()!='\n')

void main(){
char nombre[20], profesion[15];

puts("Escriba su nombre: ");

fgets(nombre, 20, stdin);
clear_buffer;

puts("Escriba su profesion: ");

fgets(profesion, 20, stdin);
clear_buffer;

printf("Su nombre y profesion es: %s, %s\n", nombre, profesion);

}

5
Impresión de datos en pantalla

La función puts() solo permite desplegar mensajes de texto.

Acepta una cadena de caracteres como argumento y la
imprime, añadiendo un salto de línea al final. Acepta
secuencias de escape.

#include <stdio.h>

void main(){
char mensaje[] = "vive feliz";
puts(mensaje); //vive feliz

puts("Hola mundo"); //equivale a printf("Hola mundo\n");

}

Por otra parte, la función printf() permite imprimir un mensaje

de texto, desplegando cualquier tipo de variable utilizando
un especificador de formato y el nombre de la variable.
También acepta secuencias de escape.

Especificad Descripción Secuen Descripción

or de cia de
formato escape
%c carácter \' comillas simples
%s cadena de caracteres \" comillas dobles
signo de
%d número entero \?
interrogación
%o número octal \\ barra invertida
%x número hexadecimal \0 carácter nulo
%ld número entero long \n nueva línea
%f número float \t tabulación
%lf número double %% porcentaje

#include <stdio.h>

void main(){
char *name = "Camilo";
int age = 24;

printf("%s tiene %d años\n", name, age);

//Camilo tiene 24 años
}

6
La función putchar() por otro lado, imprime solo un carácter
en pantalla. Recibe como único argumento una variable de
tipo char.

//imprime el alfabeto en minúsculas, donde a=97 y z=122.

#include <stdio.h>

void main(){
for (int i=97; i<122; i++){
putchar(i);
printf(" ");
}
}

Por otro lado, la función perror() recibe una cadena de

caracteres. Permite escribir un mensaje de error en el
standard error (stderr).

Redirección de entrada y salida

En general, las funciones de entrada utilizan el standard

input (stdin), que suele corresponder al teclado, mientras
que las funciones de salida usan el standard output (stdout)
que suele ser la pantalla. La redirección consiste en tomar
como entrada un archivo, o en dirigir la salida a un fichero.
La redirección se especifica en la línea de comandos del
sistema operativo cuando se ejecuta el programa.

Para redirigir la salida se escribe de la forma codigo.exe >

archivo.txt. Si el fichero ya existe, su contenido será
reemplazado. Si no existe, se creará. El símbolo >> permite
añadir la salida al final del archivo, en caso de que ya exista.

Para redirigir la entrada se necesita de un archivo fuente. Se

escribe de la forma codigo.exe < archivo.txt. Si el programa
recibe varias entradas, cada una corresponde a una línea del
archivo. Es posible redirigir la entrada y salida al mismo
tiempo así: codigo.exe < input.txt > output.txt.