Template : récupérer le type de base en c++0x

Bonjour,

Sur un des tutos de Laurent Gomilla, http://loulou.developpez.com/tutorie...eur3d/partie7/, il est proposé une méthode pour extraire le type de base d'un autre type, en sortant référence et const :

Code:

---

1 2 3 4 5 6 7 8

template <typename T> struct Base {typedef T Type;}; template <typename T> struct Base<T&> {typedef T Type;}; template <typename T> struct Base<const T> {typedef T Type;}; template <typename T> struct Base<const T&> {typedef T Type;};   // Base<int>::Type équivaut à int // Base<const int&>::Type équivaut également à int // etc...

---

Mais je me suis dis qu'il doit surement avoir l'équivalent en c++0x, donc je vais de ce pas faire un tour dans la documentation de boost sur typetrait ici boost sur typetrait ici, mais je n'arrive pas à trouver quelque chose de correspondant.

Si quelqu'un peut m'indiquer s'il connaît, où pour confirmer qu'il faudrait utiliser conjointement std::remove_const et std::remove_reference, je serais reconnaissant!

Je suis sous g++-4.6. Merci d'avance :) Bonne journée!

Bonjour,

Le C++ supporte l'héritage multiple donc ça n'a pas vraiment de sens de parler du "type de base d'un autre type"..

Par exemple :

Code:

---

1 2 3 4 5 6 7 8

struct A{}; struct B{}; struct C : public A, public B{}; struct D{}: struct E{};   struct F : public C, public D, public E{}; {};

---

Que est le "type de base de F" ? A, B, C, D ou E ? Tout à la fois ? :mrgreen:

Donc non, ce n'est pas possible. En revanche, il existe en C++0x et dans boost un trait qui permet de tester si un type est parent d'un autre, il s'agit du trait std::is_base_of :

Code:

---

1 2	std::cout << std::is_base_of<A, F>::value // affiche "1"

---

Ah oui pardon je me suis mal exprimé :)

Quand je parlais du type de base je faisais l'analogie avec le tutoriel cité en début de poste, à savoir récupéré le type sans certains attributs comme const, ou encore retirer les références :

Code:

---

1 2 3 4 5 6 7 8

template <typename T> struct Base {typedef T Type;}; template <typename T> struct Base<T&> {typedef T Type;}; template <typename T> struct Base<const T> {typedef T Type;}; template <typename T> struct Base<const T&> {typedef T Type;};   // Base<int>::Type équivaut à int // Base<const int&>::Type équivaut également à int // etc...

---

Mais cela de façon factoriser, avec des trais standards par exemples!

Pour faire ca il faut que tu regardes dans le header type_traits , par exemple :

Code:

---

1 2 3 4

template<class> struct remove_const; template<class> struct remove_reference; template<class> struct remove_pointer;

---

Merci, j'ai regardé et je pense que c'est bien ce qu'il me faut!

Bonne journée!

Oh bon sang désolé j'étais complètement à coté de la plaque. :aie:

Outre les deux traits mentionnés par Flob90, tu peux aussi t'intéresser à std::remove_cv qui, grossièrement, supprime les const et volatile et surtout std::decay qui semble être une combinaison de std::remove_reference et std::remove_cv. C'est ce qui semble se rapprocher le plus d'un trait qui permettant de retrouver "le type de base" :mrgreen: (sauf que std::decay semble aussi gérer certain cas particulier comme les tableaux et les fonctions)

@Arzar: En C++, decay se réfère au fait de passer des tableaux ou des fonctions à des pointeurs, de T[] à T* par exemple. Je pense que ce type traits (decay) est fait pour ca, le sortir pour autre chose c'est un peu gros je pense, et ca ne répondra pas nécessairement aux besoins.

En fait j'essaie d'utiliser une combinaison des deux traits std::remove_const et std::remove_reference, j'y arrive mais pas en une seule ligne comme dans l'exemple suivant :)

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include <type_traits>   typedef const int& Actuel;   int main() { typedef typename std::remove_reference< Actuel >::type noRef; typedef typename std::remove_const< noRef >::type noRefConst1;   typedef typename std::remove_reference< typename std::remove_const<Actuel>::type >::type noRefConst2;     noRefConst1 a; noRefConst2 b;   return 1; }

---

Lorsqu'on compile le code il plante lors de l'initialisation de b, mais pas de a, preuve qu'on ne retire pas bien le const ou la reference.

Merci pour vos réponse!

Bonjour,

std::remove_reference< std::remove_const<T>> n'est pas équivalent à std::remove_const< std::remove_reference<T>>.

Il faut bien essayer d'enlever d'abord les références puis les qualificatifs cv :

Code:

---

typedef std::remove_const< std::remove_reference<Actuel>::type >::type noRefConst3;

---

P.S. : j'imagine qu'il s'agit d'une erreur de copier/coller, mais typename ne doit pas être utilisé en dehors d'un générique

Oui pardon les typenames viennent de la classe template..

Par contre bonne nouvelle c'était bien ça :D

Mais avant de finir si tu pouvais m'expliquer pourquoi il fallait d'abord enlever la référence puis le const? Et pas l'inverse?

Merci à tous!

Citation:

---

Envoyé par Flob90

@Arzar: En C++, decay se réfère au fait de passer des tableaux ou des fonctions à des pointeurs, de T[] à T* par exemple. Je pense que ce type traits (decay) est fait pour ca, le sortir pour autre chose c'est un peu gros je pense, et ca ne répondra pas nécessairement aux besoins.

---

Oui, je connais le sens usuel de decay en C++, mais pour le trait std::decay le sens usuel a été un peu bousculé pour permettre non seulement de transformer des types tableaux et fonction en pointeur vers élément et pointeur de fonction mais aussi pour servir de raccourci à std::remove_reference/std::remove_cv. Ce n'est pas overkill, c'est fait pour.

Citation:

---

Envoyé par N3242

Let U be remove_reference<T>::type.
If is_array<U>::value is true, the member typedef type shall equal remove_extent<U>::type*.
If is_function<U>::value is true, the member typedef type shall equal add_pointer<U>::type.
Otherwise the member typedef type equals remove_cv<U>::type. [Note: This behavior is similar to the lvalue-to-rvalue (4.1), array-to-pointer (4.2), and function-to-pointer (4.3) conversions applied when an lvalue expression is used as an rvalue, but also strips cv-qualifiers from class types in order to more closely model by-value argument passing. —end note ]

---

Par exemple dans le code source de libc++, on peut voir que std::decay est utilisé assez souvent (pour implémenter bind, function, future, thread, pair et tuple) dans ce sens.

Ou encore ici

Citation:

---

In addition, I'll like to mention that std::decay typically works as a shortcut for remove_cv<remove_refernence<...>>

---

@Arzar: J'avais lu mais pas vu ca comme ca. Par contre ca dépends quand même de ce que l'op entend comme type de base pour T[] par exemple, si pour lui c'est T alors decay ne convient pas.

Salut,

Citation:

---

Envoyé par victor_gasgas

Mais avant de finir si tu pouvais m'expliquer pourquoi il fallait d'abord enlever la référence puis le const? Et pas l'inverse?

---

Je le comprend comme ça :
Imagines que tu remplace la référence par un pointeur constant : typedef const int*const Actuel;
Premier scénario :
Tu enlèves d'abord const cela donne const int *
Puis tu enlèves le pointeur => const int

Second scénario
Dans l'autre sens, tu enlèves d'abord le pointeur => const int
Puis le const => int

Merci pour ces explications!