Hola, sean bienvenidos a este post. Hoy hablaremos sobre flujos, como son y cual es su proposito. Nosotros hasta ahora hemos visto algunos ejemplos de flujos, cout y cin, con el primero imprimimos en pantalla y con el segundo le damos la posibilidad de ingresar un texto de pantalla a una variable, y todo esto por medio de la libreria iostream, esta es la encargada todos los estandares de entrada/salida de nuestros programas. Y cual es la ventaja de esto?, la portabilidad porque un programa hecho en C++ en un pc, puede ser compilado en una terminal sun (Unix) para su utilizacion o crearlo en la PC de la oficina y llevar el codigo a casa, compilarlo y continuar trabajando. Veamos un poco como trabaja la libreria iostream, primero hablaremos de encapsulacion: las clases provenientes de iostream ven el conjunto de datos como un flujo de datos, un byte detras de otro, supongamos esta situacion; si el destino es un archivo o la pantalla el origen por lo general es de una parte del programa, en cambio si el origen se inviertese el origen podria ser el teclado o un archivo del disco y ser ingresado en una variable. Los flujos encapsulan los problemas relacionados con el envio y recepcion de los datos desde y hacia el disco o la pantalla y una vez creado el flujo el programa trabaja con este y el flujo se encarga de los detalles. Nuestro siguiente paso es el almacenamiento en el buffer, en general escribir en un dispositivo, un disco o una pantalla, nos lleva a un problema de performance debido a que el programa debe estar constantemente escribiendo o leyendo de los dispositivos, por ejemplo el disco rigido, y para solucionar esto utilizamos el almacenamiento en el buffer, el proceso es asi: toda la informacion del flujo no se escribe en el disco sino es almacenada en un buffer donde una vez completo se volcara todo en el disco, una vez vacio este comienza nuevamente el proceso de almacenamiento. Como vimos hasta ahora tenemos flujos y buferes, vamos un poco mas en detalle las clases encargadas de las mismas:

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

Ahora hablaremos de los objetos estandar de E/S (Entrada/Salida), y sobre algunos utilizados ya por nosotros:

  • 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.

Hablemos un poco de redireccionar, como citamos en el caso de clog, el mensaje producido por el objeto clog puede ser redireccionado a un archivo, en lugar de la pantalla, y esto tambien se puede hacer con el resto de los objetos como por ejemplo cerr, donde el error en lugar de mostrarlo en pantalla podemos enviarlo a un archivo, es decir redireccionar significar enviar el resultado a un dispositivo distinto al predetermnado. La redireccion es similar a la de los sistemas operativos por linea de comando (Linux, Unix y DOS) donde el simbolo <  significa redirigir entrada, el simbolo > significa redirigir salida y  el simbolo | redirigir la salida hacia la entrada de un segundo programa, en conclusion la redireccion es algo mas propio del sistema operativo y la clase iostream nos permite trabajar con las mismas. Aunque ya lo hemos visto en posts anteriores, hablemos del objeto cin con el siguiente ejemplo:

flujos01.cpp

# include <iostream>

using namespace std;

int main()
{
int miInt;
double miDoble;
long miLong;
float miFloat;
unsigned miUnsigned;

cout << “int: “;
cin >> miInt;
cout << “double: “;
cin >> miDoble;
cout << “long: “;
cin >> miLong;
cout << “float: “;
cin >> miFloat;
cout << “unSigned: “;
cin >> miUnsigned;

cout << “\nInt: \t\t” << miInt << endl;
cout << “Double: \t” << miDoble << endl;
cout << “Long: \t\t” << miLong << endl;
cout << “Float: \t\t” << miFloat << endl;
cout << “unSigned: \t” << miUnsigned << endl;
return 0;
}

Como pueden ver es un ejemplo bastante sencillo, donde primero crearemos nuestras variables para almacenar lo ingresado a traves del teclado, luego viene un bloque donde tendremos un cout, el cual mostrara un texto en pantalla, seguido de un cin donde esperara el valor para almacenarlo en la variable para luego tener un bloque donde haremos una breve descripcion e imprimiremos en pantalla los valores almacenados de cada una de las variables, esto es la salida del ejemplo anterior:

$ ./program/flujos01
int: 2
double: 982919291
long: 22222
float: 3.33
unSigned: 22

Int: 2
Double: 9.82919e+08
Long: 22222
Float: 3.33
unSigned: 22

