MÓDULO

Área: TECNOLOGÍA

4 Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA)

Módulo: Programación avanzada C++
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA)

Programación avanzada C++

Índice

Introducción ......................................................................................................................................................... 1
1. Flujos en C++................................................................................................................................................. 2
1.1. Concepto .............................................................................................................................................................. 2
1.2. Librería iostream .................................................................................................................................................. 3
1.3. Operadores ........................................................................................................................................................... 4
2. Salida con formato...................................................................................................................................... 13
2.1. Clase ios .............................................................................................................................................................. 13
2.2. Manipuladores ................................................................................................................................................... 18
Cierre .................................................................................................................................................................. 20
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA)

Programación avanzada C++

Mapa de Contenido

Programación
avanzada C++

Flujos en C++ Salida con formato

Concepto Clase ios

Librería iostream Manipuladores

Operadores
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 1

Programación avanzada C++

RESULTADO DE
Crea un programa computacional complejo utilizando características
APRENDIZAJE
avanzadas de C++, para resolver un problema dado.
DEL MÓDULO

Introducción
La práctica profesional de la programación implica manejar distintos niveles de programación. C++ se enfoca
en los niveles medios y bajos gracias a la amplia gama de librerías y funciones de acceso a bajo nivel que
proporciona. Estas funciones permiten leer documentos provenientes de fuentes tan distintas como
procesos industriales, comerciales, además de interacciones con Internet. Luego de efectuar la lectura del
documento, su contenido puede procesarse con funciones proporcionadas por distintas clases y generar la
salida en el formato que se desee. Conocer estas “prestaciones” del lenguaje permite mejorar las
oportunidades de empleo al programador que las maneje, especialmente en empresas que trabajan con
código de bajo nivel escrito en C++ o, incluso, en C.

La ampliación del lenguaje C considerando la orientación al objeto, permite utilizar C++ para mejorar la
productividad, siendo este uno de sus principales objetivos. C++ está diseñado para ser práctico, pues el
diseño del lenguaje C++ está pensado para proveer herramientas útiles y claras para el desarrollo y
programación de código de alto desempeño, haciendo uso de una serie de herramientas que destacamos a
continuación.

En primer lugar, el lenguaje está diseñado para ayudarte en todo lo posible para el desarrollo del código,
mediante la incorporación de funciones ya programadas. C++ deja fuera una serie de reglas arbitrarias
usadas en C, sobre todo, los aspectos relacionados con la asignación de memoria. C++ ha eliminado muchos
“agujeros” de su antecesor, el lenguaje C, ofreciendo un mejor control de tipos y análisis en tiempo de
compilación. También obliga a declarar funciones, de modo que el compilador pueda evaluar y controlar su
uso.

Por otra parte, C++ incorpora una serie de características que C no posee. El uso de referencias permite un
manejo más conveniente de direcciones para parámetros de funciones y retorno de valores. Manejo de
nombres, a través de la llamada sobrecarga de funciones, permite usar el mismo nombre para diferentes
funciones. Los espacios de nombres, llamados namespaces, también mejoran la seguridad respecto a C.

SABER MÁS

La suite de aplicaciones Adobe, que incluye herramientas que se han transformado en

el estándar para el diseño gráfico, diseño web, audiovisual, edición musical y otros, se
encuentra programada enteramente usando C++ desde sus primeras versiones hasta la
actualidad.
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 2

Programación avanzada C++

1. Flujos en C++
1.1. Concepto
En C++, el stream o flujo es utilizado para señalar un concepto abstracto a través del cual datos sin estructura
pueden enviarse en forma unidireccional o bidireccional desde un programa. Estos flujos se consideran una
construcción de I/O a bajo nivel, y se encuentran definidos mediante un conjunto de clases que se distribuye
en la librería estándar de C++.

En él módulo anterior hablamos de iostream indicando algunas funciones de I/O como cout y cin. En este
módulo profundizaremos en el concepto de stream, indicando que un programa C++ visualiza entrada o
salida como un flujo que extrae bytes desde alguna fuente de entrada, o un flujo que inserta bytes en un
flujo de salida respectivamente. Así, un flujo se puede considerar como una secuencia de bytes que lleva
datos o información. Los bytes pueden formar una cadena de datos de tipo carácter o tipo numérico. La
entrada puede ser, por ejemplo, un teclado, o también pueden provenir desde otro dispositivo de
almacenamiento como un disco pendrive u otro programa. De forma análoga los bytes del flujo de salida
pueden ir a un monitor, una impresora, a un archivo, o también a otro programa. Esta manera de ver los
streams en general, permite que un programa C++ trate la entrada desde un dispositivo como un escáner, de
igual forma que se trata la entrada desde un archivo. El programa examina simplemente el flujo, sin
necesidad de saber cuál es el origen de este. Lo mismo ocurre con la salida, el programa la genera, sin
conocer a donde van destinados los bytes.}

