1/7

GUIA DE LABORATORIO N 8
PROGRAMACION ORIENTADA AL OBJETO
OBJETIVOS
1. Entender y aplicar la sobrecarga de operadores con funciones operadoras y con
funciones amigas.
2. Conocer la herencia, clases base y clases derivadas.

SOBRECARGA DE OPERADORES
Ejem 1.
// sobrecarga del operador +
#include <iostream>
class punto
{
int x, y; public: punto(){}
// constructor
punto(int i, int j){x=i; y=j;}//constructor
void get_xy(int &i, int &j){i=x; j=y;}
//sobrecarga funcion operadora miembro
punto operator+(punto p2);
};
//sobrecarga de + relacionada con la clase punto
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
}
int main()
{
int x,y,r,s;
cout<<Ingrese la coordenadas del primer punto:;cin>>x>>y;
cout<<Ingrese la coordenadas del segundo punto:;cin>>r>>s;
punto p1(x,y),p2(r,s),p3;
int x, y;
p3 = p1 + p2; //suma de dos objetos y llamada a operator+()
p3.get_xy(x,y); cout<<"(p1 + p2) = p3 , X: "<<x<<", Y: "<<y<<endl;
}
Ejem 2.
// sobrecarga de los operadores - y el =
Prof.: Ing. Felix Huari

Curso: Algoritmos y Programacin

2/7
#include <iostream>
class punto
{ int x, y;
public: punto(){} // constructor
punto(int i, int j){x=i; y=j;} // constructor
void get_xy(int &i, int &j){i=x; j=y;}
punto operator+(punto p2);
punto operator-(punto p2);
punto operator=(punto p2);
};
//sobrecarga de + relacionada con la clase punto
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
}
//sobrecarga de - relacionada con la clase punto
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
}
//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;
}
int main()
{
int x,y,r,s;
cout<<Ingrese la coordenadas del primer punto:;cin>>x>>y;
cout<<Ingrese la coordenadas del segundo punto:;cin>>r>>s;
punto p1(x,y),p2(r,s),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;
Prof.: Ing. Felix Huari

Curso: Algoritmos y Programacin

3/7
}
Ejem 3.
// sobrecarga del operador + para pi + int // asi como para pi+pi
#include <iostream>
class punto
{
int x, y; public:
punto(){} // constructor
punto(int i, int j){x=i; y=j;} //constructor
void get_xy(int &i, int &j){i=x; j=y;}
punto operator+(punto p2); // pi + pi
punto operator+(int i); // pi + int
};
//sobrecarga de + relacionada con la clase punto
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
}
//sobrecarga de + para pi + int
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;
}
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;
}
Ejem 4.
// sobrecarga del operador == // sobrecarga del operador &&
#include <iostream>
Prof.: Ing. Felix Huari

Curso: Algoritmos y Programacin

4/7
const int FALSE=0, TRUE=1;
class punto
{
int x, y; public:
punto(){} // constructor
punto(int i, int j){x=i; y=j;} //constructor
void get_xy(int &i, int &j){i=x; j=y;}
int operator==(punto p2); // pi == pj
int operator&&(punto p2); // pi && pj
};
//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;
}
int main()
{
punto p1(10,15),p2(5,3),p3(5,3);
int x, y;
// operador ==
if (p1==p2)
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";
Prof.: Ing. Felix Huari

Curso: Algoritmos y Programacin

5/7
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(int i, int j){x=i; y=j;} //constructor
void get_xy(int &i, int &j){i=x; j=y;}
punto operator++(); // pi++
punto operator--(); // pi-};
//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;
}
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;
Prof.: Ing. Felix Huari

Curso: Algoritmos y Programacin

6/7
float imag;
public :
Complex() {} // constructor
Complex(float,float); //
constructor
void print(); Complex operator+(
const Complex&);
};
Complex::Complex(float a,float b)
{
real=a;
imag=b;
}
void Complex::print()
{
cout << real << " + i" << imag << endl;
}
Complex Complex::operator+(const Complex& x)
{
return Complex(real+x.real,imag+x.imag);
}
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();
}
Ejem 7.
#include <iostream>
class complex
{
float real;
float imag;
public : complex() {} // constructor
complex(float a,float b); // constructor
void print();
//sobrecarga + con funcion amiga
friend complex operator+(complex x,complex y);
};

Prof.: Ing. Felix Huari

Curso: Algoritmos y Programacin

7/7
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();
}

PROBLEMAS PROPUESTOS
1. Sobrecargue la clase Complex para permitir operaciones como la resta,
producto, divisin 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 heterogneas.

Prof.: Ing. Felix Huari

Curso: Algoritmos y Programacin