Renvoyer un type d'objet;

Question

Est-il possible de renvoyer le type d'un objet? Par exemple, je voudrais avoir construire comme ceci:

//pseudocode 
    template<class T> 
    void f(int value) 
    { 
    //depends on type T different action can be taken 
    } 

template<class T> 
type getType(T obj) 
{ 
return (type of obj); 
} 

puis dans le principal:

f<getType(Object)>(value); 

Answer 1

Oui dans un certain sens, mais vous devez déplacer T dans un paramètre. C'est l'astuce conditionnelle exploré par Eric Niebler et expliqué here.

template<typename T> 
struct id { typedef T type; }; 

template<typename T> 
id<T> make_id(T) { return id<T>(); } 

struct get_type { 
    template<typename T> 
    operator id<T>() { return id<T>(); } 
}; 

#define pass_type(E) (true ? get_type() : make_id((E))) 

pass_type(expression) donne un objet id<T> de telle sorte que T est le type cv-inconditionnel de cette expression. Donc, vous pouvez le faire

template<class T> 
void f(int value, id<T>) 
{ 
    // Now go on as usual on T 
} 

f(value, pass_type(Object)); 

Answer 2

En C++ 0x, il est decltype et automatique qui peut être utilisé

Answer 3

Dans la métaprogrammation de modèle, cela se fait normalement via des modèles de classe.

template <typename T> 
struct GetType 
{ 
    typedef T type; // usually it's something more complex 
}; 

// example: partial specialization is used to compute element type of some container template 
template <typename T> 
struct GetType< MyContainerType<T> > 
{ 
    typedef T type; 
}; 


......................... 

// and now you use it: 
f<GetType<Object>::type>(value); 

Ici, struct GetType<T> peut être considéré en fonction (méta) avec un argument de type et de retourner une valeur de type.

Answer 4

Je pense que vous avez juste besoin d'utiliser la spécialisation de modèle de fonction:

template<> 
void f(int value) 
{ 
    .. operations when an int 
} 


template<> 
void f(char value) 
{ 
    .. operations when a char 
} 


template<> 
void f(double value) 
{ 
    .. operations when a double 
} 


template<class T> 
void f(T value) 
{ 
    .. operations when a T (not int, char or double) 
}