[Template] Spécialisation partielle d'un template

**Kurisu** · 17/11/2008, 09h51

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 :

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

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

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 ?

**3DArchi** · 17/11/2008, 10h07

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.

**Kurisu** · 17/11/2008, 11h32

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

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

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

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()			
	{
	}

**Kurisu** · 17/11/2008, 12h47

Je reprends mon exemple:
ceci fonctionne

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

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

**3DArchi** · 17/11/2008, 12h53

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

**Kurisu** · 17/11/2008, 13h18

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.

**Alp** · 17/11/2008, 15h44

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 :

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

template <class T> void f(T t)

en

Code :

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

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

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

Code :

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

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

**Kurisu** · 17/11/2008, 16h46

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 :

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

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

**Kurisu** · 17/11/2008, 17h41

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 :

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

**Kurisu** · 19/11/2008, 12h09

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 :

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

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

**Alp** · 19/11/2008, 13h39

En C++ tu peux "jouer" avec boost.mpl et boost.type_traits pour obtenir quelque chose de similaire

**Kurisu** · 19/11/2008, 15h47

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

).

**Alp** · 19/11/2008, 16h03

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

**3DArchi** · 19/11/2008, 16h53

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 :

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

**Médinoc** · 19/11/2008, 17h21

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

Code C :

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

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() { ... }
	...
};

**Alp** · 19/11/2008, 18h48

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.

**Kurisu** · 20/11/2008, 12h26

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 :

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
//!     \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>");
		}
	};

**Alp** · 20/11/2008, 13h41

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.

**3DArchi** · 20/11/2008, 17h16

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.