PDF de programación - Entrada/Salida en C++

Entrada/Salida en C++

1. Gestión de E/S.
2. Clases básicas.
3. E/S estándar.
4. Manejo de ficheros.

Gestión de Entrada/Salida

Principios generales (objetivos):

– Independencia y transparencia entre
recursos, emisores y receptores de
información.

– No aparezcan parámetros físicos.
– Sencillo, eficiente, flexible, seguro y

completo.

En P.O. debe manejar datos básicos y
estructurados:
– conversión objetos en información
comprensible y accesible desde los
diferentes centros emisores y receptores.

Mecanismo de E/S en P.O. se divide en:

usuario, otra aplicación, máquinas, etc.

– Salida: conversión a entidades externas:
– Entrada: inversa de la salida.
– Formato E/S: especificaciones de formato

y estructura que se captura desde o se
emite al exterior.

– Ficheros y Flujos: tratamiento

especializado de dispositivos y ficheros.

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

122

Gestión de Entrada/Salida en C++

Gestión de Entrada/Salida en C++

En C:

En C++:

– Funciones de E/S complicadas y con
– No efectúan comprobación de tipos.

importantes deficiencias.

– Funciones E/S, biblioteca iostream.h
– Comprobación de los tipos de datos.
– Tratamiento uniforme de los tipos de
– Mecanismos para crear nuevas funciones
de E/S para dispositivos no estándar, con
mismo tipo de tratamiento.

datos y clases de objetos.

El concepto de streamen C++:

a un destino (salida).

– flujo de datos desde un origen (entrada)
– Permite almacenamiento en una salida o
– Se asocian a dispositivos físicos o
– Operadores inserción << y extracción >>:

extracción desde una entrada.

ficheros.

Sobrecarga de operadores << y >>.

Clases básicas:

ios

istream

ostream

iostream

Clase ios contiene:

– puntero a objeto buffer de
– constantes y variables de formato de

almacenamiento temporal.

E/S y de error.

Clase iostream y ostream:

– definen funciones para entrada y salida

con formato, respectivamente.

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

123

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

124

Gestión de Entrada/Salida en C++

Gestión de Entrada/Salida en C++

E/S estándar en C++:

– Entrada estándar:

Parámetros y flagsde formato:

– ios define una variable que agrupa 15 bits

de estado de formato.

– ios proporciona 15 constantes que

permiten diferenciar los bits de formato:

Bit Field

ios::basefield

ios::adjustfield

Flag
---------------------------------
ios::left
ios::right
ios::internal
---------------------------------
ios::dec
ios::oct
ios::hex
---------------------------------
ios::scientific
ios::fixed
---------------------------------
ios::skipws
ios::showbase
ios::uppercase X y E mayúsculas
ios::showpoint 0.1 y 2.0 en lugar de .1 y 2.
ios::unitbuf
ios::showpos
ios::stdio
---------------------------------

muestra el signo positivo
compatibilidad con E/S de C

se ignoran espacios en blanco
muestra indicador de la base

ios::floatfield

se vacía buffer S tras cada inserción

– Salida estándar:

Representa al dispositivo de entrada
por defecto, generalmente el teclado.
El stream asociado es cin, de la clase
istream.

Representa al dispositivo de salida
por defecto, generalmente la pantalla.
El streamasociado es cout, de la
clase ostream.

– Salida de error:

Representa al dispositivo de salida
por defecto donde se envían los
mensajes de error, generalmente la
pantalla.
Los streamsasociados son cerr y
clog, de la clase ostream.

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

125

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

126

Gestión de Entrada/Salida en C++

Gestión de Entrada/Salida en C++

Establecimiento del formato con

funciones:

Ejemplo

Función
(consulta/cambio)
-------------------------------------------------------
fill
precision
width
flags
setf

cout.fill(‘-’);
cout.precision(5);
cout.width(30);
cout.flags(ios::showbase|ios::left);
cout.setf(ios::showbase|ios::left);
cout.setf(ios::dec,ios::basefield);
cout.unsetf(ios::showbase);

unsetf
-------------------------------------------------------

Establecimiento del formato con

manipuladores:
– Operadores especiales que permiten la
inserción de funciones de formato en las
operaciones de E/S.

Manipuladores de formato:
Ámbito Manipulador
Descripción
----------------------------------------------------------
E/S
E/S
E/S
E
S
S
S
E/S
S
S
S

dec
oct
hex
ws
endl
ends
flush
setw(int)
setfill(char)
setprecision(int) fija la precisión
setbase(int)
fija la base (8,10,16)
setiosflag(long) equivalente a setf()
unsetiosflag(long) equivalente a unsetf()
----------------------------------------------------------
Ejemplos:

fija base decimal
fija base octal
fija base hexadecimal
extrae espacios en blanco
inserta salto de línea
inserta carácter nulo
vuelca el stream
fija ancho de campo
fija el carácter de relleno

cout << setw(20) << setfill(‘-’) <<

setiosflag(ios::right)<< “CADENA”;

