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

【问题标题】：C++ templated metaprogramming, checking if a struct has a fieldC ++模板元编程，检查结构是否有字段
【发布时间】：2020-08-18 04:16:08
【问题描述】：

所以我最近发现 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>(); }

再次强调，这不是一个好主意，而是我们能否做到。

【问题讨论】：

你想了解concepts。这不是反射。
你如何定义反射？它是对结构领域的元分析，也就是检查，这是反射的特征之一。这不是你可以用这种形式的元编程做的唯一事情，你可以计算结构中的所有字段，将结构一般地转换为元组，获取每个字段的大小......但我离题了。另外我不确定概念在这里有什么帮助，重点是，上面的代码为您提供了一个布尔值，您可以在运行时使用它来执行逻辑。就像在字段存在时调用函数一样。
@Makogan 反射定义的一个关键部分是它发生在运行时。没有编译时反射这样的东西。我们这里有的是编译时内省，而不是反射。
查看 requires-expression。
这不是反射，因为它不允许您执行反射在本机支持反射的语言中所做的事情。它可以让你做非常非常非常小的一部分。这是反射的苍白阴影（请原谅双关语）。

标签： c++ templates macros template-meta-programming

【解决方案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

【讨论】：

重载的定义是什么？
我提供了链接（取自std::visit的示例）。

【解决方案2】：

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

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)) {});

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

【讨论】：

【解决方案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> ...

【讨论】：