C＆＃x2B;＆＃x2B;通过CRTP检测朋友课的私人成员

Question

我有一个 CRTP 基类 (Bar)，它由未指定的类继承。此派生类可能有也可能没有特定成员 (internal_foo)，并且该特定成员可能有也可能没有其他成员 (test())。

在这种情况下，internal_foo 将始终是公共的，但是 test() 是私有的，但将 Bar 声明为好友。

我可以使用特征很好地检测internal_foo，因为它是公共的。但我无法检测到 test() 因为它是私有的，即使 Bar 是朋友。

下面的示例由于 test() 是公开的而有效：

template<class, class = void >
struct has_internal_foo : std::false_type {};

template<class T>
struct has_internal_foo<T,
    void_t<
    decltype(std::declval<T>().internal_foo)
    >> : std::true_type {};

template<class, class = void>
struct internal_foo_has_test : std::false_type {};

template<class T>
struct internal_foo_has_test<T,
    void_t<decltype(std::declval<T>().internal_foo.test())
    >> : std::true_type {};

class InternalFoo
{
public:

    void test()
    {

    }
};

class BadInternalFoo
{
};

template<class T>
class Bar
{
public:
    template<class _T = T>
    std::enable_if_t<conjunction<has_internal_foo<_T>, internal_foo_has_test<_T>>::value, void>
        action()
    {
        static_cast<T&>(*this).internal_foo.test();
    }
};

class Foo : 
    public Bar<Foo>
{
public:
    InternalFoo internal_foo;
};

class BadFoo :
    public Bar<BadFoo>
{
public:
    BadInternalFoo internal_foo;
};

void test()
{
    Foo foo;
    BadFoo bad_foo;

    foo.action(); // Compiles. As expected.
    bad_foo.action(); // Does not compile. As expected.
}

但是，由于 test() 是私有的，所以下一个版本不起作用：

template<class, class = void >
struct has_internal_foo : std::false_type {};

template<class T>
struct has_internal_foo<T,
    void_t<
    decltype(std::declval<T>().internal_foo)
    >> : std::true_type {};

template<class, class = void>
struct internal_foo_has_test : std::false_type {};

template<class T>
struct internal_foo_has_test<T,
    void_t<decltype(std::declval<T>().internal_foo.test())
    >> : std::true_type {};

class InternalFoo
{
public:
    template<class T>
    friend class Bar;

    template<class, class>
    friend struct internal_foo_has_test;

private:
    void test()
    {

    }
};

class BadInternalFoo
{
};

template<class T>
class Bar
{
public:
    template<class _T = T>
    std::enable_if_t<conjunction<has_internal_foo<_T>, internal_foo_has_test<_T>>::value, void>
        action()
    {
        static_cast<T&>(*this).internal_foo.test();
    }
};

class Foo : 
    public Bar<Foo>
{
public:
    InternalFoo internal_foo;
};

class BadFoo :
    public Bar<BadFoo>
{
public:
    BadInternalFoo internal_foo;
};

void test()
{
    Foo foo;
    BadFoo bad_foo;

    foo.action(); // Does not compile
    bad_foo.action(); // Does not compile
}

如上所示，我尝试过朋友也检测结构，但这没有帮助。

有办法做我想做的事吗？

理想情况下，我希望这个解决方案是可移植的，并且最多不使用 C++11、14 之外的任何内容。 （我已经实现了 void_t & 合取）

编辑：

建议的问题没有回答这个问题。这个问题想要检测一个成员是公共的还是私有的，并且只有在它是公共的情况下才访问它，我希望检测对朋友类的私有成员返回肯定。

Answer 1

摘要和修复

看起来像 GCC 11 错误，您的第二次尝试实际上应该有效。

不过，我建议用两种方式重写 action 的定义，这样您甚至不需要成员检测习惯用法：

// Way 1
template<class _T = T>
decltype(std::declval<_T&>().internal_foo.test()) action() {
    static_cast<T&>(*this).internal_foo.test();
}

// Way 1, with a different return type via the comma operator
template<class _T = T>
decltype(std::declval<_T&>().internal_foo.test(), std::declval<ReturnType>()) action() {
    static_cast<T&>(*this).internal_foo.test();
}

// Way 2
template<class _T = T>
auto action() -> decltype(static_cast<_T&>(*this).internal_foo.test()) {
    static_cast<_T&>(*this).internal_foo.test();  // Using _T for consistency
}

请注意，我在 中使用 _T decltype 因此它依赖于模板参数并且可以被 SFINAEd 处理。另请注意，仍然可以指定任意返回类型而不使用任何 enable_if。

详细信息

我冒昧地在您的两个示例中添加了 #include 和 using namespace std; 并使用 C++17，以便可以编译它们。

评论部分的一些发现：

1. 您的第一个代码（未）按预期使用 Clang 14、gcc 11 和 gcc trunk 进行编译：https://godbolt.org/z/EbaYvfPE3
2. 您的第二个代码（没有）按预期使用 Clang add gcc trunk 进行编译，但是gcc 11 有所不同： https://godbolt.org/z/bbKrP8Mb9

有一个更简单的复制示例： https://godbolt.org/z/T17dG3Mx1

#include <type_traits>

template<class, class = void>
struct has_test : std::false_type {};

template<class T>
struct has_test<T, std::void_t<decltype(std::declval<T>().test())>> : std::true_type {};

class HasPrivateTest
{
public:
    template<class, class>
    friend struct has_test;
    friend void foo();

private:
    void test() {}
};

// Comment the following line to make it compile with GCC 11
static_assert(has_test<HasPrivateTest>::value, "");
void foo() {
    static_assert(has_test<HasPrivateTest>::value, "");
}
static_assert(has_test<HasPrivateTest>::value, "");

上面的代码使用 Clang 14 和 gcc trunk 进行编译，但被 gcc 11 拒绝，并显示 3 条“静态断言失败”消息，每个断言各一条。但是，注释掉第一个 static_assert 会使所有三个编译器都接受该代码。

因此，GCC 11（及更早版本）似乎尝试实例化模板并根据上下文进行访问检查。因此，如果第一个实例化位于友元之外，则无法访问 .test() 方法，并且结果会被缓存。但是，如果它位于 friend void foo() 内部，则可以访问 .test() 并且所有 static_assert 都会成功。

@Klaus 指出了最近的一个 GCC 错误，其修复似乎相关： https:// gcc.gnu.org/bugzilla/show_bug.cgi?id=96204