comparar dos tipos de datos y crear uno nuevo eligiendo el mayor

[alexpglez98]

Querría preguntar sobre cómo poder comparar dos tipos de datos, devolver un indicador con el mayor y crear un nuevo dato con el tipo de dato elegido. Por ejemplo, para sumar C++ crea un dato nuevo con el tipo del numerador más completo.
Mi duda sería como hacerlo. He hecho ya mi propio código que compara dos tipos de datos, lo que me falla es a la hora de crear el nuevo dato, me dice que hay declaraciones en conflicto:

Código C++:

template<class T>
template<typename T_1, typename T_2>
Matrix<T_2> Matrix<T>::operator + (const Matrix<T_1> &m_2)
{
    T c;
    T_1 b;
    char a=compare(b,c);
    switch(a)
    {
        case 's':
            Matrix<short> result(I, J);
            break;
        case 't':
            Matrix<unsigned short> result(I, J); // declaración en conflicto
            break;
        case 'i':
            Matrix<int> result(I, J);
            break;
        case 'j':
            Matrix<unsigned int> result(I, J);
            break;
        case 'l':
            Matrix<long> result(I, J);
            break;
        case 'm':
            Matrix<unsigned long> result(I, J);
            break;
        case 'x':
            Matrix<long long> result(I, J);
            break;
        case 'y':
            Matrix<unsigned long long> result(I, J);
            break;
        case 'f':
            Matrix<float> result(I, J);
            break;
        case 'd':
            Matrix<double> result(I, J);
            break;
        case 'e':
            Matrix<long double> result(I, J);
            break;
    }
    for(int i=0; i<I; i++)
    {
        for(int j=0; j<J; j++)
        {
            result.value(i,j)=this->value(i,j)+m_2.value(i,j);
        }
    }
    return result;
}
 

Adjunto las funciones de compare por si les queréis echar un vistazo.

Código C++:

template<typename D_1, typename D_2>
char compare(D_1 a, D_2 b)
{
    return is_data(fmax(range(typeid(a).name()), range(typeid(b).name())));
}r
 
char is_data(int a)
{
    char data;
    switch(a)
    {
        case 1:
            data='s';
            break;
        case 2:
            data='t';
            break;
        case 3:
            data='i';
            break;
        case 4:
            data='j';
            break;
        case 5:
            data='l';
            break;
        case 6:
            data='m';
            break;
        case 7:
            data='x';
            break;
        case 8:
            data='y';
            break;
        case 9:
            data='f';
            break;
        case 10:
            data='d';
            break;
        case 11:
            data='e';
            break;
    }
    return data;
}
 
 
int range(const char *name)
{
    int range;
    switch(*name)
    {
        case 's':
            range=1;
            break;
        case 't':
            range=2;
            break;
        case 'i':
            range=3;
            break;
        case 'j':
            range=4;
            break;
        case 'l':
            range=5;
            break;
        case 'm':
            range=6;
            break;
        case 'x':
            range=7;
            break;
        case 'y':
            range=8;
            break;
        case 'f':
            range=9;
            break;
        case 'd':
            range=10;
            break;
        case 'e':
            range=11;
            break;
    }
    return range;
}
 

Supongo que existirá alguna manera que desconozco de simplificar el código.
Gracias.

[lareto]

No creo que se pueda hacer de esa manera. La idea de un template es que el compilador escriba el código de las clases y funciones template que necesita, ahorrándonos tener que escribirlas a mano, pero las reglas del juego siguen siendo las mismas. Por ejemplo, si has declarado que una función devuelve un cierto tipo de dato, no se puede cambiar eso en tiempo de ejecución. Con la idea de polimorfismo se puede decidir qué función o qué tipo de objeto (dentro de una familia) va a invocarse o crearse, pero esa función o tipo de objeto tienes que estar definidas desde antes.

Por otro lado, typeid devuelve un objeto que puede compararse con otro typeid, pero no hay ninguna garantía que dos llamadas consecutivas vayan a devolver la misma representación de ese objeto, y mucho menos que name() vaya a devolver lo que estás esperando. El estándar C++ sólo exige que los objetos devueltos sean comparables y que su comparación devuelva true o false, nada más; cualquier otra suposición será cierta o no dependiendo del compilador que se use. Así que ese mecanismo de comparar lo que devuelve name() mejor olvidarlo, a no ser que tengas garantías de que jamás se va a compilar con otro compilador y que jamás vaya a cambiarse de versión... bueno, olvídalo.