Ahora, si los datos se transfieren sin modificarse, la operación de I/O es llamada “sin formato”. Por el
contrario, si los datos se modifican en la transferencia, por ejemplo se “formatea” la salida a texto, la
operación de I/O se llama “con formato”. La librería iostream soporta ambos tipos de operaciones y permite
que el desarrollador controle y manipule las operaciones específicas de formateo mediante el uso de
manipuladores. La librería iostream emplea para las operaciones de I/O buffers. Un buffer es un área de
memoria que se emplea como almacenamiento temporal o intermedio para la transferencia de datos desde
un dispositivo a un programa o viceversa. En la siguiente imagen podrás aclarar los conceptos antes
presentados.
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 3

Programación avanzada C++

1.2. Librería iostream
La librería iostream es la librería de I/O estándar en C++. El acceso a esta librería se realiza mediante una
directiva include <iostream>. El sistema de I/O en C++ está pensado para trabajar con diferentes dispositivos
y cada uno se trata como un dispositivo virtual o lógico, llamado stream, conformando cada uno el punto de
unión o interfaz entre el programa y el dispositivo. A este sistema de I/O se le llama sistema de
entrada/salida a través de buffers.

La estructura de los datos que se envían y reciben desde los distintos dispositivos puede variar, pero los
flujos se comportan siempre de la misma forma y todos se almacenan en áreas intermedias de memoria. Los
flujos predefinidos en C++ corresponden a las funciones de entrada/salida ya vistas en el módulo 3, pero
volveremos a presentarlas para indicar información adicional. Revisemos la siguiente imagen.
pertenece
Clase que

istream ostream
(entrada) (salida)
Nombre
flujo

cin cout cerr clog

Flujo de entrada Flujo de salida Flujo de salida de

estándar (teclado) estándar error están-dar no Flujo de error
(monitor) almacenado en el estándar a través
Tipo de

búfer. Se emplea del buffer. Este

flujo

para visualizar flujo es más

mensajes de error adecuado para
grandes
cantidades de
mensajes de error

Los streams se asocian a los programas con I/O por consola, pero pueden ser redirigidos a archivos o
dispositivos sin problemas. Los streams se abren y cierran de forma automática; antes de que la función
main se ejecute, y después que la función main haya terminado. Por lo tanto, no es necesario de abrirlos o
cerrarlos.

La librería iostream está formada por un elevado número de funciones (unas 250 funciones) y por unas 20
clases, aproximadamente. Esta librería está compuesta por varios archivos de cabecera (archivo .h). El
detalle se muestra en la siguiente tabla:
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 4

Programación avanzada C++

Nombre archivo Contenido / uso
• Información básica requerida para todos los flujos de I/O
• Contiene las funciones cin, cout, cerr y clog
iostream.h
• Proporciona capacidades de I/O con o sin formato
• Contiene los manipuladores de uso común
• Contiene la información necesaria para las operaciones de procesamiento de archivos
fstream.h
controlados por el usuario
• Contiene la información necesaria para realizar operaciones con string (cadenas)
strstream.h

• Contiene la información necesaria para realizar I/O formateada con los manipuladores de
iomanip.h
flujo
• Se usa cuando se mejora un programa ya escrito en C usando código escrito en C++
stdiostream.h

1.3. Operadores
En C++ la entrada y salida se realiza mediante los operadores << (inserción) y >> (extracción). El operador
<< reconoce todos los tipos básicos de C++, además del tipo string. Los tipos soportados son:

char ℤ int ℝ double

short ℤ long string

Clase ostream y endl

La clase ostream proporciona una implementación para cada uno de los tipos anteriores. El operador de
inserción corresponde a un operador binario que retorna una referencia a un objeto de tipo ostream.

EJEMPLO

El siguiente código muestra una implementación que usa este operador:

void usoInsercion(std::string asignatura, int bimestre)

