Discussion :

[yan]

Bonjour.
Je cherche à spécialiser une template en fonction que la classe hérite ou non d'une autre classe.

J'ai trouvé pour l'héritage avec une classe Traits
http://www.gotw.ca/publications/mxc++-item-4.htm

Mais je n'arrive pas à trouver comment aller plus loin.

En gros je voudrais :
1-dans le cas générale

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
template<typename T>
class toto
{
T * m_ptr;
 
/*...*/
}

2- si T hérite de A

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
template<typename T>
class toto
{
titi<T> m_ptr;
 
/*...*/
}

Je pense qu'il me faut une autre classe traits pour m_ptr, mais je ne voie pas comment mettre cela en oeuvre avec le test d'héritage..

Y as peut être une meilleur solution...

[yan]

j'ai trouvé, avec une autre template interne qui se spécialise en fonction du résultat de l'héritage.
Ca donne

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
template<typename T>
class toto
{
 
   template <bool P1,typename P2>
    struct interptr
    {
    };
 
    template<typename P2>
    struct interptr<false,P2>
    {
        P2   * ptr; 
        P2* get() {return ptr;}
        const P2* get()const {return ptr;}
    };
    template<typename P2>
    struct interptr<true,P2>
    {
        QWeakPointer<typename P2> ptr; 
         P2* get() {return ptr.data();}
        const P2* get()const {return ptr.data();}
    };
 
    interptr<IsDerivedFromHelper<T,QObject>::Is , T> m_ptr; 
 
 
...
 
};

[camboui]

Je tombe à la renverse en voyant ce code:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Example 4-3(c): An IsDerivedFrom constraints base 
// with testable value
//
template<typename D, typename B>
class IsDerivedFrom
{
  class No { };
  class Yes { No no[3]; }; 

  static Yes Test( B* ); // not defined
  static No Test( ... ); // not defined 

  static void Constraints(D* p) { B* pb = p; pb = p; } 

public:
  enum { Is = sizeof(Test(static_cast<D*>(0))) == sizeof(Yes) }; 

  IsDerivedFrom() { void(*p)(D*) = Constraints; }
};

Il est donc possible de demander au compilateur d'exécuter une des méthodes Test() afin d'en évaluer la valeur retour par un sizeof(). Sidérant !

[Laurent Gomila]

Il est donc possible de demander au compilateur d'exécuter une des méthodes Test() afin d'en évaluer la valeur retour par un sizeof(). Sidérant !

Non. Simplement de résoudre l'appel, trouver la bonne surcharge et donc le type de retour correspondant à cette surcharge. Rien n'est évalué, le compilo ne fait que son boulot habituel ici. D'ailleurs tu vois bien que les fonctions Test() n'ont aucune définition, il n'y a rien à appeler.

[yan]

Il est donc possible de demander au compilateur d'exécuter une des méthodes Test() afin d'en évaluer la valeur retour par un sizeof(). Sidérant !

Je crois que le sizeof vérifie juste le taille du type de retour.

Moi ce qui me choque c'est que l'on as deux fonctions static Test qui ne retournent pas la même chose, ne prennent pas le même arguments et qui ne sont pas définie

Y as boost qui propose un truc,mais y as tellement d'include que j'ai pas trouvé comment ils font

[camboui]

Je sais bien que rien n'est évalué, itaque j'ai mis le verbe en italique.

N'empêche, vous semblez blasé de voir ce genre d'écriture

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

sizeof(foo(427));

alors que foo() serait juste déclarée (et même pas définie comme le souligne yan).
C'est la première fois que je vois autre chose qu'une variable ou un type explicite dans un sizeof().
On peut donc y ajouter le type retour d'une fonction. Y'en a d'autres comme ça ?

[Laurent Gomila]

Moi ce qui me choque c'est que l'on as deux fonctions static Test qui ne retournent pas la même chose, ne prennent pas le même arguments et qui ne sont pas définie

- "retournent pas la même chose, ne prennent pas le même arguments" --> ce sont deux surcharges, quoi
- "ne sont pas définie" --> ça poserait un problème à l'éditeur de liens lorsqu'il rencontrerait un appel, mais comme le compilateur n'en a pas généré, il n'y a pas besoin de définition

Y as boost qui propose un truc,mais y as tellement d'include que j'ai pas trouvé comment ils font

La plupart des détections utilisant SFINAE s'implémentent très exactement avec ce type de code, y compris dans boost

[Alp]

Par ailleurs yan, tu trouveras pas mal de templates pour savoir si une classe dérive d'une autre etc dans boost.type_traits.

[yan]

- "retournent pas la même chose, ne prennent pas le même arguments" --> ce sont deux surcharges, quoi

Il me semblais que le type retourné ne pouvais pas être différent

SFINAE.... va bien falloire que je comprenne ce que c'est réellement un de ces jours

[Alp]

