[C con Clase] Sobrecarga de operadores: Operaciones conmutativas

Steven Davidson srd4121 en njit.edu
Mar Mar 10 17:44:20 CET 2009


Hola Vicente,

vicente lozano wrote:
> Vale me ha quedado claro con los datos numericos pero ahora me ha 
> surgido una duda con las cadenas:
> 
> Si yo quiero sobrecargar + para que pueda sumar tipo miCadena con
> char* que debo usar, crear las 4 operaciones:
> 
> Cadena& operator+( char*, char*)

Esta sobrecarga no es posible, porque los tipos de ambos operandos son 
fundamentales.

> Cadena& operator+( char*, Cadena&)
> Cadena& operator+( Cadena&, char*)
> Cadena& operator+( Cadena&, Cadena&)
> 

Estas sobrecargas no deberían retornar una referencia a un objeto, sino 
uno nuevo.

> o
> 
> Usar templates
> 
> o
> 
> Sobrecargar el casting para que funcione como lo que me has comentado
> de los doubles?
> 

Podrías, pero a veces esto crea más problemas que soluciones. Hay que 
tener mucho cuidado al sobrecargar cástings para clases.

> He escrito la primera y bien, pero no me parece lo mas apropiado. He 
> intentado hacer la 3° poniendo:
> 
> char& char*() { return *pstr;}
> 
> pero no compila y ademas creo que eso que he escrito esta muy mal, un
> poco sin pies ni cabeza pero llevo ya muchas horas por aqui jeje.

Esto es porque no hay que poner un tipo de retorno. Al tratarse de un 
cásting, ya se conoce el tipo de retorno. Esto sería,

class Cadena
{
   ...
   char *()  { return pstr; }
};

Ahora podemos hacer lo siguiente:

Cadena cad;
...
int nLongitud = strlen(cad);

Quiero aclarar que no es nada recomendable realizar este cásting, ya que 
estás cediendo acceso a la información directamente al exterior. Esto 
rompe la encapsulación que nos interesa. Lo que podemos hacer es hacer 
un cásting a 'const char *'.

> 
> Y templates aun no lo he mirado pero vamos que cual creeis que es
> mejor opcion de las que sean posibles.
> 

Sugiero la primera solución que planteas: crea las tres sobrecargas. 
Esto es,

Cadena operator+( const char *, const Cadena& );
Cadena operator+( const Cadena &, const char * );
Cadena operator+( const Cadena &, const Cadena & );

Como puedes ver, creamos un nuevo objeto el cual se retorna. También 
verás que aceptamos parámetros constantes.

Como mencioné en el correo-e anterior, puedes implementar una sola 
versión con clases, porque 'const char *' puede ser promocionado a 
'Cadena'. Esto significa que sólo tenemos que implementar esta sobrecarga:

Cadena operator+( const Cadena &, const Cadena & );

Las otras versiones existen indirecta pero implícitamente. Por ejemplo,

Cadena cad1( "Hola" ), cad2( " mundo" ), cad3;

cad3 = cad1 + cad2;     // operator+( cad1, cad2 )
cad1 = "Adios" + cad2;  // operator+( Cadena("Adios"), cad2 )
cad2 = cad3 + "!";      // operator+( cad3, Cadena("!") )

Lo siguiente también se puede hacer, pero hay que crear un objeto 
temporal explícitamente:

cad3 = Cadena("Hola") + " mundo";


Espero que esto te sirva.

Steven





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