C++ - Vorlage Einschränkungen

Question

Ich frage mich, gibt es eine Möglichkeit, Einschränkungen für die Vorlagenklasse festlegen?
Geben Sie an, dass jeder in der Vorlage ersetzte Typ einen bestimmten Vorgänger haben muss (eine Schnittstelle realisieren).

template < class B > //and every B must be a child of abstract C 
class A { 
public: 
    B * obj; 
    int f() { 
     return B::x + this->obj->f(); 
    } 
}; 

Wie => in Haskell

func :: (Ord a, Show b) => a -> b -> c 

Answer 1

Sie können use BOOST_STATIC_ASSERT oder eine ähnliche Bibliothek Ihre Beschränkungen für die Template-Parameter behaupten.

Zum Beispiel:

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

template <class UnsignedInt> 
class myclass 
{ 
private: 
    BOOST_STATIC_ASSERT((std::numeric_limits<UnsignedInt>::digits >= 16) 
         && std::numeric_limits<UnsignedInt>::is_specialized 
         && std::numeric_limits<UnsignedInt>::is_integer 
         && !std::numeric_limits<UnsignedInt>::is_signed); 
public: 
    /* details here */ 
}; 

EDIT: Für Ihr Beispiel: Sie

template < class B > 
class A { 
    BOOST_STATIC_ASSERT(boost::is_base_of<C, B>); 

public: 
    B * obj; 
    int f() { 
     return B::x + this->obj->f(); 
    } 
}; 

Answer 2

schreiben Sie einen Trick wie diese verwenden könnten (wenn Sie nicht-Boost verwenden wollen) :

class Base 
    { 
    public: 
     static const int TEMPLATE_REQUIRES_BASE_CLASS = 0; 
    }; 

class Correct : public Base 
    { 
    }; 

class Incorrect 
    { 
    }; 

template <typename T> 
class TMPL 
    { 
    static const int TEMPLATE_REQUIRES_BASE_CLASS = T::TEMPLATE_REQUIRES_BASE_CLASS; 
    T *m_t; 
    }; 

void main() 
{ 
TMPL<Correct> one;  // OK 
TMPL<Incorrect> two; // Will not compile 
} 

Die erste Zeile wird kompiliert. Die zweite wird nicht kompiliert und die folgenden Fehler geben:

test.cpp 
test.cpp(18) : error C2039: 'TEMPLATE_REQUIRES_BASE_CLASS' : is not a member of 'Incorrect' 
     test.cpp(12) : see declaration of 'Incorrect' 
     test.cpp(25) : see reference to class template instantiation 'TMPL<T>' being compiled 
     with 
     [ 
      T=Incorrect 
     ] 
test.cpp(18) : error C2065: 'TEMPLATE_REQUIRES_BASE_CLASS' : undeclared identifier 
test.cpp(18) : error C2057: expected constant expression 

Answer 3

Eine zukünftige Version von C++ wird diese nativ mit Konzepten unterstützen (die es nicht in C++ 11).

Eine Möglichkeit, das Problem zu nähern ist die Spezialisierung auf eine Dummy-Template-Parameter zu verwenden:

class C {}; 
template <class B, class dummy=void> 
class A; 

template <class B> 
class A<B, typename enable_if<is_base_and_derived<C, B> >::type> 
{ 
    // class definition here 
}; 

struct D : C {}; 

A<D> d;  // fine 
A<int> n; // compile error - undefined class A<B> 

I Stand-alone-Definitionen von enable_if und is_base_and_derivedhere gesetzt haben.

Answer 4

Vorlagen sind eine Art Ente, die in C++ schreibt.

Wenn Ihre Klasse alles unterstützt, was die Vorlage verwendet, kann sie als Vorlageargument verwendet werden, andernfalls nicht.

Wenn in Ihrer Vorlage haben Sie so etwas wie

C *instance; 

void foo(T *t) 
{ 
    instance = t; 
} 

dann sind Sie erzwingen, dass T abgeleitet von C (oder zumindest assignement-kompatibel für Zeiger)

Answer 5

folgende Arbeiten in VC10 mit static_assert. Ich habe gerade gesehen, dass dies verwendet wird und habe mich nicht wirklich damit beschäftigt, was static_assert tatsächlich tut - vielleicht kann jemand anderes das beantworten.

#include <type_traits> 

class Base 
{ 

}; 

class Derived : public Base 
{ 

}; 

class SomeRandomClass 
{ 

}; 

template<typename T> 
class A 
{ 
    static_assert(std::tr1::is_base_of<Base, T>::value, "T not derived from Base"); 
}; 



int _tmain(int argc, _TCHAR* argv[]) 
{ 
    argc; argv; 

    // 
    // This will compile 
    A<Derived> a; 

    // 
    // This will throw a compilation error 
    A<SomeRandomClass> b; 

    return 0; 
} 

Der Compiler ausgegeben wird:

1>d:\temp\aaa\aaa\aaa.cpp(25): error C2338: T not derived from Base 
1>   d:\temp\aaa\aaa\aaa.cpp(41) : see reference to class template instantiation 'A<T>' being compiled 
1>   with 
1>   [ 
1>    T=SomeRandomClass 
1>   ]