OBJETIVO

El objetivo de la presente sesión es:

 Conocer acerca de sobrecarga de operadores

 Declaración de la función sobrecarga de operadores
 Definición de la función sobrecarga de operador
 Llamada a la función operadora
 Sobrecarga de operador binario y unario
 Operador this
 Ejemplo de aplicación

A L G O R I T M O S Y E S T R U C T U R A D E D AT O S 1
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 función
operadora.
Un operador solo funciona con objetos de una clase.
Por lo general la función operadora es miembro de la
clase o una función amiga.
El valor devuelto de la función operadora es la clase
para la que se define.

ALGORITMOS Y ESTRUCTURA DE DATOS 2

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 3

DECLARACION DE LA FUNCION PROTOTIPO
DE SOBRECARGA
 Para declarar debe incluir el prototipo de la función dentro
de la clase o indicar como función amiga.
class <Nombre de la clase>
{ private:
<tipo dato> datos privados;
public:
<tipo dato> Nombre funcion(lista parametros);
<tipo dato> operator <op> (lista parametros);
friend <tipo dato> operator <op> (lista parametros);
};
ALGORITMOS Y ESTRUCTURA DE DATOS 4
DEFINICION DE LA FUNCION DE SOBRECARGA
 Si es función miembro:
<tipo de dato> <Nombre clase>:: operator <op> (Lista parametros)
{
Sentencia(s);
}

 Si es función amiga:
<tipo de dato> operator <op> (Lista parametros)
{
Sentencia(s);
}

ALGORITMOS Y ESTRUCTURA DE DATOS 5

 LLAMADA A UNA FUNCION QUE SOBRECARGA
UN OPERADOR
 Para llamar a una función que sobrecarga un operador se
puede hacer de 2 formas:
 Forma abreviada:

objeto1<operador>(Lista parámetros actuales)

si es función miembro

 Forma general:

objeto.operator<operador>(Lista de parámetros actuales)

ALGORITMOS Y ESTRUCTURA DE DATOS 6

SOBRECARGA DE OPERADORES
LA SOBRECARGA DE OPERADORES BINARIOS

 La función tendrá solo un parámetro.

 Este parámetro contendrá al objeto que esta en el lado derecho.
 El objeto del lado izquierdo genera la llamada a la función
operadora y se pasa implícitamente a través de this.

SOBRECARGA DE UN OPERADOR UNARIO

 Solo se tiene un operando

 No tiene parámetros.
 El operando genera la llamada a la función operadora.

ALGORITMOS Y ESTRUCTURA DE DATOS 7

 PUNTERO THIS

 Todo objeto tiene un puntero asociado a él, a este puntero

se llama puntero this.
 El puntero this guarda la dirección de memoria del objeto
 Este puntero apunta al mismo objeto
 A través de este puntero se accede a sus datos y
funciones miembro.

ALGORITMOS Y ESTRUCTURA DE DATOS 8

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 9

EJEMPLO CON EL PUNTERO THIS
friend Complejo operator-(Complejo R,Complejo S);
Complejo operator+(Complejo p);
};
//Definicion de funciones miembro
Complejo::Complejo()
{ real=0; imag=0;
}
Complejo::Complejo(float a, float b)
{
real=a; imag=b;
}

ALGORITMOS Y ESTRUCTURA DE DATOS 10

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 11

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 12

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 13

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 función operador +
};

ALGORITMOS Y ESTRUCTURA DE DATOS 14

 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 15

 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 16

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 17

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 18

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 19
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 20

APLICACIÓN 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 tamaño 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 21
 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 22

 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 23
 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 24

 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 25

 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 26

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 27

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 28
CONTINUACION…

ALGORITMOS Y ESTRUCTURA DE DATOS 29