dynamische Template-Zahl?

Hallo,

ich brauche eine Klasse, die mit zwischen 1 und 5 Templates initialisiert wird. Geht das irgendwie? Und mit irgendwie meine ich, ob man das mit abstrusen (boost-) Konstrukten realisieren kann oder sonst wie.

THX

template<typename t1, typename t2, ...>
class C
{
};

unskilled

wozu brauchst du das denn?

würde evtl auch schon ein einfaches

template<
  class T1,
  class T2 = T1,
  class T3 = T2,
  class T4 = T3,
  class T5 = T4
>
struct asd
{
/*...*/
};

reichen?

bb

Die Klasse muss Objekte der angegebenen Template-Typen erstellen und über einen Kommunikationsmechanismus versenden.
Im Prinzip geht das mit deiner Lösung, wobei ich dann noch überprüfen müsste, ob die Typen gleich sind (per typeid), um herauszufinden, wieviele Typen angegeben sind.

hustbaer

Nimm lieber void als Default, oder einen eigens dafür gemachten Dummy-Typ.

template<
  class T1,
  class T2 = void,
  class T3 = void,
  class T4 = void,
  class T5 = void>
struct asd
{
/*...*/
};

// bzw.

struct unused_template_argument {};

template<
  class T1,
  class T2 = unused_template_argument,
  class T3 = unused_template_argument,
  class T4 = unused_template_argument,
  class T5 = unused_template_argument>
struct asd
{
/*...*/
};

Oder übergib deiner Klasse gleich ein boost::tuple<>:

template <class T>
struct asd
{
/*...*/
};

typedef asd<boost::tuple<int, char, float> > foo;

volkard

voelleicht kriegst du was mit variadic templates hin.
http://en.wikipedia.org/wiki/Variadic_Templates

Danke für die nützlichen Tipps. Ich werde mich mal versuchen.
---------
btw.

volkard schrieb:

voelleicht kriegst du was mit variadic templates hin.
http://en.wikipedia.org/wiki/Variadic_Templates

Ist das in aktuellem C++ machbar oder erst mit C++0x?

drakon

Erst mit C++0x.

camper

#include <cstddef>
#include <boost/mpl/remove.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/vector.hpp>

template<
    typename T0,        typename T1 = void, typename T2 = void, typename T3 = void, typename T4 = void,
    typename T5 = void, typename T6 = void, typename T7 = void, typename T8 = void, typename T9 = void>
struct foo
{
	typedef typename boost::mpl::remove<boost::mpl::vector<T0,T1,T2,T3,T4,T5,T6,T7,T8,T9>,void>::type args;
	static const std::size_t num_args = boost::mpl::size<args>::type::value;
};

Wenn noch ggf. doppelt genannte Typen u.ä eliminiert werden müssen, ist das auch möglich, oder auch nach der Größe sortieren oder so.