C++ / iostream

Bienvenidos sean a este post, hoy ahondaremos un poco mas sobre esta libreria.

Si vienen de los posts anteriores, habran notado que siempre utilizamos esta libreria para nuestros codigos. Dado que la misma nos permitira manejar todos los elementos de entrada/salida. Nos permite utilizar un monton de herramientas pero las que mas hemos usado fueron cout y cin. Siendo el primero para mostrar informacion en consola y el otro para ingresar informacion desde nuestra consola. La posibilidad de usar librerias como estas le brindan a nuestros codigo algo muy util como es la portabilidad. Es decir, poder llevar nuestros codigos a distintos sistemas operativos sin necesidad de cambiarlo (mucho). Ojo, el codigo es portable no los programas que se compilan de este codigo. Para poder usarlo debemos compilarlo en el equipo donde lo ejecutamos para que funcione correctamente.

A continuacion,, les comento algunas de las clases que mas usaremos de esta libreria:

• streambuf, maneja el buffer y sus metodos, este es el encargado de llenar, vaciar, limpiar y manejar de cualquier forma el buffer.
• ios, es la clase base para los flujos de entrada y salida, tiene como variable miembro un objeto streambuf.
• istream, derivada de la clase ios y se especializa en el comportamiento de los flujos de entrada.
• ostream, derivada de la clase ios y se especializa en el comportamiento de los flujos de salida.
• iostream, se deriva de istream y ostream y proporciona los metodos de entrada y salida para escribir en pantalla.
• fstream, proporciona entrada y salida desde archivos

Pasemos a hablar sobre algunos de los objetos derivados de estas clases que mas se utilizan,, asi como tambien los utilizados previamente:

• cin: encargada de manejar la entrada desde el teclado, la entrada mas estandar.
• cout: se encarga de manejar la salida a pantalla, es decir la salida mas estandar.
• cerr: se encarga de mostrar el mensaje de error en el dispositivo mas estandar, la pantalla y como se encuentra fuera del buffer lo hace inmediatamente.
• clog: se encarga de manejar los mensajes de error en el buffer, tambien lo direcciona en la salida mas estandar, pantalla, pero tiene la posibilidad de «redireccionarlo» a un archivo.

En realidad todos estos se encargan de redireccionar a los lugares que necesitemos utilizar. Hablemos primero de clog, donde este objeto encargado de generar los mensajes de log para llevar un control lo podemos redireccionar a un archivo para poder analizarlo en otro momento. Esto mismo podemos hacerlo con cerr en lugar de mostrarlo en pantalla, o la salida predeterminada, lo podemos enviar a un archivo para poder analizarlo tambien. Podemos decir que el redireccionamiento es la capacidad de enviar el contenido a un dispositivo distinto del predeterminado. Si bien ya vimos como trabajar con cin y cout, veamos el siguiente ejemplo para ver unas variantes de estos:

#include <iostream>

int main()
{
        int miInt;
        float miFloat;
        char miPalabra[50];

        std::cout << "Ingresa un int, float y char: ";
        stt::cin >> miInt >> miFloat >> miPalabra;

        std::cout << "int: " << miInt << std::endl;
        std::cout << "float: " << miFloat << std::endl;
        std::cout << "char: " << miPalabra << std::endl;

        return 0;
}

Este es un codigo simple para repasar como trabajaban cout y cin. Primero declaramos tres variables donde almacenaremos valores del tipo int, float y char. En el ultimo caso, palabras de hasta 50 caracteres. Luego, le pediremos que ingrese tres valores pero en lugar usar tres cin distintos los pasamos uno detras del otro. Lo ideal es pasarlos en el mismo orden para que se almacenen de forma correcta. Lo siguiente sera mostrar cada valor recibido e identificando a cada uno. Compilemos y veamos como es su salida:

En este post, vimos como mediante get y cin podiamos tomar toda la informacion que le ingresabamos. Volveremos a usarlo pero para utilizarlo de otra manera. Tomemos el ejemplo anterior y modifiquemoslo de la siguiente manera:

#include <iostream>

