sesión 10: sobrecarga (2) 1. 2009/1 circuitos digitales iii 2010/1 circuitos digitales iii 2010/1...

1

Informática IISesión 10: Sobrecarga (2)

2009/1Circuitos Digitales III 2010/1Circuitos Digitales III 2010/1Circuitos Digitales IIICircuitos Digitales III 2010/1Informática II Universidad de Antioquia

CONTENIDOCONTENIDO

2

Sobrecarga de Operadores1

Sobrecarga de un operador2

Sobrecarga de dos operadores3


La sobrecarga de operadores permite redefinir algunos de los operadores existentes en C++ para que actúen de una determinada manera.

La manera de trabajar es definida por el programador como. Métodos de los objetos de una clase creada por el

mismo. Funciones externas a las clases.

3

SOBRECARGA DE OPERADORES



La sobrecarga de operadores se emplea para declarar “cómo es que funciona” dicho operador.

Cuando sobrecargamos cualquier operador nos referimos a cambiar su funcionalidad pero no su gramática original.

Así por ejemplo: Suma: a + b; a+; Asignación: a = a+b; a + b = a;

4




Cuando en C++ determinamos el uso de un operador :

+, -, *, /, %, =, <, …

Estamos haciendo uso de funciones con identificadores (nombres) especiales.+ → operator+

- → operator-

* → operator*

5




La sobrecarga de un operador puede ser declarada de la siguiente forma:

tipodeRetorno operatorop (parametros);

6

// Ejemplo declaración para el sobrecargado del operador +float operator+ (float x);

Void, int, char, …

Palabrareservada

-, --, + , ++, =, ==, …

Void, int, char, …




Suponiendo que tenemos tres objetos de una misma clase: c1, c2, c3

c3 = c1.suma(c2);

Sería más sencillo utilizar la sobrecarga de operadores:

c3 = c1.operator+(c2);

c3 = c1+ c2;

7




El objetivo de la sobrecarga de operadores es simplificar al máximo el código a implementar.

A cambio agregar algunas definiciones en las clases.

Una clase que disponga de operadores sobrecargados es una clase más compleja de definir, pero más sencilla e intuitiva de utilizar.

8




Existen dos clases de sobrecargas: De un operador De dos operadores

9




CONTENIDOCONTENIDO

10





La sobrecarga puede ser empleada para redefinir las operaciones unitarias. Algunas de ellas son:

+= -= *= /= %= ^= &= |=

++ --

entre otras

Los operadores de un operador realizan modificaciones sobre los mismos objetos que llaman dicha función.

11

Sobrecarga de un OperadorSobrecarga de un Operador


Sobrecarga de un Operador (pre ++)Sobrecarga de un Operador (pre ++)

class Contador{private:

int x;int y;

public://constructoresContador();Contador(const Contador& original);//Obtener y Asignarint getX() const {return x;}int getY() const {return y;}void setX(int _x);void setY(int _y);//Otros Métodosvoid incrementar();//sobrecargar el operador void operator++(); // -> cont++;~Contador();

};

12

//constructor por defectoContador::Contador(): x(0),y(0){}

//constructor de copiaContador::Contador(const Contador&

original){x=original.x;y=original.y;

}

void Contador::setX(int _x){x=_x;

}void Contador::setY(int _y){

y=_y;}void Contador::incrementar(){

x=x+2;y=y+4;

}

//definición sobrecarga del operador preincremento (++i)

void Contador::operator++(){x=x+2;y=y+4;

}//Destructorcontador::~contador(){}

#include <iostream>using namespace std;

int main(){Contador mycontador();mycontador.incrementar();

cout<<“Metodo Incrementar: ”<< mycontador.getX()<<“,”<<mycontador.getX()<<endl;

++mycontador;cout<<“Operador ++: " << mycontador.getX()<<“,”<<mycontador.getX()<<endl;

return 0;}

Metodo Incrementar: 2,4

Operador ++: 4,8


Ahora lo que generalmente se desea es poder es retornar un objeto tipo contador, de este modo poder reasignarlo a otro objeto tipo contador.

13

//definición de la operador preincremento (++i)

Contador Contador::operator++(){x=x+2; y=y+4;Contador temp;temp.setX(x);temp.setY(y);return temp;

}

using namespace std;

