c++ - 如何根据名称检测成员变量的存在和类型？

Question

我知道如何编写一个类，该类可以在编译时检测给定类 T 是否具有具有给定类型类型的给定名称的成员，例如

#include <type_traits>

template <typename T, typename Type, bool = std::is_class<T>::value>
struct has_member_foo
{
private:
  template <Type T::*> struct helper;

  template <typename U>
  static std::false_type test(...);

  template <typename U>
  static std::true_type test(helper<&U::foo> *);

  typedef decltype(test<T>(nullptr)) testresult;
public:
  static const bool value = testresult::value;
};

template <typename T, typename Type>
struct has_member_foo<T, Type, false> : std::false_type { };

struct Has_Foo
{
  int foo;
};

struct Has_No_Foo
{
  int bar;
};

void test()
{
  static_assert(has_member_foo<Has_Foo, int>::value == true, ":(");
  static_assert(has_member_foo<Has_No_Foo, int>::value == false, ":(");
  static_assert(has_member_foo<int, int>::value == false, ":(");
}

我不喜欢你必须说明成员变量的确切类型，因为如果我想在大多数时候使用这些特征，我会关心这个成员是否可以转换为某种类型，是一个整数类型，等等. 而不是关于确切的类型。我希望能够检测具有给定名称的成员变量的存在和类型。我希望能够写出这样的东西:

static_assert(has_member_foo<T>::value && std::is_integral<typename has_member_foo<T>::type>::value,
              "The type has to have an integral member with name foo");

如果我知道构造 &T::foo 是合法的，则可以通过类似的方式获取成员的类型

template <typename T, typename U>
T get_member_type(T U::*);

typedef decltype(get_member_type(&T::foo)) the_member_type;

但我无法生成 SFINAE 得到正确结果的两种方法的组合，主要是因为 helper-struct 必须知道指向成员的指针的签名。最终代码将是一个以名称作为参数的预处理器宏，因此任何解决方案都可以使用预处理器。

Answer 1

这是对名为 id 的变量执行此操作的简单方法:

#include <type_traits>

using namespace std;

template<typename T, typename V = bool>
struct has_id : false_type { };

template<typename T>
struct has_id<T,
    typename enable_if<
        !is_same<decltype(declval<T>().id), void>::value,
        bool
        >::type
    > : true_type
{
    typedef decltype(declval<T>().id) type;
};

下面是您将如何使用它:

#include <iostream>

using namespace std;

struct X { int id; };

int main()
{
    static_assert(
        has_id<X>::value && is_integral<has_id<X>::type>::value,
        "Error!"
        );
}

---

如果你能容忍宏，你可以让事情变得更简单:

#define DEFINE_MEMBER_CHECKER(member) \
    template<typename T, typename V = bool> \
    struct has_ ## member : false_type { }; \
    template<typename T> \
    struct has_ ## member<T, \
        typename enable_if< \
            !is_same<decltype(declval<T>().member), void>::value, \
            bool \
            >::type \
        > : true_type \
    {  \
        typedef decltype(declval<T>().member) type; \
    };

#define HAS_MEMBER(C, member) \
    has_ ## member<C>::value

#define MEMBER_TYPE(C, member) \
    has_ ## member<C>::type

然后您可以这样使用它们:

DEFINE_MEMBER_CHECKER(id)

int main()
{
    static_assert(
        HAS_MEMBER(X, id) && is_integral<MEMBER_TYPE(X, id)>::value,
        "Error!"
        );
}