Déduire le type d'opérateur/la fonction pour les modèles

Question

Est-ce que quelque chose comme ceci est possible? Ou est-ce que quelqu'un devrait pirater une structure return_type et la spécialiser pour chaque paire de types natifs?

Answer 1

Entendu de decltype?

En C++0x vous pouvez faire

template<class T, class U> 
auto mul(T x, U y) -> decltype(x*y) 
{ 
    return x*y; 
} 

Answer 2

http://www2.research.att.com/~bs/C++0xFAQ.html#decltype

Answer 3

pré-C++ 0x

Je ne sais pas exactement ce que vous voulez accomplir, si:

template<typename T, typename U> 
void my_mul(T t, U u, bool& overflow) 
{ 
    my_mul_impl(t*u, overflow); 
} 

template<typename TmultU> 
void my_mul_impl(TmultU mult, bool& overflow) 
{ 
    //here you know the type and can do something meta-weird :) 
    if(mult > type_traits<TmultU>::max_allowed_in_my_cool_program()) 
     overflow = true; 
} 

Il y a more

Answer 4

J'utilise Visual Studio 2008, donc j'ai dû trouver un moyen non C++ 0x. J'ai fini par faire quelque chose comme ça.

template<typename T> struct type_precedence { static const int value = -1; }; 
template< > struct type_precedence<long double> { static const int value = 0; }; 
template< > struct type_precedence<double> { static const int value = 1; }; 
template< > struct type_precedence<float> { static const int value = 2; }; 
template< > struct type_precedence<unsigned long long> { static const int value = 3; }; 
template< > struct type_precedence<long long> { static const int value = 4; }; 
template< > struct type_precedence<unsigned long> { static const int value = 5; }; 
template< > struct type_precedence<long> { static const int value = 6; }; 
template< > struct type_precedence<unsigned int> { static const int value = 7; }; 
template< > struct type_precedence<int> { static const int value = 8; }; 
template< > struct type_precedence<unsigned short> { static const int value = 9; }; 
template< > struct type_precedence<short> { static const int value = 10; }; 
template< > struct type_precedence<unsigned char> { static const int value = 11; }; 
template< > struct type_precedence<char> { static const int value = 12; }; 
template< > struct type_precedence<bool> { static const int value = 13; }; 

///////////////////////////////////////////////////////////////////////////////////////// 

template<typename T, typename U, bool t_precedent = ((type_precedence<T>::value) <= (type_precedence<U>::value))> 
struct precedent_type { 
    typedef T t; 
}; 
template<typename T, typename U> 
struct precedent_type<T,U,false> { 
    typedef U t; 
}; 

///////////////////////////////////////////////////////////////////////////////////////// 

template<typename T, typename U> 
typename precedent_type<T,U>::t my_mul() { return T * U; } 

EDIT: Voici l'exemple - Je le fais en fait pour multiplier les vecteurs. Il ressemble à ceci:

template<int N, typename T, typename U> 
vec<N,typename precedent_type<T,U>::t> operator *(const vec<N,T>& v1,const vec<N,U>& v2) { 
    ... 
} 

... 

double3 = float3 * double3; 
float4 = float4 * int4; 
etc. 

Answer 5

Vous pouvez le faire non C++0x code:

template<typename T, typename U> class Mul 
{ 
    T t_; 
    U u_; 
public: 
    Mul(const T& t, const U& u): t_(t), u_(u) {} 
    template <class R> 
    operator R() 
    { 
    return t_ * u_; 
    } 
}; 

template<typename T, typename U> 
Mul<T, U> mul(const T& t, const U& u) 
{ 
    return Mul<T, U>(t, u); 
} 

Utilisation: omble chevalier t = 3; court u = 4; int r = mul (t, u);

Ici, nous avons deux types de déductions. Nous déclarons implicitement le type de retour par l'utilisation, pas exactement decltype (T * U)