Programación Orientada A Objetos

Área: TECNOLOGÍA M4
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA)
Pr
og
Índice ra
ma
ció
n
Introducción ......................................................................................................................................................... 1 av
an
1. Flujos en C++................................................................................................................................................. 2
za
1.1. Concepto .............................................................................................................................................................. 2 da
1.2. Librería iostream .................................................................................................................................................. 3 C+
1.3. Operadores ........................................................................................................................................................... 4
2. Salida con formato...................................................................................................................................... 13
2.1. Clase ios .............................................................................................................................................................. 13
2.2. Manipuladores ................................................................................................................................................... 18
Cierre .................................................................................................................................................................. 20
Pr
og
Mapa de Contenido ra
ma
ció
n
Programación av
avanzada C++ an
za
da
C+
Flujos en C++ Salida con formato
Concepto Clase ios
Librería iostream Manipuladores
Operadores
Curso: PROGRAMACIÓN ORIENTADA A OBJETOS (C++, JAVA) Pág. 1
Pr
RESULTADO og
Crea un programa computacional complejo utilizando ra
DE
características avanzadas de C++, para resolver un problema dado. ma
APRENDIZAJE ció
DEL MÓDULO n
av
an
za
Introduc da
C+
ció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.
SA
BE
R
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.
Pr
1. Flujos en C++ og
ra
ma
1.1. Concepto ció
n
En C++, el stream o flujo es utilizado para señalar un concepto abstracto a través del cual datos sin estructura av
pueden enviarse en forma unidireccional o bidireccional desde un programa. Estos flujos se consideran una an
construcción de I/O a bajo nivel, y se encuentran definidos mediante un conjunto de clases que se distribuye za
en la librería estándar de C++. da
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.
Pr
1.2. Librería iostream og
ra
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 ma
directiva include <iostream>. El sistema de I/O en C++ está pensado para trabajar con diferentes dispositivos ció
y cada uno se trata como un dispositivo virtual o lógico, llamado stream, conformando cada uno el punto de n
unión o interfaz entre el programa y el dispositivo. A este sistema de I/O se le llama sistema de av
entrada/salida a través de buffers. an
za
da
La estructura de los datos que se envían y reciben desde los distintos dispositivos puede variar, pero los C+
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.
Clase que
istream ostream
pertenece
(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
Tipo de
(monitor) almacenado en el estándar a través

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:
Nombre archivo Contenido / uso Pr
og
• Información básica requerida para todos los flujos de I/O ra
• Contiene las funciones cin, cout, cerr y clog ma
iostream.h
• Proporciona capacidades de I/O con o sin formato ció
• Contiene los manipuladores de uso común n
• Contiene la información necesaria para las operaciones de procesamiento de archivos av
fstream.h
controlados por el usuario an
• Contiene la información necesaria para realizar operaciones con string (cadenas) za
strstream.h da
C+
• 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;
}
En este código aparece una secuencia de caracteres que no habíamos visto: el manipulador endl cumple la Pr
función de la secuencia de escape “\n”, además de vaciar el buffer asociado. Se prefiere al uso de dicha og
ra
secuencia.
ma
ció
Función put n
av
an
Además de las funciones del operador de inserción, la clase ostream proporciona la función put para mostrar za
caracteres e insertarlos en el flujo. da
C+
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 ù
… … … …
Pr
og Fu
ra w
ma sr
ció pu
n
av
anLa
za funci
daón
C+writ
e se
utiliz
a
para
inser
tar
una
secu
enci
a de
cara
ctere
s, o
most
rand
o
cade
nas,
en
el
flujo.
Reci
be
dos
pará
metr
os:
el
prim
ero
corr
espo
nde
a un
punt
ero a
una
secu
enci
a de
cara
ctere
s, 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:
Pr
og EJE
ra MPL
maO
ció
n El
av sigui
an ente
za ejem
da plo
C+ mue
stra
una
decl
araci
ón
válid
a de
punt
ero:
#i
cl
de
<i
st
ea
>
#i
cl
de
<s
ri
g.
>
in
ma
n(
{
//
r
pu
al
ca
de
ca
ch
ca
=
sá
.
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++;
}
rturn 0;
}
Pr
og O
ra or
ma ex
ció ón
n
av
anE
za l
da
C+o
p
e
r
a
d
o
r
d
e
e
x
t
r
a
c
c
i
ó
n
>
>
t
i
e
n
e
c
o
m
o
f
unció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
contad
or =
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.
Pr
og Fu
ra ge
ma ge
ció
n
av D
ane
za n
dat
C+r
o
d
e
l
a
s
l
i
b
r
e
r
í
a
s
,
l
a
c
l
a
s
e
i
s
t
r
e
a
m
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á?”.
Pr
og EJE
ra MP
ma LO
ció
n
#
av l
an <
za t
da m
C+
i
m
(
{
s
<
"
u
d
c
"
s
c
c
]
s
e
,
s
<
"
u
s
c
c
"
s
c
c
]
s
e
,
s
<
i
f
c
"
c
s
:
l
r
}
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.
Pr
og >
ra
ma >
ció
n Lib
av
an rer
za
da ía
C+ fst
re
La
funci
ón
read
lee
un
cierto
núme
ro de
bytes
(o
carac
teres)
guard
ándol
os en
una
varia
ble
punte
ro
tipo
char.
Por:
EJE
MP
LO
#
l
<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.e
nd);
int largo = flujo.tellg();
flujo.seekg(0,flujo.beg);
//creamos un puntero a un arregllo de caracteres para