{
std::cout << "El nombre de la asignatura es " << asignatura
<< " y corresponde al bimestre " << bimestre << std::endl;
}
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 5

Programación avanzada C++

En este código aparece una secuencia de caracteres que no habíamos visto: el manipulador endl cumple la
función de la secuencia de escape “\n”, además de vaciar el buffer asociado. Se prefiere al uso de dicha
secuencia.

Función put

Además de las funciones del operador de inserción, la clase ostream proporciona la función put para mostrar
caracteres e insertarlos en el flujo.

EJEMPLO

Puedes ver el funcionamiento de la función put en el siguiente código:

void pruebaPut(char c1, char c2, char c3, int n )

{
std::cout.put(c1).put(c2).put(c3).put(n) << std::endl;
}

Nótese que pueden usarse tanto caracteres como enteros en los parámetros de la función put, pero el
resultado mostrado será siempre en caracteres. Como decíamos en el módulo anterior, los caracteres se
representan internamente como números enteros. En consecuencia, pasar un entero a la función put,
generará el carácter correspondiente a la “posición” indicada por el entero, correspondiente al código de
caracteres ASCII (American Standard Code for Information Interchange).

En la siguiente tabla puedes ver algunos de los caracteres indexados en el código ACSII.

Valor Carácter Valor Carácter

1 ☺ 145 æ
2 ☻ 146 Æ
3 ♥ 147 ô

4 ♦ 148 ö

5 ♣ 149 ò

6 ♠ 150 û

7 “beep” (sonido) 151 ù

… … … …
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 6

Programación avanzada C++

Función write, srtlen y puntero

La función write se utiliza para insertar una secuencia de caracteres, o mostrando cadenas, en el flujo.
Recibe dos parámetros: el primero corresponde a un puntero a una secuencia de caracteres, y el segundo, el
largo de la secuencia.

EJEMPLO

Puedes ver el funcionamiento de la función write en el siguiente código:

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

void pruebaWrite(char* secuencia)

{
int largo = strlen(secuencia);
std::cout.write(secuencia,largo);
}

Para obtener el largo de la secuencia de caracteres, hemos usado la función srtlen(secuencia_caracteres)

que retorna el número de caracteres de una secuencia. strlen pertenece a la librería de cabecera string.h, la
cual debe incorporarse al código mediante una directiva include.

Un puntero, indicado con * (asterisco) es una variable entera que señala una dirección de memoria. Es
decir, el puntero indica la ubicación en memoria de la variable. En el caso del ejemplo anterior, char*
secuencia, el puntero char* indica la dirección en memoria del primer carácter de la secuencia, puesto que
char es un tipo para declarar caracteres individuales, y por tanto, no podría almacenar varios caracteres a la
vez. En el siguiente ejemplo puedes ver una declaración válida de puntero:
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 7

Programación avanzada C++

EJEMPLO

El siguiente ejemplo muestra una declaración válida de puntero:

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

int main()
{
//caracter es un puntero al primer caracter de la cadena
char* caracter = "Hoy es sábado ... qué bueno";

//obtenemos el tamaño de la secuencia

int largo = strlen(caracter);

//mostramos los caracteres que están en posiciones pares dentro de

la secuencia
int posicion = 0;
while(posicion<largo)
{
if(posicion%2==0)
std::cout << caracter[posicion] << std::endl;

posicion++;
}
return 0;
}
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 8

Programación avanzada C++

Operador de extracción >>

El operador de extracción >> tiene como función leer datos de un flujo de entrada, usando comúnmente la
función cin. El símbolo >> señala la dirección del flujo, y lee los datos hasta que encuentra uno que no es del
tipo requerido, como tabuladores o retorno de carro por ejemplo. Este operador se puede utilizar en una
serie de entradas, lo que normalmente se llama cascada.

EJEMPLO

Puedes ver el funcionamiento de >> en el siguiente código:

#include <iostream>

int main()
{
std::cout << "Ingrese caracteres con Enter " <<
"hasta completar cinco para terminar" << std::endl;

int numero = 5;
int contador = 1;
char c;

while(std::cin >> c && contador++ < numero)

{
std::cout << c;
}

return 0;
}

En este código, la función cin inserta caracteres dentro de la instrucción while hasta que la condición del
número de caracteres (5) ya no se cumple.
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 9

Programación avanzada C++

Función get y getline

