[C con Clase] Sobrecarga de operadores: Operaciones conmutativas

[vicente lozano]

Vale, muchas gracias creo que me has aclarado muchas dudas sobre este tema,
ahora lo comprendo mejor.

2009/3/10 Steven Davidson <srd4121 en njit.edu>

> 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
>
>
> _______________________________________________
> Lista de correo Cconclase Cconclase en listas.conclase.net
> http://listas.conclase.net/mailman/listinfo/cconclase_listas.conclase.net
> Bajas: http://listas.conclase.net/index.php?gid=2&mnu=FAQ
>
------------ próxima parte ------------
Se ha borrado un adjunto en formato HTML...
URL: <http://listas.conclase.net/pipermail/cconclase_listas.conclase.net/attachments/20090311/3b788aec/attachment.html>