如果可能的话静态断言，否则动态断言？

假设我有一个模板函数，它接受一个整数和一个对类型 T 的实例的 const 引用。现在，根据整数，只有某些 T 是可接受的，否则在运行时会引发异常。

如果此函数的所有使用都使用常量整数，则可以将 int 设为模板参数并使用静态断言来检查它是否可接受。所以而不是func(1,c)有人会用func<1>(c)并将获得编译时类型检查。有什么办法可以写func(1,c)并仍然保留编译时检查，同时也能够编写func(i,c)并使用动态断言？目标是使其对开发人员透明。如果能够添加这种安全性而不用担心开发人员担心编译时常量之类的事情，那就太棒了。他们可能只会记得func(1,c)总是有效并使用它，避免检查。

如何尽可能使用静态断言定义函数，否则使用动态断言？

以下代码显示了 GCC 的解决方案：伊万·谢尔巴科夫:

#include <iostream>
#include <cassert>

template<typename T>
void __attribute__((always_inline)) func(const int& i, const T& t);

void compile_time_error_() __attribute__((__error__ ("assertion failed")));

template<>
  void __attribute__((always_inline))
  func(const int& i, const float& t)
{
    do {
        if (i != 0) {
            if (__builtin_constant_p(i)) compile_time_error_();
            std::cerr << "assertion xzy failed" << std::endl;
            exit(1);
        }
    } while (0);
    func_impl<float>(i,t);
}

这仅允许 i=0 和 T=float 的组合。对于其他组合，一个好方法是创建一个宏来生成以下代码template<> func(const int& i, const T& t)用 T 和 i != 0 替换。

好吧，如果你使用 GCC，你可以使用肮脏的 hack，但它只有在启用函数内联（-O1 或更多）时才有效：

void my_error() __attribute__((__error__ ("Your message here")));

template <typename T1, typename T2> struct compare_types 
{
    enum {Equals = 0};
};

template <typename T1> struct compare_types<T1,T1> 
{
    enum {Equals = 1};
};

template <typename Type> __attribute__((always_inline)) void func(int a, Type &x)
{
    if (__builtin_constant_p(a))
    {
        if (a == 1 && compare_types<Type,char>::Equals)
            my_error();
    }
}

在这种情况下，当a == 1 and Type is char，你会得到一个错误。这是一个将触发它的示例：

int main()
{
    char x;
    func(1, x);
    return 0;
}

请注意，此示例严重依赖于特定于 gcc 的__builtin_constant_p()函数并且不能与其他编译器一起使用！