bei folgendem code

struct A
{
    template <typename T>void add_scene() 
	{
		do_some_stuff();
	}
	template<typename H, typename T> 
	void add_scene< Loki::Typelist<H,T> >()
	{
		do_the_same_stuff_as_above();
	}

	template<> 
	void add_scene<Loki::NullType> (){}
};

Kann mir jemand den Fehler erklären? msdn hilft mir hier gerade nicht viel weiter.

nocheinmitglied schrieb:

template<typename H, typename T> 
void add_scene< Loki::Typelist<H,T> >()
{
  do_the_same_stuff_as_above();
}

ist nicht erlaubt.
Es sollte statt dessen

//Falscher Code

heissen.

MfG, EOutOfResources

EDIT: Quatsch

(Woher soll der compiler dann auch wissen welche Klassen ich meine? Vllt. möchte ich nur Loki::Typelist<Widget,NullType> haben, was auch eine mögliche spezialisierung für z.B. die letzte Funktion ist)

Ich benötige außerdem T und H.

EDIT: Nur Müll

template<typename T>
struct selector
{
  typedef default_type type;
};

//partielle Spezialisierung von Klassen ist erlaubt ;)
template<typename H, typename T>
struct selector< Loki::Typelist<H,T> >
{
  typedef typelist type;
  typedef H first_type;
  typedef T second_type;
};

struct A
{
    template <typename T>void add_scene(const T& param) 
    {
        add_scene_impl(param, typename selector<T>::type());
    }
    template<typename T>
    void add_scene_impl(const T& param, default_type)
    {
        do_some_stuff();
    }
    template<typename T> 
    void add_scene_impl(const T& param, typelist)
    {
        typedef typename selector<T>::first_type H;
        typedef typename selector<T>::second_type T;
        do_the_same_stuff_as_above();
    }
};

(ungetestet und ohne Garantie)

PS: Ist es eigentlich korrekt, daß deine add_scene-Methoden keine Parameter entgegennehmen?

Dann vielleicht so:

template<>
template<class T, class U>
void add_scene< Loki::Typelist<T, U> >() 
{ 
}

Nein auch nicht

Ich habe auch schon versucht, die Funktion außerhalb zu definieren und dort die Spezialisierung durchzuführen. Dies funktioniert leider auch nicht.

In dem Fall hast du wohl ein Problem - C++ erlaubt keine partiellen Template-Spezialisierungen für Funktionen. Das heißt, du müsstest die Funktionalität auslagern in eine Hilfsfunktion und mit TMP-Methoden auswählen:

template<typename T>
struct selector
{
  typedef default_tpye type;
};

//partielle Spezialisierung von Klassen ist erlaubt ;)
template<typename H, typename T>
struct selector< Loki::Typelist<H,T> >
{
  typedef typelist type;
  typedef H first_type;
  typedef T second_type;
};

struct A
{
    template <typename T>void add_scene(const T& param) 
    {
        add_scene_impl(param, typename selector<T>::type());
    }
    template<typename T>
    void add_scene_impl(const T& param, default_type)
    {
        do_some_stuff();
    }
    template<typename T> 
    void add_scene_impl(const T& param, typelist)
    {
        typedef typename selector<T>::first_type H;
        typedef typename selector<T>::second_type T;
        do_the_same_stuff_as_above();
    }
};

(ungetestet und ohne Garantie)

PS: Ist es eigentlich korrekt, daß deine add_scene-Methoden keine Parameter entgegennehmen?

Hi, ich dachte parzielle template Spezialisierungen sind nur welche, bei denen die Funktion mehrere Parameter entgegen nimmt und nur 1 template Argument Spezialisert wird. Also etwa sowas

template<typename T, typename U>
void foo() {}
template<typename T>
void foo<T,widget>() {}

Dies würde in meinem Fall aber nicht auftreten. Ich spezialisiere alle Argumente.

Deine Implementierung sieht gut aus (besser als mein Workaround, bei der die Funktion innerhalb einer template Struktur definiert ist).

Werde dies nutzen. Danke

P.S. Ja, es ist richtig das meine add Funktion kein Objekt entgegen nimmt und nur Klassen, da meine Klasse die Objekte selber erstellt (mittels einer Objekt Fabrik) und nur wissen möchte, welche Klassen erstellt werden müssen/dürfen.

Hi, ich dachte parzielle template Spezialisierungen sind nur welche, bei denen die Funktion mehrere Parameter entgegen nimmt und nur 1 template Argument Spezialisert wird. Also etwa sowas

template<typename T, typename U>
void foo() {}
template<typename T>
void foo<T,widget>() {}

Dies würde in meinem Fall aber nicht auftreten. Ich spezialisiere alle Argumente.

Da ist der Denkfehler: partielle Spezialisierung bedeutet, daß du für eine Teilmenge der möglichen Datentypen bereitstellst, die selber wieder durch Template-Parameter sepzifiziert wird. Das betrifft auch Konstruktionen wie

template<typename Cont>
void foo();
template<typename T>
void foo<std::vector<T> >();

oder die Beziehung zwischen T und TypeList<> in deinem Code.

nocheinmitglied schrieb:

Hi, ich dachte parzielle template Spezialisierungen sind nur welche, bei denen die Funktion mehrere Parameter entgegen nimmt und nur 1 template Argument Spezialisert wird. Also etwa sowas

template<typename T, typename U>
void foo() {}
template<typename T>
void foo<T,widget>() {}

Dies würde in meinem Fall aber nicht auftreten. Ich spezialisiere alle Argumente.

Da ist der Denkfehler: partielle Spezialisierung bedeutet, daß du für eine Teilmenge der möglichen Datentypen bereitstellst, die selber wieder durch Template-Parameter sepzifiziert wird. Das betrifft auch Konstruktionen wie

template<typename Cont>
void foo();
template<typename T>
void foo<std::vector<T> >();

oder die Beziehung zwischen T und TypeList<> in deinem Code.

oh, da habe ich wirklich etwas sehr falsch verstanden.
Vielen Dank
[solved]

Sonst sehr chic. Ich freue mich immer, so was lesen zu dürfen.

Darf man das Schlüsselwort default so einsetzen oder ist das nur irgend ein Name in deinem Fall?

Das war nur als Platzhalter gedacht. Müsste ich mal korrigieren.