Cuando nosotros manejamos valores de tipos numericos no tendremos ningun inconveniente, nuestro mayor problema va a resultar cuando intentemos manejar cadenas para ingresarlas en una variable, por como pueden ver en el ejemplo anterior cuando sean cadenas de texto constantes, es decir un texto entre comillas despues del redireccionador <<, no nos genera grandes inconvenientes y cuando ingresemos un valor de tipo cadena tampoco siempre y cuando sea una sola palabra porque cin cuando encuentra un espacio lo considerara un final de linea e ignorara lo siguiente, por ejemplo si estuvieramos cargando nombres completos el segundo nombre no lo cargaria, es decir si ingresaramos Martin Humberto la variable solo recibira el valor de Martin ignorando completamente el segundo nombre, para evitar este incoveniente podriamos utilizar lo expresado en el siguiente ejemplo:

flujos02.cpp

# include <iostream>

using namespace std;

int main()
{
int miInt;
double miDoble;
long miLong;
float miFloat;
unsigned miUnsigned;
char miPalabra[ 50 ];

cout << “int: “;
cin >> miInt;
cout << “double: “;
cin >> miDoble;
cout << “long: “;
cin >> miLong;
cout << “float: “;
cin >> miFloat;
cout << “unSigned: “;
cin >> miUnsigned;
cout << “Palabra: “;
cin >> miPalabra;

cout << “\nInt: \t\t” << miInt << endl;
cout << “Double: \t” << miDoble << endl;
cout << “Long: \t\t” << miLong << endl;
cout << “Float: \t\t” << miFloat << endl;
cout << “unSigned: \t” << miUnsigned << endl;
cout << “Palabra: \t” << miPalabra << endl;

cout << “\nInt, Double, Long, Float, Palabra, Unsigned: “;
cin >> miInt >> miDoble >> miLong;
cin >> miFloat >> miPalabra >> miUnsigned;

cout << “\nInt: \t\t” << miInt << endl;
cout << “Double: \t” << miDoble << endl;
cout << “Long: \t\t” << miLong << endl;
cout << “Float: \t\t” << miFloat << endl;
cout << “unSigned: \t” << miUnsigned << endl;
cout << “Palabra: \t” << miPalabra << endl;

return 0;
}

Este ejemplo es similar al anterior pero solamente se agrega una variable nueva, un nuevo ingreso y un nuevo bloque para el llamado ingresos multiples, pasemos a ver en detalle, la nueva variable es: char miPalabra[ 50 ]; esta se encargara de almacenar una cadena de texto, la siguiente linea nueva es:

cout << “Palabra: “;
cin >> miPalabra;

Donde ingresaremos la palabra, despues vendra el bloque donde veremos todos los datos ingresados para tener nuevamente unas lineas para volver a ingresar nuevos en las variables:

cout << “\nInt, Double, Long, Float, Palabra, Unsigned: “;

cin >> miInt >> miDoble >> miLong;
cin >> miFloat >> miPalabra >> miUnsigned;

La primera linea se encargara de mostrar en pantalla, el orden en cual deberiamos ingresarlo y las otras dos lineas seran las encargadas de almacenar los variables en cada de una las variables, luego tenemos nuevamente el bloque donde se mostraran los valores cargados en las variables, veamos la salida asi les muestro el ejemplo:

$ ./program/flujos02
int: 2
double: 900020292721
long: 22222
float: 3.33
unSigned: 22
Palabra: Hola

Int: 2
Double: 9.0002e+11
Long: 22222
Float: 3.33
unSigned: 22
Palabra: Hola

Int, Double, Long, Float, Palabra, Unsigned: 4 8891019268834 33333 4.44 Adios 10

Int: 4
Double: 8.89102e+12
Long: 33333
Float: 4.44
unSigned: 10
Palabra: Adios

Como pueden ver en el primer bloque, van a estar las opciones para ingresar los valores a la variables, en el segundo bloque vemos los datos almacenados, en el tercer bloque volvemos a ingresar los nuevos valores pero observen como primero muestra la etiqueta con el orden y luego nosotros los ingresamos con un espacio, con esto cin entiende que cada valor va con la variable despues del redireccionador, para finalmente mostrar los nuevos valores almacenados en el cuarto bloque, como ven con esto podriamos solucionar el error comentado anteriormente sobre palabras separados con un espacio pero tampoco es la verdadera solucion, eso lo veremos un poco mas adelante, pero de esto podemos desprender que cin evalua cada contenido y lo asigna en el orden con el cual es recibido. Ahora pasemos a ver a la funcion miembro get() con el siguiente ejemplo:

