c++ - 这是关于成员(member)访问规则的正确总结吗？

Question

我正在尝试完全理解 [class.access] 的多个段落中定义的成员访问规则C++ 标准的部分。他们相当complex or even confusing因此我需要一个简短但准确且详尽的总结。

我编译这个程序是为了测试 protected 成员在几种情况下的可访问性(因为 protected 成员的规则是最复杂的):¹

#include <iostream>

class B {
  protected:
    int i = 1;
    static int const I = 1;
};

class X: public B {
  protected:
    int j = 2;
    static int const J = 2;
  public:
    void f();
    friend void g();
};

class D: public X {
  protected:
    int k = 3;
    static int const K = 3;
};

void X::f() {
  B b;
  X x;
  D d;
  //std::cout << b.i;  // error: 'i' is a protected member of 'B'
  std::cout << b.I;
  std::cout << x.i;
  std::cout << x.I;
  std::cout << x.j;
  std::cout << x.J;
  std::cout << d.i;
  std::cout << d.I;
  std::cout << d.j;
  std::cout << d.J;
  //std::cout << d.k;  // error: 'k' is a protected member of 'D'
  //std::cout << d.K;  // error: 'K' is a protected member of 'D'
}

void g() {
  B b;
  X x;
  D d;
  //std::cout << b.i;  // error: 'i' is a protected member of 'B'
  //std::cout << b.I;  // error: 'I' is a protected member of 'B'
  std::cout << x.i;
  std::cout << x.I;
  std::cout << x.j;
  std::cout << x.J;
  std::cout << d.i;
  std::cout << d.I;
  std::cout << d.j;
  std::cout << d.J;
  //std::cout << d.k;  // error: 'k' is a protected member of 'D'
  //std::cout << d.K;  // error: 'K' is a protected member of 'D'
}

int main() {
  B b;
  X x;
  D d;
  //std::cout << b.i;  // error: 'i' is a protected member of 'B'
  //std::cout << b.I;  // error: 'I' is a protected member of 'B'
  //std::cout << x.i;  // error: 'i' is a protected member of 'B'
  //std::cout << x.I;  // error: 'I' is a protected member of 'B'
  //std::cout << x.j;  // error: 'j' is a protected member of 'X'
  //std::cout << x.J;  // error: 'J' is a protected member of 'X'
  //std::cout << d.i;  // error: 'i' is a protected member of 'B'
  //std::cout << d.I;  // error: 'I' is a protected member of 'B'
  //std::cout << d.j;  // error: 'j' is a protected member of 'X'
  //std::cout << d.J;  // error: 'J' is a protected member of 'X'
  //std::cout << d.k;  // error: 'k' is a protected member of 'D'
  //std::cout << d.K;  // error: 'K' is a protected member of 'D'
  return 0;
}

我对直接可访问性得出以下结论:²

• 任何实体都可以直接访问类的公共(public)成员(参见 [class.access/base-5.1] )；
• 类的私有(private)成员只能由该类的成员和好友直接访问(参见 [class.access/base-5.2] )；
• 某个类的 protected 成员只有该类的成员和 friend (参见 [class.access/base-5.3] )、基类的成员和 friend 才能直接访问如果这些 protected 成员继承自这些基类或这些基类的基类(参见 [class.access/base-5.4] )，³ 以及派生类的成员如果这些 protected 成员不是非静态数据成员，也不是非静态成员函数(参见 [class.access/base-5.3] )，则属于该类(参见 [class.access/class.protected-1] )。

我的总结正确吗？

<小时/>

¹ 我使用了 Clang 9.0.0 编译器和 C++ 17。

² 访问成员(member) i一个类B可以是直接的，即通过该类:b.i (直接访问)，或间接访问，即通过派生类 D该类别的:d.i (继承访问)。由于派生类继承的成员是该派生类的成员，但其可访问性发生了变化(参见 [class.access/base-1] )，因此对类成员的继承访问可以视为对该类的派生类的继承成员的直接访问类(class)。换句话说，只需要考虑直接访问。

³ 我的条款与标准[class.access/base-5.4]中引用的条款略有不同。 :

A member m is accessible at the point R when named in class N if

• …
• …
• …
• there exists a base class B of N that is accessible at R, and m is accessible at R when named in class B.

这是因为编译器的行为不同，我的感觉是编译器是正确的。我认为该标准的条款存在两个问题:

• 访问点 R 应仅限于 B 类的成员和友元(编译器通过在程序中 d.* 中的 main 访问引发错误来执行此操作)；
• 类 N 中的成员 m 应限制为从类 B 继承，而不是被类 N 覆盖(编译器会通过引发 d.i 、 d.I 、 d.j 的错误来完成此操作， d.J 和 X::f 中的 g 访问，已在程序中的 i 中覆盖 I 、 j 、 J 和 D 。

Answer 1

如果您的问题基于访问，这些是 C++ 中的规则。我将在下面做一个基本的总结，但要获得详尽的解释，请访问 here 。这将更详细地介绍每种方法的工作原理。

public
A public member of a class is accessible anywhere

protected
1. to the members and friends of that class
2. to the members and friends (until C++17) of any derived class of that class, but only when the class of the object through which the protected member is accessed is that derived class or a derived class of that derived class

private
A private member of a class is only accessible to the members and friends of that class, regardless of whether the members are on the same or different instances

要查看示例，请访问上面的链接。

对于嵌套类，您位于基类的范围内，因此可以访问私有(private)和 protected 成员。如果成员是静态的，您将能够直接访问，否则必须构造该类的对象才能访问该类中的这些成员。以下是上面 class X 的示例:

class X: public B {
public:
    class A {
    public:
        void b() {
            std::cout << J << std::endl;
            std::cout << S << std::endl;
        }
        void d(X x) {
            std::cout << x.j << std::endl;
            std::cout << x.s << std::endl;
        }
    };

    void f();

protected:
    int j = 2;
    static int const J = 2;
private:
    friend void g();
    int s = 3;
    static int const S = 4;
};

以下是使用公共(public)、 protected 和私有(private)进行继承时的含义

public
When a class uses public member access specifier to derive from a base, all public members of the base class are accessible as public members of the derived class and all protected members of the base class are accessible as protected members of the derived class (private members of the base are never accessible unless friended)

protected
When a class uses protected member access specifier to derive from a base, all public and protected members of the base class are accessible as protected members of the derived class (private members of the base are never accessible unless friended)
private
When a class uses private member access specifier to derive from a base, all public and protected members of the base class are accessible as private members of the derived class (private members of the base are never accessible unless friended).

注意:派生类继承基类的所有方法，但以下异常(exception)。

• 基类的构造函数、析构函数和复制构造函数

• 重载的运算符(例如基类)——这些运算符可能不会按您的预期运行，并且应该以您为每个类的每个运算符重写的方式实现。

• 基类的友元函数。

现在至于 friend 说明符，这来自 cpp 引用 here在这里您将获得有关如何使用它的示例和详细说明。

您还可以在那里找到有关标准库的大量信息的示例，您还可以了解 future 标准的内容以及您的编译器支持哪些功能。