Dentro de las librerías, la clase istream contiene la función get que permite la captura de cadenas de
caracteres, incluyendo espacios en blanco. Esta función no realiza conversiones de tipos, simplemente
captura una cadena de caracteres de entrada, y los coloca en alguna variable. Por ejemplo:

EJEMPLO

#include <iostream>

int main()
{
std::cout << "Escriba una palabra o frase de 16 caracteres" <<
std::endl;
int largo = 16;
char cadena[largo];

std::cin.get(cadena,largo);
std::cout << "Lo que ingresaste fue: " << cadena << std::endl;

return 0;
}

La clase istream contiene también la función getline, similar a get, pero con la diferencia que getline elimina
el carácter de terminación de la entrada del buffer ('\0'), mientras que get, lo deja. La función get puede ser
problemática, ya que deja el carácter de terminación de la entrada en el buffer, y este se toma en la siguiente
instrucción de entrada de datos. Vea los siguientes códigos y compare los resultados de usar get o getline,
cuando se ingresan las cadenas “hola,…” y “como, está?”.
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 10

Programación avanzada C++

EJEMPLO

#include <iostream>

int main()
{
std::cout << "Escriba una cadena de caracteres" << std::endl;
char cadena1[12];
std::cin.get(cadena1, 12);

std::cout << "Escriba una segunda cadena de caracteres" << std::endl;

char cadena2[12];
std::cin.get(cadena2, 12);

std::cout << "Lo que ingresaste fue: " << cadena1 << " y " << cadena2 <<
std::endl;

return 0;
}

La salida de este código es “Lo que ingresaste fue: hola, .. y .”. Es decir, no permitió que se ingresará la
segunda cadena, ya que el carácter de término de la entrada quedo en el buffer, impidiendo que la segunda
cadena pudiera siquiera leerse. En comparación, este otro código:

EJEMPLO

#include <iostream>

int main()
{
std::cout << "Escriba una cadena de caracteres" << std::endl;
char cadena1[12];
std::cin.getline(cadena1,12);

std::cout << "Escriba una segunda cadena de caracteres" << std::endl;

char cadena2[12];
std::cin.getline(cadena2,12);

std::cout << "Lo que ingresaste fue: " << cadena1 << " y " << cadena2 <<
std::endl;

return 0;
}

Tiene como salida: “Lo que ingresaste fue: hola,... y como, esta?”, que es la salida esperada.
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 11

Programación avanzada C++

>> Librería fstream

La función read lee un cierto número de bytes (o caracteres) guardándolos en una variable puntero tipo
char. Por:

EJEMPLO

#include <iostream>
//librería para leer y escribir en archivos
#include <fstream>

int main()
{
//declaramos un objeto ifstream apuntando a "archivo.txt"
std::ifstream flujo ("archivo.txt", std::ifstream::binary);

if(flujo)
{
//obtenemos el tamaño del archivo
flujo.seekg(0,flujo.end);
int largo = flujo.tellg();
flujo.seekg(0,flujo.beg);

//creamos un puntero a un arregllo de caracteres para almacenar

la lectura
char * caracteres = new char[largo];

//guardamos la lectura en el arreglo

flujo.read(caracteres,largo);

//mostramos lo leído
int i = 0;
while(i<largo)
std::cout << "Caracter: " << caracteres[i++] << std::endl;
}
else
std::cout << "No se pudo crear el flujo";

return 0;
}
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 12

Programación avanzada C++

Lo primero que hacemos en este ejemplo es incluir la librería fstream y con ella podremos declarar objetos
de tipo ifstream para manipular archivos. La declaración de un objeto ifstream incluye dos parámetros: el
nombre del archivo a manipular y su tipo. Los tipos posibles son “texto” y “binario”. La lectura/escritura de
archivos de texto está limitada a un rango de valores por byte que pueden leerse (no todos los bytes podrán
leerse), mientras que el tipo binario no tiene restricciones respecto de los valores de bytes a leer.

A continuación, preguntamos si el objeto ifstream pudo crearse correctamente. Para ello, usamos la
instrucción if, que tendrá un valor distinto de cero si fue creado correctamente.