flujos03.cpp

# include <iostream>

using namespace std;

int main()
{
char ch;
while((ch = cin.get()) != EOF)
{
cout << “ch: ” << ch << endl;
}
cout << “\nListo!\n”;
return 0;
}

Este es el modo mas basico de get() donde con esta forma solamente procesa un solo caracter, aunque a get() habitualmente no se lo usa de esta forma porque no nos permite concatenar variables como en el caso anterior porque no tiene un valor iostream pero para nuestro ejemplo y ver de forma basica nos viene ideal, en el ejemplo podemos ver como definimos una variable del tipo char, en este caso ch, despues vendra un bucle while() donde dira que ch es igual al obtenido por get() de cin y siempre y cuando sea distinto de EOF (End Of File), en el bucle nos imprimira el caracter recibido y se quedara ahi hasta que le demos un EOF, es decir utilizar un Ctrl+D (o Ctrl+Z en DOS) en donde nos imprimira el Listo!, vean la salida:

$ ./program/flujos03
Hola Mundo
ch: H
ch: o
ch: l
ch: a
ch:
ch: M
ch: u
ch: n
ch: d
ch: o
ch:

[ aca aprete el Ctrl+D ]

Listo!

Aca se ve como ingreso un texto, en este caso el mitico Hola Mundo, presiono Enter y el get() se encarga de desmenuzarlo a traves del bucle while(), si ingresaramos otro texto hubiera hecho exactamente lo mismo hasta ser apretado el EOF (Ctrl + D) para mostrarnos el Listo! y salir del programa, ahora veremos a get() con un caracter como parametro, analicemos el siguiente ejemplo:

flujos04.cpp

# include <iostream>

using namespace std;

int main()
{
char a, b, c;
cout << “Escriba tres letras: “;
cin.get(a).get(b).get(c);
cout << “a: ” << a << “\nb: ” << b << “\nc: ” << c << endl;
return 0;
}

En este ejemplo creamos tres variables (a,b,c) del tipo cadena, imprimimos una etiqueta donde pedimos el ingreso de tres letras, y observen como cada get() tiene asignada una variable, por ende en cada variable asignara el caracter en el orden informado, luego imprimira en pantalla el valor recibido, la salida es asi:

$ ./program/flujos04
Escriba tres letras: mhm
a: m
b: h
c: m

Como pueden ver asigno un caracter a cada variable, usandolo de esta forma podemos concatenar informacion, como hicimos antes, porque al tener una variable como parametro el valor vuelve a ser el de tipo iostream y por ejemplo nosotros hubieramos poder haber hecho esto:

cin.get(a) >> b >> c;

Ahora vamos a ahondar un poco mas en como usar get() y una nueva funcion miembro de cin, en este caso getline(), pasemos a ver el ejemplo:

flujos05.cpp

# include <iostream>

using namespace std;

int main()
{
char cadenaUno[ 256 ];
char cadenaDos[ 256 ];
char cadenaTres[ 256 ];

cout << “Escriba la cadena Uno: “;
cin.get(cadenaUno, 256);
cout << “Cadena Uno: ” << cadenaUno << endl;
cout << “Escribe la caddena Dos: “;
cin >> cadenaDos;
cout << “Cadena Dos: ” << cadenaDos << endl;
cout << “Escribe la cadena Tres: “;
cin.getline(cadenaTres, 256);
cout << “Cadena Tres: ” << cadenaTres << endl;
return 0;
}

En este ejemplo vamos a ver las tres formas de carga por medio de cin, primero creamos tres variables, en el primer caso utilizaremos get() donde lo guardaremos en la primer variable, cadenaUno, y le decimos el tamaño de la misma, luego utilizaremos el operador de extraccion para cargar la segunda variable, cadenaDos, y por ultimo utilizaremos getline() para cargar nuestra tercer variable, cadenaTres, veamos la salida del programa:

$ ./program/flujos05
Escriba la cadena Uno: uno dos tres
Cadena Uno: uno dos tres
Escribe la caddena Dos: cuatro cinco seis
Cadena Dos: cuatro
Escribe la cadena Tres: Cadena Tres: cinco seis

