Discussion :

[regis.portalez]

Bonjour,

j'ai créé une classe template, dans laquelle je veux ecrire un constructeur qui dépend d'un parametre template. En gros ca ressemble à ca :

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
 
 
enum methodes
{
      premiere = 0,
      deuxieme = 1,
} ;
 
template <typename T>
class maclasse
{
       T    champ1 ;
       int  champ2 ;
 
    public:
       template <int methode>
       maclasse (T a, int b) ;
} ;
 
template <typename T> template <premiere>
maclasse<T>::maclass(T c1,  int c2) { code... }
 
template <typename T> template <deuxieme>
maclasse<T>::maclasse(T c1,  int c2) { autre code... }

problème : il me dit syntax error : identifier "premiere"

Je ne vois pas trop comment faire et un peu d'aide serait la bienvenue. D'ailleurs je ne sais même pas s'il est possible de templater le constructeur...
Merci beaucoup.

[Klaim]

Essaie ça ?

Code :

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

1
2
3
4
5
6
 
template <> template <premiere>
maclasse<T>::maclass(T c1,  int c2) { code... }
 
template <> template <deuxieme>
maclasse<T>::maclasse(T c1,  int c2) { autre code... }

edit> Heu non c'est pas bon du tout

[regis.portalez]

Salut,

merci mais ça me fait pareil...

[Klaim]

Code :

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

1
2
template <typename T> 
maclasse<T>::template maclass<premiere>(T c1,  int c2) { code... }

J'avais mal lu ton code (syntaxe ninja oblige), essaie plutot quelque chose comme ça voir.


edit> J'ai pas de quoi vérifier sous la main mais il se peut que cette variante marche :

Code :

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

1
2
template <typename T> 
maclasse<T>::template<> maclass<premiere>(T c1,  int c2) { code... }

[regis.portalez]

Non plus
le compilo (cl) me dit que maclasse n'est pas une fonction

J'en déduis (à tort?) qu'on ne peut que templater des fonctions et pas le constructeur dans une classe template.

C'est dommage, mais je vais changer la signature de mon constructeur en ajoutant premiere et deuxieme en paramètre à la fin de mon constructeur...

Merci beaucoup, et si qqn a des idées sur le sujet, je suis toujours preneur!

Zou

[Klaim]

Il me semble bien que si mais la syntaxe est souvent obscure et j'ai tendance a l'oublier... j'ai du faire un truc semblable une fois auparavant mais je me souvient pas de l'issue. (et j'ai pas de compilo de libre sous la main, mais je tenterai tout a l'heure ...)

[regis.portalez]

J'ai résolu (partiellement) la question en rajoutant un paramètre template dans la classe elle même. A mon avis c'est mieux.

Code :

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

1
2
3
4
5
6
7
8
9
10
 
template <typename T, int methode>
class maclasse
{
     T champ1 ;
     int champ2 ;
 
   public:
     maclasse (T c1, int a) ;
} ;

et ensuite je fais les deux spécialisations partielles de classe en fonction de la valeur de int.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
 
template <typename T>
class maclasse<T, premiere>
{
       //specialisation 1
} ;
 
 
template <typename T>
class maclasse<T, premiere>
{
       //specialisation 2
} ;

Du coup la question est résolue pour moi parce que je n'ai que deux valeurs dans mon enum, mais si qqn veut faire la même chose avec N >> 1 valeurs dans son enum de méthodes, je vois pas trop comment faire. Surtout si la classe est un peu grande (ce qui est en fait mon cas)... (ninja )
J'attend ta réponse avec impatience.

Merci beaucoup!

[Steph_ng8]

Bonjour,
Je te rassure tout de suite, c'est tout à fait possible de définir une fonction template membre d'une classe elle-même template.
La construction par intervalle, l'assignation par intervalle ou l'insertion d'un intervalle pour les conteneurs de la STL en sont de parfaits exemples.

La déclaration du constructeur dans la classe est correcte.
C'est sa définition qui pose problème.
Tout d'abord, comme tout ce qui est template, il faut définir le cas général (quitte à ce qu'il ne fasse rien ou lance une exception quoi qu'il arrive) :

Code :

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

1
2
3
4
5
6
template <typename T>
template <int methode>
maclasse<T>::maclasse(T c1, int c2)
{
    (...)
}

Et ensuite, on peut spécialiser :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
template <typename T>
template <>
maclasse<T>::maclasse<premiere>(T c1, int c2)
{
    (...)
}
 
template <typename T>
template <>
maclasse<T>::maclasse<deuxieme>(T c1, int c2)
{
    (...)
}

Ceci dit, je verrais le paramètre template « methode » du type « methodes » plutôt que « int ».
Mais c'est un détail…

[edit]
Mea culpa, ceci ne fonctionne pas…
[/edit]

[nowahn]

Bonjour,

Premièrement, d’après mes essais, il semble qu’on ne puisse pas spécialiser totalement une fonction membre sans spécialiser totalement la classe contenante aussi. En tout cas, je trouve pas la syntaxe, et mon compilateur (gcc) me renvoie un message d’erreur qui me semble vouloir dire ça (même si il me paraît un peu obscur) :

