Discussion :

[camboui]

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]

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]

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]

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]

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]

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)