[C con Clase] Sobrecarga de operadores

Steven Davidson steven en conclase.net
Dom Jun 24 20:24:44 CEST 2007


Hola Rodolfo,

El pasado 2007-06-24 17:42:26, rodolfo escribió:

r> Hola amigos.-
r> Revisando un ejercisio de Deitel, en el que una clase IntGrande, sobrecarga
r> algunos operadores, encontré lo siguiente:
r> Tiene un operador de conversión y una funcion de sobrecarga de operator+ :
r> IntGrande::IntGrande( const char *cadena )
r> {
r>    // convierte una cadena de caracteres a un valor de tipo IntGrande
r> }
r> // operador de suma; IntGrande + IntGrande
r> IntGrande IntGrande::operator+( const IntGrande &op2 )
r> {
r>    //  suma dos valores de tipo IntGrande
r> }
r> Y ademas sobrecarga el operador suma invocando de manera explícita al 
r> constructor
r> de conversión:
r> // IntGrande + cadena que representa un valor entero grande
r> IntGrande IntGrande::operator+( const char *op2 )
r> {
r>    // convierte op2 en un IntGrande, e invoca a
r>    // operator+ para dos objetos IntGrande
r>    return *this + IntGrande( op2 );
r> } // fin del operador operator+
r> Pregunta: ¿ Si tengo ya una sobrecarga que suma dos IntGrandes. Necesito
r> acaso una sobrecarga que invoque de manera explícita al constructor de 
r> conversión ?
r> No se supone que el compilador lo hace de manera automática, convirtiendo la 
r> cadena
r> a IntGrande y luego sumándola con el otro IntGrande.
r> ¿ Hay alguna razón en especial para esa sobrecarga explícita ?
r> ¿ no siempre es segura la manera implícita ?

En general, no sería necesario. Sin embargo, en este caso sí lo es. Analicemos lo que sucedería si no fuéramos explícitos. Acabaríamos con la siguiente definición:

IntGrande IntGrande::operator+( const char *op2 )
{
  return *this + op2;
}

Esto es equivalente a:

IntGrande IntGrande::operator+( const char *op2 )
{
  return (*this).operator+( op2 );
}

Como puedes ver, estamos invocando a esta misma función y entonces estaríamos ante una invocación recursiva. Sin embargo, no hay forma de detener esta invocación, y el sistema operativo se quejará, si es "listo".

El caso es que queremos invocar el operador + con dos operandos de tipo 'IntGrande'. Para hacer esto, instanciamos un objeto temporal de tipo 'IntGrande' a partir de la cadena constante 'op2'.

Si lo prefieres, puedes instanciar un objeto y luego usar el operador +. Por ejemplo,

IntGrande IntGrande::operator+( const char *op2 )
{
  IntGrande temp( op2 );
  return *this + temp;  // Suma entre objetos 'IntGrande'
}


Espero haber aclarado la duda.

Steven


Más información sobre la lista de distribución Cconclase