c++ - ¿Cómo obtener el tipo resultante de multiplicar dos tipos diferentes?




class c++11 (2)

Además de las otras respuestas, si no necesita el result_type para su uso posterior, pero solo para especificar el tipo de retorno del operator() , hay otra forma, al no definir el alias para result_type en c ++ 11 .

Puede proporcionar un tipo de retorno final junto con el retorno auto siguiente manera:

template< typename TA, typename TB>
struct multiplier
{
    auto operator()(TA a, TB b) const -> decltype(a * b)
//  ^^^^^                             ^^^^^^^^^^^^^^^^^^^
    {
        return a * b;
    }
};

( Ver en vivo en línea )

¿Cómo se podría obtener el tipo resultante de multiplicar dos tipos diferentes, es decir

template< typename TA, typename TB>
struct multiplier
{
    using result_type = // something here finds result of TA * TB
    result_type operator()( TA a, TB b ) const
    {
        return a * b;
    }
};

Sé que en C ++ es perfectamente válido multiplicar dos valores numéricos de diferente tipo y esto dará un valor en un tipo que el compilador conoce. Es decir, multiplicar un double y un int dará como resultado una respuesta de tipo double .

Como tal, en una clase de plantilla donde los tipos se conocen en tiempo de compilación, debería ser posible determinar el tipo que se creará. De hecho, se puede crear una lambda para devolver el resultado de este valor, es decir

auto foo = [](int a, float b){ return a * b;}
auto c = foo( 13, 42.0 );

Esto haría que c sea ​​un float .

Tenga en cuenta que estoy limitado a poder usar solo funciones de c ++ 11 o inferiores.


Puede usar decltype y std::declval para esto. decltype le dará el tipo de expresión y std::declval "creará" un objeto del tipo para usted, incluso si no puede / no sabe cómo construirlo. Eso te da algo como

using result_type = decltype(std::declval<TA&>() * std::declval<TB&>());

Tenga en cuenta que estoy usando referencias lvalue para el tipo. Esto se hace porque, por defecto, el decval le dará una referencia de valor que podría darle un tipo diferente.





return-type