Sobrecarga de Operadores y E/S en C++

Sobrecarga de Operadores yE/S en C++ Antonio LaTorre de la Fuente

Índice • Sobrecarga de Funciones • Sobrecarga de Operadores • Entrada/Salida sobre streams básicos • Entrada/Salida sobre streams de fichero • Entrada/Salida sobre streams de cadena

Sobrecarga de Funciones • Nuevo con respecto a C • Funciones con el mismo nombre pero distintoprototipo: número y/o tipo de argumentos • Útil si se quiere poder realizar una mismaoperación sobre distintos tipos de datos

Sobrecarga de Funciones void print (double number) {cout

Ambigüedad • ¿Qué pasa si incluimos en nuestro código…? unsigned num = 3; print (num); • El compilador no sabe a qué función llamar: func_over.cc:18: error: call of overloaded print(unsigned int&) is ambiguous func_over.cc:6: note: candidates are: void print(int) func_over.cc:7: note:func_over.cc:8: note:void print(int, std::string) void print(double)

Ambigüedad • Se soluciona usando static_cast unsigned num = 3; print (static_cast(num)); • ¿Qué pasaría si hiciéramos…? int num = 3; print (num);

Name Mangling • Estrategia que usa el compilador para poderdiferenciar dos funciones con el mismo nombre int f (void) {return 1;} int f (int) {return 0;} void g (void) {int i = f (), j = f (0);} • Esto se traduciría en: int __f_v (void) {return 1;} int __f_i (int) {return 0;} void __g_v (void) {int i = __f_v (), j = __f_i (0);}

Operadores en C++• Lista de operadores válidos en C++ + - * / % ^ & |~ ! , = < > =++ -- > == != && ||+= -= *= /= %= ^= &= |== [] () -> ->* new delete• Se declaran de la siguiente forma: tipo operator operador([argumentos])

Operadores en C++• Hay algunos operadores especiales que nopueden ser sobrecargados • :: (resolución de ámbito) • . (selección de un miembro) • .* (selección de un miembro referenciado por un puntero) • ?: (operador condicional) • sizeof (tamaño de) • typeid (identificación del tipo)

Precedencia de Operadores• Los operadores en C++ tienen distintaprecedencia, y a veces no es obvio • Lo mejor es usar () en casa de no estar seguro • Tabla de precedencias: Inglés: http://www.cplusplus.com/doc/tutorial/operators/ Español: http://es.wikipedia.org/wiki/Operadores_en_C_y_C%2B%2B

Sobrecarga de operadores• Podemos sobrecargar tanto operadores unarioscomo binarios tipo_ret operator op_unario (tipo1 arg1); tipo_ret operator op_binario (tipo1 arg1, tipo2 arg2); • En este caso, ambos argumentos se muestran demanera explícita

Sobrecarga de operadores• Ambas notaciones son equivalentes C operator- (C n) {…} C operator- (C n, C m) {…} int main (void) { } C a, b, c, d;c = -b;d = b – a; int main (void) { } C a, b, c, d;c = operator- (b);d = operator- (b, a);

Sobrecarga de operadores• Si los operadores son métodos de una clase, unode los argumentos es implícito (aquél que invocaal operador) class C { } public: C operator- ();C operator- (C);

Sobrecarga de operadores• Estas dos notaciones son equivalentes int main (void) { C a, b, c, d; c = -b; d = b – a; } int main (void) { C a, b, c, d; c = b.operator-(); d = b.operator-(a); }

Sobrecarga de operadores• Ejemplo: Números Complejos class Complejo { } public:Complejo (double r, double i) : real(r), imag(i) {}… private:double real;double imag;

Operadores Aritméticos• Suma de números complejos: Complejo Complejo::operator+ (const Complejo& z2) const { } Complejo res (0, 0); res.real = this->real + z2.real;res.img = this->img + z2.img; return res;

Operadores Relacionales• Comparación de números complejos: bool Complejo::operator== (const Complejo& z2) const { } return this->real == z2.real && this->imag == z2.imag;

Operadores de auto-incremento• Son operadores unarios • Permiten pre-incrementar y post-incrementar elvalor de una variable Pre-incremento:C C::operator++() Post-incremento: C C::operator++(int x) Complejo Complejo::operator++() { } real += 1;return *this;

Funciones “Amigas”• Son funciones ajenas a una clase que puedenacceder a los elementos privados de esa clase • Ejemplo: • Tenemos dos clases: Vector y Matriz • Queremos definir el producto vectorial entreambas clases • El contenido de los objetos es privado

Funciones “Amigas”class Vector { friend operator* (const Matriz&matriz, const Vector& vector); } public: … private:int size;int* data; class Matriz { friend operator* (const Matriz&matriz, const Vector& vector); } public: … private:int rows, columns;int** data; Vector operator* (const Matriz& matriz, const Vector& vector) {…}

Operadores de asignación• Se sobrecargan para evitar la copia binaria deobjetos class Vector { } public:Vector& operator= (const Vector& vector) {size = vector.size;data = new int[vector.size];for (unsigned i = 0; i < size; i++)data[i] = vector.data[i];return *this;} private:int size;int* data; class Vector { } public:Vector& operator= (const Vector&vector) {size = vector.size;data = vector.data;return *this;} private:int size;int* data;

Operadores de inserción y extracción• Permiten escribir / leer en la salida / entradaestándar • Hay que sobrecargar los operadores: ostream& operator> (istream& is, T& arg) • Podemos hacer que estos métodos sean amigosde nuestra clase o implementar un métodopúblico que imprima los datos

Operadores de inserción y extracciónclass Complejo { } public:void printComplejo(ostream & os);… private:double real;double imag; ostream& operator

Operador de Indexación• Es el operador [] • Es un operador binario y de clase: recibe elobjeto donde se aplica y el índice facilitado • Útil, p.ej., para acceso seguro a datos: int Vector::operator[] (int i) { } if (i >= 0 && i < this->size)return data[i];else {cout

Conversión de tipos• Hay dos posibilidades para llevar a caboconversiones entre tipos definidos por elusuario: • Los constructores de conversión • Los operadores de conversión • Son útiles para hacer, por ejemplo: Complejo a (2, 3), b (0, 0); b = a + 5;

Constructores de conversión• Hay que añadir un constructor que nos permitacrear el objeto a partir de un objeto del tipo quequeramos convertir class Complejo { }public:Complejo (double r, double i) : real(r), imag(i) {}Complejo (int r) : real(r), imag(0) {}Complejo operator+ (const Complejo& z2) const;… private:double real, imag; Complejo a (2, 3), b (0, 0); b = a + 5;

Operadores de conversión• Se usan para proporcionar una conversión de untipo de usuario a otro tipo (de usuario o no) • Tiene la sintaxis: C::operator T(); • Donde C es el tipo de usuario que queremosconvertir y T es el tipo en el que queremosconvertir C

Operadores de conversiónclass Complejo { } public:Complejo (double r, double i) : real(r), imag(i) {}operator double() {return real;}Complejo operator+ (const Complejo& z2) const;… private:double real, imag; Complejo a (2, 3); double b = a + 5; double c = a.operator double() + 5; double d = static_cast(a) + 5;

Ambigüedades en la conversiónSurgen si hay varias conversiones implícitas posibles class Complejo { }public:Complejo (double r = 0, double i = 0): real(r), imag(i) {}operator double() {return real;}Complejo operator+ (const Complejo& z2) const;… private:double real, imag; Complejo a(2, 3), c(0,0); double b = 5; c = a + b; El compilador no sabe siconvertir “b” a“Complejo” y realizarla suma o convertir“a” a “double”, hacerla suma y convertir elresultado a Complejo.

Operador de llamada a función• Es el operador () • Siempre debe ser definido dentro de una clase • x (y, z) se interpreta como x.operator (y, z) • Útil para implementar callbacks (pasar códigocomo argumento de una función). Losdenominados Objetos Función • También para el acceso a matricesmultidimensionales

Operador de llamada a funciónclass Inicializar {private:double val;public:Inicializar (double x = 0) : val(x) {}void operator() (Vector& v); }; void Inicializar::operator() (Vector& v) { for (unsigned i = 0; i < vector.size(); i++) v[i] = this->val; } int main (void) { Vector v(5); Inicializar ini(1); ini(v); }

Operador new• Al reservar memoria con new y new[] se invoca a lasfunciones operator new y operator new[]: void* operator new (size_t tamaño); void* operator new[] (size_t tamaño); • Estas funciones reservan y memoria y luego llaman elconstructor correspondiente • Se pueden sobrecargar para una clase C: void* C::operator new (size_t tamaño); void* C::operator new[] (size_t tamaño); • Son funciones estáticas aunque no se declaren como tal(static), porque se invocan antes que el constructor • Primero se busca en la clase (y clases base) y luego la global

Operador newvoid* Vector::operator new (size_t tam) { reservarMemoria (tam, 0); } void* Vector::operator new[] (size_t tam) { reservarMemoria (tam, 0); } void* Vector::reservarMemoria (size_t tam, char c) { void* p = malloc (tam); if (p == 0) { cout

Operador delete• Al liberar memoria con delete y delete[] se invoca a lasfunciones operator delete y operator delete[]: void operator delete (void*); void operator delete[] (void*); • Estas funciones llaman al destructor y luego liberan la memoriadel objeto • Se puede sobrecargar para una clase C: void C::operator delete (void*, [size_t]); void C::operator delete[] (void*, [size_t]); • Son funciones estáticas aunque no se declaren como tal(static), porque se invocan después del destructor • Primero se busca en la clase (y clases base) y luego la global

Operador deletevoid Vector::operator delete (void* p, size_t tam) { if (p) memset (p, 0, tam); free (p); } void Vector::operator delete[] (void* p, size_t tam) { if (p) memset (p, 0, tam); free (p); }

Índice • Sobrecarga de Funciones • Sobrecarga de Operadores • Entrada/Salida sobre streams básicos • Entrada/Salida sobre streams de fichero • Entrada/Salida sobre streams de cadena

Visión General de la E/S en C++• Streams y Buffers • Especializaciones según el tipo de operación y elorigen/destino de los datos

Clases istream y ostream• Derivan de la clase ios • Deben ser conectadas a un buffer (del tipo quesea) • cin y cout son de tipo istream y ostream • Normalmente, para hacer E/S sobre ficheros ocadenas se usan las clases especializadas, pero sepodrían usar estas clases básicas • Para usarlas: #include

Clases istream y ostream• Los Manipuladores nos permiten cambiar lasopciones de formato de los streams (#include) • Son funciones especialmente diseñadas paratrabajar junto con los operadores de inserción() • Se modifica el formato encadenándolos al objetoque representa el stream cout

Clases istream y ostream• Manipuladores sin parámetros:(no)boolapha: Mostrar booleanos como true y false(no)showbase: Mostrar prefijo de tipo (0x, 0, etc.)(no)showpoint: Forzar la escritura del punto decimal(no)showpos: Forzar la escritura de un ‘+’ para valores positivos(no)skipws: Permite ignorar caracteres de espaciado(no)unitbuf: Forzar el vaciado del buffer tras cada operación(no)uppercase: Mostrar caracteres alfabéticos en mayúsculasdec, hex, oct: Cambiar base (decimal, hexadecimal y octal)fixed, scientific: Usar notación de coma fija o científicainternal, left, right: Alinear el textoendl, ends, flush: Finalizar línea, cadena y vaciar buffer

Clases istream y ostream• Manipuladores con parámetrossetprecision (int): Fija la precisión en coma flotantesetw (int): Fija el tamaño de un campo (que se rellenaautomáticamente en caso de ser necesario)setfill (char): Selecciona el carácter para el rellenosetbase (int): Fija la base numérica a usar (8, 10 ó 16)setiosflags (mask): Fija cualquiera de los anteriores flagsresetiosflags (mask): Reinicia los flags a los valores por defecto• Otra forma de hacer lo mismo • Manipuladores sin parámetros: métodos setf y unsetf • Manipuladores con parámetros: métodos propios (fill, width,precision, etc.)

Clases istream y ostream• Ejemplos cout

Clase ostream• Permite hacer operaciones de escritura con y sinformato • Sin formato: put y write • Con formato: operator

Clase ostream• La sobrecarga del operador de inserción permiterealizar escritura con formato • Se puede sobrecargar para cualquier tipo ostream& operator

Clase ostream• El método put permite escribir un carácter en elstream ostream& put (char ch) • El método write permite escribir n caracteres deun array en el stream ostream& write (const char* pch, int n) • El método flush fuerza el vaciado del bufferasociado al stream ostream& flush ()

Clase ostream• El método tellp permite obtener la posición enel stream de salida (principalmente ficheros) pos_type tellp () • Los métodos seekp permiten cambiar la posiciónde escritura en relación a la posición actual… ostream& seekp (pos_type pos) • …o en relación a una posición de referencia ostream& seekp (off_type des, ios_base::seekdir pos)

Clase ostream• Ejemplos: const char* cadena = “Hola mundo”; cout

Clase istream• Permite realizar operaciones de lectura con y sinformato: • Sin formato: get, getline, read, ignore, peek,gcount, unget, putback • Con formato: operator>> • Al igual que la clase ostream, permite gestionarerrores y reposicionar el puntero de lectura

Clase istream• La sobrecarga del operador de extracciónpermite realizar lectura con formato • Se puede sobrecargar para cualquier tipo istream& operator>> (istream& is, T& data) • Y usar los manipuladores vistos anteriormente(aunque algunos pueden tener sentidoúnicamente para la clase ostream)

Clase istream• El método get permite leer un carácter delstream: istream& get (char& ch) • El método getline permite leer una línea, con unalongitud máxima hasta encontrar un delimitador istream& getline (char* ch, int n, char delim = “\n”) • El método read permite leer n caracteres istream& read (char* ch, int n)

Clase istream• El método ignore extrae y descarta una cadenade hasta n caracteres, mientras no encuentre undelimitador dado istream& ignore (int n = 1, int delim = eof ()) • El método peek devuelve el siguiente carácterdel stream sin extraerlo int peek () const

Clase istream• El método gcount devuelve el número decaracteres leídos en la última extracción sinformato int gcount () const • El método unget devuelve el último carácterextraído al stream istream& unget () • El método putback devuelve c al stream istream& putback (char c)

Clase istream• El método tellg permite obtener la posición en elstream de entrada (principalmente ficheros) pos_type tellg () • Los métodos seekg permiten cambiar la posiciónde lectura en relación a la posición actual… istream& seekg (pos_type pos) • …o en relación a una posición de referencia istream& seekg (off_type des, ios_base::seekdir pos)

Clase istream• Ejemplos char c, cad [100], cad2[10]; cin >> cad;// Introducimos por teclado Hola mundo cin.get(c);// cad = Hola, c= cin.getline (cad, 100, \n); // cad=mundo cin.read (cad2, 10); // Introducimos por teclado // Hola mundo cruel.Adios cout cad; // cad=!Adios!

Clase iostream• Clase derivada tanto de istream como de ostream • Proporciona acceso de lectura/escritura astreams • Presenta los mismos métodos que las clases delas que deriva

Gestión de errores• Los streams manejan 4 bits de error: • eofbit: Se alcanzó el final del fichero en una operación de E/S • failbit: El método de E/S falló • badbit: Hubo un problema con el stream al realizar laoperación • goodbit: Ninguno de los anteriores bits está activado • Los métodos eof, fail, bad y good devuelven elvalor de estos bits

Índice • Sobrecarga de Funciones • Sobrecarga de Operadores • Entrada/Salida sobre streams básicos • Entrada/Salida sobre streams defichero • Entrada/Salida sobre streams de cadena

E/S sobre streams de fichero• Proporcionada por el fichero de cabecera:#include • Provee de las clases ofstream (salida), ifstream(entrada) y fstream (entrada/salida) • Distintos modos para abrir un fichero: ios::in, ios::out, ios::trunc, ios::app, ios::binary, ios::ate • El fichero se puede abrir en el constructor o conel método open

Métodos de apoyo• El método eof indica si se alcanzó el final delfichero: bool eof () const • El método is_open indica si existe un ficheroabierto asociado con el stream bool is_open () const • El método close cierra el fichero abierto y lodesliga del stream bool close ()

Clase ofstream• Clase derivada de ostream especializada enrealizar escrituras sobre ficheros • El fichero se puede abrir al construir un objetode tipo ofstream o con el método open ofstream (const char* nombre_fichero,ios_base::openmode modo = ios::out | ios::trunc) void open (const char* nombre_fichero,ios_base::openmode modo = ios::out | ios::trunc)

Clase ofstream• Ejemplo: ofstream of (fichero.txt"); of.write ("Hola mundo\n", 11); of

Clase ifstream• Clase derivada de istream especializada enrealizar lecturas desde ficheros • El fichero se puede abrir al construir un objetode tipo ifstream o con el método open ifstream (const char* nombre_fichero,ios_base::openmode modo = ios::in) void open (const char* nombre_fichero,ios_base::openmode modo = ios::in)

Clase ifstream• Ejemplo: ifstream f (fichero.txt"); char buffer[100]; f.getline (buffer, 100); cout

Clase fstream• Combina las funcionalidades de ifstream yofstream • El fichero se puede abrir al construir un objetode tipo fstream o con el método open fstream (const char* nombre_fichero,ios_base::openmode modo = ios::in | ios::out) void open (const char* nombre_fichero,ios_base::openmode modo = ios::in | ios::out)

E/S usando Registros• Podemos escribir estructuras de datos complejas• Los datos se guardan en formato binario, enlugar de escribirse carácter a carácter • Podemos hacerlo con los métodos read y write • Requiere una conversión de la estructura en unarray de caracteres • Uso de reinterpret_cast()

E/S usando Registrosstruct nodo_agenda {char nombre[30];char direccion[40];long telefono; }; nodo_agenda persona; cin.getline (30, persona.nombre); cin.getline (40, persona.direccion); cin >> persona.telefono; ofstream ofs (“agenda”); ofs.write (reinterpret_cast(&persona), sizeof(nodo_agenda)); ofs.close ();

Índice • Sobrecarga de Funciones • Sobrecarga de Operadores • Entrada/Salida sobre streams básicos • Entrada/Salida sobre streams de fichero • Entrada/Salida sobre streams decadena

La clase String• Clase que sirve para trabajar con cadenas decaracteres • También almacena el tamaño de la cadena • Gestiona automáticamente la memoria dinámicaasociada a la cadena • Facilita las operaciones más habituales concadenas de caracteres • Hace falta incluir el siguiente fichero decabecera: #include

La clase String• Cómo construimos un objeto de tipo string: string cad1; // Construye una cadena vacía string cad2 (cad1); // Constructor de copia char arr[] = “Hola mundo”); string cad3 (arr); // Constructor a partir de un array de char • Podemos consultar el tamaño de una cadena: cout

La clase String• Podemos asignar cadenas sin miedo (la memoriala gestiona la propia clase): string cad1 = “Hola mundo”; string cad2 = “Adios mundo”; cad2 = cad1; • Si nos interesa, podemos recuperar el array decaracteres asociado al objeto string string cad1 = “abcdefgh”; const char* arr1 = cad1.c_str(); // Sí añade ‘\0’ const char* arr2 = cad1.data(); // No añade ‘\0’ char buffer[80]; cad1.copy (buffer, cad1.size(), 0);

La clase String• También podemos realizar las operaciones decomparación habituales: ==, !=, , = • Se comparan letra por letra y se usa el ordenalfabético string str1 = “abcdefg”, str2 = “Abcdefg”; if (str1 < str2) cout

La clase String• Se pueden insertar caracteres en una cadena: string cad = “Hola”; cad += “ mundo”; // Añade “ mundo” al final cad.append (“ cruel”); // Añade “ cruel” al final cad.insert (11, “nada “); // Inserta “nada “ en la posición 11 cout

La clase String• También podemos buscar subcadenas: int pos; string cad = “abcdefghijk”; pos = cad.find (“efg”); // pos = 4 pos = cad.find (“i”); // pos = 8 • Reemplazar subcadenas: cad.replace (cad.find (“efg”), 2, “ zyx ”); // cad = “abcd zyx ghijk” • Y extraer subcadenas: string cad1 = “Esto es una cadena”; string cad2 = cad1.substr (12, 6); // cad2 = “cadena”

Entrada/Salida sobre streams de cadena• Proporcionada por el fichero de cabecera:#include • Provee de las clases ostringstream (salida),istringstream (entrada) y stringstream (e/s) • Permite realizar operaciones de E/S sobreobjetos de tipo string (parecido al sprintf de C) • Se pueden usar los métodos de las clases básicasistream, ostream y stream (respectivamente)

Entrada/Salida sobre streams de cadena• Definen dos métodos adicionales: string str ( ) constvoid str (const string & s) • Permiten recuperar e inicializar la cadenaasociada al stream • También se les puede asociar una cadena en elconstructor istringstream (const string& str,ios_base::openmode modo = ios_base::in)

Ejemplo con ostringstreamostringstream buffer; string nombre = "Antonio"; int edad = 27; char aficion[] = "leer"; buffer

Ejemplo con istringstreamstring nombre2; int edad2 = 0; char aficion2[80]; istringstream buffer2 ("Antonio , 27 , leer"); buffer2 >> nombre2; // nombre2 = Antonio buffer2.ignore(100, ','); // Descartamos la , buffer2 >> edad2; // edad2 = 27 buffer2.ignore(100, ','); // Descartamos la , buffer2 >> aficion2; // aficion2 = leer