如何创建模板属于特定类型的编译时断言？

Question

我有一个模板函数，并希望在编译时确保它不会在特定类的子类型或超类型上实例化。

如果违反此规定，如何导致 C++ 编译器错误？

class base {
};
class derived : public base {
};
class lowest : public derived {
};

template <typename T>
bool isCorrect(const T& obj) {
  typedef foo<T> D;
  foo<T> *def = foo<T>::find();
  return (def && def->getAnswer(object));
}

我希望 isCorrect 仅适用于类 衍生，但不适用于 base 或 lowest。请注意，可能存在许多其他最低类和要排除的一系列基类以及可接受的替代派生类。

C++ 中有没有办法限制模板仅适用于我明确指定的派生类？

Answer 1

类型特征，特别是 is_base_of。

#include <type_traits>

template <typename T>
bool isCorrect(const T& obj) {
  static bool const is_base = std::is_base_of<base, T>::value;
  static bool const derives = std::is_base_of<derived, T>::value;
  // specify allowed types here
  static bool const is_derived = std::is_same<T, derived>::value;
  // ---
  static_assert((!is_base && !derives) || is_derived, "wrong argument type");

  typedef foo<T> D;
  foo<T> *def = foo<T>::find();
  return (def && def->getAnswer(object));
}

请注意，这是 C++11 特定的，但您可以使用 Boost.TypeTraits 获得相同的行为。

Answer 2

这是我所知道的一种技术。

首先，创建另一个模板类policy_enforcer。声明此类而不定义它，并为派生提供它的特化也已定义：

template<typename T> struct policy_enforcer;
template<> struct policy_enforcer<derived> { };

然后，在您希望的函数中锁定，包括表达式 sizeof(policy_enforcer)。由于不完整类型上的 sizeof 是一个编译错误，这将阻止代码编译。

使用实时代码更新： 使用 base, < a href="http://www.ideone.com/uOdLk" rel="nofollow">使用派生，使用最低。

Answer 3

您可以使用模板专门化。

您只能为您希望使用的类型实现 isCorrect。

对于其他类型，您可以实现虚拟方法，例如返回 false，或者根本不实现 isCorrect，在这种情况下，它将无法针对其他类型进行编译。

#include <iostream>

using namespace std;

class base {
};
class derived : public base {
};
class lowest : public derived {
};

// using this it will fail if you try to pass anything
// else than `derived`
//  template <typename T>
//     bool isCorrect(const T& obj);

template <typename T>
bool isCorrect(const T& obj) {
    cout << __PRETTY_FUNCTION__ << endl;
    return false;
}

template <>
bool isCorrect<derived>(const derived& obj) {
    cout << __PRETTY_FUNCTION__ << endl;
    return true;
//  typedef foo<derived> D;
//  foo<derived> *def = foo<derived>::find();
//  return (def && def->getAnswer(object));
}

测试：

int main()
{
    base b;
    derived d;
    lowest l;

    cout << isCorrect(b) << endl;
    cout << isCorrect(d) << endl;
    cout << isCorrect(l) << endl;
}

输出：

bool isCorrect(const T&) [with T = base]
0
bool isCorrect(const T&) [with T = derived]
1
bool isCorrect(const T&) [with T = lowest]
0