Hello,

J'ai un bout de code qui ressemble à ça
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
45
struct AbsMsg { };
 
template <class T>
struct Msg: public AbsMsg { };
 
template <class Impl, class... Args>
struct A {
	std::tuple<Args...> m_tuple;
	Impl m_impl;
	size_t m_step;
 
	void action(AbsMsg *msg) {
		// TODO jouer avec les templates pour "convertir" m_step en parametre template
		// et appeler m_impl.bar<m_step>(msg);
	}
};
 
struct I;
 
struct B : public A<I, int, char> {
	friend struct I;
};
 
struct I {
	template <size_t N>
	struct AlwaysFalse {
		enum { value = false; };
	};
 
	template <size_t N>
	void foo(Msg<typename std::tuple_element<N, decltype(m_tuple)>::type>* msg) {
		static_assert(AlwaysFalse<N>::value, "please implement");
	}
 
	template<>
	void foo<0>(Msg<int> *msg) { }
 
	template<>
	void foo<1>(Msg<char> *msg) { }
 
	template <size_t N>
	void bar(AbsMsg* msg) {
		foo<N>((Msg<typename std::tuple_element<N, decltype(m_tuple)>::type>*) msg);
	}
};
Le problème est que B a besoin de I complet (héritage / parametre template) et que I à besoin de B complet (friend).
Ya un moyen de s'en sortir ?

Ou une autre solution qui permettrait d'arriver au même résultat ?

Si seulement les fonctions template pouvaient etre virtuelles, foo irait dans A et serait spécialisée dans B et ça simplifierait tout ><