la lectura
almacenar char * caracteres = new char[largo];
//guardamos la lectura en
el arreglo
flujo.read(caracteres,larg
o);
//mostramo
s lo leído
} int i = 0;
else while(i<la
rgo)
std::cout << "Caracter: " << caracteres[i++] << std::endl;
std::cout << "No se pudo crear el flujo";
return 0;
}
PrL
ogo
ra
ma
cióp
nr
avi
anm
zae
da
r
C+
o
q
u
e
h
a
c
e
m
o
s
e
n
e
s
t
e
e
j
e
m
p
l
o
e
s
i
n
c
l
uir 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.
Pr
og2.
ra
maSal
ció
n id
av
ana
za
daco
C+
n
for
m
at
o
2.1.
Cla
se
ios
L
a
c
l
a
s
e
i
o
s
p
r
o
p
o
r
c
i
o
n
a
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.
Pr
og Li
ra rí
ma st
ció y
n ti
av
an
zaEJEM
daPLO
C+
E
l
s
i
g
u
i
e
n
t
e
c
ó
d
i
g
o
g
e
n
e
r
a
u
n
a
l
i
s
t
a
d
e 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;
}
PrP
oga
ra
r
ma
cióa
n
avg
ane
zan
da
e
C+
r
a
r
n
ú
m
e
r
o
s
a
l
e
a
t
o
r
i
o
s
,
p
r
i
m
e
r
o
d
e
b
e
m
os 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:
Función precision
01
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);

PrE
ogl
ra
ma
cióp
nr
avi
anm
zae
da
r
C+
p
r
o
t
o
t
i
p
o
c
o
r
r
e
s
p
o
n
d
e
l
a
f
u
n
c
i
ó
n
q
ue 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;
}
PrL
oga
ra
mas
cióa
nl
avi
and
zaa
da
C+p
o
r
c
o
n
s
o
l
a
q
u
e
s
e
g
e
n
e
r
a
s
e
m
u
e
s
t
r
a
e
n
l
a
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;
Pr L
oga
ra
mas
cióa
nl
avi
and
za a
da
C+p
o
r
c
o
n
s
o
l
a
q
u
e
s
e
g
e
n
e
r
a
s
e
m
u
e
s
t
r
a
e
n
l
a
siguiente figura.
2.2.
Manipulad
ores
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.
Pr
ogEJEM
ra PLO
ma
ció #
n c
an d
za <
da s
e
C+ >
+
i
m
n
{
/
m
v
n
d
d
i
h
a
/
q
i
u
c
d
s
<
"
u
c
d
"
s
>
d
/
q
i
u
e
s
<
"
u
e
;
s
>
h
a
//formateamos la salida para números decimales y M4
mostramos el número std::cout << std::dec << decimal << Pág. 20
" 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

Programación Orientada A Objetos

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Programación Orientada A Objetos

Cargado por

Copyright:

Formatos disponibles

Área: TECNOLOGÍA M4

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

Flujos en C++ Salida con formato

Concepto Clase ios

Librería iostream Manipuladores

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

cin cout cerr clog

Flujo de entrada Flujo de salida Flujo de salida de

(monitor) almacenado en el estándar a través

para visualizar flujo es más

char ℤ int ℝ double

short ℤ long string

Clase ostream y endl

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

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

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

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

Valor Carácter Valor Carácter

7 “beep” (sonido) 151 ù

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

void pruebaWrite(char* secuencia)

Para obtener el largo de la secuencia de caracteres, hemos usado la función

//mostramos los caracteres que están en posiciones

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

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

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

//creamos un puntero a un arregllo de caracteres para

std::cout << "No se pudo crear el flujo";

A continuación, preguntamos si el objeto ifstream pudo crearse correctamente. Para ello,

Finalmente, se llama nuevamente a seekg, pero colocando la posición a ser leída en

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

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

//llenamos el arreglo numeros con

//salida sin formato width

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

//salida con formato width

Volviendo al código, inicializamos los números aleatorios mediante la instrucción

1 int precision ();

2 int precision (int);

//mostramos la precisión por defecto

//mostramos pi con distintas

1 char fill ();

2 char fill (char);

Como en las funciones anteriores, el primer prototipo devuelve el valor de la variable de

Manipulador Entrada/Salida Descripción

//formateamos la salida para números hexadecimales y

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

//establecemos el ancho del campo en

//rellenamos los espacios en blanco con el

//justificamos la salida a la derecha y mostramos

También podría gustarte