Discussion :

[Kurisu]

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]

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]

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]

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]

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]

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.