cin >> ws >> setbase(8) >> x;

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

127

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

128

Gestión de Entrada/Salida en C++

Gestión de Entrada/Salida en C++

Gestión de errores E/S:

– Cuando ocurre un error en la E/S en un

stream, este error se refleja en un
atributo de estado del stream:

class ios
{
public:

enum io_state

{ goodbit = 0x00;
eofbit = 0x01;
failbit = 0x02;
badbit = 0x03;

};

inline int good() const;
inline int eof() const;
inline int fail() const;
inline int bad() const;

...

};

Ejemplo:
char cadena[30];
int estado;

cin.clear(); //limpia estado de errores
estado=cin.rdstate(); //lee estado de

//error del stream

switch(estado)

{ case ios::goodbit : ...
case ios::eofbit : ...
case ios::failbit : ...
case ios::badbit : ...

}

...

Equivalente al switch:

cin.clear(ios::failbit); //se pone un

if(cin.good()) {...}
if(cin.eof()) {...}
if(cin.fail()) {...}
if(cin.bad()) {...}

//error a mano

...

if(!cin) cout << “ERROR”;
if(cin) cout << “Todo va bien!”;

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

129

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

130

Gestión de Entrada/Salida en C++

Gestión de Entrada/Salida en C++

La clase ostream:

class ostream
{ ...
public:

ostream & operator<< (int);
ostream & operator<< (long);
ostream & operator<< (char);
ostream & operator<< (float);
ostream & operator<< (char *);
ostream & put(char);
ostream & write(const char *,int);
ostream & flush(); // vacía buffer

...
};

Ejemplos:

Devuelven objeto
ostreampor referencia:
* permite concatenar
llamadas a operadores
y funciones.

int c=‘Q’;
cout.put(c); // la salida es Q
cout.put(48); // carácter ‘0’, ascii 48

La clase istream:

class istream
{ ...
public:

istream & operator>> (int);
istream & operator>> (long);
istream & operator>> (char);
istream & operator>> (float);
istream & operator>> (char *);
istream & get(char &c);
istream & getline(char *s,int n,

char c=‘\n’);

istream & read(const char *,int n);
istream & putback(char c);
istream & ignore(int n,int t=EOF);
int sync();

...
};
-------- ----------------------------------
get()
getline() extrae hasta n caracteres del stream o

extrae un carácter del stream.

hasta que encuentra el carácter delimitador.
extrae n caracteres del stream.
read()
putback() devuelve un carácter al stream.
ignore() extrae y descarta n caracteres del o hasta

char *str=“ABCDEFGH”;
cout.write(str+1,4); //la salida es “BCDE”

sync()

encontrar fin de stream.
vacía el buffer de entrada.

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

131

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

132

Gestión de Entrada/Salida en C++
Sobrecarga de los operadores >> y <<

class punto
{ int x,y;

public:

friend ostream & operator<< (ostream &,

friend istream & operator>> (istream &,

punto &);

punto);

};

Se sobrecargan como
funciones friend.

Son operadores binarios:
* el primer operando es
siempre un streampor
referencia y

* el segundo un objeto

de la clase en cuestión.

ostream & operator<< (ostream & os,

punto p)

{ os << ‘(‘ << p.x << ‘,’ << p.y << ‘)’;

return(os);

}

Se devuelve el mismo stream
para otras operaciones de
concatenación

Gestión de Entrada/Salida en C++

istream & operator>> (istream & is,

punto & p)

{ char c;

is >> c;
if(c!=‘(‘)

is.clear(ios::failbit);

else

{ is >> p.x >> c;

Se pone
el error
manualmente.

if(c!=‘,‘) is.clear(ios::failbit);
else

{ is >> p.y >> c;

if(c!=‘)‘)

is.clear(ios::failbit);

}

}

return(is);
}

void main(void)
{ punto p;

cin >> p;
if(!cin)

{ cout << “ERROR de formato de entrada”;

cin.clear(); //limpia registro de estado

}

};

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

133

Lenguaje C++. Leng. Prog. II. Filiberto Pla y Jorge Badenas.

134

Gestión de Entrada/Salida en C++

Gestión de Entrada/Salida en C++

Ficheros:

ios

istream

ostream

iostream

ifstream

fstream

ofstream

Abre ficheros,
por defecto,
para lectura.

Abre ficheros,
por defecto, para
lectura/escritura.

Abre ficheros,
por defecto,
para escritura.

fstreambase

...
};

Modo de
apertura

Modo de protección:

S_IREAD
S_IWRITE

class fstreambase
{ ...

public:

Nombre del
fichero a abrir

fstreambase();
fstreambase(const char *,int,int);
~fstreambase();
void open(const char*,int,int);
int is_open();
close();

Por defecto, se permite
compartirlo para
lectura/escritura.

Modos de apertura
-------------- --------------------------
lectura.
ios::in
escritura.
ios::out
abrir y saltar al final.
ios:ate
añadir.
ios::app
destruir el fichero si existe.
ios::trunc
ios::nocreate error si el fichero no existe.
ios: