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

[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

[Lavock]

C'est peut-être stupide, mais à quoi serve ces lignes :

Code :

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

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

Code :

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

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

?!?(surtout la première qui fait la même instruction 2 fois ><) ?