Vous êtes sur la page 1sur 5

1.

Streams
En C++, los archivos se manejan con un tipo particular de stream. Un stream
es una estructura de datos que se utiliza para manejar un fujo de caracteres
permitir poner o sacar de !el tipos de datos est!andar o clases de"nidas por el
usuario. #or ejemplo, cout es un stream que nos permite escri$ir caracteres en
la consola. %epasemos un poco el &uncionamiento de cout cin'
(include )iostream*
usin+ namespace std,
void main-.
/
int n,
cout )) 01n+rese un numero entero0 )) endl,
cin ** n,
cout )) 0El numero que usted in+reso es el 0 )) n )) endl,
2
En este ejemplo podemos ver los dos operadores principales que se usan para
tra$ajar con streams' )) para streams de salida ** para streams de entrada.
#ara recordar mejor el si+ni"cado de estos operadores, podemos pensar que ))
pone las cosas en el stream que ** las saca. 3dem!as, podemos ver que
am$os operadores sa$en convertir entre enteros caracteres, en el sentido en
que corresponda. Estos dos operadores se pueden de"nir para cualquier clase,
pero nosotros no vamos a tra$ajar con entrada salida rede"ni!endolos.
cin es un ejemplo de un istream cout es un ejemplo de un ostream.
1.1. **
Este operador, tam$i!en llamado de e4tracci!on, saca cosas de un stream
las coloca en la varia$le reci$ida como par!ametro. En su comportamiento
por de&ecto, este operador i+nora los espacios en $lanco. #ara entender esto,
supon+amos que el stream contiene lo si+uiente'
1 5 6 7
8
1
3E91 : 5do cuatrimestre de 5;;5 5
-8 indica d!onde se va a realizar la pr!o4ima e4tracci!on.. Si la si+uiente instrucci!on
de nuestro pro+rama es
cin ** i,
donde i es una varia$le de tipo int, i va a pasar a valer 1 el estado del stream
va a ser
5 6 7
8
Si nuevamente hacemos
cin ** i,
el pro+rama va a saltear el espacio, va a poner el 5 en i va a dejar el puntero
en el si+uiente espacio en $lanco. Es decir, al leer de un stream, por de&ecto, se
i+noran los espacios en $lanco.
1.5. <anipuladores
#ara cam$iar el comportamiento de un stream, se pueden utilizar ciertas
&unciones especiales, llamadas manipuladores. =os manipuladores est!an de"nidos
en el archivo iomanip. >eamos al+unos de los m!as !utiles.
1.5.1. endl
#ara marcar el "nal de una l!?nea en un stream de salida, podemos usar el
manipulador endl
(include )iostream*
(include )iomanip*
usin+ namespace std,
void main-.
/
cout )) 0@olaA0 )) endl,
cout )) 08 este palito esta justo a$ajor de la @0 )) endl,
2
1.5.5. sBipCs, nosBipCs
Si estamos tra$ajando con un stream de entrada, queremos que ** no
i+nore los espacios en $lanco, el manipulador nosBipCs es justo lo que necesitamos.
>eamos un ejemplo'
(include )iostream*
(include )iomanip*
usin+ namespace std,
void main-.
3E91 : 5do cuatrimestre de 5;;5 6
/
char c,
cout )) 01n+rese dos di+itos separados por un espacio0 )) endl,
cin ** c, cout )) c,
cin ** c, cout )) c )) endl,
cout )) 01n+rese dos di+itos separados por un espacio0 )) endl,
cin ** nosBipCs ** c,
cin ** c, cout )) c,
cin ** c, cout )) c,
cin ** c, cout )) c,
2
Si el usuario in+resa
1 5
1 5
D$tiene la si+uiente salida
1 5
15
1 5
1 5
#ara deshacer el e&ecto de nosBipCs, simplemente utilizamos sBipCs.
1.5.6. $oolalpha, no$oolalpha
3 menudo utilizamos el stream de salida por consola para conocer el valor
de las varia$les de nuestro pro+rama en distintos momentos. Cuando pedimos
mostrar una varia$le de tipo $ool, o$tenemos un ; o un 1. Si queremos al+o un
poco m!as si+ni"cativo, podemos utilizar el manipulador $oolalpha.
(include )iostream*
(include )iomanip*
usin+ namespace std,
void main-.
/
cout )) true )) endl,
cout )) $oolalpha )) true )) endl,
2
=a salida de este pro+rama es
1
true
Euevamente, para deshacer el e&ecto de $oolalpha, utilizamos no$oolalpha.
3E91 : 5do cuatrimestre de 5;;5 7
5. 3rchivos
En C++, los archivos se manejan mediante "lestreams o &streams. Estos
son streams que adem!as proveen &unciones para manipular archivos. Es decir, si
nuestro pro+rama escri$e cosas en la consola, con los mismos comandos podemos
escri$ir cosas en un archivo. Simplemente ha que cam$iar cout por el nom$re
del stream que maneje nuestro archivo.
5.1. Entrada
#ara a$rir un archivo para lectura, utilizamos un i&stream. #ara eso, tenemos
que de"nir una varia$le de ese tipo vincularla a al+!un archivo. #ara
realizar esta vinculacion, tenemos dos m!etodos' dar el nom$re del archivo al declarar
la varia$le o utilizar el m!etodo open. 3m$os producen el mismo resultado.
>eamos un ejemplo.
(include )iostream*
(include )&stream*
(include )iomanip*
usin+ namespace std,
void main-.
/
i&stream entrada-0@ola.t4t0.,
i&stream input,
char c,
input.open-0@ello.t4t0.,
i& -entrada.+ood-..
cout )) 0El archivo @ola.t4t &ue a$ierto correctamente0,
else
cout )) 0El archivo @ola.t4t no pudo ser a$ierto correctamente0,
cout )) endl,
entrada ** c,
entrada.close-.,
input.close-.
cout )) c )) endl,
2
En este ejemplo, nuestro pro+rama a$re dos archivos para entrada lee un
caracter de uno de ellos. Cuando los archivos a no son necesarios, los cerramos
utilizando el m!etodo close. Una vez que cerramos el archivo, podemos usar el
mismo i&stream para leer de otro archivo distinto, o del mismo archivo una vez
m!as.
3dem!as de la apertura de archivos de entrada, vemos el uso del m!etodo
+ood. Este m!etodo est!a presente en todos los streams nos indica si la pr!o4ima
3E91 : 5do cuatrimestre de 5;;5 F
operaci!on de lecturaGescritura ser!a via$le. En el caso de archivos, pre+untar
+ood despu!es de a$rir un archivo nos in&orma si se pudo a$rir correctamente.
Cuando se tra$aja con streams de entrada, a menudo es necesario leer un
caracter volverlo a poner dentro del stream. #ara eso, los istreams poseen el
m!etodo put$acB-char., que coloca el caracter en el stream, pasando a ser el
pr!o4imo caracter que se leer!a.
Dtro m!etodo !util para manipular i&streams es eo&-.. Este nos dice si a
lle+amos al "nal del archivo. Eso quiere decir que a no se podr!a leer m!as.
5.5. Salida
#ara manejar un archivo de salida, utilizamos un ostream
(include )iostream*
(include )&stream*
(include )iomanip*
usin+ namespace std,
void main-.
/
o&stream salida-0@ola.t4t0.,
o&stream output,
char c,
output.open-0@ello.t4t0.,
cin ** c,
salida )) c,
salida.close-.,
output.close-.,
2
En este ejemplo, no revisamos si el archivo &ue a$ierto correctamente. Si el
archivo no e4iste, se crear!a. Solo puede ha$er pro$lemas si no se puede crear
un archivo con ese nom$re en el directorio o si al+uien tiene el archivo a$ierto.
C++ permite a$rir un archivo para escri$ir leer de !el, pero no utilizaremos
este tipo de &stream en la materia.
6. Enum
enum es un mecanismo del len+uaje para de"nir constantes sim$!olicas. #or
ejemplo, si queremos representar los palos de una $araja &rancesa en C++, crear
una clase puede ser demasiado, a que solo tenemos que tratar con cuatro valores
sencillos. Entonces, recurrimos al enum.
(include )iostream*
(include )iomanip*
3E91 : 5do cuatrimestre de 5;;5 H
usin+ namespace std,
enum #alo /Corazones I JCJ, Kre$oles I JKJ,
9iamantes I J9J, #iques I J#J2,
void main-.
/
#alo p,
p I Corazones,
cout )) p )) endl,
cout )) char-p.,
2
En este ejemplo, asi+namos a cada una de las constantes sim$!olicas -Corazones,
etc.. un caracter. Ese caracter podr!?a usarse, por ejemplo, para almacenar el palo
en un archivo.
=a salida de este ejemplo es
HL
C
Esto nos muestra que C++ trata a los enum como enteros. Si queremos ver -o
+uarda en un archivo. el caracter correspondiente al palo, de$emos encerrar la
varia$le en un char-..
Una &orma alternativa de leer escri$ir enums en streams es usar los m!etodos
put +et. Estos solo manejan un caracter. Entonces, si queremos escri$ir en
patalla un Kre$ol, podemos hacer
cout.put-Kre$ol.,
cout )) endl,
Esto nos dar!a
K
=eer un enumerado es m!as complicado. 9e$emos poner el contenido en un char
despu!es asi+narlo al enumerado. Si el usuario in+resa #
char c,
#alo p,
cin ** c,
p I #alo-c.,
dejar!a en p el valor #iques.
7. 9MN##
El compilador que la c!atedra utiliza no cumple en un 1;;O con el est!andar
3ES1 C++. En particular, no posee manipuladores -a e4cepci!on de endl
3E91 : 5do cuatrimestre de 5;;5 L
al+!un otro no mu relevante.. 9e todas &ormas, s!? $rinda una &orma de cam$iar
el comportamiento de un istream respecto a los espacios en $lanco. #ara hacer
que !estos no sean i+norados, de$emos usar el m!etodo unset& de la si+uiente
&orma
cin.unset&-ios''sBipCs.,
Si queremos volver a i+norar los espacios en $lanco, hacemos
cin.set&-ios''sBipCs.,

Vous aimerez peut-être aussi