检测是否存在私有成员

Detect existence of private member

本文关键字：成员 存在 是否 检测      更新时间：2023-10-16

我想写一个类型trait来检查某个类型是否有成员member。如果member是公共，有很多方法可以做到这一点(例如void_t)，其中最简洁的可能是Yakk的can_apply(最终可以称为std::is_detected):

struct C {
    int member;
};
template <typename T>
using member_type = decltype(&T::member);
template <typename T>
using has_member = can_apply<member_type, T>;
static_assert(has_member<C>{}, "!"); // OK

但是如果成员是private，这个trait就失败了，因为member上的访问是病态的(我们不是朋友)，并且由于访问原因导致的病态和由于这个东西不存在的原因导致的病态之间没有区别:

class D {
    int member;
};
static_assert(has_member<D>{}, "!"); // error

是否有一种方法可以在所有访问控制中编写这样的成员检查器?

对于非final非联合类类型确实有一种方法:

namespace detail {
    struct P {typedef int member;};
    template <typename U>
    struct test_for_member : U, P
    {
        template <typename T=test_for_member, typename = typename T::member>
        static std::false_type test(int);
        static std::true_type test(float);
    };
}
template <typename T>
using test_for_member =
  std::integral_constant<bool, decltype(detail::test_for_member<T>::test(0)){}>;

。诀窍是检查对不同基类的查找是否会产生歧义。(class.member.lookup)/2:

成员名查找决定名称的含义(id-expression)在类作用域(3.3.7)中。名称查找可能导致歧义，在在这种情况下，程序是病态的。[…]进行名称查找

请注意，gcc的查找在类型名称说明符s中忽略非类型名称查找时是被破坏的。

您可以创建另一个类MemberBase， 确实具有该成员，然后子类化这两个类(检查T和BaseMember的类)并尝试访问子类的成员。如果T也有member成员，那么就会出现歧义问题。

代码:

#include <type_traits>
// Yakk's can_apply
template<class...>struct voider{using type=void;};
template<class...Ts>using void_t=typename voider<Ts...>::type;
template<class...>struct types{using type=types;};
namespace details {
  template<template<class...>class Z, class types, class=void>
  struct can_apply : std::false_type {};
  template<template<class...>class Z, class...Ts>
  struct can_apply< Z, types<Ts...>, void_t< Z<Ts...> > >:
    std::true_type
  {};
}
template<template<class...>class Z, class...Ts>
using can_apply = details::can_apply<Z,types<Ts...>>;
// Main code
class MemberBase {
    public:
        int member;
};
template<class ToCheck>
class MemberCheck: public ToCheck, public MemberBase {
};
template <typename T>
using member_type = decltype(&T::member);
template <typename T>
using hasnot_member = can_apply<member_type, MemberCheck<T>>;
template <typename T> 
using static_not = std::integral_constant<bool, !T::value>;
template <typename T>
using has_member = static_not<hasnot_member<T>>;
// Tests
class A {
    int member;
};
class Ap {
    public:
    int member;
};
class B {
    float member;
};
class C {
    int member();
};
class D {
};
static_assert(has_member<A>{}, "!"); // ok
static_assert(has_member<Ap>{}, "!"); // ok
static_assert(has_member<B>{}, "!"); // ok
static_assert(has_member<C>{}, "!"); // ok
static_assert(has_member<D>{}, "!"); // fail

然而，这对我来说绝对是一个肮脏的黑客。

相关文章：