Sobrecarga de operandos

[DvNe]

Buenas,

Debo hacer un proyecto para la universidad.

Tengo que crear varias clases, una de ellas es una clase tipo FECHA, y a la hora de sobrecargar los operandos me encuentro ante la duda de si sobrecargarlos externa o internamente.

Por ejemplo, tengo que sobrecargar los operandos de comparación (<,>,<=,>=,== y !=). He comprobado que no hay diferencia entre sobrecargarlos externa o internamente, pero estos operadores deben devolver un valor bool diferente al tipo-clase, entonces ¿debo sobrecargarlos externamente?

Luego, por otro lado tengo operadores ++, -- (postfijos y prefijos), += y -= que devuelven una referencia a FECHA. Estos operadores los tengo sobrecargados internamente pero nose si podría sobrecargarlos externamente.

Y por último, tengo los operadores + y - (2 versiones de cada uno, una versión con primer parámetro FECHA y segundo INT, y otra versión con los parámetros en orden inverso) sobrecargados externamente devolviendo una FECHA pero no se si podría sobrecargarlos internamente.

Espero que alguien me pueda resolver las dudas

Un saludo, Jose

[vangodp]

Jose, en la mayoría de los foros, no solo este.Una de las normas es no solucionarte el haciendolo nosotros el problema por ti.
Se ve que ya has estado buscando y eso es genial.
Posta lo que tengas echo y entonces obtendrás respuestas por un tubo.
Saludos, espero que logres lo que te hace falta ;)

[DvNe]

Esta es la clase que definí (su cabecera) y como se puede ver puedo sobrecargarlos interna y externamente

Código C++:

#ifndef _FECHA_H_
#define _FECHA_H_
#include <iostream>
 
class Fecha {
 public:
  Fecha (const int dia = 0, const int mes = 0, const int anno = 0);
  Fecha (const Fecha& );
  Fecha (const char* );
  class Invalida {
  public: 
    Invalida(const char* texto) { razon_ = texto; }
    const char* por_que() { return razon_; }
  private:
    const char* razon_;
  };
  int anno() const { return anno_; }
  int mes() const { return mes_; }
  int dia() const { return dia_; }
 
  //OPERADORES ARITMETICOS
  Fecha operator++ (const int); // Operador postfijo
  Fecha operator-- (const int); // Operador postfijo
  Fecha& operator++ ();
  Fecha& operator-- ();
  Fecha& operator+= (const int);
  Fecha& operator-= (const int);
  Fecha operator= (const Fecha&);
  /*   //OPERADORES DE COMPARACION
  bool operator == (const Fecha&);
  bool operator != (const Fecha&);
  bool operator < (const Fecha&);
  bool operator <= (const Fecha&);
  bool operator > (const Fecha&);
  bool operator >= (const Fecha&);*/
 
  char* cadena() const;
 private:
  int dia_, mes_, anno_;
  static const int AnnoMinimo = 1600;
  static const int AnnoMaximo = 2200;
  bool Bisiesto() const;
  bool FechaValida() const throw(Fecha::Invalida);
};
 
std::ostream& operator << (std::ostream &o, const Fecha &a);
 
Fecha operator + (const int, const Fecha&);
Fecha operator + (const Fecha&, const int);
Fecha operator - (const int, const Fecha&);
Fecha operator - (const Fecha&, const int);
  //OPERADORES DE COMPARACION
bool operator == (const Fecha&, const Fecha&);
bool operator != (const Fecha&, const Fecha&);
bool operator < (const  Fecha&, const Fecha&);
bool operator <= (const  Fecha&, const Fecha&);
bool operator > (const  Fecha&, const Fecha&);
bool operator >= (const  Fecha&, const Fecha&);
#endif
 

[Pantaláimon]

Iniciado por DvNe

Buenas,

Debo hacer un proyecto para la universidad.

Tengo que crear varias clases, una de ellas es una clase tipo FECHA, y a la hora de sobrecargar los operandos me encuentro ante la duda de si sobrecargarlos externa o internamente.

Por ejemplo, tengo que sobrecargar los operandos de comparación (<,>,<=,>=,== y !=). He comprobado que no hay diferencia entre sobrecargarlos externa o internamente, pero estos operadores deben devolver un valor bool diferente al tipo-clase, entonces ¿debo sobrecargarlos externamente?

Luego, por otro lado tengo operadores ++, -- (postfijos y prefijos), += y -= que devuelven una referencia a FECHA. Estos operadores los tengo sobrecargados internamente pero nose si podría sobrecargarlos externamente.

Y por último, tengo los operadores + y - (2 versiones de cada uno, una versión con primer parámetro FECHA y segundo INT, y otra versión con los parámetros en orden inverso) sobrecargados externamente devolviendo una FECHA pero no se si podría sobrecargarlos internamente.

Espero que alguien me pueda resolver las dudas

Un saludo, Jose

Yo definiría todos los operadores internamente. Incluso cuando uno de los argumentos es un int. En este último caso porque le doy más importancia al vínculo que tiene el operador con la clase que con un tipo primitivo.

Por cierto, ten en cuenta esto si defines operadores internos:

Código C++:

Fecha operator++ (const int); // Operador postfijo
  Fecha operator-- (const int); // Operador postfijo
  Fecha& operator++ ();
  Fecha& operator-- ();
  Fecha& operator+= (const int);
  Fecha& operator-= (const int);
  Fecha operator= (const Fecha&);
 

Estos operadores modifican al objeto propio( this ). Con lo cual estan bien escritos como están. Sin embargo, para señalar que el elemento this no será modificado cuando hagas una suma, una comparación, etc. hay que añadir const al final:

Código C++:

//OPERADORES DE COMPARACION
  bool operator == (const Fecha&) const;
  bool operator != (const Fecha&) const;
  bool operator < (const Fecha&) const;
  bool operator <= (const Fecha&) const;
  bool operator > (const Fecha&) const;
  bool operator >= (const Fecha&) const;
  // etc
 

Un saludo!