int main(){Contador cont1;

cont1.incrementar();cout<<"cont1: " <<cont1.getX()<<“,”<<cont1.getY()<<endl;

Contador cont2=++cont1;cout<<"cont2: " <<cont2.getX()<<“,”<<cont2.getY()<<endl;

return 0;}

cont1: 2,4

cont2: 4,8



Pero por qué crear un objeto temporal?

Recordemos que cada objeto temporal debe ser: Construido Copiado Destruido luego del retorno del método

Cada operación de estas muy costosa computacionalmente hablando.

14



El objeto cont1 ya existe y posee un valor adecuado para las variables, porque no retornar a sí mismo mediante el puntero this. *this es el objeto. this es la dirección del objeto.

15

//definición de la operador preincremento (++i)Contador Contador::operator++(){

x=x+2;y=y+4;return *this;

}



1 •A través del objeto cont1, se llama el método que sobrecarga el operador preincremento (++).

2 •Dicho método incrementa las variables, y se retorna a sí mismo (contador) .

3 •Se llama el constructor de copia del objeto cont2, el cual recibe como argumento por defecto la referencia de un objeto del mismo tipo (cont1).

16

En esta línea de código se presenta los siguientes pasos:contador cont2=++cont1;



Los operadores posfijos son los que primero devuelven el valor y luego opera la variable, ejemplo: i++;

Para sobrecargar el operador posfijo en los objetos, es necesario el uso de objetos temporales dentro de los métodos para luego devolverlos por valor.

17

Sobrecarga de un Operador (pos ++)Sobrecarga de un Operador (pos ++)


DeclaraciónContador Contador::operator++(int flag)

{

Contador temp(*this);

x=x+2;y=y+4;

return temp;

}

/* Notese el uso de la variable flag... dicha vble es declarada pero ¡¡nunca es utilizada!! */

18

flag tipo int tiene valor 0 y no se utiliza nunca, solo sirve como criterio de distinción frente al operador de preincremento.



1• Creamos un objeto

temporal copia del objeto original.

2• Modificamos el valor de la

variable del objeto original.

3• Retornamos el objeto copia

temporal.

19

De este modo, el valor del objeto será modificado, pero en la expresión donde aparezca se tomará el valor antes de modificar.





int x;int y;

public://constructoresContador();Contador(const Contador& original);//Obtener y Asignarint getX() const {return x;}int getY() const {return y;}void setX(int _x);void setY(int _y);//Otros Métodosvoid incrementar();//sobrecarga el operador preincremento (++i)Contador operator ++();//sobrecarga del operador posincremento (i++)Contador operator ++(int flag);~Contador();

}; 20

//ConstructorContador::Contador():x(0),y(0){}

//constructor de copiacontador::contador(contador& original){

x=original.x;y=original.y;

}

int Contador::getX() const{return X;

}int Contador::getY() const{

return Y;}void Contador::setX(int _x){

x=_x;}void Contador::setY(int _y){


x=x+2;y=y+4;

}

//definicion de la operador preincremento (++i)

Contador Contador::operator++(){x=x+2;y=y+4;return *this;

}

//definicion del operador posincremento (i++)

Contador Contador::operator++(int flag){//copia del objeto Contador temp(*this); x=x+2;y=y+4;return temp;

}


int main(){

contador cont1;

cont1.incrementar();cout<<“Metodo Incrementar: "<< cont1.getX()<<“,”<< cont1.getY()<< endl;

contador cont2=++cont1;cout<<“Preincremento cont1: "<< cont1.getX()<<“,”<< cont1.getY()<< endl;cout<<“Valor de cont2: "<< cont2.getX()<<“,”<< cont2.getY()<< endl;

cont2=cont1++;cout<<“Posincremento cont1: "<< cont1.getX()<<“,”<< cont1.getY()<< endl;cout<<“Valor de cont2: "<< cont2.getX()<<“,”<< cont2.getY()<< endl;

return 0;}

Metodo Incrementar: 2,4Preincremento cont1: 4,8Valor de cont2: 4,8Posincremento cont1: 6,12Valor de cont2: 4,8


1

• Un operador puede estar sobrecargado o redefinido varias veces, de tal manera que actúe de un modo distinto dependiendo del tipo de objetos que tenga como argumentos de entrada.

2

• Las ventajas de la sobrecarga de operadores terminan cuando se utiliza de modo que añade complejidad o confusión a los programas. Por ejemplo: no se deberá nunca utilizar el operador (-) para multiplicar matrices o el (+) para imprimir vectores.