Luego debemos determinar el tamaño del archivo. Para ello usamos las funciones seekg y tellg. La función
seekg “setea” la posición del carácter que debe ser leído desde el stream, y como se ve en el código
flujo.seekg(0,flujo.end), la primera posición es cero (0) y la última, es el final del stream (flujo.end). La función
tellg entrega la posición actual del byte a ser leído, por tanto, con la llamada anterior a seekg, la posición del
byte quedo al final del stream, y el valor entregado será el número de bytes a leer.

Finalmente, se llama nuevamente a seekg, pero colocando la posición a ser leída en flujo.beg (begin), es
decir, al comienzo del archivo. Con el número de bytes a ser obtenido en las instrucciones anteriores,
declaramos un puntero a un arreglo de caracteres de tamaño largo, que usamos para leer el flujo (stream)
con la función read y dejar los bytes en el arreglo. Finalmente mostramos los caracteres (bytes)
almacenados en el arreglo.
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 13

Programación avanzada C++

2. Salida con formato
2.1. Clase ios
La clase ios proporciona la mayoría de las funciones para dar formato a la salida. Así se entregan funciones
para la anchura del campo, el número decimales de cifras numéricas, el carácter de relleno, entre otras.
Todas ellas nos permitirán editar datos de acuerdo a nuestras necesidades.

Función width

Para manipular el ancho del campo de texto existe la función width, que se puede usar con o sin un
parámetro entero. Cuando hablamos de una misma función que tiene varias implementaciones, estamos
diciendo que la función tiene una sobrecarga (polimorfismo) y que tiene varios prototipos. En el caso de la
función width, serían dos prototipos, que los veremos a continuación.

1 int width(); //informa el ancho actual del campo

2 int width(int i); //establece el ancho del campo

El primero de ellos informa el estado actual del ancho del campo, mientras que el segundo establece el ancho
del campo a i caracteres, y devuelve el valor de la anchura anterior.

La función width utiliza un objeto, por lo que puede ser usada con cout y cin. Cuando se emplea con cin,
limita el número de caracteres que se van a leer. Por otra parte, cuando se utiliza con cout, si el contenido
de la variable es menor que la anchura fijada del campo, se visualizará el contenido de dicha variable
justificado a la derecha en un campo de longitud igual a la que se haya fijado, y el resto del campo se
rellenará con espacios. Si por el contrario, la longitud del contenido de la variable es mayor que la longitud
del campo, se ignora la configuración de width y se muestra el valor completo de la variable. Por tanto,
nunca se pierde información. El valor por defecto para él ancho es 0. Esto no significa que no se tenga
reservado espacio para la salida de la variable, sino que se utilice el mínimo número de caracteres necesarios.
Después de cada inserción width se inicia a 0.
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 14

Programación avanzada C++

Librerías stdlib y time

EJEMPLO

El siguiente código genera una lista de números aleatorios enteros mediante la función rand
perteneciente a la librería stdlib.

#include <iostream>
#include <stdlib.h>
#include <time.h>
#define LARGO 16

int main()
{
double numeros[LARGO];
//inicializar los números aleatorios
int segundos = time(NULL);
srand(segundos);

//llenamos el arreglo numeros con valores aleatorios

for(int i=0; i<LARGO; i++)
//asignar el número aleatorio
numeros[i] = rand();

//salida sin formato width

for(int contador=0; contador<LARGO; contador++)
std::cout << numeros[contador] << std::endl;

std::cout << "----------------------------\n";

//salida con formato width

for(int contador=0; contador<LARGO; contador++)
{
//establecer el formato justificado a la derecha
std::cout.width(6);
std::cout << numeros[contador] << std::endl;
}

return 0;
}
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 15

Programación avanzada C++

Para generar números aleatorios, primero debemos incluir las librerías necesarias; stdlib.h para la función
rand (random o aleatorio) y time.h para la función time. La función rand genera un número aleatorio
comprendido entre 0 y la constante RAND_MAX (depende la librería, pero como mínimo es 32767). Mientras
que la función time (time(NULL)) devuelve normalmente el número de segundos transcurridos desde las
00:00 hrs. del 01/01/1970.

Volviendo al código, inicializamos los números aleatorios mediante la instrucción srand(time(NULL)).

Alternativamente se pudo haber usado, en vez de time(NULL), cualquier número entero, pero regla se usa el
valor que devuelve time(NULL). A continuación almacenamos los números aleatorios en el arreglo numeros,
para luego mostrarlos los valores sin formato. Finalmente se formatean los números usando la instrucción
cout.width(6), lo que significa que los valores serán justificados a la derecha, usando un campo de ancho 6
caracteres. La salida del programa se muestra en la siguiente figura:

