朋友类对象可以访问派生类对象上的基类私有成员吗？

Question

我很惊讶下面的代码可以编译。

似乎与（公共继承的）基类友好的类可以访问基类的成员，前提是派生类的实例。

如果继承更改为private，则编译失败。

简而言之，d.b_var 在F::func(D& d) 内如何有效？

#include <iostream>
#include <string>
using namespace std;

class B{
    int b_var;
    friend class F;
};

class D: public B{
    int d_var;
};

class F{
    public:
        void func(D &d){
            d.b_var = 5; 
        }
};

int main()
{
    cout<<"fine";
}

Answer 1

D 在使用公共继承时是 B。所以访问b_var 仍然是完全合法的。
但是，如果您尝试访问d_var，则会收到错误消息，因为您似乎知道，友谊本身并没有被继承。

继承总是使基的所有成员成为派生的成员。访问说明符仅影响标识符可见的位置。这就是为什么非法访问私有成员会产生与访问不存在的标识符不同的错误。

Answer 2

你写：

似乎以某种方式继承了友谊，并且朋友类可以访问派生类的成员。

但它应该是：

似乎与（公共继承的）基类友好的类可以访问基类的私有成员，前提是派生类的实例。

或者：

似乎与另一个类成为朋友的类可以访问其实例的私有成员。

这与您的问题有关：

简而言之，d.b_var 在F::func(D& d) 内如何有效？

因为d.b_var 是 B 类实例的成员（通过多态性），F 类的实例可以访问该实例（通过朋友状态）。

这不适用于d.d_var，因为与基类的友谊不会被继承，因此类 F 的实例无法访问 d 的私有成员。

这不适用于私有（或受保护）继承，因为由此添加了另一个“访问限制层”。此外，您还需要授予对派生类的私有继承成员的访问权限（d.b_var 然后是）。例如，让 D 成为 F 的朋友。

供参考：

• http://en.cppreference.com/w/cpp/language/friend
• http://en.cppreference.com/w/cpp/language/derived_class

Answer 3

虽然已经有很好的答案，但我认为一些图片在这里也会有所帮助。

这是您的B 类的抽象。 F 可以访问其所有成员。

当您现在实例化 D 对象时，它看起来像这样

它仍然是 B 对象，但也是 D 对象。可以这么说，它扩展了B。 F 仍然可以从 B 访问该部分，因为它仍然存在，但不能从 D 访问。

请注意，这些抽象并没有真正显示内存中的布局并解释覆盖等。但它们只是为了这个问题。

Answer 4

1. 似乎以某种方式继承了友谊，并且朋友类可以访问派生类的成员。
   简而言之，d.b_var 在F::func(D& d) 内如何有效？

d.b_var 可能会产生误导。更准确地说（另一种看法），b_var 不是派生类D 的（直接）成员。相反，D 的对象包含基类B 的子对象，它有成员b_var，并且可以被朋友F 访问。 （我们也可以把d.b_var写成d.B::b_var。）

$10/3 Derived classes [class.derived]:

base-specifier-list 指定基类的类型 派生类类型的对象中包含的子对象。 [ 示例：

struct Base {
  int a, b, c;
};

struct Derived : Base {
  int b;
};

struct Derived2 : Derived {
  int c;
};

这里，Derived2 类的对象将有一个类的子对象 Derived 又将有一个 Base 类的子对象。 - 结尾 例子]

还有

1. 如果继承更改为private，则编译失败。

因为

class B {
    int b_var;
    friend class F;
};

class D: private B {
    int d_var;
};

class F{
public:
    void func(D &d) {
        d.b_var = 5;  // Fail. Can't access subobject of B
        d.d_var = 5;  // Fail. Can't access member of D
    }
};

然后

class B {
    int b_var;
};

class D: private B {
    friend class F;
    int d_var;
};

class F{
public:
    void func(D &d) {
        d.b_var = 5;  // Fail. Can't access b_var of subobject of B
        d.d_var = 5;  // Fine.
    }
};

请注意，在最后一种情况下，即使F 是类D 的朋友，它也可以访问D 的所有私有/受保护成员，但不包括子对象B 中的成员，因为它们不是（直接）类D的成员。

Answer 5

class D 的对象由 2 个独立的部分组成：

part containing members of B 
part containing members of D

这就是为什么我们这样做时对象切片的概念起作用的原因：

D objD;
B objB = objD;

现在我们可以通过objB 从object of class D 内部访问part containing members of B。编译器记住或可以区分class D 中的两个部分。所以编译器知道通过什么来访问什么。

friend class F; 内的 class B 语句只是告诉 member functions of class F 可以访问 class B 的 private, protected and public 成员。也就是说，对于member functions of class F，class B 的所有成员都是public。

实际上，在每个类中都包含三个可访问性部分：

public
protected
private 

所以当我们声明一些class B:

class B
{
    public:
        int a;
    protected:
        int b;
    public:
        int c;
};

然后在 B 类中创建以下 3 个部分，如上所示。

现在当我们声明一些class F 是friend 的class B 时：

class B
{
    friend class F;
    private:
        int a;
    protected:
        int b;
    public:
        int c;            
};

然后编译器创建如下部分：

class B
{
    friend class F;
    private:
        int a;
    protected:
        int b;
    public:
        int c;
        //int a;  only for member functions of class F
        //int b;  only for member functions of class F             
};

请注意，int a; 和 int b; 现在对于 member functions 的 class F 是公开的。

现在，当 class D 从 class B 派生出 publicly 时，class B 的 public 部分变为 class D 的 public 部分。同样，class B 的 protected 部分变为 class D 的 protected 部分。因此，class B 的public 部分可以通过class D 的对象访问。由于B::a; 和B::b; 在members functions of class F 的公共部分中，因此B::a 和B::b 可以通过class D 的对象访问。另请注意，虽然int a; 和int b; 派生后成为class D 的成员，但编译器仍然能够区分它们并将它们视为part of class B。

现在，当 class D 派生自 class B 的 privately 时，class B 的 public 部分将变为 class D 的 private 部分。同样，class B 的 protected 部分成为 class D 的受保护部分。因此，现在class B 内部的public 部分无法通过class D 的对象访问。回想一下，class B、B::a; 和 B::b; 最初在 members functions of class F 的公共部分，但在推导 private 之后，class B 的成员即 B::a 和 B::b 现在在class D。因此，B::a 和B::b 不能通过class D 的对象访问。另请注意，虽然在推导 int a; 和 int b; 之后成为 class D 的成员，但编译器仍然能够区分它们并将它们视为 part of class B。派生后class B的一些成员的可访问性和规则发生了变化。

由于这个问题在某种程度上与public, protected and private 推导的效果有关，因此为了完整性，请参阅： Why can a derived class not access a protected member of its base class through a pointer to base?