[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