Code :

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

error: enclosing class templates are not explicitly specialized

Si je me trompe et qu’une syntaxe existe, je suis preneur.

Note que dans ton code, il faut de toute façon que tu définisse le constructeur modèle général avant de définir les constructeurs modèles spécialisés. Mais même avec ça, la spécialisation totale du constructeur ne marche pas sans spécialiser totalement la classe aussi.

Ensuite, je cherche également sur ce sujet comment templétiser un constructeur sans utiliser l’argument de modèle dans les arguments de fonction (ce qui est ton cas). D’après les réponses que j’ai, je me demande si le cas a été envisagé, car je ne trouve vraiment pas la syntaxe d’appel.

J'ai résolu (partiellement) la question en rajoutant un paramètre template dans la classe elle même.

La différence, c’est que tu te retrouve avec des objets de type différent. Ça peut te convenir … ou pas.

EDIT : grillé de peu.

Steph_ng8, tu a essayé ton code, il ne marche pas chez moi (compilateur gcc).

La construction par intervalle, l'assignation par intervalle ou l'insertion d'un intervalle pour les conteneurs de la STL en sont de parfaits exemples.

Il y a une grosse différence, c’est que dans ce que tu cites, les arguments de modèle sont utilisés dans la liste d’arguments de fonction, ce qui simplifie la syntaxe (pas besoin de <...> après le nom de la fonction). C’est tout le problème que je pose dans mon autre sujet que je cite.

Le problème immédiat est qu’on ne trouve pas la syntaxe pour spécialiser totalement une fonction membre (ici un constructeur) sans spécialiser la classe contenante. Peut-être est-ce impossible ???

