继续在 C++ error: base function is protected 中学到的东西...

C++11 指向成员的指针规则有效地去除了任何值的 protected 关键字，因为可以在不相关的类中访问 protected 成员，而无需任何邪恶/不安全的强制转换。

也就是说:

class Encapsulator
{
  protected:
    int i;
  public:
    Encapsulator(int v) : i(v) {}
};

Encapsulator f(int x) { return x + 2; }

#include <iostream>
int main(void)
{
    Encapsulator e = f(7);
    // forbidden: std::cout << e.i << std::endl; because i is protected
    // forbidden: int Encapsulator::*pi = &Encapsulator::i; because i is protected
    // forbidden: struct Gimme : Encapsulator { static int read(Encapsulator& o) { return o.i; } };

    // loophole:
    struct Gimme : Encapsulator { static int Encapsulator::* it() { return &Gimme::i; } };
    int Encapsulator::*pi = Gimme::it();
    std::cout << e.*pi << std::endl;
}

• http://ideone.com/pEXk9W
• http://ideone.com/kKlTvD
• http://ideone.com/zJX5U6

这真的符合标准吗？

(我认为这是一个缺陷，并声称 &Gimme::i 的类型确实应该是 int Gimme::* 即使 i 是基类的成员。但我在标准中没有看到任何使其如此的东西，并且有一个非常具体的示例显示了这一点。)

我意识到有些人可能会惊讶于第三种评论方法(第二个 ideone 测试用例)实际上失败了。那是因为思考 protected 正确方法不是“我的派生类可以访问，而没有其他人”，而是“如果您从我那里派生，您将可以访问您的实例中包含的这些继承变量，除非您授予它”。例如，如果 Button 继承 Control，则 Button 实例中的 Control 的 protected 成员只能由 Control 和 Button，以及(假设 Button 不禁止它)实例的实际动态类型和任何中间基。

这个漏洞颠覆了契约(Contract)，完全违背了11.4p1的精神:

An additional access check beyond those described earlier in Clause 11 is applied when a non-static data member or non-static member function is a protected member of its naming class. As described earlier, access to a protected member is granted because the reference occurs in a friend or member of some class C. If the access is to form a pointer to member (5.3.1), the nested-name-specifier shall denote C or a class derived from C. All other accesses involve a (possibly implicit) object expression. In this case, the class of the object expression shall be C or a class derived from C.

感谢 AndreyT 提供链接 http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#203它提供了激发变革的更多示例，并呼吁演进工作组提出这个问题。

也相关:GotW 76: Uses and Abuses of Access Rights

最佳答案

我已经看到了这种技术，我称之为“ protected 黑客”，在这里和其他地方多次提到。是的，这种行为是正确的，而且它确实是一种合法的方式来规避 protected 访问，而无需诉诸任何“肮脏”的黑客攻击。

当 m 是类 Base 的成员时，使 &Derived::m 表达式产生 指针的问题>Derived::* 类型是类成员指针是逆变，而不是协变。它会使生成的指针无法与 Base 对象一起使用。比如这段代码编译

struct Base { int m; };
struct Derived : Base {};

int main() {
  int Base::*p = &Derived::m; // <- 1
  Base b;
  b.*p = 42;                  // <- 2
}

因为 &Derived::m 产生一个 int Base::* 值。如果它产生一个 int Derived::* 值，代码将在第 1 行编译失败。如果我们尝试用

  int Derived::*p = &Derived::m; // <- 1

它将无法在第 2 行编译。使其编译的唯一方法是执行强制转换

  b.*static_cast<int Base::*>(p) = 42; // <- 2

这不好。

附:我同意，这不是一个非常有说服力的例子(“从一开始就使用 &Base:m 问题就解决了”)。但是，http://www.open-std.org/jtc1/sc22/wg21/docs/cwg_closed.html#203有更多信息可以解释为什么最初做出这样的决定。他们说

Notes from 04/00 meeting:

The rationale for the current treatment is to permit the widest possible use to be made of a given address-of-member expression. Since a pointer-to-base-member can be implicitly converted to a pointer-to-derived-member, making the type of the expression a pointer-to-base-member allows the result to initialize or be assigned to either a pointer-to-base-member or a pointer-to-derived-member. Accepting this proposal would allow only the latter use.

关于c++ - 在 C++11 中， protected 意味着公共(public)？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/16971897/