특정 유형 만 허용하는 C ++ 템플릿

Java에서는 다음과 같이 선택한 클래스를 확장하는 유형 만 허용하는 일반 클래스를 정의 할 수 있습니다.

public class ObservableList<T extends List> {
  ...
}

이것은 "extends"키워드를 사용하여 수행됩니다.

C ++에서이 키워드에 해당하는 간단한 것이 있습니까?

Boost Type Traits 라이브러리 와 함께 Boost의 정적 어설트 기능을 사용하는 것이 좋습니다 is_base_of.

template<typename T>
class ObservableList {
    BOOST_STATIC_ASSERT((is_base_of<List, T>::value)); //Yes, the double parentheses are needed, otherwise the comma will be seen as macro argument separator
    ...
};

다른 간단한 경우에는 전역 템플릿을 간단히 선언 할 수 있지만 유효한 유형에 대해서만 템플릿을 정의 (명시 적으로 또는 부분적으로 전문화) 할 수 있습니다.

template<typename T> class my_template;     // Declare, but don't define

// int is a valid type
template<> class my_template<int> {
    ...
};

// All pointer types are valid
template<typename T> class my_template<T*> {
    ...
};

// All other types are invalid, and will cause linker error messages.

[Minor EDIT 6/12/2013 : 선언되었지만 정의되지 않은 템플릿을 사용하면 컴파일러가 아니라 링커 가 발생하고 오류 메시지가 나타납니다.]

다른 답변에서 언급했듯이 이것은 일반적으로 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 및 유형 특성입니다.

아직 언급하지 않은 간단한 해결책은 문제를 무시하는 것입니다. int벡터 또는 목록과 같은 컨테이너 클래스를 기대하는 함수 템플릿에서 템플릿 유형으로을 사용하려고 하면 컴파일 오류가 발생합니다. 조잡하고 단순하지만 문제를 해결합니다. 컴파일러는 지정한 유형을 사용하려고 시도하고 실패하면 컴파일 오류를 생성합니다.

그것의 유일한 문제는 당신이 얻는 오류 메시지를 읽기 까다로워 질 것입니다. 그럼에도 불구하고이 작업을 수행하는 매우 일반적인 방법입니다. 표준 라이브러리는 템플릿 유형에서 특정 동작을 예상하는 함수 또는 클래스 템플릿으로 가득 차 있으며 사용 된 유형이 유효한지 확인하지 않습니다.

더 멋진 오류 메시지를 원하거나 (컴파일러 오류를 생성하지 않지만 여전히 이해가되지 않는 사례를 포착하려는 경우) 복잡한 방법에 따라 Boost의 정적 어설 션 또는 Boost concept_check 라이브러리.

최신 컴파일러를 사용하면 built_in static_assert이 있으며 대신 사용할 수 있습니다.

우리는 std::is_base_ofand 를 사용할 수 있습니다 std::enable_if:
( static_assert위의 클래스는 제거 할 수 있습니다. 우리가 참조 할 수없는 경우 사용자 정의 구현 또는 부스트 에서 사용할 수 있습니다 type_traits)

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

내가 아는 한 현재 C ++에서는 불가능합니다. 그러나 새로운 C ++ 0x 표준에는 원하는 기능을 제공하는 "개념"이라는 기능을 추가 할 계획이 있습니다. C ++ Concepts에 관한 이 Wikipedia 기사 에서 자세히 설명합니다.

나는 이것이 즉각적인 문제를 해결하지는 못한다는 것을 알고 있지만 이미 새로운 표준에서 기능을 추가하기 시작한 일부 C ++ 컴파일러가 있으므로 이미 개념 기능을 구현 한 컴파일러를 찾을 수 있습니다.

나는 모든 사전 답변이 나무의 숲을 보지 못했다고 생각합니다.

Java 제네릭 은 템플릿과 동일하지 않습니다 . 이들은 사용 형 소거 A는, 동적 기술 보다는 컴파일 시간 다형성 이며, 정적 기법 . 이 두 가지 매우 다른 전술이 잘 젤리 지 않는 이유는 분명해야합니다.

