struct A { class Sub {}; };
struct B { class Sub {}; };
struct C { class Sub {}; };

Angenommen wir haben diese Klassenstruktur. In dem Fall drei verschiedene Klassen, die alle einen Klassentypen 'Sub' im Namespace haben.
Man könnte also folgende Vererbung durchführen:

class Foo : A::Sub, B::Sub, C::Sub {};

Hier böte sich ja ein template an:

template<typename... CLASSES> class Foo : CLASSES::Sub... {};

Leider funktioniert das Entpacken der Parameterliste nicht, also der Teil 'CLASSES::Sub...'. Scheint eine Beschränkung der C++11 Spezifikation zu sein. Im Netz habe ich dazu auch keine verwertbaren Infos gefunden.

Ich könnte das natürlich jetzt rekursiv lösen:

template<class T, typename... LIST> class ComposeClass : T, ComposeClass<LIST...> {}
template<> class ComposeClass<class T> : T {};

Das finde ich aber sehr unschön, da ich im realen Fall eine virtuelle Vererbung durchführen möchte. Das würde bei dieser Variante einen Rattenschwanz an vtables nach sich ziehen, da jede Mehrfachvererbung ein neues Interface darstellt, dass durch eine weitere "Sub-vtable" abgebildet wird.

Kennt jemand eine Lösung für das Problem, sodass ich diese Mehrfachvererbung via templates ohne Rekursion realisieren kann?

Leider funktioniert das Entpacken der Parameterliste nicht,

Ansonsten gute Beschreibung, aber das führt doch wieder zu einer Abwertung.
Du schreibst nicht, was genau du getestet hast und mit welchem Compiler.

struct A { class Sub {}; };
struct B { class Sub {}; };
struct C { class Sub {}; };

template<typename... CLASSES> class Foo : CLASSES::Sub... {};

Foo<A,B,C> x;

Kein Problem mit g++ oder clang++ - sollte auch keine geben.

Habs eben spaßeshalber mit MSVC 2013 ausprobiert:

Swordfish schrieb:

wtf?

ist leider die korrekte Antwort (der Code ist i.O.)

Edit:
geht es, wenn die Basisklasse explizit angegeben wird?

x.A::a = 1;
    x.B::b = 2;
    x.C::c = 3;

Das wäre ein Fix, der bei mir funktionieren würde...

x.A::Sub::a = 1;
    x.B::Sub::b = 2;
    x.C::Sub::c = 3;

heißen.

Ich habe es mit MSVS2013 (v120) kompiliert. Das Problem ist dabei aber folgendes:
1. Wenn ich die Schreibweise 'CLASSES::Sub...' nutze, scheint es zu funktionieren, ich habe allerdings keinen Zugriff auf XXX::Sub-Member. Also das gleiche Problem, wie Swordfish reproduziert hat.
2. Wenn ich die Schreibweise 'CLASSES::...Sub" nutze (ich weiß, falscher Syntax, aber was macht man nicht alles in seiner Verzweiflung), dann stürzt der Compiler mit einem internen Compilerfehler ab!

Meine Vermutung zu 1. ist, dass das Enpacken aus 'CLASSES::Sub...' folgendes macht: ': A, B, C::Sub', also das '::Sub' nicht in den Entpackvorgang einschließt. Könnte das der Fall sein?

Ich bin schon mehrfach über das Problem gestoßen, dass ich eine Kern-klasse habe, nennen wir sie Core, für die ich ein Interface zum Zugriff auf ebendiese Kernfunktionen bereitstelle. Jetzt kommt es immer mal wieder vor, dass ich Core um weitere Funktionen erweitern möchte, die für sich zusammengefasst eine neue logische Gruppierung bilden, aber vom Umfang her es sich kaum lohnt, dafür ein neues zusätzliches Interface bereitzustellen. Jetzt könnte ich diese natürlich in Core und dem Interface für Core (nennen wir es ICore) mit aufnehmen. Dann könnte Core aber sehr schnell unübersichtlich werden.
Deshalb habe ich mir gedacht, wenn ich mir die Core-Klasse automatisch mit einem Template aus mehreren Unterklassen zusammenbauen lassen könnte, dass mir auch automatisch ein passendes Interface zur Verfügung stellt, wäre das für mich sehr übersichtlich und praktisch.

Wenn ich als Bedingung ansetze, dass die Modulklassen, aus denen Core zusammengesetzt wird '::Interface' und '::Module' enthalten, kann ich mir das bei der Komposition der Coreklasse zunutze machen. Hier mal zwei Module als Beispiel:

struct A {
	class Interface {
	public:
		virtual void foo(void) = 0;
	};

	class Module : public virtual Interface	{
	public:
		virtual void foo(void) { std::cerr << "foo A\n"; }
                void foo2(void) {/*....*/} // Not accessible via Interface
	};
};

struct B {
	class Interface {
	public:
		virtual void bar(void) = 0;
		virtual void bar2(void) = 0;
	};

	class Module : public virtual Interface	{
	public:
		virtual void bar(void) { std::cerr << "bar B\n"; }
		virtual void bar2(void) { std::cerr << "bar2 B\n"; }
	};
};

Jetzt baue ich mir automatisch eine Core-Klasse, die ein komplettes Interface zur Verfügung stellt zusammen:

// identity template from decimad (C++.de Forum)
template<typename T> 
struct identity { 
    using type = T; 
}; 

template<typename... MODULES>
struct CoreModule {
	class Interface : virtual public identity<MODULES>::type::Interface...  {};
	class Module : public Interface, public identity<MODULES>::type::Module... {};
};

typedef CoreModule<A, B> CoreClass;
typedef CoreClass::Interface ICore;
typedef CoreClass::Module Core;

Ich kann jetzt ein Objekt vom Typ 'Core' instanzieren und den restriktierten Zugriff über das komponierte Interface 'ICore' bereitstellen. 'Core' selbst ist auch kompatibel zu den jeweiligen Modul-Interfaces 'A::Interface' und 'B::Interface', falls man in einer Subroutine nur einen Zugriff auf Teile von Core zulassen möchte.

void test(ICore* core) {
	core->foo();
	core->bar();
}

void test2(A::Interface* a) { a->foo(); }

int _tmain(int argc,_TCHAR* argv[]) {
	ICore* core = new Core();
	test(core);
	test2(core);
        delete core;
	std::cin.get();
	return 0;
}

Siehe:
https://connect.microsoft.com/VisualStudio/feedback/details/809367/visual-c-internal-compiler-error-with-virtual-base-class