テンプレートを制限するイディオム/デザインパターンはありますか？

Question

タイプ名Tを特定のタイプに制限するにはどうすればよいですか？ 、他のデザインパターンがあります

template <typename T> 
struct Worker { 
    static_assert(std::is_base_of<WorkableType, T>::value, "Needs workable type"); 
    // Do something with T 
}; 

：

struct WorkableType { 
    std::string toString() { return ""; } 
    int get() { return 0;} 
} 

struct WorkabelTypeA : WorkableType { 
    std::string toString() { return "A"; } 
    int get() { return 1;} 
}; 

//Similarly 
struct WorkableTypeB : WorkableType; 

をし、静的アサートとstd::is_base_ofを使用します。

template <typename T> 
struct Worker { 
    // T can only be certain type allowing specific functionality. 
    // i.e T needs to be a product of some interface, support some functions, say T::toString(), T::print(), T::get(). 
    // Do something with T 
}; 

これは私が通常やって終わるものです：
はこれを考えてみましょうへのC++の方法を制限する不正な型付きテンプレートの誤ったインスタンス化を制限しますか？

編集：C++のコンセプトが標準になると、このように思えるようです。私が推測するまで、static_assertはおそらくenable_ifよりもきれいで冗長でしょう。

Answer 1

あなたはSFINAEとテンプレート特殊化を使用することができます

// type trait that evaluates always to false to use in the primary template 
template<typename ... T> struct always_false : std::false_type { }; 

// primary template 
template<typename T, typename Enable = void> 
struct Worker { 
    static_assert(always_false<T, Enable>::value, "Needs workable type"); 
}; 

// specialisation 
template<typename T> 
struct Worker<T, std::enable_if_t<std::is_base_of<WorkableType, T>::value>> { 
... 
}; 

Answer 2

それは次のように、特殊化を使用することができます。

#include<string> 

struct WorkableType { 
    std::string toString() { return ""; } 
    int get() { return 0; } 
}; 

struct A {}; 
struct B {}; 

template<typename> struct Worker; 
template<> struct Worker<A>: WorkableType {}; 

int main() { 
    Worker<A> wa; 
    // this won't compile 
    // Worker<B> wb; 
} 

Answer 3

あなたが特性を作成し、クラスでそれを確認することができます

、だから、の必要はありませんが継承。たとえば、次のように

template <typename T> 
using toString_t = decltype(std::declval<T>().toString()); 

template <typename T> 
using get_t = decltype(std::declval<T>().get()); 

// Use C++17, but can be done in C++11 
template <typename T> 
using has_toString = std::is_detected<toString_t, T>; 

template <typename T> 
using has_get = std::is_detected<get_t, T>; 

そして

template <typename T> 
struct Worker { 
    static_assert(has_toString<T>::value, "T should have toString"); 
    static_assert(has_get<T>::value, "T should have get"); 
}; 

Demo

Answer 4

あなたができるようにしたい正確にどのタイプを知っている場合、その特性クラスはそれを行うための簡潔な方法である：

#include <utility> 

// by default nothing is workable 
    template<class T> 
    struct is_workable : std::false_type 
    { 
    }; 

template <typename T> 
struct Worker { 
    static_assert(is_workable<T>(), "not a workable type"); 
    // T can only be certain type allowing specific functionality. 
    // i.e T needs to be a product of some interface, support some functions, say T::toString(), T::print(), T::get(). 
    // Do something with T 
}; 

// define a worker 
struct A {}; 

// make it workable 
template<> struct is_workable<A> : std::true_type {}; 

// define another worker but forget to make it workable 
struct B {}; 

int main() 
{ 
    Worker<A> wa{}; 
// Worker<B> wb{}; // compile error - not workable 
};