如何检测给定名称的成员变量的存在和类型？

Question

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

#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; 

但我不能产生两种方法的组合，即SFINAEs到正确的结果，主要是由于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!" 
     ); 
} 

Answer 2

#include <type_traits> 

template<typename T> 
struct test_code { typedef void type; }; 

template<typename T> 
using TestCode = typename test_code<T>::type; 

template<typename T, typename=void> 
struct has_member_foo:std::false_type {}; 
template<typename T> 
struct has_member_foo<T, 
    TestCode< decltype(std::declval<T>().foo) > 
>:std::true_type 
{ 
    typedef decltype(std::declval<T>().foo) type; 
}; 
template<typename T> 
using FooMemberType = typename has_member_foo<T>::type; 

struct test_nofoo {}; 
struct test_foo { int foo; }; 

#include <iostream> 
int main() { 
    std::cout << has_member_foo<test_nofoo>::value << has_member_foo<test_foo>::value << std::is_same<int, FooMemberType<test_foo>>::value << "\n"; 
} 

应该工作。如果您的编译器尚不支持模板别名，请将TestCode< decltype(std::declval<T>().foo) >替换为typename test_code< decltype(std::declval<T>().foo) >::type。