Templates und Vererbung - Argument einer Basisklasse

don_basto

Hallo,

ich habe eine Liste als Template und möchte sicherstellen, dass als Template-Parameter nur Typen zulässig sind, die von einer Basisklasse abgeleitet sind. Beispiel:

template <class T> Liste 
{
public:
   // ...
   T& getSome(void) {
      // durchsucht die Liste und gibt das erste
      // Objekt zurück mit  T::isSome()==true
      // ..
   };
};

class Basis {
public:   
   // ...
   bool isSome(void);

private:
   bool bSome;
};

Dabei sollten für T nur Typen zulässig sein, die von Basis erben. Geht das?

otze

klar, mit boost geht das

#include <boost/static_assert.hpp>
#include <boost/type_traits.hpp>

template <class T> Liste
{
    BOOST_STATIC_ASSERT(boost::is_base_and_derived<Basis,T>::value);
public:
   // ...
   T& getSome(void) {
      // durchsucht die Liste und gibt das erste
      // Objekt zurück mit  T::isSome()==true
      // ..
   };
};

das ergebnis des ganzen ist, dass wenn T nicht von basis abgeleitet ist, der compiler einen fehler gibt.

don_basto

Danke für den Tip. Gibt es eine Möglichkeit, ohne das Einbinden einer zusätzlichen LIB, dass Problem zu lösen?
Ist es möglich, herauszufinden, ob das Template-Argument von der Basis geerbt hat?

Shade Of Mine

don_basto schrieb:

Danke für den Tip. Gibt es eine Möglichkeit, ohne das Einbinden einer zusätzlichen LIB, dass Problem zu lösen?
Ist es möglich, herauszufinden, ob das Template-Argument von der Basis geerbt hat?

Ja, was glaubst du macht boost denn?
Es sind einfach eine handvoll templates, da ist keine magie dabei.

don_basto

Shade Of Mine schrieb:

Ja, was glaubst du macht boost denn?

Meine Frage zielte darauf ab, ob es machbar ist, die Funktionalität selbst zu programmieren, ohne das Einbinden von boost. Oder ob das zu aufwendig wäre?

finix

don_basto schrieb:

Meine Frage zielte darauf ab, ob es machbar ist, die Funktionalität selbst zu programmieren, ohne das Einbinden von boost. Oder ob das zu aufwendig wäre?

Dann schau's dir doch einfach an!?

// Das irgendwo global definieren:
template<typename base>
void compiletime_assert_is_derived_from(base *) { }

// ...

// Diesen Aufruf in den Konstruktor oder so.
// Wenn T nicht von Base abgeleitet ist, sollte der Compiler es ablehnen
compiletime_assert_is_derived_from<Base>(static_cast<T*>(0));

Ich habe exakt die selbe Frage schonmal gestellt und Hume hat nen Source gepostet, benutzt mal suchen

don_basto

@glamdrink

Hab den Beitrag nach langem Suchen gefunden, muss ihn erstmal verstehen.

Danke @all.