int main()
{
        char ch;
        while((ch = std::cin.get()) != EOF )
        {
                std::cout << "ch: " << ch <<std::endl;
        }
        std::cout << "Listo!" << std::endl;

        return 0;
}

Primero declaramos una variable que solo almacena un caracter. Luego mediante un while le asignamos un valor y para ello usaremos a cin y get. Esto es para que lea toda la linea sin interrupcion y repetiremos el bucle mientras no ingresemos un EOF. Este es ingresado mediante CTRL+D para los derivados de UNIX, para los de la competencia se utiliza a CTRL+Z. Mientras no pasemos esta combinacion de teclas el bucle no terminara. En el bloque del mismo mostraremos cada uno de los caracteres que componen lo que ingresemos. Por ultimo, una vez finalizado el bucle mostraremos un mensaje de finalizacion. Compilemos y veamos como trabaja mediante el siguientte video:

En el video podemos ver como, cada vez que ingresamos un texto, sin importar los espacios en blanco, nos devuelve cada uno de los caracteres del texto. Solamente cuando presionamos CTRL+D termino el bucle y nos mostro el mensaje de listo. Otra alternativa que podemos usar es getline, y trabaja exactamente de la misma manera. La unica diferencia entre ellos es que get no ignora el caracter nulo que identifica el final del texto y getline si lo hace. Analicemos el siguiente codigo:

#include <iostream>

int main()
{
        char msj[10];
        char msj2[10];

        std::cout << "Ingresa un texto: ";
        std::cin.get(msj,10);
        std::cout << "Ingresa otro texto: ";
        std::cin.getline(msj2,10);
        std::cout << msj << std::endl;
        std::cout << msj2 << std::endl;

        return 0;
}

Aqui declaramos dos variables que almacenan hasta 9 caracteres, recuerden que el ultimo siempre sera \n para indicar el final del texto.. Luego pediremos que ingresen los valores para ambas variables y procedemos a mostrarlo. En el primer caso, usaremos a get para obtener los datos y en el segundo usaremos a getline. Compilemos y veamos que sucede:

En el video pueden ver como se completo automaticamente el segundo cin y no mostro nada a la salida. Para solucionar esto, podemos usar a ignore. Para ello debemos modificar el codigo anterior de la siguiente manera:

#include <iostream>

int main()
{
        char msj[10];
        char msj2[10];

        std::cout << "Ingresa un texto: ";
        std::cin.get(msj,10);
        std::cin.ignore(9,'\n');
        std::cout << "Ingresa otro texto: ";
        std::cin.getline(msj2,10);
        std::cout << msj << std::endl;
        std::cout << msj2 << std::endl;

        return 0;
}

La unica modificacion es agregar a ignore, donde primero pasamos hasta que posicion ignorara todos los caracteres y que debe ignorar al caracter de finalizacion de la cadena. El resto sigue siendo de la misma manera. Compilemos y veamos como es su salida:

$ ./ios
Ingresa un texto: tincho
Ingresa otro texto: tinchicus
tincho
tinchicus
$

Ahora si pudimos ingresar ambos valores y se mostraron al final. Esto gracias a que ignoramos el caracter de final. Otra solucion, hubiera sido invertir los ingresos. Es decir, usar primero a getline y luego a get porque getline ignora de manera automatica el caracter de final como mencionamos anteriormente. Otras dos funciones interesantes que disponemos son peek y putback. Siendo peek para ignorar un caracter durante la extraccion y putback se utiliza para insertar un caracter en la extraccion. Vamos a analizar el siguiente codigo:

#include <iostream>

int main()
{
        char ch;
        std::cout << "Escribe una frase: ";

        while(std::cin.get(ch)) {
                if (ch == 'n')
                        std::cin.putback('$');
                else
                        std::cout << ch;

                while(std::cin.peek() == 'a')
                        std::cin.ignore(1, 'a');
        }

        return 0;
}