Pero bueno, entiendo que de todos modos estaría muy bien tener una respuesta (tu objeto Matrix suma de dos Matrixes) del tipo más comprensivo (estaba por poner "abarcativo", ¡dioses!), evitando que algún valor se trunquen eventualmente.

A ver qué te parece...

Si puedes compilar con C++11, se me ocurre un sucio hack echando mano de "auto" y de "decltype". auto es el tipo de una variable que el compilador deduce del entorno, y decltype devuelve el tipo de la variable de su argumento.

1) Entonces, se podría dejar que el compilador resuelva las promociones entre los tipos de datos, como lo hace siempre, por ejemplo:
short + int = int, etcétera.

2)

Código C++:

auto type = (data_1) 1 + (data_2) 2;
 

si data_1 fuera un int y data_2 un double, "auto" sería un doble.

3)

Código C++:

decltype(type) c[a][b]={{0,0},{2,7},{0,0},{4,9},{0,0}};
 

estaría declarando tu matriz de tipo double, siguiendo el ejemplo.

4) y de la misma manera, poniendo decltype(type) en donde necesites definir el tipo, por ejemplo también en

Código C++:

Matrix<decltype(type)> M(a, b);
 

Así tendrías las promociones definidas al crear los objetos de tipo Matrix, y las sumas de sus elementos también ya serían del mismo tipo.

Lareto :)

[eferion]

Iniciado por alexpglez98

Mi duda sería como hacerlo. He hecho ya mi propio código que compara dos tipos de datos, lo que me falla es a la hora de crear el nuevo dato, me dice que hay declaraciones en conflicto:

Te da conflicto porque las variables que declaras dentro de los case tienen todas, por decirlo de alguna forma, el mismo ámbito y colisionan entre ellas. Puedes evitar el problema simplemente poniendo el contenido de los case entre llaves:

Código C++:

case 's':
{
  Matrix<short> result(I, J);
  break;
}
 
case 't':
{
  Matrix<unsigned short> result(I, J); // declaración en conflicto
  break;
}
 

En cualquier caso has de saber que los objetos que estás creando dentro del switch se eliminan al salir de dicho switch, por lo que el if que tienes después te va a dar error porque no va a encontrar una variable que se llamen "result".

Por otro lado, tienes que tener en cuenta que los templates son tratados de forma especial por el compilador. En tiempo de compilación el compilador chequea los diferentes usos de los templates y crea una versión específica para cada uso. Esto quiere decir que un programa compilado no tiene templates sino funciones y clases sobrecargadas (todas las especializaciones que se usen en el programa).

El rollo que te he contado implica que el tipo de retorno, "Matrix<T_2>" va a tener que estar determinado en el momento de llamar a la función y su repercusión más inmediata es que no vas a poder retornar dentro de la misma especialización un Matrix<int> y un Matrix<char> porque son tipos diferentes... y no puedes elegir al gusto el tipo a retornar dentro de la función porque la elección hay que hacerla bastante antes.

Dicho de otra forma, "result" tiene que estar declarado forzosamente tal que:

Código C++:

template<class T>
template<typename T_1, typename T_2>
Matrix<T_2> Matrix<T>::operator + (const Matrix<T_1> &m_2)
{
  Matrix<T_2> result( I, J );
 
  // ...
 
  return result;
}
 

Los tipos de I y J no aparecen en tu código. Si son variables globales te aconsejo evitar su uso. Si son constantes (en C++ te aconsejo usar static const en vez de define para declarar constantes) entonces olvida lo que te he dicho.

Por otro lado, y ya para terminar, el bucle que calcula la suma de las dos matrices anteriores puede que necesite una pequeña ayuda con las conversiones de datos para evitar warnings durante la compilación... quizás algo del tipo:

Código C++:

for(int i=0; i<I; i++)
{
    for(int j=0; j<J; j++)
    {
        result.value(i,j) = static_cast<T_2>( this->value(i,j) ) + static_cast<T_2>( m_2.value(i,j) );
    }
}
 

Un saludo.

[alexpglez98]

Lareto, entiendo lo que dices. Aunque no se como aplicarlo muy bien, igual tendría que hacer una función intermediaria para poderlo implementar..
I y J son variables de la clase, asi que supongo que no hay problema en ponerlo asi. Lo de las constantes no lo estoy teniendo muy en cuenta, el caso es que no acabo de haber entendido el const del todo. Lo tendré en cuenta por si tengo algún error futuro, gracias.

Yo creo que lo mejor sería devolver long double, aunque no aprovecha muy bien la memoria, pero después de la función el objeto long double se eliminaría y nos quedaríamos igual de bien.