Is there an idiom/design pattern for restricting templates?

Question

How do one restrict the typename T to specific type?
Consider this:

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

This is what I usually end up doing:

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;

And use static assert and std::is_base_of:

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

Is there any other design pattern, a more C++ way to restrict accidental instantiation of bad typed templates?

Edit: Seems like this would be better solved with C++ Concepts when it becomes the standard. Until then i guess, static_assert is probably more cleaner and verbose than enable_if.

Google "C++ concepts." I believe GCC has a working implementation. — Angew is no longer proud of SO, Sep 05 '16 at 07:14
Possible diuplicate http://stackoverflow.com/q/874298/612920 — Mansuro, Sep 05 '16 at 07:16
@themagicalyang There's also [Boost.Concepts](http://www.boost.org/doc/libs/1_61_0/libs/concept_check/concept_check.htm). I didn't mean the C++ contexts as "you can use this out of the box," but like "here's where you can take inspiration." — Angew is no longer proud of SO, Sep 05 '16 at 07:41

score 2 · Answer 1 · edited Sep 05 '16 at 07:36

2

You could use SFINAE and template specialisation:

// 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>> {
...
};

edited Sep 05 '16 at 07:36

Nawaz

353,942
115
666
851

answered Sep 05 '16 at 07:14

101010

41,839
11
94
168

I don't see the gain with OP's snippet though. – Jarod42 Sep 05 '16 at 07:47
@Jarod42 There's more C++ to it :P – 101010 Sep 05 '16 at 07:52
@101010 true. I am not how it would scale when multiple types need checking. I would probably fall back to static assert in that case. – themagicalyang Sep 05 '16 at 08:01
@themagicalyang If there are more types for checking then you would specialise for those types as well. – 101010 Sep 05 '16 at 08:02
Will this work for `template Worker{}` – themagicalyang Sep 08 '16 at 06:43

score 1 · Answer 2 · answered Sep 05 '16 at 07:44

1

You can create traits and check that in your class, So, no need of inheritance. For example:

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

And then

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

answered Sep 05 '16 at 07:44

Jarod42

203,559
14
181
302

The issue is that it still says anything that has toString and get can go to Worker, while that's not exactly the case. Not every type that has toString and get may be workable. So to do a error check, all types that are workable can be derived from a dummy base type (WorkableType) for the sole purpose of doing a static assert (or enable if). – themagicalyang Sep 05 '16 at 08:00
@themagicalyang: You may have more strict traits (as return type should be convertible/equal to some type). Inheritance is not needed. – Jarod42 Sep 05 '16 at 08:05

score 1 · Answer 3 · answered Sep 05 '16 at 08:21

If you know exactly which types you want to allow, then a traits class is a succinct way to do it:

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

score 0 · Answer 4 · answered Sep 05 '16 at 07:34

0

You can use specializations as it follows:

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

answered Sep 05 '16 at 07:34

skypjack

49,335
19
95
187

Doesn't really help when you explicitly specialize. – themagicalyang Sep 05 '16 at 08:05
@themagicalyang Why not? Maybe I misunderstood the problem? I'm to delete the answer if it's so. Let me know. – skypjack Sep 05 '16 at 08:07

Is there an idiom/design pattern for restricting templates?

4 Answers4