Limitazioni modello C++

Question

Mi chiedo se esiste un modo per impostare restrizioni sulla classe template.
Specificare che ogni tipo sostituito nel modello deve avere un antenato specifico (realizzare un'interfaccia).

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(); 
    } 
}; 

Come => in Haskell

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

Answer 1

È possibile use BOOST_STATIC_ASSERT o una libreria simile per far valere i restrizioni sul parametro di template.

Ad esempio:

#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: Per il vostro esempio, è possibile scrivere

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

si potrebbe usare un trucco del genere (se non si desidera utilizzare Boost) :

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 
} 

La prima riga verrà compilata. La seconda non compilerà e darà il seguente errore:

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

Una futura versione di C++ supporterà in modo nativo utilizzando concetti (che non ha fatto in C++ 11).

Un modo per affrontare il problema è quello di utilizzare la specializzazione su un parametro di modello fittizio:

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> 

ho messo le definizioni stand-alone di enable_if e is_base_and_derivedhere.

Answer 4

I modelli sono una sorta di anatra che digita in C++.

Se la classe supporta tutto ciò che utilizza il modello, può essere utilizzato come argomento modello, altrimenti non può.

Se nel modello di avere qualcosa di simile

C *instance; 

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

allora stai far rispettare che T è derivato da C (o almeno assegnazione compatibile per i puntatori)

Answer 5

le seguenti opere in VC10 utilizzando static_assert. Ho appena visto questo usato e non ho davvero scavato molto in quello che static_assert fa in realtà - forse qualcun altro può rispondere a questo.

#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; 
} 

L'essere output del compilatore:

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>   ]