3

• Los únicos operadores de C++ que no se pueden sobrecargar son:• El operador punto (.),• El if aritmético (?:)• El operador sizeof, • El scope operator (::)• puntero a miembro de un objeto (.*).

21

Sobrecarga de un OperadorSobrecarga de un Operador


CONTENIDOCONTENIDO

22





OPERADORES BINARIOSOPERADORES BINARIOS Son aquellos que requieren dos operandos,

como la suma o la resta. Cuando se sobrecargan operadores en el interior se asume que el primer operando es el propio objeto de la clase donde se define el operador. Debido a esto, sólo se necesita especificar un operando como argumento.

23


SOBRECARGANDO EL OPERADOR +

SOBRECARGANDO EL OPERADOR +


int x;int y;

public://constructoresContador();Contador(int _x, int _y);Contador(Contador& original);//Asignar y Obtenerint getX() const {return x};int getY() const {return y};void setX(int _x);void setY(int _y);void incrementar();//sobrecarga el operador +Contador operator+(const Contador& c);~Contador();

};

24

contador::contador():x(0),y(0){}

contador::contador(int _x, int y):x(_x),y(_y){}

//constructor de copiacontador::contador(contador& original){

x=original.x;y=original.y;

}void contador::setX(int _x){

x=_x;}void Contador::setY(int _y){


x=x+2;y=y+2;

}

//definición del operador +Contador Contador::operator+(const Contador&

c){Contador temp;temp.setX(variable+c.getX());temp.setY(variable+c.getY());return temp;

}

Contador::~Contador(){}


//Ejemplo operador +int main(){

contador cont1(5,3),cont2(6,9);contador cont3=cont1+cont2;cout<<"el valor de cont1 es: "<<cont1.getX()<<“,”<<cont1.getY()<<endl;cout<<"el valor de cont2 es: "<<cont2.getX()<<“,”<<cont2.getY()<<endl;cout<<"el valor de cont3 es: "<<cont3.getX()<<“,”<<cont3.getY()<<endl;

return 0;}

el valor de cont1: 5,3el valor de cont2: 6,9el valor de cont3: 11,112


Qué pasa si el objeto cont1 tiene como variables miembro punteros que acceden a memoria dinámica?

El objeto cont2 al ser de la misma clase que cont1 igualmente ya cuenta con espacio en memoria dinámica, luego solo basta con copiar el nuevo valor respectivo en dicho espacio.

25

int main(){

contador cont1(5,3),cont2(6,9);cont2=cont1;cout<<"el valor de cont1 es: "<<cont1.getX()<<“,”<<cont1.getY()<<endl;cout<<"el valor de cont2 es: "<<cont2.getX()<<“,”<<cont2.getY()<<endl;return 0;

}

SOBRECARGANDO EL OPERADOR =





26

//sobrecarga el operador =const contador& operator =(const contador &c);

//definicion del operador =const contador& contador::operator =(const contador &c)

{if(this==&c){

return *this;}else{

x=c.x;y=c.y;

}return *this;

}


ResumenResumen Así, cuando hacemos la sobrecarga de un

operador y realizamos su llamado nos referimos a:

27

Expresión Método Función

@a a.operator@() operator@(a)

a@b a.operator@(b) operator@(a,b)

a=b a.operator=(b)

a[b] a.operator[](b)

a-> a.operator->()

a@ a.operator@(0) operator@(a,0)


BibliografíaBibliografía Curso C++ con clase

http://c.conclase.net/curso/?cap=043 Pagina de Referencia lenguaje C++: http://www.cplusplus.com/reference/std/exceptio

n/exception/ http://www.cplusplus.com/reference/std/stdexcep

t/ Sams Teach yourselft C++ in 21 days:

http://newdata.box.sk/bx/c/htm/ch20.htm#Heading1

28

http://c.conclase.net/curso/?cap=043

http://www.cplusplus.com/reference/std/exception/exception/

http://www.cplusplus.com/reference/std/exception/exception/

http://www.cplusplus.com/reference/std/stdexcept/

http://www.cplusplus.com/reference/std/stdexcept/

sesión 10: sobrecarga (2) 1. 2009/1 circuitos digitales iii 2010/1 circuitos digitales iii 2010/1...

Documents