C: (parte 10) Funciones Entrada/Salida básica

Vamos a ver con algo más de detalle las órdenes habituales de entrada y salida estándar: printf y scanf, que ya conocemos, putchar y getchar, que aun no habíamos visto. Todas ellas se encuentran definidas en <stdio.h>.

Printf

Ya conocemos el manejo básico de la orden “printf”:

printf( formato [, dato1, dato2, ...])

(el corchete indica que la cadena de texto de formato debe existir siempre, pero los datos adicionales son opcionales, pueden no aparecer).

Esta orden muestra un texto formateado en pantalla. Para usarla es necesario incluir <stdio.h> al principio de nuestro programa. Hemos visto cómo emplearla para mostrar número enteros, números reales y caracteres. Ahora vamos a ver más detalles sobre qué podemos mostrar y cómo hacerlo:

Si usamos %% se mostrará el símbolo de porcentaje en pantalla.

Queda alguna otra posibilidad que todavía es demasiado avanzada para nosotros, y que comentaremos mucho más adelante, cuando hablemos de “punteros”.

Además, las órdenes de formato pueden tener modificadores, que se sitúan entre el % y la letra identificativa del código.

    • Si el modificador es un número, especifica la anchura mínima en la que se escribe ese argumento (por ejemplo: %5d).
  • Si ese número empieza por 0, los espacios sobrantes (si los hay) de la anchura mínima se rellenan con 0 (por ejemplo: %07d).
  • Si ese número tiene decimales, indica el número de dígitos totales y decimales si los que se va a escribir es un número (por ejemplo %5.2f), o la anchura mínima y máxima si se trata de una cadena de caracteres (como %10.10s).
  • Si el número es negativo, la salida se justificará a la izquierda, dejando espacios en blanco al final (en caso contrario, si no se dice nada, se justifica a la derecha, dejando los espacios al principio).

Casi todo el fácil de seguir, pero aun así hay vemos alguna cosa desconcertante…

Por ejemplo, ¿por qué el número real aparece como 234.567001, si nosotros lo hemos definido como 234.567? Hay que recordar que los números reales se almacenan con una cierta pérdida de precisión. En un “float” sólo se nos garantiza que unas 6 cifras sean correctas. Si mostramos el número con más de 6 cifras (estamos usando 9), puede que el resultado no sea totalmente correcto. Si esta pérdida de precisión es demasiado grande para el uso que queramos darle, deberemos usar otro tipo de datos, como double.

Lo de que el número negativo quede mal cuando lo intentamos escribir como positivo, también nos suena conocido: si el primer bit de un número con signo es uno, indica que es un número negativo, mientras que en un número positivo el primer bit es la cifra binaria más grande (lo que se conoce como “el bit más significativo”). Por eso, tanto el número -1234 como el 4294966062 se traducen en la misma secuencia de ceros y unos, que la sentencia “printf” interpreta de una forma u otra según le digamos que el número el positivo o negativo.

Como curiosidad, ese número 4294966062 sería un valor distinto (64302) si usáramos un compilador de 16 bits en vez de uno de 32, porque sería una secuencia de 16 ceros y unos, en vez de una secuencia de 32 ceros y unos.

Otra opción más avanzada es que si usamos un asterisco (*) para indicar la anchura o la precisión, los primeros datos de la lista serán los valores que se tomen para indicar la anchura y la precisión real que se usarán:

Scanf

Como ya sabemos, el uso de “scanf” recuerda mucho al de “printf”, salvo porque hay que añadir el símbolo & antes de los nombres de las variables en las que queremos almacenar los datos. Aun así, los códigos de formato no son exactamente los mismos.

Al igual que en “printf”, se puede indicar un número antes del identificador, que nos serviría para indicar la cantidad máxima de caracteres a leer. Por ejemplo, “scanf(“%10s”, &texto)” nos permitiría leer un texto de un tamaño máximo de 10 letras.

Aun así, “scanf” a veces da resultados desconcertantes, por lo que no es la orden más adecuada cuando se pretende crear un entorno amigable. Más adelante veremos formas alternativas de leer del teclado.

Putchar

Es una forma sencilla de escribir un único carácter en la pantalla:

putchar('A');

o si usamos una variable:

putchar(x);

Getchar

Lee el siguiente carácter que esté disponible en el buffer del teclado (una memoria intermedia que almacena todas las pulsaciones de teclas que hagamos):

letra = getchar();

Si no quedaran más letras por leer, el valor que nos daría es EOF, una constante predefinida que nos indicará el final de un fichero (End Of File) o, en este caso, de la entrada disponible por teclado. Se usaría así:


letra = getchar();
if (letra==EOF) printf("No hay más letras");

Un Saludo.

Anuncios

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s