template-member-function specialisation

nocheinmitglied

Leider nicht:
error C3206: 'A::add_scene' : invalid template argument for 'T', missing template argument list on class template 'Loki::Typelist'

(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.

EOutOfResources

---

EDIT: Nur Müll

Eisflamme

---

CStoll

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_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?

nocheinmitglied

EOutOfResources schrieb:

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.

nocheinmitglied

CStoll schrieb:

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.

CStoll

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.

nocheinmitglied

CStoll schrieb:

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]

Eisflamme

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

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

CStoll

Eisflamme schrieb:

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.