Ing.

Felix Huari Algoritmos y Programacin 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 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.
Ing. Felix Huari Algoritmos y Programacin 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++
Ing. Felix Huari Algoritmos y Programacin 3
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);
};
Ing. Felix Huari Algoritmos y Programacin 4
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);
}
Ing. Felix Huari Algoritmos y Programacin 5
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.
Ing. Felix Huari Algoritmos y Programacin 6
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 +
};
Ing. Felix Huari Algoritmos y Programacin 7
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();
system("PAUSE");
}
Ing. Felix Huari Algoritmos y Programacin 8
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;
}
Ing. Felix Huari Algoritmos y Programacin 9
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;
}
Ing. Felix Huari Algoritmos y Programacin 10
SALIDA DEL RESULTADO
Ing. Felix Huari Algoritmos y Programacin 11
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>
#include <stdlib.h>
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;
system("pause");
}
Ing. Felix Huari Algoritmos y Programacin 12
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;
system("pause");
}
Ing. Felix Huari Algoritmos y Programacin 13
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];
}
Ing. Felix Huari Algoritmos y Programacin 14
EJEMPLO DE 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
Ing. Felix Huari Algoritmos y Programacin 15
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;
Ing. Felix Huari Algoritmos y Programacin 16
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();
system("PAUSE");
}
Ing. Felix Huari Algoritmos y Programacin 17
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++;
}
}
void Operadores::VerMatriz()
{ for(int i=0;i<N;i++)
{ for(int j=0;j<N;j++)
cout<<A[i][j]<<"\t";
cout<<endl;
}
}
Ing. Felix Huari Algoritmos y Programacin 18
CONTINUACION
void Operadores::operator++()
{ for(int i=0;i<N;i++)
for(int j=0;j<N;j++)
A[i][j]++;
}
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;
}
Ing. Felix Huari Algoritmos y Programacin 19
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;
}
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;
}
Ing. Felix Huari Algoritmos y Programacin 20
CONTINUACION
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;
}