Holas;
Sobrecarga de Operadores
Los operadores, al igual que las funciones, pueden ser Los operadores, al igual que las funciones, pueden ser
sobrecargados (overloaded):
–La mayor parte de los operadores de C++ pueden ser redefinidos para actuar sobre objetos de una clase.
–Se puede cambiar la definición de un operador, pero no su gramática: nº de
operandos, precedencia y asociatividad.
–El tipo de los operandos determina qué definición del operador se va a utilizar.
–Al menos uno de los operandos debe ser un objeto de la clase.
La sintaxis para declarar un operador sobrecargado es la siguiente::
tipo operator operador([argumentos]);
Donde:
tipo indica el tipo del valor retornado por la función, y
operador es unos de los siguientes: +,-,*,/,%,&,!,>,<,=,[],new, delete, ...
Código:
classComplejo
{
private:
floa treal,imag;
public:
Complejo(floatx,floaty) {real=x;imag=y;}
Complejo operator+(Complejoc);
void Print();
}
Complejo Complejo::operator+(Complejoc)
{
return Complejo(real+c.real,imag+c.imag);
}
void main()
{
Complejo c1(1.5,4.5);
Complejo c2(-2,-1);
Complejo c3 = c1+c2; //=c3=c1.operator+(c2);
c3.Print();
}
Los operadores pueden definirse como Los operadores pueden definirse como
miembros o como
friends de una clase:
–En los operadores
friend el número de argumentos debe ser el estándar del operador.
–Para los operadores
miembro de una clase, el primer operando debe ser siempre un objeto de la clase. En la declaración y definición sólo hace falta definir el segundo argumento.
–Los operadores que modifican el primer operando se suelen declarar como
miembros.
–Los operadores que no modifican los operandos suelen ser declarados como
friend.
–Los operadores de asignación (=, +=, -=, …), deben ser sobrecargados por
funciones miembro.
Código:
classComplejo
{
private:
float real;
float imag;
public:
Complejo(floatx=0, floaty=0)
{
real=x; imag=y;
}
Complejo operator+(Complejoc);
friend bool
operator == (Complejoc1, Complejoc2);
friend bool operator<(Complejo, Complejo);
double mod()
{
return sqrt(real*real + imag*imag);
}
void Print();
};
bool operator<(Complejoc1, Complejoc2)
{
retur nc1.mod() < c2.mod();
}
//funcion amiga.Operador de relacion
bool operator==(Complejoc1, Complejoc2)
{
if(c1.real==c2.real && c1.imag==c2.imag)
return true;
else return false;
}
void main()
{
Complejoc1(1.5,4.5);Complejoc2(1.5,4.5);
if(c1==c2) cout << "Soniguales";
else cout << "Sondiferentes";
(c1<c2)? cout << “Menor”: cout << “Nomenor”;
}
–C++ tiene una clase denominada
ostream definida con el operador << para la salida de valores de tipos predefinidos (
int, long, double, etc..).
Código:
class ostream
{
//...
public:
//..
ostream &operator<<(int);
ostream &operator<<(double);
};
–La función
operator<< retorna una referencia al objeto de tipo ostream que llamó, para que éste pueda ser aplicado a otro valor:
cout << f1 << f2;
–Una forma sencilla de sobrecargar el operador << es implementar una función miembro amiga (
friend)de esta clase, que tenga la siguiente forma:
friend ostream &operator<<(ostream &os, clase_usuario &c);
Donde
os es una referencia a un objeto tipo
ostream, en nuestro caso
cout y
c es una referencia a una
clase del usuario que se desea visualizar.
En el cuerpo de la función irá una expresión de la siguiente forma:
os << valor1 << valor2 << valor3;
Código:
ostream &operator<<(ostream &os, Complejo &c)
{
return ( os << "(" << c.r << "," << c.i << ")" );
}
–C++ tiene una clase denominada
istream definida con el operador >> para la entrada de valores de tipos predefinidos (
int, long, double, etc..).
Código:
class istream
{
//...
public:
//..
istream &operator>>(int);
istream &operator>>(double);
};
–La función operator>>retorna una referencia al objeto de tipo ostream que llamó, para que éste pueda ser aplicado a otro valor:
cin>> f1 >> f2;
–Una forma sencilla de sobrecargar el operador >> es implementar una función miembro amiga (
friend)de esta clase, que tenga la siguiente forma:
friend istream &operator>>(istream &is,clase_usuario &c);
Donde ises una referencia a un objeto tipo
istream, en nuestro caso
cin y
c es una referencia a una clase del usuario que se desea visualizar.
En el cuerpo de la función irá una expresión de la siguiente forma:
is>> valor1 >> valor2 >> valor3;
Código:
istream &operator>>(istream &is,Complejo &c)
{
cout << "Escribauncomplejo:";
return (is>>c.r>>c.i);
}
Código:
#include<iostream.h>
class Complejo
{
private:
floatr,i;
public:
Complejo(floatpr=0,floatpi=0)
{
r=pr;i=pi;
}
Complejo operator+(Complejoc);
Complejo operator-(Complejoc);
friend ostream &operator<<(ostream &os,Complejo&);
friend istream &operator>>(istream &is, Complejo&);
void Print() { cout << r << "," << i << "i\n"; }
};
Complejo Complejo::operator +(Complejo c)
{
return Complejo(r+c.r,i+c.i);
}
Complejo Complejo::operator -(Complejo c)
{
return Complejo(r-c.r,i-c.i);
}
ostream &operator<<(ostream &os, Complejo &c)
{
return (os << "(" << c.r << "," << c.i << ")" );
}
istream &operator>>(istream &is, Complejo &c)
{
cout<<"Escriba un complejo:";
return(is >> c.r >> c.i);
}
void main()
{
Complejo c1(3,4);
Complejo c2(-2,1);
Complejo c3(1,-2);
Complejo r=c1+c2+c3;
r.Print();
//operadores
Complejon, n1;
cin >> n >> n1;
cout << “Los complejos son:“;
cout << n << "-“ << n1;
}
Es parte del tutorial de la
Escuela superior de Ingenieros de San Sebastián, espero que te sirva, al igual que mí, recién estoy despegando...
Nos vemos.