컴파일 타임 구문을 사용하여 런타임을 시뮬레이션하는 대신 extends실제로 수행 하는 작업을 살펴 ​​보겠습니다 . Stack Overflow 및 Wikipedia에 따르면 extends는 서브 클래 싱을 나타내는 데 사용됩니다.

C ++은 서브 클래 싱도 지원합니다.

또한 제네릭 형식으로 유형 삭제를 사용하고 유형 검사를 수행하도록 확장되는 컨테이너 클래스를 표시합니다. C ++에서는 유형 삭제 기계 장치를 직접 수행해야합니다. 이는 매우 간단합니다.

전체 클래스를 만드는 것이 아니라 사용하기 쉽도록 typedef로 감싸서 보자.

typedef std::list<superclass*> subclasses_of_superclass_only_list;

예를 들면 다음과 같습니다.

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

이제 List는 일종의 컬렉션을 나타내는 인터페이스 인 것 같습니다. C ++의 인터페이스는 단지 추상 클래스, 즉 순수한 가상 메소드 만 구현하는 클래스 일뿐입니다. 이 방법을 사용하면 개념이나 템플릿 전문화없이 C ++로 Java 예제를 쉽게 구현할 수 있습니다. 가상 테이블 조회로 인해 Java 스타일 제네릭만큼 느리게 수행되지만 종종 허용되는 손실이 될 수 있습니다.

List 유형에서 파생 된 T 유형 만 허용하는 것과 같습니다.

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

행정상 요약 : 그렇게하지 마십시오.

j_random_hacker의 답변은이 를 수행 하는 방법 을 알려줍니다 . 그러나 나는 또한처럼 당신이해야한다고 지적하는 것입니다 하지 이렇게. 템플릿의 요점은 호환 가능한 모든 유형을 허용 할 수 있으며 Java 스타일 유형 제약 조건이이를 위반한다는 것입니다.

자바의 타입 제약은 버그가 아니다. Java는 제네릭에서 유형 삭제를 수행하므로 유형 매개 변수 값만으로 메소드를 호출하는 방법을 알 수 없기 때문에 존재합니다.

반면에 C ++에는 그러한 제한이 없습니다. 템플릿 매개 변수 유형은 사용되는 작업과 호환되는 모든 유형이 될 수 있습니다. 공통 기본 클래스가 필요하지 않습니다. 이것은 파이썬의 "Duck Typing"과 비슷하지만 컴파일 타임에 수행됩니다.

템플릿의 힘을 보여주는 간단한 예 :

// Sum a vector of some type.
// Example:
// int total = sum({1,2,3,4,5});
template <typename T>
T sum(const vector<T>& vec) {
    T total = T();
    for (const T& x : vec) {
        total += x;
    }
    return total;
}

이 합 함수는 올바른 연산을 지원하는 모든 유형의 벡터를 합할 수 있습니다. int / long / float / double과 같은 프리미티브와 + = 연산자를 오버로드하는 사용자 정의 숫자 유형 모두에서 작동합니다. 심지어이 함수를 사용하여 문자열을 조인 할 수도 있습니다. + =를 지원하기 때문입니다.

프리미티브의 박싱 / 언 박싱이 필요하지 않습니다.

또한 T ()를 사용하여 T의 새 인스턴스를 구성합니다. 이것은 암시 적 인터페이스를 사용하는 C ++에서 사소한 것이지만 유형 제한이있는 Java에서는 실제로 가능하지 않습니다.

C ++ 템플릿에는 명시적인 형식 제약 조건이 없지만 여전히 형식이 안전하며 올바른 작업을 지원하지 않는 코드로 컴파일되지 않습니다.

일반 C ++에서는 불가능하지만 개념 검사 (예 : Boost의 BCCL 사용)를 통해 컴파일 타임에 템플릿 매개 변수를 확인할 수 있습니다 .

C ++ 20부터 개념은 언어 의 공식 기능 이되었습니다 .

class Base
{
    struct FooSecurity{};
};

template<class Type>
class Foo
{
    typename Type::FooSecurity If_You_Are_Reading_This_You_Tried_To_Create_An_Instance_Of_Foo_For_An_Invalid_Type;
};

