Ayuda con c++ y Java

[nostromo_]

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”;
}

Sobrecarga del operador de inserción “<<“:

–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 << ")" );
}

Sobrecarga del operador de extracción “>>”:

–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.