P.O.O - Sobrecarga de Operadores

1/9
GUIA DE LABORATORIO Nº 13
SOBRECARGA DE OPERADORES
OBJETIVO
Entender y aplicar la sobrecarga de operadores con funciones operadoras y con
funciones amigas.
Ejem 1.
// sobrecarga del operador +
#include <iostream>
class punto
{ private:
int x, y;
public:
punto();// constructor por defecto
punto(int i, int j); //Constructor con parametros
void get_xy(int &i, int &j);
punto operator+(punto p2); //sobrecarga funcion operadora miembro
friend void Print(punto z);
};
//sobrecarga de + relacionada con la clase punto

punto::punto()
{ x=0; y=0;
}
punto::punto(int i, int j)
{x=i; y=j;
}
void punto::get_xy(int &i, int &j)

{i=x; j=y;
}
punto punto::operator+(punto p2)

{ punto temp;
temp.x = x + p2.x;
temp.y = y + p2.y;
return temp; //devuelve un objeto de tipo punto
}
void Print(punto z)
{ cout<<"(p1 + p2) = p3 , X: "<<z.x<<", Y: "<<z.y<<endl;
}
Algoritmos y programación Prof.: Ing. Felix Huari

2/9
void LeerDatos(int &x1, int &y1, int &x2, int &y2)

{ cout<<”Ingrese la coordenadas del primer punto:”;cin>>x1>>y1;
cout<<”Ingrese la coordenadas del segundo punto:”;cin>>x2>>y2;
}
//Funcion principal
int main()
{ int x1,y1, x2,y2,a,b;
LeerDatos(x1, y1,x2, y2);
punto p1(x1,y1),p2(x2,y2),p3;
int x, y;
p3 = p1 + p2; //suma de dos objetos y llamada a operator+()
p3.get_xy(a, b);
Print(p3);
}
Ejem 2.
// sobrecarga de los operadores +, - y el =
#include <iostream>
class punto
{ int x, y;
public:
punto();// constructor por defecto
punto(int i, int j); //Constructor con parametros
punto operator+(punto p2);
punto operator-(punto p2);
punto operator=(punto p2);
};
//Funciones miembro
punto::punto()
{ x=0; y=0;
}
{x=i; y=j;
}

{i=x; j=y;
}

{ punto temp;
temp.x=x+p2.x;
temp.y=y+p2.y;

3/9

}
//sobrecarga de - relacionada con la clase punto

punto punto::operator-(punto p2)
{ punto temp;
temp.x=x-p2.x;
temp.y=y-p2.y;
}
//sobrecarga de = relacionada con la clase punto
punto punto::operator=(punto p2)
{ x=p2.x;
y=p2.y;
//devolucion del objeto que se asigna
return *this;
}
void LeerDatos(int &x1, int &y1, int &x2, int &y2)

{ cout<<”Ingrese la coordenadas del primer punto:”;cin>>x1>>y1;
cout<<”Ingrese la coordenadas del segundo punto:”;cin>>x2>>y2;
}
//Funcion principal
int main()
{ int x1,y1,x2,y2,x,y;
cout<<”Ingrese la coordenadas del primer punto:”;cin>>x>>y;
cout<<”Ingrese la coordenadas del segundo punto:”;cin>>r>>s;
punto p1(x1,y1),p2(x2,y2),p3;
p3=p1+p2; //suma de dos objetos y llamada a operator+()
p3.get_xy(x,y); cout<<"(p1+p2)= X: "<<x<<", Y: "<<y<<endl;
p3=p1-p2; //resta de dos objetos y llamada a operator-()
p3.get_xy(x,y); cout<<"(p1-p2)= X: "<<x<<", Y: "<<y<<endl;
p3=p1; //asignacion de un objeto y llamada a operator=()
p3.get_xy(x,y); cout<<"(p3=p1)= X: "<<x<<", Y: "<<y<<endl;
}
Ejem 3.
#include <iostream>
class punto
{ int x, y;
public:
punto(); // constructor
punto(int i, int j); //constructor con parametros
punto operator+(punto p2);

4/9
punto operator+(int i);

};
//Funciones miembro
punto::punto()
{ x=0; y=0;
}
{x=i; y=j;
}

{i=x; j=y;
}

{ punto temp;
temp.x=x+p2.x;
temp.y=y+p2.y;
}
punto punto::operator+(int i)
{ punto temp;
// suma un valor entero a un objeto punto
temp.x=x+i;
temp.y=y+i;
return temp;
}
//Funcion principal
int main()
{
punto p1(3,5),p2(2,1),p3;
int x, y;
p3=p1+p2; //suma de dos objetos y llamada a operator+()
p3.get_xy(x,y); cout<<"(p1+p2) X: "<<x<<", Y: "<<y<<endl;
p3=p1+5; //suma de objeto + entero y llamada a operator+(int)
p3.get_xy(x,y); cout<<"(p1+5) X: "<<x<<", Y: "<<y<<endl;
p1=p1+p2+p3; //suma de tres objetos y llamada a operator+()
p1.get_xy(x,y); cout<<"(p1+p2+p3) X: "<<x<<", Y: "<<y<<endl;
}

5/9
Ejem 4.
// sobrecarga del operador == y &&
#include <iostream>
const int FALSE=0, TRUE=1;
class punto
{ int x, y;
public:
punto(); // constructor
int operator ==(punto p2);
int operator &&(punto p2);
};
//Funciones miembro
punto::punto()
{ x=0; y=0;
}
{x=i; y=j;
}

{i=x; j=y;
}
//sobrecarga de == relacionada con la clase punto

