C++ 模板元编程，检查结构是否有字段

Question

所以我最近发现 C++ 确实有反射，它只是发生在没有人，甚至 C++ 委员会都不知道，直到一位俄罗斯天才打开了通往不可能调试的可能性世界的大门。

有了这个序言，让我们来看看这个反人类罪：

template <typename T, typename D = decltype(T().field)>
struct foo { bool b = true; };

template <typename T>
struct foo<T, void> { bool b = false; };

template <typename T>
constexpr bool HasField() { return foo<T>().b; }

编译成功。给定任何其成员不是私有的类型，您可以检查该类型是否定义了一个名为 field.

的文件

但是，这会强制您为要检查的每个字段编写该模式。它会工作，但它会在各处添加一堆复制意大利面并使代码变丑（并不是说即使你复制一次代码也会很漂亮）。

因此，出于纯粹的好奇心，我想想想进行通用 POD 字段检查的最不恶心的方法是什么。

我的一个想法是：

#define HAS_FIELD(field) \
    template <typename T, typename D = decltype(T().#field)> \
    struct foo_#field { bool b = true; }; \
    \
    template <typename T> \
    struct foo_#field<T, void> { bool b = false; }; \
    \
    template <typename T> \
    constexpr bool HasField#field() { return foo<T>().b; }

这至少减少了只需要写入一个宏调用的行数。但是我不满意，我正在尝试看看我们是否可以使用模板和宏来获得一个可以在任何地方调用的函数，而无需在前面加上宏。

即我们希望能够做到（或类似）：

struct POD {/**/};
int main() { HasField(POD, FieldName); }

请注意，目前这几乎是可能的：

struct POD {/**/};
HAS_FIELD(FieldName)
int main() { HasFieldFieldName<POD>(); }

同样重要的不是这是否是个好主意，而是我们是否可以。

Answer 1

您可以包装一个仿函数（如 lambda）：

// C++20
#define HasField(C, Field) \
    [](){ \
        return overloaded{[]<typename T>(int) -> decltype(std::declval<T>().Field, void(), std::true_type()) { return {}; }, \
                          []<typename T>(...) { return std::false_type{}; }}.operator()<C>(0); \
    }()

Demo

Answer 2

“C++ 模板，完整指南”一书中介绍了一种通用技术（因此这不是我的！），用于测试成员 variable/function、class 嵌套类型。这是一个例子：

namespace details
{
template <typename F, typename... Args, typename = decltype(std::declval<F>()(std::declval<Args &&>()...))>
auto
IsValidImpl(void *) -> std::true_type;

template <typename F, typename... Args>
auto
IsValidImpl(...) -> std::false_type;
} // namespace details

inline constexpr auto gk_isValid = [](auto f) {
  using InputType = decltype(f);
  return [](auto &&... args) { return decltype(details::IsValidImpl<InputType, decltype(args) &&...>(nullptr)){}; };
};

template <typename T>
struct TypeT
{
  using Type = T;
};

template <typename T>
constexpr auto gk_type = TypeT<T>{};

template <typename T>
T ValueT(TypeT<T>);

struct Foo {
    int bar;
};

struct Bar {
};

inline constexpr auto HasBar = gk_isValid([](auto x) -> decltype((void)ValueT(x).bar) {});

static_assert(HasBar(gk_type<Foo>), "foo has bar");
static_assert(!HasBar(gk_type<Bar>), "bar has no bar");

检查嵌套类型或运算符的示例：

constexpr auto hasSizeType = isValid([](auto x) -> typename decltype((void)valueT(x))::size_type {});
constexpr auto hasLess = isValid([](auto x, auto y) -> decltype(valueT(x) < valueT(y)) {});

当然，您将需要一种宏包装以使其更有用。但这是通向通用性的第一步...

Answer 3

看看BOOST_MPL_HAS_XXX_TRAIT_DEF。

例如：

BOOST_MPL_HAS_XXX_TRAIT_DEF(Juju)

定义 has_Juju<T> 类型 ::value 等于 true 或 false

那么可以这样使用：

#include <boost/mpl/has_xxx.hpp>

BOOST_MPL_HAS_XXX_TRAIT_DEF(Juju)
template <class T>
bool isThereAnyJuju()
{
   return boost::mpl::bool_<has_Juju<T>::value>();
}

模板也可以通过使用 nice boost::mpl::bool_

来使用具有或不具有该名称的字段的知识

#include <boost/mpl/bool_fwd.hpp>
... boost::mpl::bool_<has_Juju<T>::value> ...

C++ 模板元编程，检查结构是否有字段

C++ templated metaprogramming, checking if a struct has a field

c++

macros

templates

template-meta-programming