Il me semblais que le type retourné ne pouvais pas être différent

SFINAE.... va bien falloire que je comprenne ce que c'est réellement un de ces jours

http://cpp.developpez.com/faq/cpp/?p...MPLATES_SFINAE
http://alpmestan.wordpress.com/2009/...ion-to-sfinae/
http://cplusplus.co.il/2009/09/11/su...ot-an-error-1/
http://cplusplus.co.il/2009/09/12/su...ot-an-error-2/

Si t'as des questions n'hésite pas.

[3DArchi]

Salut,

- "ne sont pas définie" --> ça poserait un problème à l'éditeur de liens lorsqu'il rencontrerait un appel, mais comme le compilateur n'en a pas généré, il n'y a pas besoin de définition

Et le fait que ce ne soit pas défini indique bien que tout est fait à la compilation et qu'aucun code supplémentaire n'est ajouté à l'exécutable cible. Donc, coût metaprog == 0

[camboui]

Si t'as des questions n'hésite pas.

Oui, moi

Peut-on vérifier la présence d'un membre d'une classe ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
struct A
{
int test();
};
 
struct B
{
};
 
...
 
isMemberOf<test, A>:is;// would be true
isMemberOf<test, B>:is;// would be false

[yan]

Oui, moi

Peut-on vérifier la présence d'un membre d'une classe ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
struct A
{
int test();
};
 
struct B
{
};
 
...
 
isMemberOf<test, A>:is;// would be true
isMemberOf<test, B>:is;// would be false

il semble que oui
http://www.cplusplus.com/forum/general/21255/

[Alp]

Oui tout à fait.
De manière globale, regarde ça : http://www.developpez.net/forums/d75...ssant-typedef/
SFINAE y est un peu décortiquée.
(et tous les liens ci-dessus)

[Laurent Gomila]

Par contre on ne peut pas avoir un template unique du genre isMemberOf, il en faut obligatoirement un par fonction différente (ça peut se générer via une macro -- je crois que c'est ce que boost propose).

[Alp]

Oui : http://www.boost.org/doc/libs/1_42_0...ospection.html

[camboui]

merci !

Mais il semble que ça ne fonctionne pas si le membre est une méthode template. Or c'est justement dans ce cas que je pourrais en avoir besoin

[Alp]

merci !

Mais il semble que ça ne fonctionne pas si le membre est une méthode template. Or c'est justement dans ce cas que je pourrais en avoir besoin

Une fonction membre template

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

template <typename T> void f(const T& t);

n'est pas une fonction membre. f<int>, f<char> etc le seraient. Donc c'est un peu plus tricky. Il faudrait demander sur comp.lang.c++.moderated ça je pense. J'ai p-ê une vague idée, je ferai un peu de recherches.

[yan]

J'ai pas encore tous compris, mais ça avance. Pour checker la présence d'un membre, j'ai trouvé deux méthode :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
#include <iostream>
 
template<typename T, typename Sig>                                 
struct has_foo {                     
    template <typename U, U> struct type_check;
    template <typename V> static char (& chk(type_check<Sig, &V::foo>*))[1];
    template <typename  > static char (& chk(...))[2]; 
    static bool const value = (sizeof(chk<T>(0)) == 1);
};
 
struct A {
    void foo();
};
 
struct B : A {};
 
int main()
{
    using namespace std;
    cout << boolalpha << has_foo<A, void (A::*)()>::value << endl; // true
    cout << boolalpha << has_foo<B, void (B::*)()>::value << endl; // false
cout << boolalpha << has_foo<B, void (A::*)()>::value << endl; // true
}

Si héritage, il faut savoir dans quel classe de la hiérarchis foo à été créé...

une autre qui trouve foo au travers l'héritage mais check pas la signature

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
#include <iostream>
 
template <typename Type> 
class has_foo
{ 
   class yes { char m;}; 
   class no { yes m[2];}; 
   struct BaseMixin 
   { 
     void foo(){} 
   }; 
   struct Base : public Type, public BaseMixin {}; 
   template <typename T, T t>  class Helper{}; 
   template <typename U> 
   static no deduce(U*, Helper<void (BaseMixin::*)(), &U::foo>* = 0); 
   static yes deduce(...); 
public: 
   static const bool result = sizeof(yes) == sizeof(deduce((Base*)(0))); 
}; 
 
struct A {
    void foo();
};
 
struct B : A {};
 
struct C {
 };
 
struct D {
    int foo;
 };
int main()
{
    using namespace std;
    cout << boolalpha << has_foo<A>::result << endl; //true
    cout << boolalpha << has_foo<B>::result << endl; //true
    cout << boolalpha << has_foo<C>::result << endl; //false
    cout << boolalpha << has_foo<D>::result << endl; //true
}

Existe t'il une autre solution pour avoir les deux??

[Alp]

Les macros de MPL ne gèrent pas ça ?