不能使用指向来自私有基的公共成员函数的指针

鉴于这Base不像您的示例那样模棱两可或虚拟，我们需要关注的唯一问题是可访问性部分。

还是我们？

实际上，我们可以使用标准中的一个小漏洞：

7.6.3 显式类型转换（强制转换符号）（强调我的）

4执行的转换

(4.1)一个const_­cast( [expr.const.cast] ), （4.2）一个static_­cast（[expr.static.cast]）， (4.3) astatic_­cast后跟 a const_­cast, (4.4) a reinterpret_­cast( [expr.reinterpret.cast] )，或 (4.5) areinterpret_­cast后跟 a const_­cast,

可以使用显式类型转换的强制转换表示法来执行。相同的语义限制和行为适用，但static_­cast在以下情况下执行转换是有效的，即使基类不可访问：

(4.6)指向派生类类型对象的指针或派生类类型的左值或右值可以分别显式转换为指向明确基类类型的指针或引用； (4.7)指向派生类类型成员的指针可以显式转换为指向明确非虚基类类型成员的指针； (4.8)指向明确非虚拟基类类型对象的指针、明确非虚拟基类类型的glvalue或指向明确非虚拟基类类型成员的指针可以显式转换为指针、引用或指向派生类类型成员的指针。

[...]

因此，尽管任何 C++ 转换方法（如static_cast/reinterpret_cast等）都不允许从Base::*to转换，但允许Derived::*c 样式转换执行它，即使在基类不可访问时也是如此。

例如：

int main() {
  Derived d;
  auto fn = &Derived::foo;

  // cast to base (only legal with c-style cast)
  // Base* b = static_cast<Base*>(&d); // not legal
  // Base* b = reinterpret_cast<Base*>(&d); // not legal
  Base* b = (Base*)&d; // legal
  (b->*fn)(12);

  // cast member function pointer to derived
  // (also only legal with c-style cast)
  using MemFn = int (Derived::*)(int) const;
  // auto fnD = static_cast<MemFn>(fn); // not legal
  // auto fnD = reinterpret_cast<MemFn>(fn); // not legal
  auto fnD = (MemFn)fn; // legal
  (d.*fnD)(12);

  // or as a one liner (provided by @KamilCuk in the ments):
  // slightly hard to read, but still legal c++:
  (d.*((int(decltype(d)::*)(int))&decltype(d)::foo))(12); // legal
}

螺栓示例

是有效的 C++。

因此，只需将DerivedtoBase或成员函数指针强制转换为绑定到Derived.

标准中甚至有一个例子可以做到这一点：11.8.3 基类和基类成员的可访问性（3）

4、为什么不&Derived::foo返回Derived::*memfn指针？

因为标准是这样说的。我不知道他们为什么会这样决定，但我可以推测可能的原因是什么：

您可以检查哪个派生最多的类实现了给定的成员函数。&Derived::foo如果返回Derived::*指针，这将中断。（例如，这可以与 CRTP 一起使用，以检查给定Derived类是否为 的给定成员提供了新定义Base）例如：

class Base {
public:
    int foo(int x) const { return 2*x; }
};

class Derived : private Base {
public:
    using Base::foo;
};

template<class T>
struct implementing_class_helper;

template<class T, class R>
struct implementing_class_helper<R T::*> {
    typedef T type;
};

template<class T>
struct implementing_class : implementing_class_helper<typename std::remove_cv<T>::type> {

};

template<class T>
using implementing_class_t = implementing_class<T>;

int main() {
  static_assert(std::is_same_v<
    typename implementing_class<decltype(&Derived::foo)>::type,
    Base
  >, "Shenanigans!");
}

如果要创建存根函数，例如：

class Base {
public:
  int foo(int x) const { return 2*x; }
};

class Derived : Base {
public:
  // pretending using Base::foo; would result in this:
  int foo(int x) { return Bar::foo(x); }
};

编译器现在会遇到问题，因为Base::foo和Derived::foo是不同的函数，但仍然需要比较等于Base::foo，因为这是实际的实现。
因此，编译器需要知道所有using Base::foo;编译单元中包含的所有类，并确保无论何时将它们::foo与结果进行比较Base::foo，结果都是true. 对于一个奇怪的边缘情况，这听起来像是很多实现工作。