Aqui usaremos un while que tomara todos los caracteres que ingresemos hasta que presionemos Enter. En el tenemos un condicional donde si el caracter es igual a n mediante putback procedemos a «reemplazarlo» porque en lugar de pasar ese caracter insertaremos el simbolo de dinero ($). De lo contrario muestra el caracter correspondiente. Luego tenemos un while donde mediante peek le diremos que saldra cuando sea igual a ese caracter. En el bloque usaremos a ignore para ignorar a este. Por lo tanto, en cualquier texto que ingresemos reemplazara a las n con $ e ignorara a los caracteres a. Compilemos y veamos como es su salida:

$ ./ios
Escribe una frase: Martin Miranda
Mrti$ Mir$d
Marta Gargaglione
Mrt Grgglio$e
youtube.com
youtube.com
$

Observen los distintos ejemplos que pasamos y solamente se trabajo cuando hubo coincidencia, en caso contrario se pasa limpio como se ve en el ultimo ejemplo.

Con esto cubrimos lo mas importante y basico de cin, pasemos a hablar sobre funciones que podemos usar en cout. Algunos de los que disponemos son los siguientes:

• <<, es el operador mas basico para mostrar la informacion en pantalla.
• put(), permite imprimir un caracter, se puede concatenar.
• write(), permite mostrar un texto en pantalla y le podemos definir cuanto mostrar.
• width(). define la cantidad de caracteres a mostrar, si es mayor a la cantidad de la variable agregara los espacios en blanco suficientes para llenar los faltantes pero si es menor muestra los datos de la variable tal como es.
• fill(), llena los espacios en blanco creados por width() con el caracter informado, por ejemplo width(‘*’) llenara los espacios con asteriscos (*).
• setf(), nos permite definir el tipo de indicador para las clases iostream, por ejemplo nosotros podemos definir la ubicacion de texto con: setf(ios::left), este ubicara lo mostrado en pantalla con orden desde la izquierda, o setf(ios::showbase) donde nos mostrara la base de un dato numerico.

Vamos a tomar varios de estos y apliquemoslo en un ejemplo para ver como trabajan:

#include <iostream>

int main()
{
        char texto[] = "tinchicus.com";
        std::cout.put('B').put('l').put('o').put('g').put('\n');
        std::cout.width(20);
        std::cout << texto << std::endl;
        std::cout.width(20);
        std::cout.fill('*');
        std::cout << texto << std::endl;
        std::cout.write(texto, 9) << std::endl;

        return 0;
}

En este codigo aplicaremos algunas de las funciones anteriorrmente descriptas. La primera es put donde no solo pasamos un caracter sino que tambien realizamos una concatenacion con distintos put para formar una palabra, blog, y al final pasamos el caracter no solo de final sino de nueva linea. Lo siguiente es utilizar a width, lo cual incrementara el tamaño de los caracteres a mostrar para luego mostrar el valor en texto. Volvemos a aplicar un width y luego usamos a fill para rellenar los espacios nuevos que se agregaron y mostramos nuevamente a texto. Por ultimo, usamos a write para mostrar a texto pero le limitamos la cantidad de caracteres. Con esto comentado, compilemos y veamos que sucede con todas las funciones:

$ ./ios
Blog
       tinchicus.com
*******tinchicus.com
tinchicus
$

En el primer caso, vemos la palabra formada mediante los put. Luego tenemos las salidas donde aplicamos el width. En el primer caso solo vemos los espacios en blanco agregados y en el segundo caso los reemplazamos con los asteriscos enviados por fill. Y en el ultimo caso, observen como pudimos recortarlo mediante el limite de caracteres de write.

Con esto hemos complementado un poco mas sobre la libreria que estabamos utilizando, asi como tambien sobre algunas funciones adicionales que podemos utilizar tanto para cin como cout.

En resumen, hoy hemos visto a iostream, que es, para que sirve, que nos habilita en nuestros codigos, algunas funcionalidades extras para cin y cout, asi como tambien una serie de ejemplos para ver los distintos que comentamos. Espero les haya resultado de utilidad en tumblr, Twitter o Facebook para recibir una notificacion cada vez que subo un nuevo post en este blog, nos vemos en el proximo post.