int punto::operator ==(punto p2)
{ if (x==p2.x && y==p2.y)
return TRUE;
else
return FALSE;
}
//sobrecarga de && para la clase punto
int punto::operator &&(punto p2)
{
return ((x==p2.x) &&(y==p2.y))?TRUE:FALSE;
}
//Funcion principal
int main()
{
punto p1(10,15),p2(5,3),p3(5,3);
int x, y;
// operador ==
if (p1==p2)

6/9
cout<<"p1 es igual que p2\n";

else
cout<<"p1 no es igual que p2\n";
if (p2==p3)
cout<<"p2 es igual que p3\n";
else
cout<<"p2 no es igual que p3\n";
// operador &&
if (p1 && p2)
cout<<"p1 && p2 es verdad\n";
else
cout<<"p1 && p2 no es verdad\n";
if (p2 && p3)

cout<<"p2 && p3 es verdad\n";
else
cout<<"p2 && p3 no es verdad\n";
}
Ejem 5.
// sobrecarga de operadores unarios ++ y –
#include <iostream>
class punto
{ int x, y;
public:
punto()]; // constructor
punto operator++();
punto operator--();
};
//Funciones miembro
punto::punto()
{ x=0; y=0;
}
{x=i; y=j;
}

{i=x; j=y;
}

7/9
//sobrecarga de ++ relacionada con la clase punto

punto punto::operator++()
{
x++;
y++;
//devolucion del objeto al cual se asigna
return *this;
}
//sobrecarga de + para pi + int
punto punto::operator--()
{
x--;
y--;
return *this;
}
//Funcion principal
int main()
{
punto p1(5,3),p2(4,7);
int x, y;
++p1; //incremento en el objeto p1
p1.get_xy(x,y); cout<<"(++p1)= X: "<<x<<", Y: "<<y<<endl;
--p2; //decremento en el objeto p2
--p2;
p2.get_xy(x,y); cout<<"(--p2)= X: "<<x<<", Y: "<<y<<endl;
}
Ejem 6.
#include <iostream>
class complex
{ float real;
float imag;
public :
complex();// constructor
complex(float a,float b); // constructor con parametros
void print();
friend complex operator+(complex x,complex y); //sobrecarga + con funcion amiga
};
//Funciones miembro
complex::complex(float a,float b)
{ real=0;
imag=0;
}

8/9
complex::complex(float a,float b)
{ real=a;
imag=b;
}
void complex::print()
{ cout << real << " + i" << imag << endl;
}
complex operator+(complex x,complex y)

{ complex z;
z.real=x.real+y.real;
z.imag=x.imag+y.imag;
return z;
}
//Progrma principal
int main()
{ complex x(1.0,3.0),y(2.0,1.0); complex z;
x.print();
cout << " + " << endl;
y.print();
z=x+y;
cout << " = " << endl;
z.print();
}

9/9
PROBLEMAS PROPUESTOS
1. Sobrecargue la clase Complex para permitir operaciones como el producto,
división de objetos complejo. Resuelva con funciones operadoras miembro.
2. Respecto al ejercicio anterior resuelva ahora con funciones operadoras
amigas.
3. Escribir un programa que simule la hora del sistema, para ello sobrecargue
el operador unario ++.
4. Escribir un programa que permita sobrecargar el operador && que permita
verificar si 2 fracciones son heterogéneas.
5. Dado una clase llamada fecha cuyos atributos son d, m, a y además dia,
mes y anyo. En la primera se almacena la fecha actual y en los otros se
almacena la fecha del dia siguiente. Implementar el programa para
sobrecargara los siguientes operadores:
a) Sobrecargar el operador ^ que genere la fecha del dia siguiente.
b) Sobrecargar el operado / que permita leer la fecha actual, se sabe que
esta función es amiga.
c) Sobrecargar el operador [] que permita validar la fecha actual, si la fecha
es correcta retorna true, caso contrario retorna false.
d) Sobrecargar el operador >= que permita mostrar las dos fechas.
6. Dado una clase llamado Number que tiene como atributos una dato tipo
entero y una cadena. En el primero se almacena el número entero y en el
segundo se almacena el equivalente en numeración romana. Cree las
funciones sobrecargadas necesarias y la función principal.

P.O.O - Sobrecarga de Operadores

Cargado por

Copyright:

Formatos disponibles

P.O.O - Sobrecarga de Operadores

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

P.O.O - Sobrecarga de Operadores

Cargado por

Copyright:

Formatos disponibles

1/9

//sobrecarga de + relacionada con la clase punto

void punto::get_xy(int &i, int &j)

punto punto::operator+(punto p2)

Algoritmos y programación Prof.: Ing. Felix Huari

void LeerDatos(int &x1, int &y1, int &x2, int &y2)

void punto::get_xy(int &i, int &j)

//sobrecarga de + relacionada con la clase punto

Algoritmos y programación Prof.: Ing. Felix Huari

return temp; //devuelve un objeto de tipo punto

//sobrecarga de - relacionada con la clase punto

void LeerDatos(int &x1, int &y1, int &x2, int &y2)

Algoritmos y programación Prof.: Ing. Felix Huari

punto operator+(int i);

void punto::get_xy(int &i, int &j)

//sobrecarga de + relacionada con la clase punto

Algoritmos y programación Prof.: Ing. Felix Huari

void punto::get_xy(int &i, int &j)

//sobrecarga de == relacionada con la clase punto

Algoritmos y programación Prof.: Ing. Felix Huari

cout<<"p1 es igual que p2\n";

if (p2 && p3)

void punto::get_xy(int &i, int &j)

Algoritmos y programación Prof.: Ing. Felix Huari

//sobrecarga de ++ relacionada con la clase punto

Algoritmos y programación Prof.: Ing. Felix Huari

complex operator+(complex x,complex y)

Algoritmos y programación Prof.: Ing. Felix Huari

Algoritmos y programación Prof.: Ing. Felix Huari

También podría gustarte