Vous êtes sur la page 1sur 8

SOBRECARGA DE OPERADORES Ejercicios:

1.

//sobrecarga del operador + #include <iostream> #include <stdlib.h> 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: "<<x<<", Y: "<<y<<endl; system("pause"); return 0; }
2.

// sobrecarga de los operadores - y el = #include <iostream> #include <stdlib.h> 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: "<<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; system("pause"); return 0; }

3.

// sobrecarga del operador + para pi + int // asi como para pi+pi #include <iostream> #include <stdlib.h> 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;} 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() //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: "<<x<<", Y: "<<y<<endl; //suma de objeto + entero y llamada a operator+(int) p3=p1+5; p3.get_xy(x,y); cout<<"(p1+5) X: "<<x<<", Y: "<<y<<endl; //suma de tres objetos y llamada a operator+() p1=p1+p2+p3; p1.get_xy(x,y); cout<<"(p1+p2+p3) X: "<<x<<", Y: "<<y<<endl; system("pause"); return 0; }
4.

// sobrecarga del operador == // sobrecarga del operador && #include <iostream> #include <stdlib.h> 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 <iostream> #include <stdlib.h> 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;} punto operator++(); // pi++ punto operator--(); // pi-}; //sobrecarga de + relacionada con la clase punto punto punto::operator++() { x++; y++; //devolucin 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: "<<x<<", Y: "<<y<<endl; --p2; //decremento en el objeto p2 --p2; p2.get_xy(x,y); cout<<"(--p2)= X: "<<x<<", Y: "<<y<<endl; system("pause"); return 0; }

6.

#include <iostream> #include <stdlib.h> 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 <iostream> #include <stdlib.h> 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; } //definicin de la funcin 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, divisin 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, nmero 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 nmero de pisos y la misma capacidad.

4. Escriba el cdigo para la clase matriz, la cual tiene como datos miembros, un arreglo bidimensional, el nmero de filas m, y el nmero de columnas m. Implemente funciones para sobrecargar los operadores +, -, *, =, ==, !=, para realizar operaciones como suma, resta, multiplicacin y asignacin entre objetos de la clase matrices, as como para determinar si dos matrices son iguales o no.

Vous aimerez peut-être aussi