다른 답변에서 언급했듯이 이것은 일반적으로 C ++에서 보증되지 않습니다. C ++에서는 “이 클래스에서 상속”이외의 다른 제약 조건을 기반으로 일반 형식을 정의하는 경향이 있습니다. 정말로 그렇게하고 싶다면 C ++ 11에서 쉽게 할 수 있습니다 <type_traits>.

#include <type_traits>

template<typename T>
class observable_list {
    static_assert(std::is_base_of<list, T>::value, "T must inherit from list");
    // code here..
};

이것은 사람들이 C ++에서 기대하는 많은 개념을 깨뜨립니다. 자신의 특성을 정의하는 것과 같은 트릭을 사용하는 것이 좋습니다. 예를 들어 observable_listtypedef가있는 모든 유형의 컨테이너와을 반환 const_iterator하는 begin및 end멤버 함수 를 허용하려고 할 수 const_iterator있습니다. 상속하는 클래스로 이것을 제한하면 상속 list하지 않지만 list이러한 멤버 함수 및 typedef를 제공 하는 자체 유형을 가진 사용자는 을 사용할 수 없습니다 observable_list.

이 문제에 대한 두 가지 해결책이 있습니다. 그중 하나는 아무것도 구속하지 않고 오리 타이핑에 의존하는 것입니다. 이 솔루션의 큰 단점은 사용자가 이해하기 어려운 막대한 양의 오류를 포함한다는 것입니다. 또 다른 솔루션은 인터페이스 요구 사항을 충족시키기 위해 제공된 유형을 제한하는 특성을 정의하는 것입니다. 이 솔루션의 가장 큰 단점은 추가 글쓰기를 포함하여 성가신 것으로 보일 수 있다는 것입니다. 그러나 긍정적 인 측면은 자신의 오류 메시지를 la로 작성할 수 있다는 것입니다 static_assert.

완전성을 위해 위의 예에 대한 솔루션이 제공됩니다.

#include <type_traits>

template<typename...>
struct void_ {
    using type = void;
};

template<typename... Args>
using Void = typename void_<Args...>::type;

template<typename T, typename = void>
struct has_const_iterator : std::false_type {};

template<typename T>
struct has_const_iterator<T, Void<typename T::const_iterator>> : std::true_type {};

struct has_begin_end_impl {
    template<typename T, typename Begin = decltype(std::declval<const T&>().begin()),
                         typename End   = decltype(std::declval<const T&>().end())>
    static std::true_type test(int);
    template<typename...>
    static std::false_type test(...);
};

template<typename T>
struct has_begin_end : decltype(has_begin_end_impl::test<T>(0)) {};

template<typename T>
class observable_list {
    static_assert(has_const_iterator<T>::value, "Must have a const_iterator typedef");
    static_assert(has_begin_end<T>::value, "Must have begin and end member functions");
    // code here...
};

위의 예에서 C ++ 11의 기능을 보여주는 많은 개념이 있습니다. 호기심에 대한 일부 검색어는 가변형 템플릿, SFINAE, 표현 SFINAE 및 유형 특성입니다.

답변

#include <type_traits>
#include <list>

class Base {};
class Derived: public Base {};

#if 0   // wrapper
template <class T> class MyClass /* where T:Base */ {
private:
    static_assert(std::is_base_of<Base, T>::value, "T is not derived from Base");
    typename std::enable_if<std::is_base_of<Base, T>::value, T>::type inner;
};
#elif 0 // base class
template <class T> class MyClass: /* where T:Base */
    protected std::enable_if<std::is_base_of<Base, T>::value, T>::type {
private:
    static_assert(std::is_base_of<Base, T>::value, "T is not derived from Base");
};
#elif 1 // list-of
template <class T> class MyClass /* where T:list<Base> */ {
    static_assert(std::is_base_of<Base, typename T::value_type>::value , "T::value_type is not derived from Base");
    typedef typename std::enable_if<std::is_base_of<Base, typename T::value_type>::value, T>::type base;
    typedef typename std::enable_if<std::is_base_of<Base, typename T::value_type>::value, T>::type::value_type value_type;

};
#endif

int main() {
#if 0   // wrapper or base-class
    MyClass<Derived> derived;
    MyClass<Base> base;
//  error:
    MyClass<int> wrong;
#elif 1 // list-of
    MyClass<std::list<Derived>> derived;
    MyClass<std::list<Base>> base;
//  error:
    MyClass<std::list<int>> wrong;
#endif
//  all of the static_asserts if not commented out
//  or "error: no type named ‘type’ in ‘struct std::enable_if<false, ...>’ pointing to:
//  1. inner
//  2. MyClass
//  3. base + value_type
}

class Shape { };
class Triangle : public Shape { };

typedef std::list<Shape*> only_shapes_list;
only_shapes_list shapes;

shapes.push_back(new Triangle()); // Works, triangle is kind of shape
shapes.push_back(new int(30)); // Error, int's are not shapes

template<typename T,
         typename std::enable_if<std::is_base_of<List, T>::value>::type* = nullptr>
class ObservableList
{
    // ...
};