enum et template

Version imprimable

enum et template

Voici un petit code.
Code:

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 struct MyStruct { enum keyname {first,second}; template<keyname _E> void make() const; template<> void make<first>() const { } template<> void make<second>() const { } }; template<typename _T,_T::keyname _K> struct MasterStruct { template<typename P> void foo()(P const & v) const { v.make_key<_K>(); } };
J'ai un enum dans une structure et une méthode template sur cet enum avec spécialisation. Jusque là c'est OK.

Ensuite j'aimerais passer cette première structure en template d'une autre, et de là appeler une des méthodes spécialisées de la première structure. Bien sûr ça ne passe pas.
Comment faire ?
Merci.

Est-ce que c'est de la triche si on transfère l'enum dans une classe mère ? :mrgreen:

Code:

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
41
 
struct Base
{
   enum keyname {first, second};
};
 
struct MyStruct : public Base
{
   template<keyname K>
   void make() const 
   {
   }
 
   template<>
   void make<first>() const
   {
   }
 
   template<>
   void make<second>() const
   {
   }
};
 
 
template <typename T>
struct MasterStruct
{
   template <Base::keyname k>
   void foo(T const & v) const
   {
      v.make<k>();
   }
};
 
int main()
{
   MasterStruct<MyStruct> ms;
   MyStruct s;
   ms.foo<MyStruct::first>(s);
}

20/11/2009, 04h24
Alp

Sans faire avec un trick comme le suggère Arzar, non, c'est impossible. Si tu veux passer des valeurs appartenant à un enum à une fonction templates, le compilo doit savoir à la déclaration du template quel est l'enum en question. Ceci est rendu impossible si tu dis au compilo "ouais l'enum sera dans mon type T t'inquiètes". Pour faire ce genre de choses, il faudrait pouvoir métaprogrammer les templates, et ce n'est pas au programme de C++98 ni C++03 ni C++0x :aie:

J'ai trouvé une autre manière de faire. Au lieu d'avoir un enum, je change simplement le nom des méthodes.

Code:

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
struct MyStruct
{
	void first(std::string & s) const
	{
		s="first";
	}
	void second(std::string & s) const
	{
		s="second";
	}
};
 
template<typename T>
struct MasterStruct
{
	mutable std::string s;
	void (T::*mf_)(std::string &) const;	// the member function pointer
 
	explicit MasterStruct(void (T::*mf)(std::string &) const):mf_(mf) {}
 
	void operator()(T const & v) const
	{
		(v.*mf_)(s);
	}
};
 
template<typename T> inline MasterStruct<T> const make_MasterStruct(void (T::*mf)(std::string &) const)
{ return MasterStruct<T>(mf); }
 
 
int _tmain(int argc, _TCHAR* argv[])
{
	MasterStruct<MyStruct> master=make_MasterStruct(&MyStruct::first);
	MyStruct ms;
	master(ms);
	std::wcout << master.s.c_str() << std::endl;
}

Est-ce plus élégant ?

Bonjour

Et en utilisant typename dans

Code:

template<typename _T,typename _T::keyname _K>

pour spécifier que _T::keyname est bien un type ?
J'ai pu instancier le code suivant sous VS2005 :

Code:

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
struct MyStruct
{
	enum keyname {first,second};
 
	template<keyname _E>
	void make() const;
	template<>
	void make<first>() const
	{
	}
	template<>
	void make<second>() const
	{
	}
};
 
template<typename _T,typename _T::keyname _K>
struct MasterStruct
{
	template<typename P>
	void foo/*()*/(P const & v) const
	{
		v.make/*_key*/<_K>();
	}
};
 
/* ... */
MasterStruct<MyStruct,MyStruct::first>  Ms;
MyStruct Test;
Ms.foo(Test);

Presque. Pour que ca compile, il faut sortir les spécialisations de make de la définition de la classe et préciser que make est une fonction template lors de son appel :

Code:

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
41
42
43
44
#include <iostream>
struct MyStruct
{
	enum keyname {first,second};

	template<keyname _E>
	void make() const;
};
template<>
void MyStruct::make<MyStruct::first>() const
{
   std::cout<<"first"<<std::endl;
}
template<>
void MyStruct::make<MyStruct::second>() const
{
   std::cout<<"second"<<std::endl;
}

template<typename _T,typename _T::keyname _K>
struct MasterStruct
{
	template<typename P>
	void foo(P const & v) const
	{
		v.template make<_K>();
	}
/* ou 
	void foo(_T const & v) const
	{
		v.template make<_K>();
	}
*/
};
int main()
{
   /* ... */
   MasterStruct<MyStruct,MyStruct::first>  Ms1;
   MyStruct Test;
   Ms1.foo(Test);
   MasterStruct<MyStruct,MyStruct::second>  Ms2;
   Ms2.foo(Test);
   return 0;
}

