[Template] Spécialisation partielle d'un template

Version imprimable

Voir 40 message(s) de cette discussion en une page

Bonjour, je suis en train d'essayer de faire une spécialisation partielle d'un constructeur: je veux qu'il puisse être défini dans le template pour être d'un type ou de void.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 namespace kage { //! \template InstanceOf //! @brief instance of a definition template< class _Self, class _Definition, class _Base = KAGE_EMPTY<_Self>, typename _Param = void, class _DefPtr = KAGE_WP(_Definition) > class InstanceOf : public _Base { _DefPtr _definition; public: friend class _Definition; _DefPtr getDefinition() { return _definition; } protected: InstanceOf(_Param p); public: virtual ~InstanceOf() {} }; } //namespace kage
Voilà, pour le constructeur, je dois appeler le constructeur parent, qui lui peut ou ne pas avoir un paramètre. Evidemment, un paramètre void nommé, ca ne fonctionne pas, donc je dois spécialiser le template pour accepter aussi les paramètres void.
Code:

1 2 3 4 5 6 7 8 9 10 11 12 template< class _Self, class _Definition, class _Base, typename _Param, class _DefPtr > kage::InstanceOf< _Self, _Definition, _Base, _Param, _DefPtr>::InstanceOf(_Param p) : _Base(p) { } template< class _Self, class _Definition, class _Base, class _DefPtr > kage::InstanceOf< _Self, _Definition, _Base, void, _DefPtr>::InstanceOf(void) : _Base() { }
Autant dire que si je poste ca ici, c'est que ca ne fonctionne pas. D'où mes questions: est-ce que ce que je veux faire est possible? si oui, quelle serait la syntaxe ou la facon correcte de s'y prendre? Sinon, ben quelles autres solutions y-a-t'il ?

17/11/2008, 10h07
3DArchi

De mémoire, il me semble qu'on ne peut spécifier partiellement une méthode. Seule une classe peut être spécifiée partiellement.

Pourtant, je viens de tester en petit, ce truc fonctionne:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
template<typename _param>
class PTest
{
public:
	PTest(_param);
};
 
template<>
PTest<void>::PTest(void)
{}
 
template<>
PTest<int>::PTest(int p)
{p;}
 
void mtest()
{
	PTest<void> vPtest;
	PTest<int>	iPtest(3);
 
}

Ce qui voudrait dire que je dois spécialiser le constructeur du template pour chaque type de paramètre. Or, dans le cas concret, ca ne fonctionne pas en définissant ceci:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
 
template< class _Definition, class _Base, class _DefPtr >
kage::InstanceOf< _Definition, _Base, GLenum, _DefPtr>::InstanceOf(GLenum p) :
	_Base(p)			
	{
	}
 
template< class _Definition, class _Base, class _DefPtr >
kage::InstanceOf< _Definition, _Base, void, _DefPtr>::InstanceOf(void) :
	_Base()			
	{
	}

Je reprends mon exemple:
ceci fonctionne

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
template<typename _param>
class PTest
{
public:
	PTest(_param);
};
 
template<>
PTest<void>::PTest(void)
{
	std::cout << "void param" << std::endl;
}
 
template<typename _T>
PTest<_T>::PTest(_T p)
{
	std::cout << typeid(_T).name() << " param " << p << std::endl;
}
 
 
void mtest()
{
	PTest<void>	vPtest;
	PTest<int>	iPtest(3);
 
}

alors que ceci ne fonctionne pas:

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
template<class _Base, typename _P>
class AnotherTest : public _Base
{
public:
	typedef _Base Parent;
	AnotherTest(_P);
};
 
template<class _B>
AnotherTest<_B, void>::AnotherTest(void):
	Parent()
{
	std::cout << "base class: " << typeid(_B).name() << std::endl;
	std::cout << "param: void" << std::endl;
}
 
template<class _B, typename _X>
AnotherTest<_B, _X>::AnotherTest(_X x):
	Parent(x)
{
	std::cout << "base class: " << typeid(_B).name() << std::endl;
	std::cout << "param: " << typeid(_X).name() << x << std::endl;
}
 
class Foo
{
public:
	Foo(){}
};
 
class Bar
{
	int i;
public:
	Bar(int _i):i(_i){}
};
 
void atest()
{
	AnotherTest<Foo, void>	vATest;
	AnotherTest<Bar, int>	vBTest(4);
}

Quelqu'un pourrait m'expliquer les raisons de cette erreur de compilation?
(Sous VC, c'est "error C2244: 'AnotherTest<_Base,_P>::AnotherTest': unable to match function definition to an existing declaration" )

17/11/2008, 12h53
3DArchi

Dans le premier cas, tu fais une spécialisation totale (OK) et dans le second une partielle (NOK). Je pense que c'est ça.
17/11/2008, 13h18
Kurisu

OK (ou plutôt NOK). Si ca ne marche, quels sont donc mes alternatives?
Faire une spécialisation totale de mon cas d'utilisation?
Est-ce qu'il y a une autre facon de s'y prendre à la spécialisation partielle?

EDIT: Ca marche (bien sûr) avec une spécialisation totale, mais ce serait intéressent d'avoir une facon de s'y prendre pour les spécialisations partielles.
17/11/2008, 15h44
Alp
Citation:

Envoyé par Kurisu

OK (ou plutôt NOK). Si ca ne marche, quels sont donc mes alternatives?
Faire une spécialisation totale de mon cas d'utilisation?
Est-ce qu'il y a une autre facon de s'y prendre à la spécialisation partielle?

EDIT: Ca marche (bien sûr) avec une spécialisation totale, mais ce serait intéressent d'avoir une facon de s'y prendre pour les spécialisations partielles.

Imaginons que tu veuilles spécialiser une fonction

Code:

template <class T> void f(T t)

en

Code:

template <class T> void f<T*> (T* t)

Alors, tu passes par une structure que tu spécialises partiellement, ce qui est autorisé :
Code:

1 2 3 4 5 6 7 8 9 template <class T> struct S { void f(T t) { } }; template <class T> struct S<T*> { void f(T* t) { } };
17/11/2008, 16h46
Kurisu
Merci Alp, je vois pour la spécialisation partielle d'une fonction membre. Comment dois-je m'y prendre lorsque cette fonction membre est le constructeur?

Puis dans ton exemple, si la structure S contient un membre, est-ce que je dois le redéfinir dans la spécialisation?
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 template <class T> struct S { T member; void f(T t) { } }; template <class T> struct S<T*> { //faut-il redefinir member ici? T* member; void f(T* t) { } };

Bon, voici une solution pour mon problème initial utilisant la spécialisation partielle d'une classe. Ce bout de code me déplaît quand même peu...

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
namespace kage
{
	template< class _Definition, class _DefPtr = KAGE_WP(_Definition) >
	class	DefinedInstance
	{
		_DefPtr		_definition;
	public:
		friend	class	_Definition;
 
		_DefPtr		getDefinition()		{	return _definition;	}
 
		DefinedInstance(_DefPtr def):	_definition(def) {}
		virtual ~DefinedInstance()		{}
	};
 
	template< class _Definition, class _Base, typename _Param = void, class _DefPtr = KAGE_WP(_Definition) >
	class	InstanceOf2 : public _Base, public DefinedInstance<_Definition, _DefPtr>
	{
	protected:
		InstanceOf2(_DefPtr def, _Param p) :
			DefinedInstance(def),
			_Base(p)
		{
		}
	public:
		virtual ~InstanceOf2()	{}
	};
 
	template< class _Definition, class _Base, class _DefPtr >
	class	InstanceOf2<_Definition, _Base, void, _DefPtr> : public _Base, public DefinedInstance<_Definition, _DefPtr>
	{
	protected:
		InstanceOf2(_DefPtr def) :
			DefinedInstance(def),
			_Base()
		{
		}
	public:
		virtual ~InstanceOf2()	{}
	};
} //namespace kage

19/11/2008, 12h09
Kurisu
Je voulais quand même savoir, est-ce qu'il y a une autre facon de s'y prendre pour résoudre mon problème initial, qui était d'avoir un constructeur différent selon le(s) paramètre(s) du constructeur d'une classe parente ?

Sous D par exemple, je m'y prendrai avec un static if:
Code:

1 2 3 4 5 6 7 8 template(class Base, typename Param) class Instance : Base { static if(Param == void) Instance(void):Base(){} static else Instance(Param p):Base(p){} };
(enfin, ceci est du pseudo-code, je ne sais pas si c'est du code D valable).
19/11/2008, 13h39
Alp

En C++ tu peux "jouer" avec boost.mpl et boost.type_traits pour obtenir quelque chose de similaire ;)
19/11/2008, 15h47
Kurisu

Alp>c'est bien ce que je pensais, mais tu n'aurais pas un exemple concret?
Je n'ai pas encore trop d'expérience poussée dans la meta-programmation avec Boost.MPL (seulement avec Boost.Prepro ;) ).
19/11/2008, 16h03
Alp

Tu peux regarder du cote des metafonctions if_, enable_if et compagnie.

J'avoue que je ne vois pas trop comment opérer même avec les méta-fonction. En fait, le problème est de définir deux constructeurs différents avec des paramètres différents en fonction d'un des paramètres template. Et là, j'ai beau tourner le problème, je ne vois pas.
J'arrive à faire quelque chose comme ça, mais à mon sens ça n'est pas satisfaisant:
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 #include <boost/mpl/eval_if.hpp> #include <boost/mpl/void.hpp> #include <boost/type_traits/is_void.hpp> class BaseVoid { public: BaseVoid(boost::mpl::void_){}// là, ça me gène }; class BaseNonVoid { public: BaseNonVoid(int){} }; template<class Base, class ParamT> class Derive:public Base { public: Derive( typename boost::mpl::if_<boost::is_void<ParamT>, boost::mpl::void_, ParamT>::type _p=boost::mpl::if_<boost::is_void<ParamT>, boost::mpl::void_, ParamT>::type()// là, ça me gène ) :Base(_p) { } }; int main () { Derive<BaseVoid, void> o1; Derive<BaseNonVoid, int> o2(2); Derive<BaseNonVoid, int> o3; // là, ça me gène return 0; }

Pour moi, c'est la classe dérivée qui devrait être spécialisée partiellement.

Code:

1
2
3
4
5
6
7
8
9
10
11
class Base { ... };
template< class T > class Derivee : public Base
{
	Derivee(T obj) { ... }
	...
};
template< > class Derivee<void> : public Base
{
	Derivee() { ... }
	...
};

19/11/2008, 18h48
Alp

Ben tu fais un enable_if si le type donné en paramètre est T1 pour l'un des constructeurs, un enable_if si le type donné en paramètre est T2 pour un autre, et ainsi de suite.

Alp> justement, je ne vois pas trop comment écrire ca, au niveau syntaxique. Tu pourrais écrire un petit exempe s'il te plaît.

Médinoc> oui, je m'y suis comme toi. Mais du coup, je dois définir 2 fois le contenu de classe, qui ne varie pas. En fait, c'est uniqement le constructeur qui varie.

EDIT: voici ce que j'ai écrit, bien sûr, j'ai pas mal d'erreurs de compilation. J'ai un gros doute si mon code est correct 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 //! \template InstanceOf //! @brief instance of a definition, generic definition template< class _Definition, class _Base, typename _Param = void, class _DefPtr = KAGE_WP(_Definition) > class InstanceOf : public _Base, public DefinitionLink<_Definition, _DefPtr> { public: friend class _Definition; typedef _Base Base; protected: InstanceOf(_DefPtr def, typename boost::enable_if< !boost::is_void<_Param>::value, _Param >::type T) : DefinitionLink(def), _Base(T) { KAGE_DEBUG("created InstanceOf<generic>"); } public: virtual ~InstanceOf() { KAGE_DEBUG("destroyed InstanceOf<generic>"); } };

20/11/2008, 13h41
Alp

Je ne peux pas là, mais il s'agirait de sous traiter la construction à un type ou à un autre si T = T1 ou T = T2.
Ensuite un if ou un enable if devrait te permettre d'appeler l'un ou l'autre.

C'est très prise de tête et bien sûr il serait meilleur de carrément "écrire" le constructeur selon le type passé, mais bon.

Et si tu faisais hériter ta classe du paramètre template ? Tu peux ainsi importer le code du constructeur que tu veux.
20/11/2008, 17h16
3DArchi

Citation:

Envoyé par Alp

Je ne peux pas là, mais il s'agirait de sous traiter la construction à un type ou à un autre si T = T1 ou T = T2.
Ensuite un if ou un enable if devrait te permettre d'appeler l'un ou l'autre.

Je suis comme Kurisu. Je ne vois pas comment tu fais pour lui passer le paramètre à ta classe T1 ou T2. Il me manque une étape.
20/11/2008, 18h42
loufoque

Citation:

InstanceOf(_DefPtr def, typename boost::enable_if< !boost::is_void<_Param>::value, _Param >::type T)

Déjà, enable_if prend une meta-fonction et tu lui passes une constante, ça commence mal...

Voir 40 message(s) de cette discussion en une page