01
Función precision

Cuando se desea establecer el número de dígitos (incluidos los decimales) se utiliza la función precision. Sus
prototipos son:

1 int precision ();

2 int precision (int);

 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 16

Programación avanzada C++

El primer prototipo corresponde a la función que retorna el valor de la variable de estado de precisión
(número de dígitos). El segundo prototipo representa la función que fija la precisión a un valor determinado,
y devuelve el estado anterior. El valor por defecto es 0, y significa que los números se representan hasta con
6 dígitos (incluyendo los decimales), y si el número tiene más decimales, el último dígito se redondea. Puedes
ver lo anterior en el siguiente ejemplo.

EJEMPLO

#include <iostream>

int main()
{
//declaramos el número pi con el mayor número de decimales
//que entrega el computador
double pi = 3.1415926535897932384626433832795;

//mostramos la precisión por defecto

std::cout << "La precision por defecto es: " <<
std::cout.precision() << " decimales " << std::endl;

//mostramos pi con distintas precisiones

for(int i=1; i<=23; i++)
{
std::cout.precision(i);
std::cout << "Con precision\t";
std::cout.width(23);
std::cout << std::cout.precision() << "\t" << pi << std::endl;
}

return 0;
}
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 17

Programación avanzada C++

La salida por consola que se genera se muestra en la siguiente figura.

Los espacios no utilizados del campo de salida son rellenados por la función cout con espacios en blanco.
Para cambiar el carácter que se usa como relleno, se puede usar la función fill, pudiendo de esta manera,
fijar un carácter de relleno. Esta función tiene dos prototipos:

1 char fill ();

2 char fill (char);

Como en las funciones anteriores, el primer prototipo devuelve el valor de la variable de estado de relleno
actual, y el segundo lo cambia y devuelve el anterior. El ejemplo que presentamos a continuación muestra el
código usado para ejemplificar la función precision, pero modificado para que rellene con ceros los espacios
en blanco que se generan cuando cambia la precisión en su valor, no en el número de decimales de pi. Note
que para lograr que los espacios se rellenen con ceros, solo se debió agregar la siguiente instrucción.

EJEMPLO

…
std::cout.width(23);
std::cout.fill('0'); //instrucción fill agregada
std::cout << std::cout.precision() << "\t" << pi << std::endl;
…
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 18

Programación avanzada C++

La salida por consola que se genera se muestra en la siguiente figura.

2.2. Manipuladores
Las instrucciones para manipular el formato de salida tratadas hasta ahora son útiles, pero C++ amplía las
opciones de formato con los denominados manipuladores. Los manipuladores son funciones especiales que
se pueden emplear con los operadores de inserción y extracción para formatear la entrada y la salida. La
siguiente tabla muestra los manipuladores disponibles en C++.

Manipulador Entrada/Salida Descripción

dec E/S Formato de datos numéricos en decimal
endl S Envía carácter de nueva línea
ends S Envía un nulo \0
flush S Vacía un flujo
hext E/S Formato de datos numéricos en hexadecimal
oct E/S Formato de datos numéricos en octal
resetiosflags(long lg) E/S Desactiva los indicadores de lg
setbase(int i) S Formato de los números en la base i
setfill(char c) E/S Establece c como carácter de relleno
setiosflags(long lg) E/S Activa los indicadores de lg
setprecision(int i) E/S Establece i dígitos decimales
setw(int i) E/S Establece i dígitos decimales
ws E Ignora los caracteres en blanco iniciales

Los manipuladores dec, hex, oct, ws, endl, ends, y flush se encuentran definidos en iostream, mientras que
los demás están en iomanip. El siguiente código muestra el uso de algunas de estas funciones.
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 19

Programación avanzada C++

EJEMPLO

#include <iostream>

int main()
{
//declaramos dos variables numéricas
double decimal;
int hexadecimal;

//pedimos que se ingrese un número con decimales

std::cout << "Ingrese un número con decimal\n";
std::cin >> decimal;

//pedimos que se ingrese un número entero

std::cout << "Ingrese un número entero\n";
std::cin >> hexadecimal;

//formateamos la salida para números decimales y mostramos el número

std::cout << std::dec << decimal << " decimal" << std::endl;

//formateamos la salida para números hexadecimales y mostramos el número

std::cout << std::hex << hexadecimal << " hexadecimal" << std::endl;

return 0;
}

