Question

I know that I can use templates to assume that certain classes used by the template have certain member variables; however, I was wondering if there was a way to explicitly declare that the template class has to have a certain member variable or function?

I am talking about something like this example:

template <typename T>
class Assume
{
    int value;
    Assume(T* object) : value(T->AssumedMember) {};
};


class A
{
    int AssumedMember;
    A(int val) : AssumedMember(val) {};
};


int main()
{
    A* a = new A(5);
    Assume<A> assumer(a);
    return 0;
}

I know that, at least with the compiler used in MSVC++, something similar to this example should compile without a problem;

I was merely wondering if there was a way to declare that, for the template or class’s use, that T, from typename T, has a member variable AssumedMember. As of now, the only way to really understand that Assume will only work if used with a class that has the right required members (variables, functions, or operators), one would either have to compile and look at the given compiler error, or read through the entire template yourself to determine if anything extra is being used that has not been defined yet.

(also, on an unrelated note, does anyone know of a way to declare a whole block of declarations as being a template? As if using something like:
template <typename T> { /*class... member definitions, etc..*/ }
to declare a whole block of definitions to use the same template?)

Answer 1

No, there’s no way to declare a templates requirements other than in the template’s definition. You can use static_asserts, for example, to put those requirements right up front in the definition and give better error messages.

To declare several template functions at once you could use a template class with static member functions:

template<typename T>
struct Foo {
    static int bar(T t);
    static T baz();
};

Foo<int>::bar(1);
auto s = Foo<std::string>::baz();

But there’s no general purpose way of doing this for any kind of template declaration, and I don’t think this saves you much of anything.

---

Example of custom type traits for use with static_asserts

I use some C++11 stuff, but it can be done in C++98 as well

#include <type_traits>

// the custom type traits
template<typename T> struct exists : std::true_type {};

template<typename T>
struct has_value_type {
    template<typename U>
    static typename std::enable_if<exists<typename U::value_type>::value,char>::type
    Test(int);

    template<typename U> static int Test(...);
    static constexpr bool value = sizeof(Test<T>(0)) == sizeof(char);
};

template<typename T>
struct has_member_i {
    template<typename U>
    static typename std::enable_if<0!=sizeof(&U::i),char>::type Test(int);
    template<typename U> static int Test(...);
    static constexpr bool value = sizeof(Test<T>(0)) == sizeof(char);
};

// your template for which you want to declare requirements
template<typename T>
void test(T t) {
    static_assert(has_value_type<T>::value, "value_type must be a member type alias of T");
    static_assert(has_member_i<T>::value, "i must be a member variable of T");
}

// one type that meets the requirements and one that doesn't
struct Foo {
    typedef int value_type;
    int i;
};

struct Bar {};

int main() {
    test(Foo());
    test(Bar());
}