파생 클래스가 FooSecurity 구조를 상속하는지 확인하고 컴파일러가 모든 올바른 위치에서 화를 내도록하십시오.

C ++ 20 개념 사용법

https://ko.cppreference.com/w/cpp/language/constraints cppreference는 상속 사용 사례를 명시 적 개념의 예로 제공합니다.

template <class T, class U>
concept Derived = std::is_base_of<U, T>::value;
 
template<Derived<Base> T>
void f(T);  // T is constrained by Derived<T, Base>

여러 기초에 대해 구문은 다음과 같습니다.

template <class T, class U, class V>
concept Derived = std::is_base_of<U, T>::value || std::is_base_of<V, T>::value;
 
template<Derived<Base1, Base2> T>
void f(T);

GCC 10은 https://gcc.gnu.org/gcc-10/changes.html 을 구현 한 것으로 보이며 Ubuntu 20.04에서 PPA로 얻을 수 있습니다 . https://godbolt.org/ 내 로컬 GCC 10.1이 concept아직 인식하지 못 하므로 무슨 일이 일어나고 있는지 확실하지 않습니다.

C ++에서이 키워드에 해당하는 간단한 것이 있습니까?

아니.

달성하려는 목표에 따라 적절한 (또는 더 나은) 대체물이있을 수 있습니다.

STL 코드를 살펴 보았습니다 (리눅스에서는 SGI 구현에서 파생 된 것으로 생각합니다). "개념 주장"이있다; 예를 들어, 당신이 이해하는 유형이 필요한 경우 *x와 ++x, 개념의 주장은 아무것도 실시하지 않는 기능 (또는 뭔가 유사한)에서 해당 코드를 포함한다. 약간의 오버 헤드가 필요하므로 정의에 따라 달라지는 매크로에 넣는 것이 #ifdef debug좋습니다.

만약 서브 클래스 관계가 정말로 당신이 알고 싶은 것이라면, 당신은 생성자에게 T instanceof list그것을 주장 할 수 있습니다 (C ++에서 다르게 철자 된 것을 제외하고). 그렇게하면 컴파일러에서 확인할 수없는 방법을 테스트 할 수 있습니다.

이러한 유형 검사에 대한 키워드는 없지만 최소한 순서대로 실패하는 코드를 넣을 수 있습니다.

(1) 함수 템플릿이 특정 기본 클래스 X의 매개 변수 만 허용하도록하려면 함수의 X 참조에 할당하십시오. (2) 프리미티브가 아닌 함수를 수락하거나 다른 방법으로 클래스를 필터링하려는 경우 함수 내에서 (빈) 템플릿 도우미 함수를 호출하여 수락하려는 클래스에 대해서만 정의하십시오.

클래스의 멤버 함수에서도 (1) ​​및 (2)를 사용하여 이러한 클래스 검사를 전체 클래스에서 강제로 수행 할 수 있습니다.

당신은 아마 당신의 고통을 완화하기 위해 스마트 매크로에 넣을 수 있습니다. :)

글쎄, 당신은 다음과 같은 것을 읽는 템플릿을 만들 수 있습니다 :

template<typename T>
class ObservableList {
  std::list<T> contained_data;
};

그러나 이것은 제한을 암시 적으로 만들뿐 아니라 목록처럼 보이는 것을 제공 할 수는 없습니다. 사용되는 컨테이너 유형을 제한하는 다른 방법이 있습니다 (예 : 모든 컨테이너에 존재하지 않는 특정 반복기 유형을 사용하여 명시 적 제한보다 더 암시적임).

내가 아는 한, Java 문을 최대한 반영하는 구문은 현재 표준에 존재하지 않습니다.

템플릿 내에서 특정 typedef를 사용하여 작성하는 템플릿 내에서 사용할 수있는 유형을 제한하는 방법이 있습니다. 이렇게하면 특정 typedef를 포함하지 않는 유형에 대한 템플리트 전문화 컴파일이 실패하므로 특정 유형을 선택적으로 지원 / 지원하지 않을 수 있습니다.

C ++ 11에서 개념을 도입하면 이것을 쉽게 만들 수 있지만 원하는 것을 정확하게 수행 할 것이라고는 생각하지 않습니다.