El siguiente código muestra como trabajar con números usando manipuladores.

#include <iostream>
#include <iomanip>
#define LARGO 16

int main()
{
//declaramos la variable para almacenar una cadena de caracteres
char frase[LARGO];
std::cout << "Ingrese una frase\n";
std::cin.getline(frase,LARGO);

//establecemos el ancho del campo en 32 caracteres

std::cout << std::setw(32);

//rellenamos los espacios en blanco con el caracter '?'

std::cout << std::setfill('?');

//justificamos la salida a la derecha y mostramos la frase

std::cout << setiosflags(std::ios::right) << frase << std::endl;

return 0;
}
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 20

Programación avanzada C++

Cierre
Los streams o flujos representan el “movimiento” de datos que se desarrolla entre un
programa y un dispositivo. Un dispositivo pude ser de entrada, como un teclado o un escáner, o
de salida, como una impresora o un monitor. C++ provee una serie de clases, agrupadas en la
llamada librería estándar, la cual proporcionan las funciones para manejar streams. La librería
estándar en C++ la constituye las clases incorporadas en iostream, y en todas las operaciones se
puede trabajar con áreas de memoria intermedia llamadas buffers. Los streams se abren y
cierran de manera automática, de forma que el programador no debe preocuparse de realizar
estas operaciones.

Los operadores de inserción (<<) y extracción (>>) permiten escribir y leer datos en un stream.
• Los tipos de datos que pueden ser insertados y extraídos desde un stream corresponden
a los tipos básicos y no se necesita ningún tipo de conversión.
• Las funciones put y write, pertenecientes a la clase ostream, permiten insertar un
carácter o una cadena de caracteres al flujo respectivamente.
• C++ posee la capacidad de acceder directamente a memoria y se efectúa con el uso de
punteros. Un puntero se declara mediante un * (asterisco) y representa la dirección en
memoria donde se almacena el contenido de una variable.
• Cuando se quieren utilizar funciones para extraer datos desde un stream, pueden usarse
las funciones get y getline, pertenecientes a la clase istream. La función get permite
extraer datos desde el stream, pero tiene el problema que deja el carácter de término de
extracción al comienzo del buffer, con lo cual, la siguiente cadena no se lee. Mientras
que getline no tiene este problema.

La función read, perteneciente a la clase fstream, permite leer desde un stream proveniente de
un archivo. Normalmente esta función trabaja con seekg y tellg, que permiten posicionar el
cursor para la lectura del siguiente carácter, y obtener la posición actual del cursor
respectivamente.

La clase ios posee las funciones necesarias para formatear el stream de salida; la función width
se utiliza para establecer el ancho del campo de caracteres que serán mostrados o insertados en
el stream, mientras que la función precision, permite definir el número de dígitos que serán
mostrados o insertados en un stream. Por su parte, la función fill, permite “rellenar” los espacios
en blanco de una cadena de caracteres con un carácter específico pasado como parámetro de la
función.

Los manipuladores son funciones exclusivas de C++, que permiten manejar la entrada/salida de
streams. Algunos de ellos, como dec o hex, permiten manipular valores numéricos para generar
un formato de salida personalizado.
 Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 21

Programación avanzada C++

APORTE A TU FORMACIÓN

La programación en C++ te ayudará a diseñar software de

una manera más profesional, debido a que el desarrollo de
los programas se realiza en un nivel más “bajo” que lo
ocurrido con Java. Por esta razón, se necesita mayor
compresión y cuidado al diseñar y escribir las instrucciones
que realizarán ciertas tareas.

No es necesario inicializar las variables, pero debe tener el

máximo de cuidado al momento de obtener los resultados
porque pueden obtenerse valores no deseados. De manera
análoga, el uso de punteros obliga a trabajar las variables a
usar con cuidado, poniendo el máximo empeño en usar los tipos correctos de datos o declarar las
estructuras que realizarán los cálculos o procedimientos requeridos.

Todo esto te obligará a poner el mayor esfuerzo en la escritura de código. Este esfuerzo tendrá
recompensas para su desarrollo profesional, las que se verán demostradas de dos maneras: primero,
C++ te permitirá permite conocer y manejar un nuevo lenguaje de programación. Y segundo, te
permitirá mejorar notablemente tus capacidades de programación.