SOBRECARGA DE OPERADORES Ejercicios: 1. //sobrecarga del operador +
#include #include using namespace std; 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()
//sobrec5.cpp
{ punto p1(2,5),p2(5,3),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: "< "<
#include #include using namespace std; class punto { int x, y;// si no se especifica, se considera private
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()
//sobrec6.cpp
{ punto p1(5,4),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: "<
3. // sobrecarga del operador + para pi + int // asi como para pi+pi
#include #include using namespace std; 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;} // pi + pi punto operator+(punto p2); // pi + int punto operator+(int i); }; //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()
//sobrec7.cpp
{ 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: "<
p3=p1+5; p3.get_xy(x,y); cout<<"(p1+5) X: "<
Y: "<
//suma de tres objetos y llamada a operator+()
p1=p1+p2+p3; p1.get_xy(x,y); cout<<"(p1+p2+p3) X: "<
Y: "<
// sobrecarga del operador == // sobrecarga del operador &&
#include #include using namespace std; const int FALSE=0, TRUE=1; class punto { int x, y; public: punto(){} // constructor punto(int i, int j){x=i; y=j;} //constructor alternativo 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"; else
cout<<"p2 && p3 no es verdad\n";
system("pause"); return 0; } 5. // sobrecarga de operadores unarios ++ y --
#include #include using namespace std; 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;} // pi++ punto operator++(); // pi-punto operator--(); }; //sobrecarga de + relacionada con la clase punto punto punto::operator++()
{ x++; y++; //devolución del objeto al cual se asigna return *this;
} //sobrecarga de + para pi + int punto punto::operator--()
{ x--; y--; return *this;
} int main()
//sobrec9.cpp
{ punto p1(5,3),p2(4,7); int x, y; ++p1; //incremento en el objeto p1 p1.get_xy(x,y); cout<<"(++p1)= X: "<
6.
#include #include using namespace std; class Complex { float real; float imag; public :
Complex() {} // constructor Complex(float,float); // constructor alternativo void print(); Complex operator+(const Complex&); //referencia del objeto }; Complex::Complex( float a,float b) { real=a; imag=b; } void Complex::print()
{ cout << real << " + i" << imag << endl; } //sobrecarga del operador+ Complex Complex:: operator+(const Complex& x)
{ return Complex(real+x.real,imag+x.imag);
} int main() // sobrec10.cpp
{ Complex x(1.0,3.0),y(2.0,1.0); Complex z; x.print(); cout << " + " << endl; y.print(); //suma de dos objetos
z=x+y; cout << " = " << endl; z.print();
system("pause"); return 0; } 7. #include #include using namespace std; 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);
}; complex::complex( float a,float b) { real=a; imag=b; } void complex::print()
{ }
cout << real << " + i" << imag << endl;
//definición de la función amiga complex operator+(complex x,complex y)
{ complex z; z.real=x.real+y.real; z.imag=x.imag+y.imag; return z; } int main() // sobrec11.cpp
{ 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(); system("pause"); return 0; }
Ejercicios Propuestos: 1. Sobrecargue la clase Complex para permitir operaciones como la resta, producto, división de objetos complejo. Resuelva con funciones operadoras miembro. 2. Respecto al ejercicio anterior resuelva ahora con funciones operadoras amigas. 3.
Cree la clase ascensor que tiene como datos miembros piso actual, número de pisos y capacidad, asimismo implemente unas funciones para sobrecargar los operadores ++ para subir un piso, -- para bajar un piso, == para determinar si dos objetos de la clase ascensor son iguales y != para determinar sin son diferentes. Considere que dos ascensores son iguales si tenen el mismo número de pisos y la misma capacidad.
4. Escriba el código para la clase matriz, la cual tiene como datos miembros, un arreglo bidimensional, el número de filas m, y el número de columnas m. Implemente funciones para sobrecargar los operadores +, -, *, =, ==, !=, para realizar operaciones como suma, resta, multiplicación y asignación entre objetos de la clase matrices, así como para determinar si dos matrices son iguales o no.