Como pueden ver, cuando llenamos a cadenaUno este es perfectamente impreso en la siguiente linea, esto gracias al get() porque con este metodo donde definimos la variable y el tamaño a almacenar, y este va a llenar la variable hasta el limite establecido o si encuentra el caracter de finalizacion, lo que ocurra primero. En el segundo caso, al usar el operador de extraccion cuando encuentra el espacio en blanco lo toma como un caracter de finalizacion por ende muestra el valor asignado y pasa a la siguiente linea, en este caso para ingresar el valor a la cadenaTres, y como la linea anterior sigue cargada en el buffer este lo transferira automaticamente por medio del getline() y nunca dara la posibilidad de completar esta variable por medio del usuario, la diferencia entre get() y getline() es que en el primero no ignora el caracter de terminacion y en el segundo caso si. Ahora veremos como evitar el inconveniente antes mencionado, la imposibilidad de cargar la tercer variable por el usuario, por medio del metodo propio de cin llamado ignore(), veamos el ejemplo y luego lo analizamos:

flujos06.cpp

# include <iostream>

using namespace std;

int main()
{
char cadenaUno[ 255 ];
char cadenaDos[ 255 ];

cout << “Escriba cadena Uno: “;
cin.get(cadenaUno, 255);
cout << “Cadena Uno: ” << cadenaUno << endl;
cout << “Escriba cadena Dos: “;
cin.getline(cadenaDos, 255);
cout << “Cadena Dos: ” << cadenaDos << endl;
cout << “\nAhora intentenlo de nuevo!!” << endl;
cout << “Escriba Cadena Uno: “;
cin.get(cadenaUno, 255);
cout << “Cadena Uno: ” << cadenaUno << endl;
cin.ignore(255, ‘\n’);
cout << “Escriba Cadena Dos: “;
cin.getline(cadenaDos, 255);
cout << “Cadena Dos: ” << cadenaDos << endl;
return 0;
}

En este ejemplo vamos a crear dos variables, luego vamos a completar la primera pero nos volvera a ocurrir el error anterior porque volvera a omitir el ingreso a cadenaDos, porque sigue almacenado en el buffer el caracter de salida, para evitar esto volveremos a ingresar un valor a cadenaUno pero ahora usaremos la siguiente linea:

cin.ignore(255, ‘\n’);

Esta se encargara de omitir todos los caracteres hasta la posicion indicada y el caracter de salida, permitiendonos poder ingresar el valor de cadenaDos como se ve en la salida:

$ ./program/flujos06
Escriba cadena Uno: Habia una vez
Cadena Uno: Habia una vez
Escriba cadena Dos: Cadena Dos:

Ahora intentenlo de nuevo!!
Escriba Cadena Uno: Habia una vez
Cadena Uno: Habia una vez
Escriba Cadena Dos: una princesa
Cadena Dos: una princesa

Como pueden ver el primer bloque todavia nos refleja el error provocado por el buffer, en el segundo bloque podemos ver como el problema se soluciono gracias al ignore() porque este metodo nos permite limpiar el buffer del caracter informado, en este caso la nueva linea (\n), y por ende getline() nos va a permitir llenar la variable cadenaDos con la informacion deseada, ignore() no tiene que ir al final del archivo sino podemos definir hasta donde, por ejemplo podriamos haber hecho ignore(80, ‘\n’) y esto omitiria hasta la posicion 80 y luego continuaria hasta encontrar el caracter a limpiar. Ahora veremos los ultimos dos metodos adicionales de cin a traves del siguiente ejemplo:

flujos07.cpp

# include <iostream>

using namespace std;

