SOBRECARGA DE OPERADORES

La sobrecarga de operadores es similar a la sobrecarga

de funciones.
El operador sobrecargado no pierde su contenido
original.
Para sobrecargar un operador, se crea una funcin
operadora.

Un operador solo funciona con objetos de una clase.

Por lo general la funcin operadora es miembro de la
clase o una funcin amiga.

El valor devuelto de la funcin operadora es la clase

para la que se define.
ALGORITMOS Y ESTRUCTURA DE DATOS

SOBRECARGA DE OPERADORES
Al sobrecargar un operador no se puede cambiar la
precedencia del operador.

El numero de operandos que tiene un operador no

puede modificarse.
Los operandos que no se puede sobrecargar son .,
::, .*, ? y los operadores preprocesador.
No podemos construir nuestros propios operadores,
solo es posible sobrecargar los operadores definidos
en el C++

ALGORITMOS Y ESTRUCTURA DE DATOS

DECLARACION DE LA FUNCION PROTOTIPO

DE SOBRECARGA
Para declara debe incluir el prototipo de la funcin dentro
de la clase o indicar como funcin amiga.
class <Nombre de la clase>
{ private:
<tipo dato> datos privados;
public:
<tipo dato> Nombre funcion(lista parametros);
<tipo dato> operator <op> (lista parametros);

};

ALGORITMOS Y ESTRUCTURA DE DATOS

DEFINICION DE LA FUNCION DE SOBRECARGA

Para definir una funcin de sobrecarga es como sigue:

<tipo de dato> <Nombre clase>:: operator <op> (Lista parametros)
{
Sentencia(s);
}

ALGORITMOS Y ESTRUCTURA DE DATOS

SOBRECARGA DE OPERADORES
LA SOBRECARGA DE OPERADORES BINARIOS
La funcin tendr solo un parmetro.
Este parmetro contendr al objeto que esta en el lado derecho.
El objeto del lado izquierdo genera la llamada a la funcin
operadora y se pasa implcitamente a travs de this.
SOBRECARGA DE UN OPERADOR UNARIO
Solo se tiene un operando
No tiene parmetros.
El operando genera la llamada a la funcin operadora.

ALGORITMOS Y ESTRUCTURA DE DATOS

PUNTERO THIS
Todo objeto tiene un puntero asociado a el, a este puntero
se llama puntero this.
El puntero this guarda la direccin de memoria del objeto
Este puntero apunta al mismo objeto
A travs de este puntero se accede a sus datos y
funciones miembro.

ALGORITMOS Y ESTRUCTURA DE DATOS

EJEMPLO CON EL PUNTERO THIS

#include <iostream>
using namespace std;
class Complejo
{ private:
float real;
float imag;
public:
Complejo();
Complejo(float,float);
void Ver();

ALGORITMOS Y ESTRUCTURA DE DATOS

EJEMPLO CON EL PUNTERO THIS

friend Complejo operator-(Complejo R,Complejo S);
Complejo operator+(Complejo p);
};
//Definicion de funciones miembro
Complejo::Complejo()
{
}
Complejo::Complejo(float a, float b)
{
real=a; imag=b;
}
ALGORITMOS Y ESTRUCTURA DE DATOS

EJEMPLO CON EL PUNTERO THIS

void Complejo::Ver()
{ cout<<endl;
cout<<this->real<<" "<<this->imag<<"i"<<endl;
cout<<endl;
}
Complejo Complejo::operator+(Complejo p)
{ this->real=real+p.real;
this->imag=imag+p.imag;
return *this;
}
ALGORITMOS Y ESTRUCTURA DE DATOS

EJEMPLO CON EL PUNTERO THIS

Complejo operator-(Complejo R,Complejo S)
{
Complejo T;
T.real=R.real - S.real;
T.imag=R.imag - S.imag;
return T;
}
void Lectura(float &x1, float &y1,float &x2, float &y2)
{cout<<endl<<"M(x1,y1) ";cin>>x1>>y1;
cout<<"N(x2,y2) ";cin>>x2>>y2;
}
ALGORITMOS Y ESTRUCTURA DE DATOS

10

EJEMPLO CON EL PUNTERO THIS

//Funcion principal
int main()
{ float x1,y1,x2,y2;
Lectura(x1,y1,x2,y2);
Complejo M(x1,y1),N(x2,y2),P,Q;
M.Ver();
N.Ver();cout<<"M - N"<<endl;
P=M-N;
P.Ver();cout<<"M + N"<<endl;
Q=M.operator+(N); Q.Ver();
}
ALGORITMOS Y ESTRUCTURA DE DATOS

11

SOBRECARGA DE OPERADOR BINARIO +

#include <iostream>
// Declaracion de la clase
class punto
{ private:
int x,y,z;
public:
punto(){} // Constructor vacio
punto(int, int, int);
void MostrarPunto();
punto operator+(punto q); // Sobrecarga de funcion
operador +
};
ALGORITMOS Y ESTRUCTURA DE DATOS

12

CONTINUACION ...
// programa principal
int main()
{ punto p1(1,1,8),p2(3,2,-1),p3;
cout<<"\tP1=";p1.MostrarPunto();
cout<<"\tP2=";p2.MostrarPunto();
p3=p1+p2; //Suma los dos objetos y ocurre la llamada a operator+()
cout<<"----------------------------"<<endl;
cout<<"\tP3=";p3.MostrarPunto();
}

ALGORITMOS Y ESTRUCTURA DE DATOS

13

CONTINUACION ...
//Definicion de las funciones miembro de la clase
punto::punto(int a, int b, int c)

