使用 static_assert 检查传递给宏的类型

Question

不幸的是，我的库的原始版本留下了几个宏，这些宏使用了一些非常疯狂的 C。特别是，我有一系列宏，它们期望将某些类型传递给它们。 是否可以按照以下方式做一些事情：

static_assert(decltype(retval) == bool);

以及如何做？有什么聪明的替代方案吗？

是的，我知道宏很糟糕。我知道 C++ 不是 C 等。

Update0

这里有一些 相关代码，以及 源文件。欢迎提出建议。原来的问题保持不变。

Answer 1

我发现这是最干净的，使用 @UncleBens 建议：

#include <type_traits>

static_assert(std::is_same<decltype(retval), bool>::value, "retval must be bool");

Answer 2

如果您确实关心 const 和 易失性 限定符，并且希望确保类型也与您要比较的类型完全匹配，就像@Matt Joiner所说：

#include <type_traits>

static_assert(std::is_same<decltype(my_variable), uint64_t>::value, 
              "type must be `uint64_t`"); 

我你不关心const，但是，如果想要简单地确保类型是某种类型而不考虑 const，请改为执行以下操作。请注意，这里需要 std::remove_const<>::type：

static_assert(std::is_same<std::remove_const<decltype(my_variable)>::type, uint64_t>::value, 
              "type must be `uint64_t` OR `const uint64_t`");   

volatile 也是如此。如果您也不关心类型的 易失性 部分，则可以使用 std::remove_volatile<>::type 忽略它：

static_assert(std::is_same<std::remove_volatile<decltype(my_variable)>::type, uint64_t>::value, 
              "type must be `uint64_t` OR `volatile uint64_t`");

如果您不这样做不关心 const 或 volatile，您可以使用 std::remove_cv<>::type 删除它们：

static_assert(std::is_same<std::remove_cv<decltype(my_variable)>::type, uint64_t>::value, 
              "type must be `uint64_t` OR `const uint64_t` OR `volatile uint64_t` OR `volatile const uint64_t`");

另请注意，截至C++17 你可以这样做：

1. std::remove_cv_t 代替 std::remove_cv::type ，并且：用
2. std::is_same_v 代替 std::is_same::value。

参考文献：

1. 使用 static_assert 检查传递给宏的类型
2. https://en.cppreference.com/w/cpp/types/ is_same
3. https://en.cppreference.com/w/cpp/language /decltype
4. https://en.cppreference.com/w/cpp/ header/type_traits
5. https://en.cppreference.com/w/cpp /types/remove_cv - std::remove_cv<>、std::remove_const、std::remove_volatile<>< /code>

相关：

1. [我使用上述 static_assert 技巧的另一个答案] 如何制作跨度
2. 静态在 C 中断言 [我自己的答案]
3. 如何在 C 中使用静态断言来检查传递给宏的参数类型 [我自己的问题]
4. 在 C 中对宏参数进行类型检查
5. *****C++ 将模板类型限制为数字

Answer 3

免责声明：这是一个糟糕的答案，肯定有更好的解决方案。只是一个例子:)

它肯定已经实现了，但是自己实现是微不足道的；

template <class T1, class T2> struct CheckSameType; //no definition
template <class T> struct CheckSameType<T,T>{}; //

template <class T1, class T2>
AssertHasType(T2)
{
   CheckSameType<T1, T2> tmp; //will result in error if T1 is not T2
}

像这样使用：

AssertHasType<bool>(retval);

替代（GMan 建议）：

template <class T1, class T2> struct SameType
{
    enum{value = false};
}
template <class T> struct SameType<T,T>
{
    enum{value = true};
}; 

static_assert(SameType<decltype(retval), bool>::value);

Answer 4

看来您需要 decltype 因为您有一个表达式，但想要验证类型。现在已经有足够的方法可以做到这一点（C++03）。例如，要检查 bool

inline void mustBeBool(bool) { }
template<typename T> inline void mustBeBool(T t) { & (&t); } // Takes address of rvalue (&t)

// Use:
#define DifficultMacro(B) do { mustBeBool(B); foo(B); } while (false)

Answer 5

大多数宏都可以替换为内联函数和/或模板。作为一个恰当的例子，过于聪明的参数大小检查 Posix isnan 宏是 C++0x 中的一个模板。哦，例子不好，但你明白了。

该规则的主要例外是本质上实现更高级别语言功能的宏。例如，更智能的异常处理、协方差或参数化声明集。

在某些情况下，无法合理表示为内联函数或模板的宏可以用更智能的预处理（即代码生成）来替换。然后你在某个地方有一个脚本可以生成必要的代码。例如，可以使用宏和模板在纯 C++ 中创建选项类，但它很麻烦，并且作为一种更容易理解并且可能更易于维护的替代方案，可以使用生成必需类的脚本，但需要额外的成本构建步骤并处理多种语言。

干杯&呵呵，，