[EDIT] pour que ça compile avec gcc (MinGW 4.2.1)

En tout cas, avec VC10, il suffit d'un coup de typename et ça passe comme une lettre à la poste. Incroyable.

Code:

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
 
struct MyStruct
{
   enum keyname {first, second};
 
   template<keyname K>
   void make() const 
   {
   }
 
   template<>
   void make<first>() const
   {
   }
 
   template<>
   void make<second>() const
   {
   }
};
 
 
template <typename _T, typename _T::keyname _K>
struct MasterStruct
{
   template<typename P>
   void foo(P const & v) const
   {
      v.make<_K>();
   }
};
 
int main()
{
   MasterStruct<MyStruct, MyStruct::first> ms;
   MyStruct s;
   ms.foo<MyStruct>(s);
}

Citation:

Envoyé par Arzar

En tout cas, avec VC10, il suffit d'un coup de typename et ça passe comme une lettre à la poste. Incroyable.

Tolérance, tolérance.
Typename, c'est normal.
En revanche, Visual aurait du rejeter l'appel (en c++03) :

Code:

v.make<_K>();

La norme dit bien qu'il faut employer le mot clé template devant l'appel :
Citation:
When the name of a member template specialization appears after . or -> in a postfix-expression, or after
nested-name-specifier in a qualified-id, and the postfix-expression or qualified-id explicitly depends on a
template-parameter (14.6.2), the member template name must be prefixed by the keyword template.
Otherwise the name is assumed to name a non-template. [Example:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 class X { public: template<size_t> X* alloc(); template<size_t> static X* adjust(); }; template<class T> void f(T* p) { T* p1 = p->alloc<200>(); // ill-formed: < means less than T* p2 = p->template alloc<200>(); // OK: < starts template argument list T::adjust<100>(); // ill-formed: < means less than T::template adjust<100>(); // OK: < starts template argument list }
—end example]
Pour le fait de ne pouvoir définir une spécialisation d'une méthode template dans la définition de la classe, je n'ai pas trouvé dans la norme.
A moins que ça :

Citation:

When writing a specialization, be careful about its location; or to make it compile will be such a trial as to kindle its self-immolation.

Wouarf 8O :ccool:
Spectaculaire !
Ça fonctionne parfaitement sous VS2005.

alp, faudra revoir ses leçons ;)

Mieux, voici ceci qui fonctionne aussi
Code:

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 struct MyStruct { typedef void (MyStruct::*mf_type)(std::string &) const; void first(std::string & s) const { s="first"; } void second(std::string & s) const { s="second"; } }; template<typename T,typename T::mf_type Fn> struct MasterStruct { mutable std::string s; void operator()(T const & v) const { (v.*Fn)(s); } }; int _tmain(int argc, _TCHAR* argv[]) { MasterStruct<MyStruct,&MyStruct::first> master; MyStruct ms; master(ms); std::wcout << master.s.c_str() << std::endl; }
Je n'en reviens toujours pas 8-)

Maintenant, est-ce portable tout ça ? Ou bien Microsoft fait-il encore bande à part ?

21/11/2009, 01h08
Alp

Citation:

Envoyé par camboui

alp, faudra revoir ses leçons ;)

T'as bien raison !

J'avais joué avec ce genre de manips il y a un peu plus de 2 ans quand j'entrais dans la partie métaprogrammation du C++, et je me souviens avoir eu des problèmes. C'était à l'époque de gcc 3.x et visual 6/7 si je me souviens bien, ce qui peut expliquer que ça ne passait pas.

En tout cas ce sera ancré à vie dans ma tête que c'est autorisé par la norme :)
21/11/2009, 01h51
koala01

Salut,

Tiens... Moi, il me semblait que la spécialisation de fonction template était interdite, du moins en C++9x... Aurais-je rêvé, ou me serais-je fourvoyé du fait du comportement de mon compilateur sur le sujet :question:
21/11/2009, 03h10
Alp

Citation:

Envoyé par koala01

Salut,

Tiens... Moi, il me semblait que la spécialisation de fonction template était interdite, du moins en C++9x... Aurais-je rêvé, ou me serais-je fourvoyé du fait du comportement de mon compilateur sur le sujet :question:

C'est la spécialisation partielle de fonction membre template qui n'est pas acceptée.
21/11/2009, 11h01
koala01

Citation:

Envoyé par Alp

C'est la spécialisation partielle de fonction membre template qui n'est pas acceptée.

AAAh, voila... Un petit mot, vite oublié, qui fait toute la différence :D