x=a;
y=b;z=c;

}
void punto::MostrarPunto()
{
cout<<"("<<x<<","<<y<<","<<z<<")"<<endl;
}
ALGORITMOS Y ESTRUCTURA DE DATOS

14

CONTINUACION ...
punto punto::operator+(punto q)
{ punto temp;
temp.x=x+q.x;
temp.y=y+q.y;
temp.z=z+q.z;
return temp;
}

ALGORITMOS Y ESTRUCTURA DE DATOS

15

SOBRECARGA OPERADOR UNARIO [ ]

/* Dado el programa principal como dato se pide definir la clase misterio
y las funciones necesarias para producir la siguiente salida */

#include <iostream>
using namespace std;
// programa principal
int main()
{ misterio x(10,20,30);
for(int i=0;i<3;i++)
cout<<"\t"<<x[i];
cout<<endl<<endl;
}

ALGORITMOS Y ESTRUCTURA DE DATOS

16

SOBRECARGA OPERADOR [ ]
#include <iostream>
#include <stdlib.h>
using namespace std;
class misterio
{ private:
int a,b,c;
int A[3];
public:
misterio(int, int, int);
int operator[](int); // sobrecarga del operador []
};
int main()
{ misterio x(10,20,30);
for(int i=0;i<3;i++)
cout<<"\t"<<x[i];
cout<<endl<<endl;
}
ALGORITMOS Y ESTRUCTURA DE DATOS

17

SOBRECARGA OPERADOR [ ]
misterio::misterio(int r, int s, int t)
{
a=r;
b=s;
c=t;
}
int misterio::operator[](int i)
{ if(i==0)
A[i]=a;
else if(i==1)
A[i]=b;
else
A[i]=c;
return A[i];
}
ALGORITMOS Y ESTRUCTURA DE DATOS

18

APLICACIN DE SOBRECARGA DE OPERADORES

#include <iostream>
using namespace std;
const int M=20; // Dato asumido para efectos de declaracion
class Operadores
{ private:
int N; // Indica el tamao de la matriz cuadrada A
int A[M][M]; // Es la matriz
public:
Operadores(int);
void Generar();

void VerMatriz();
bool SumaElementosEsPar();
void operator++(); // Incrementa los elementos de la matriz
ALGORITMOS Y ESTRUCTURA DE DATOS

19

CONTINUACION
void operator+(int k); //Incrementa los elementos de la matriz en k
void operator*(int b); //Multiplica los elementos de la matriz por b
friend void operator-(Operadores &p, int a); //Decrementa los elementos de la matriz en a
friend void operator/(Operadores &p,int b); //Decrementa los elementos de la matriz en b
void operator%(int); //Almacena como elementos el resto
}; // fin de la clase
int main()
{

Operadores q(3);int a=5,b=7,c=3,d=1,e=3;

q.Generar();cout<<"Matriz Original"<<endl;

q.VerMatriz();

++q;cout<<"Matriz Original Incrementados en una unidad sus

elementos"<<endl; q.VerMatriz();
q+a;cout<<"Matriz incrementado en "<<a<<" veces"<<endl;

ALGORITMOS Y ESTRUCTURA DE DATOS

20

CONTINUACION

q.VerMatriz();cout<<"Matriz multiplicada sus elementos

por "<<b<<endl;
q*b; q.VerMatriz();
if(q.SumaElementosEsPar())
cout<<"Es Verdad\n";
else
cout<<"Es falso\n";
q/e;cout<<"Matriz dividido entre "<<e<<endl; q.VerMatriz();
q%c; cout<<"Matriz con resto "<<c<<endl; q.VerMatriz();
q-d;cout<<"Matriz con diferencia de "<<d<<endl;
q.VerMatriz();
}
ALGORITMOS Y ESTRUCTURA DE DATOS

21

CONTINUACION
Operadores::Operadores(int m)
{ N=m;
}
void Operadores::Generar()
{ int k=1,i,j;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
{ while(k%2!=0)
{ A[i][j]=k; k++; }
k++;
}
}

ALGORITMOS Y ESTRUCTURA DE DATOS

22

CONTINUACION
void Operadores::VerMatriz()
{ for(int i=0;i<N;i++)
{ for(int j=0;j<N;j++)
cout<<A[i][j]<<"\t";
cout<<endl;
}
}
void Operadores::operator++()
{ for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
A[i][j]++;
}

ALGORITMOS Y ESTRUCTURA DE DATOS

23

CONTINUACION
void Operadores::operator+(int k)
{ for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
A[i][j]+=k;
}
void Operadores::operator*(int k)
{ for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
A[i][j]*=k;
}

ALGORITMOS Y ESTRUCTURA DE DATOS

24

CONTINUACION
void Operadores::operator%(int k)
{ for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
A[i][j]%=k;
}
void operator-(Operadores &p, int a)
{ for(int i=0;i<p.N;i++)
for(int j=0;j<p.N;j++)
p.A[i][j]-=a;
}

ALGORITMOS Y ESTRUCTURA DE DATOS

25

CONTINUACION
void operator/(Operadores &p,int b)
{ for(int i=0;i<p.N;i++)
for(int j=0;j<p.N;j++)
p.A[i][j]/=b;
}
bool Operadores::SumaElementosEsPar()
{ int i,j,s=0;
for(i=0;i<N;i++)
for(j=0;j<N;j++)
s+=A[i][j];
if(s%2==0)
return true;
else
return false;
}
ALGORITMOS

Y ESTRUCTURA DE DATOS

26

CONTINUACION

ALGORITMOS Y ESTRUCTURA DE DATOS

27