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

如何解决C ++模板化元编程，检查结构是否具有字段

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

再次要点是；这是否是一个好主意，这是我们是否可以。

解决方法

您可以将函子包装为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

,

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

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

,

看看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>();
}

模板还可以通过使用不错的boost::mpl::bool_

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

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