[C con Clase] Sobrecarga de operadores: Operaciones conmutativas

[vicente lozano]

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*)
Cadena& operator+( char*, Cadena&)
Cadena& operator+( Cadena&, char*)
Cadena& operator+( Cadena&, Cadena&)

o

Usar templates

o

Sobrecargar el casting para que funcione como lo que me has comentado de los
doubles?

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.

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

Gracias de nuevo y saludos, me voy que hoy salgo un poco antes para cortarme
el pelo :)

2009/3/10 vicente lozano <vicentelozano en gmail.com>

> Si, muchas gracias por una respuesta tan completa.
>
> Investigare los templates, creo que son parecidos a los tipos genericos de
> ADA no?
>
> 2009/3/9 Steven Davidson <srd4121 en njit.edu>
>
> Hola Vicente,
>>
>>
>> vicente lozano wrote:
>>
>>> Hola!
>>>
>>> Estaba pensando, mientras leia un ejemplo de una clase fracciones,
>>> que quizas exista alguna forma de declarar algo como esto:
>>>
>>> friend Fraccion operator+ ( Fraccion &fr, int & in)
>>> friend Fraccion operator+ ( Fraccion &fr, float & fl)
>>> friend Fraccion operator+ ( Fraccion &fr, double & do)
>>>
>>> friend Fraccion operator+ ( void &anything, Fraccion &f)
>>> {
>>>  return (f+anything);
>>> }
>>>
>>> Es posible? Es seguro?
>>>
>>>
>> Tal y como está, no se puede por el tipo 'void &', aunque sí podrías usar
>> un puntero a 'void'. De todas maneras, lo que quieres hacer se puede lograr
>> a través de otro mecanismo propio de C++ llamado "plantillas" o "templates"
>> en inglés. En tu caso, esto sería,
>>
>> template< typename T >
>> Fraccion operator+( const T &sumando, const Fraccion &fraccion )
>> {
>>  ...
>> }
>>
>> Esta función-plantilla serviría como una función general del operador +.
>> a. Podemos implementar versiones concretas aun teniendo esta plantilla. Por
>> ejemplo,
>>
>> template<>
>> Fraccion operator+( const int &sumando, const Fraccion &fraccion )
>> {
>>  ...
>> }
>>
>> Obviamente, las plantillas no van a solucionarte todos los problemas, por
>> ejemplo, podemos tener lo siguiente:
>>
>> Punto pt(4,3);
>> Fraccion f(1,2);
>>
>> f = pt + f;
>>
>> El compilador generará la sobrecarga del operador + correspondiente al
>> tipo 'Punto', pero aún así, esto no resuelve el problema de sumar un punto a
>> una fracción.
>>
>>
>> De todas maneras, los ejemplos que has escrito no requieren varias
>> versiones, ya que C++ tiene reglas semánticas establecidas para cambiar de
>> tipo para los tipos fundamentales. Por ello, sugiero crear una sola versión
>> para el tipo de dato más "elevado" que es 'long double'. Esto es,
>>
>> Fraccion operator+( const Fraccion &fr, long double sumando );
>>
>> Si usamos cualquier otro tipo fundamental, éste será convertido
>> implícitamente (promocionado) a 'long double'. Por ejemplo,
>>
>> Fraccion f(1,2);
>> short int nNum=5;
>>
>> f = f + nNum;
>>
>> El valor en 'nNum' es convertido y pasado a 'long double'. Con esto, no
>> necesitamos crear múltiples versiones.
>>
>> Ahora bien, si tienes pensado implementar diferentes funcionalidades para
>> cada versión del operador + dependiendo del tipo fundamental, entonces
>> tendrás que realizar las sobrecargas explícitamente.
>>
>>
>> La otra posibilidad es que no necesitemos todas estas sobrecargas ya que
>> podríamos simplemente usar el constructor de 'Fraccion'. Esto implica que
>> sólo tenemos que implementar una sobrecarga del operador + que acepte dos
>> objetos de tipo 'Fraccion'. Por ejemplo,
>>
>> class Fraccion
>> {
>>  ...
>>  Fraccion( long double izq=0, long double der=1 );
>> };
>>
>> Fraccion operator+( const Fraccion &izq, const Fraccion &der );
>>
>> Podemos hacer lo siguiente,
>>
>> Fraccion f(1,2);
>> short int nNum=5;
>>
>> f = f + nNum;
>>
>> Aquí, implícitamente hacemos lo siguiente:
>> operator+( f, Fraccion( (long double)nNum ) );
>>
>>
>> Espero haber aclarado la duda.
>>
>> 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/20090310/330fc8d7/attachment.html>