enum et template

**camboui** · 19/11/2009, 23h04

Voici un petit 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
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.

**Arzar** · 20/11/2009, 02h00

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

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
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);
}

**Alp** · 20/11/2009, 04h24

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

**camboui** · 20/11/2009, 16h03

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

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
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 ?

**gb_68** · 20/11/2009, 16h20

Bonjour

Et en utilisant typename dans

Code :

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

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 :

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
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);

**3DArchi** · 20/11/2009, 16h51

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 :

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
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)

**Arzar** · 20/11/2009, 16h56

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

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
 
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);
}

**3DArchi** · 20/11/2009, 17h19

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 :

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

v.make<_K>();

La norme dit bien qu'il faut employer le mot clé template devant l'appel :

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 :

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
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 :

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.

**camboui** · 20/11/2009, 20h09

Wouarf

Spectaculaire !
Ça fonctionne parfaitement sous VS2005.

alp, faudra revoir ses leçons

Mieux, voici ceci qui fonctionne aussi

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
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

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

**Alp** · 21/11/2009, 01h08

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

**koala01** · 21/11/2009, 01h51

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

**Alp** · 21/11/2009, 03h10

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

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