3

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?)

4

2 回答 2

2

标准委员会一直在研究这个特性，称为“概念”。但是，它并没有进入 C++11。

但是，有两个编译器可以使用它（具有各种功能）。看看ConceptGCC或ConceptClang。

于 2012-06-09T19:43:45.733 回答
1

不，除了在模板的定义中，没有办法声明模板要求。例如，您可以使用 static_asserts 将这些要求放在定义的最前面，并提供更好的错误消息。

要一次声明多个模板函数，您可以使用带有静态成员函数的模板类：

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

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

但是对于任何类型的模板声明都没有通用的方法，而且我认为这不会为您节省太多任何东西。

与 static_asserts 一起使用的自定义类型特征示例

我使用了一些 C++11 的东西，但它也可以在 C++98 中完成

#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());
}
于 2012-06-09T19:40:16.347 回答