int main()
{
char ch;
cout << “Escriba una frase: “;
while(cin.get(ch))
{
if (ch == ‘!’)
cin.putback(‘$’);
else
cout << ch;
while(cin.peek() == ‘#’)
cin.ignore(1, ‘#’);
}
return 0;
}

En este ejemplo vemos los dos ultimos metodos adicionales de cin, estos son putback() y peek(), vamos a crear una variable de tipo array de caracteres, despues escribiremos una frase, luego por medio del ciclo while() leeremos la frase ingresada y usaremos un condicional donde verificara si ch es igual al signo de admiracion (!) y en caso afirmativo lo reemplazara con el signo de pesos ($) de lo contrario imprime el caracter de ch luego mediante un bucle while() chequearemos si cin es igual a numeral (#) procede a ignorarlo una vez terminado el ciclo quedara esperando por mas entradas, si escribimos otra frase sera reemplazada por lo explicado anteriormente y de la unica forma de salir es por medio de Ctrl+D, veamos la salida:

$ ./program/flujos07
Escriba una frase: Hola#Mundo#!
HolaMundo$
Hola#Mundo!de!Nuevo!
HolaMundo$de$Nuevo$

Como pueden ver en la salida, se ingresa una frase y luego del enter este reemplaza el signo de admiracion (!) con el signo de pesos ($) y el signo numeral (#) se lo omite, si ingresamos otra frase se vuelve a cambiar los caracteres antes mencionados y podriamos agregar hasta el infinito y solo se terminara cuando presionemos Ctrl+D, ahora hablemos un poco mas de los metodos:

  • peek(), se fija en el siguiente caracter y no lo extrae, como en el ejemplo lo utilizamos para ignorarlo.
  • putback(), se encarga de insertar un caracter en el flujo de entrada, en el ejemplo lo usamos para reemplazar un caracter.

Si bien este no es el mejor ejemplo para mostrar estos comandos si es el mas practico para verlo de manera simple porque si el numeral (#) estuviera al principio no lo modificaria, hasta aqui vimos como trabaja cin y los metodos mas utilizados pasemos a ver el metodo cout. Hasta ahora hemos visto el modo mas basico de cout donde solamente lo utilizamos para mostrar cadenas, numeros y otras representaciones pero ahora pasaremos a ver como podemos formatear la salida de la misma, cuando nosotros usamos el metodo endl no solamente le damos el fin de linea sino tambien limpiamos el buffer porque este metodo tambien llama al metodo flush() y nosotros podemos llamarlo directamente por la siguiente forma:

cout << flush;

Esto es unicamente para cerciorarse de la limpieza del buffer y en pantalla se vea unicamente el contenido. Como vimos en cin, cout tambien tiene otros metodos para imprimir en pantalla mas alla de operador de extraccion, estas son put() y write(). Veamos la funcion de put() con el siguiente ejemplo:

flujos08.cpp

# include <iostream>

using namespace std;

int main()
{
cout.put(‘H’).put(‘o’).put(‘l’).put(‘a’).put(‘\n’);
return 0;
}

Este ejemplo bien simple nos mostrara en pantalla la palabra hola, como pueden ver el put() nos imprime unicamente un caracter en este caso el informado entre parentesis pero como es del tipo ostream nos permite concatenarlo como se ve en la linea y esto nos armara la linea y como el ultimo put() tiene el caracter de nueva linea dara el enter final. Ahora veamos el siguiente ejemplo para ver como funciona el metodo write():

flujos09.cpp

# include <iostream>
# include <string.h>

using namespace std;

int main()
{
char Uno[] = “Uno, si por tierra”;
int longitudCompleta = strlen(Uno);
int muyCorta = longitudCompleta – 4;
int muyLarga = longitudCompleta + 4;

cout.write(Uno, longitudCompleta) << “\n”;
cout.write(Uno, muyCorta) << “\n”;
cout.write(Uno, muyLarga) << “\n”;

return 0;
}

Con el metodo write() podremos imprimir el texto almacenado pero a su vez podremos formatearlo, por ejemplo nosotros creamos tres variables donde en la primera se almacenara la longitud total de la variable con el texto (longitudCompleta), tendremos otra variable mas corta donde le restaremos cuatro a la longitud total y finalmente otro mas largo donde incrementaremos el valor de la longitud total. En las siguientes lineas, imprimiremos mediante el cout y el metodo write(), veamos la salida:

$ ./program/flujos09
Uno, si por tierra
Uno, si por ti
Uno, si por tierr#$&

Como vemos la primera salida nos muestra la linea completa, porque usamos la longitud total, en el segundo caso lo recorta porque utilizamos la variable con la longitud mas corta y por ultimo en este caso nos imprimira basura al final porque utilizamos la variable con una mayor longitud, los ultimos caracteres pueden variar o tener efectos diferentes, como por ejemplo limpiarte la pantalla. Ahora hablaremos un poco sobre como podemos dar formato a la salida de cout. Vamos a ver el siguiente ejemplo para ver los distintos tipos de formateadores:

flujos10.cpp

# include <iostream>
# include <iomanip>

using namespace std;

int main()
{
const int numero = 185;

cout << “El numero es ” << numero << endl;
cout << “El numero en hexa es ” << hex << numero << endl;
cout.setf(ios::showbase);
cout << “El numero en hexa es ” << hex << numero << endl;
cout << “El numero en hexa es “;
cout.width(10);
cout << hex << numero << endl;
cout << “El numero en hexa es “;
cout.width(10);
cout.fill(‘*’);
cout << hex << numero << endl;
cout << “El numero en hexa es “;
cout.width(10);
cout.fill(‘ ‘);
cout.setf(ios::left);
cout << hex << numero << endl;
cout << “El numero en hexa es “;
cout.width(10);
cout.setf(ios::internal);
cout << hex << numero << endl;
cout << “El numero es: ” << setw(10) << hex << numero << endl;

return 0;
}

En este caso vamos a ser un listado de todos los formateadores, primero veamos la salida del programa:

$ ./program/flujos10
El numero es 185
El numero en hexa es b9
El numero en hexa es 0xb9
El numero en hexa es 0xb9
El numero en hexa es ******0xb9
El numero en hexa es 0xb9
El numero en hexa es            0xb9
El numero es:           0xb9

Ahora veamos caso por caso de como trabajan los formateadores de salida:

  • hex, en este caso transforma el numero en hexadecimal, la salida es: El numero en hexa es b9.
  • setf(ios::showbase), es el encargado de mostrar la base del numero convertido, en este caso el hexadecimal, la salida es: El numero en hexa es 0xb9.
  • width(10), establece el ancho del texto a mostrar, donde 10 puede ser un valor n si este es mayor al valor a mostrar adicionara espacio adicional y si es menor no adicionara nada.
  • fill(‘*’), este se encargara de completar el espacio sobrante con el caracter informado, en este caso asterisco (*), y esta relacionado con width().
  • setf(ios::left), esta opcion nos permitira ubicar el texto a la izquierda, en el ejemplo establecimos un ancho de diez pero al estar alineado a la izquierda no se ve el corrimiento.
  • setf(ios::internal), esta opcion setea la ubicacion al valor interno por defecto, es decir a la derecha.
  • setw(10), esta opcion establece el ancho con un valor de diez.

Como se pudieron ver en este ejemplo, estos son los distintos metodos para poder dar un mejor formato a la salida producida por cout, tambien vimos como definir las salidas de tipo iostream, esta nos permitira mostrar algunas caracteristicas, como la base de un numero (setf(ios::showbase)), el signo positivo de un numero (setf(ios::pos)), con esto damos por terminada la primera parte de flujos, hemos visto con mas detalle a cin y cout, los cuales los hemos estado viendo en todos nuestros programas pero nunca nos detuvimos a ver como funcionaba y cuales otros metodos propios se pueden utilizar con estas dos funciones. Hagamos un breve resumen de las dos funciones vistas

cin

  • Operador >>, es el metodo mas basico utilizado por nosotros hasta ahora donde solo ingresara el valor, lo malo de este metodo es que considera al espacio como caracter de salida por esto no lo podemos usar para almacenar una frase porque solo guardara la primera palabra.
  • get(), este es el siguiente metodo para tomar informacion toma un solo caracter, si se lo deja vacio sigue con la misma funcion pero dejara de ser un valor iostream y por ende pierde el concatenado, si le agregamos una variable (get(a)) vuelve a obtener la posibilidad de concatenar por volver a ser clase iostream y por ultimo la version final de get() podemos definir una variable, el tamaño de la variable y el caracter de terminacion (\n) pero este ultimo es opcional porque se toma como valor predeterminado.
  • getline(), trabaja exactamente igual al tercer metodo de get() pero la diferencia va a estar en que este ignora el caracter de terminacion.
  • ignore(), es utilizado para ignorar una x cantidad de caracteres definidos en el primer parametro y el segundo parametro es el encargado de informar cual va a ser omitido.
  • peek(), se fija cual es el siguiente caracter pero no lo extrae y puede asociarse con una accion, por ejemplo ignore()
  • putback(), este inserta un caracter en el flujo de entrada, se puede usar para reemplazar un caracter.

cout

  • Operador <<, 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 pero 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.

Hasta aqui hemos terminado la primera parte del manejo de informacion a traves de flujos, hemos visto por arriba como trabaja en el ordenador y con el lenguaje, a sus funciones mas basicas, las cuales hemos estado utilizando hasta ahora, otras formas de cargar nuestra informacion y tambien como ordenar la salida de como mostrarlo en pantalla, en la segunda parte hablaremos sobre printf(), como manipular los archivos y algunas otras funciones mas. Espero les haya sido util, nos vemos en el proximo post.

Anuncios