Le problème qui viendra si on trouve cette syntaxe, c’est la syntaxe pour appeler un tel constructeur (ça fait plusieurs jours que je cherche, voir l’autre sujet que je cite

[gbdivers]

Bonjour regis.portalez

Ton problème est un peu étrange...

Pour répondre à la question : oui, on peut mettre un constructeur en template mais il faut que le type soit déduit par le compilateur (impossible d'appeler le constructeur templété directement) :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
template<typename T>
class A
{
public:
    template<typename U> A(const U& a);
};
 
template<typename T> template<typename U>
A<T>::A(const U& a)
{
}
 
A<int> a(10.2); // ok, type double passé en paramètre template
A<int> a = A<int>::A<double>(10); // error: cannot call constructor ‘A<int>::A’ directly

Tu souhaites non pas passer un type mais une valeur (provenant d'un enum). Habituellement, on utilise les "nontype template class", par exemple pour spécifier la taille d'un tableau :

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
template<typename T, int SIZE>
class B
{
private:
    T data[SIZE];
public:
    B();
};
 
template<typename T, int SIZE>
B<T, SIZE>::B()
{
}
 
B<int, 10> b; // ok

Si j'ai bien compris aussi, c'est que tu souhaites en fait écrire plusieurs constructeur différents, avec une spécialisation du constructeur avec un "nontype template parameter", pour appeler de la façon suivante :

Code :

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

1
2
C c1<premiere>; // création d'un object de type C en appelant le premier type de constructeur
C c2<second>; // création d'un object de type C en appelant le second type de constructeur

Tu ne peux pas mettre le "nontype parameters" en paramètre template de classe sinon tes types ne seront pas compatible. (je comprends bien pour le moment ton problème ?)

Code :

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

1
2
3
B<int, 0> b1; // appel du premier constructeur
B<int, 1> b2; // appel du second constructeur
b1 = b2; // erreur : types incompatible

Il est possible de contourner ce problème en mettant un opérateur de conversion :

Code :

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

1
2
3
template<typename T2, int SIZE2>
B& operator= (const B<T2, SIZE2>& b)
{ ... }

ou de créer une classe parent sans "nontype parameter template" puis de mettre des opérateurs de conversion depuis les types hérités vers le type parent...

A priori, il est possible également d'utiliser boost::mpl ou une méthode permettant de convertir une valeur en type (http://programming.itags.org/c-progr...nguage/171842/)


Personnellement, je préférerais passer par une classe builder template, qui se chargerait de créer une instance du type souhaité (maclass<T>) en fonction d'un "nontype parameter" de classe :

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
template <typename T>
class MaClasse
{
    template<int ID> friend class Builder; // si nécessaire
};
 
template<int ID>
class Builder
{
public:
    template <typename T> static MaClasse<T> create();
};
 
// spécialisation pour ID = 0
template<> template <typename T>
MaClasse<T> Builder<0>::create()
{ ... }
 
// spécialisation pour ID = 1
template<> template <typename T>
MaClasse<T> Builder<1>::create()
{ ... }
 
// appels :
MaClasse<int> a0 = Builder<0>::create<int> ();
MaClasse<double> a1 = Builder<1>::create<double> ();
MaClasse<double> a2 = Builder<2>::create<double> (); // pas de spécialisation pour ID = 2

EDIT : complètement grillé par plusieurs réponses avant moi...

EDIT2 :
Le code de Steph_ng8 ne fonctionne pas non plus chez moi (gcc). A priori, ce type de spécialisation ne fonctionne qu'avec des "type parameters"

[Steph_ng8]

Hé, hé, hé…
Grilled, grilled !

Hum…

Je crois que j'ai répondu un peu vite.
Sur la syntaxe, c'est correct, mais effectivement lorsque les paramètres template peuvent être déduits pour des fonctions autres que les constructeurs.

En lisant le post de nowhan, je me suis souvenu que j'avais fait des tests (infructueux) suite au problème présenté dans le topic qu'il mentionne.
J'ai donc essayé le code que je propose, et il ne compile pas non plus (gcc idem).

[regis.portalez]

Salut,

Et bien mon problème a pas l'air si simple que ça finalement

Le code de steph_ng8 ne fonctionne pas non plus chez moi, même sur mon petit prog test (identique à celui de mon premier poste).

Là je suis un peu pris par le taf, mais je vais regarder ta solution gbdivers, parce qu'elle me paraît pas mal (mais oui mon problème est étrange...)

nowahn : en effet, je viens de me rendre compte qu'avoir des objets de type différents à la fin, c'est pas terrible...

Quant à ma première idée de changer la signature de mon constructeur pour lui mettre une valeur supplémentaire à la fin (methode), ça ne me satisfait pas tout à fait. Parce que du coup il faut faire un test sur la valeur de méthode, et que ce test prend un temps d'execution comparable à celui du code qui suit... d'où mon désir que cette valeur soit connue à la compilation.




ps : Je peux pas vous dire quel est le vrai code derrière ce problème (confidentiel), c'est dommage parce que ça paraîtrait plus clair d'un coup...

Donc il faut malheureusement se contenter de le voir comme un problème général de C++

[gbdivers]

Quant à ma première idée de changer la signature de mon constructeur pour lui mettre une valeur supplémentaire à la fin (methode), ça ne me satisfait pas tout à fait. Parce que du coup il faut faire un test sur la valeur de méthode, et que ce test prend un temps d'execution comparable à celui du code qui suit... d'où mon désir que cette valeur soit connue à la compilation.

L'idée est de remplacer une syntaxe de type :

Code :

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

maclass<int> unobject<string>;

en :

Code :

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

maclass<int> unobject( string() );

Le type template est connu à la compilation dans les 2 cas (c'est le but) mais dans le premier cas, on appelle directement un constructeur template (ce qui est illégale) alors que dans le second cas, le type template du constructeur est déduit du type de paramètre passé comme argument (et je pense que ça ne génère pas de temps d'exécution supplémentaire)

Dans ton cas, où tu souhaites utiliser un "nontype parameter", cette syntaxe ne fonctionne pas en effet (la valeur sera évaluée à l'exécution). A priori, c'est possible que cela fonctionne quand même mais avec quelques trafics (voir le lien que j'ai donné)

[Jean-Marc.Bourguet]

J'ai pas tout lu, mais je desire rappeler qu'il est impossible de specialiser un membre template d'une classe template uniquement sur les parametres templates du membre, il faut aussi specialiser explicitement sur les parametres templates de la classe.

[Invité]

Juste pour rajouter que un non-type parameter peut-etre specifier au compilo, via une classe qui permet d'associer un type à un entier :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
template<int I>
class Int2Type{};  // cf Modern C++
 
class Foo
{
      template<int I>
      Foo( Int2Type<I> const&);
};
 
// utilisation :
 
Foo a( Int2Type<1>());
Foo b( Int2Type<2>());

[nowahn]

@regis.portalez :

Pour résoudre ton problème sans surcharge à l’exécution, je pense que tu peux utiliser un paramètre supplémentaire au constructeur :

Code C++ :

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
class methode1 {};
class methode2 {};
 
template <typename T>
class maclasse
{
       T    champ1 ;
       int  champ2 ;
 
    public:
       maclasse (T a, int b, methode1) ; // dernier paramètre non nommé.
       maclasse (T a, int b, methode2) ;
} ;
 
template<typename T>
maclasse<T>::maclasse(T a, int b, methode1)
{
   // code n’utilisant pas la classe methode1
}
 
template<typename T>
maclasse<T>::maclasse(T a, int b, methode2)
{
   // code n’utilisant pas la classe methode2,
   // mais code différent du constructeur précédent.
}
 
// utilisation :
maclasse<float> objet1(0.0, 0, methode1());
maclasse<float> objet2(0.0, 0, methode2());

À priori, le dernier paramètre des constructeurs sera éliminé de l’exécutable (après que le constructeur a été choisi à la compilation par le mécanisme de surcharge de fonction) même par le plus pourri des optimiseurs.
La limitiation de ce code est que pour rajouter une troisième politique, il faut rajouter un troisième constructeur. Ceci devrait être un travail pour les modèles (template), mais c’est justement le sujet le l’autre sujet que j’ai ouvert ...

[dragonjoker59]

C'est sur ce principe qu'est défini le constructeur par conversion des shared_ptr de boost/tr1 (cf. static_pointer_cast, const_pointer_cast et dynamic_pointer_cast)