C++继承中成员函数的访问

Question

我只是对下面关于继承的小程序感到困惑：

#include<iostream>
using namespace std;

struct B {
    virtual int f() { return 1; }
}; // f is public in B

class D : public B { 
    int f() { return 2; }
}; // f is private in D

int main()
{
    D d;
    B& b = d;
    cout<<b.f()<<endl; // OK: B::f() is public, D::f() is invoked even though it's private
    cout<<d.f()<<endl; // error: D::f() is private
}

1. 我不明白为什么D::f() 是私有的，D 是从B 继承的，所以B 中的公共函数f
   在D也是公开的（我知道没有继承，成员访问默认是私有的）
2. f是B中的一个虚函数，所以如果我们调用b.f()，我们实际上是调用D::f()，但是就像上面的插图，为什么D::f()是私有的，也能被调用？李>

谁能详细解释一下简单的继承问题？

Answer 1

这与虚拟调度是一个运行时概念有关。 B 类不关心哪个类扩展了它，也不关心它是私有的还是公共的，因为它不知道。

我不明白为什么 D::f() 是私有的，D 是从 B 继承的公共函数，所以 B 中的公共函数 f 在 D 中也是公共的（我知道没有继承，成员访问默认是私有的）

D::f() 是私有的，因为您将其设为私有。此规则不受继承和虚拟调度的影响。

f是B中的虚函数，所以如果我们调用bf()，我们实际上是调用了D::f()，但是正如上面的插图，为什么D::f()即使被调用也能被调用是私人的吗？

因为实际上，在调用b.f() 时，编译器并不知道实际调用的是哪个函数。它将简单地调用函数f()，并且由于B::f 是虚拟的，因此将在运行时 选择被调用的函数。运行时程序没有关于哪个函数是私有或受保护的信息。它只知道函数。

如果函数是在运行时选择的，编译器在编译时无法知道将调用哪个函数，也无法知道访问说明符。事实上，编译器甚至不会尝试检查调用的函数是否是私有的。访问说明符可能存在于编译器尚未看到的某些代码中。

根据您的经验，您不能直接致电D::f。这正是 private 会做的：禁止成员的直接访问。但是，您可以通过指针或引用间接访问它。您使用的虚拟调度将在内部执行此操作。

Answer 2

为什么 D::f() 是私有的也能被调用？

要了解虚函数机制，最好了解它通常是如何实现的。运行时的函数实际上只不过是函数体的可执行代码所在的内存地址。要调用函数，我们需要知道它的地址（指针）。在内存中具有虚函数表示的 C++ 对象包含所谓的 vtable - 一个指向虚函数的指针数组。

关键是在派生类中vtable重复（并且可能扩展）基类的vtable，但是如果虚函数被覆盖，它的指针被替换在派生对象的vtable中。

当通过基类指针完成虚函数调用时，虚函数的地址被计算为vtable数组中的偏移量。不做其他检查，只取函数地址。 如果它是基类对象，它将是基类函数的地址。如果是派生类对象，就是派生类函数的地址，与是否声明为私有无关。

这就是它的工作原理。

Answer 3

这实际上与虚拟调度关系不大，而与访问说明符的含义有关。

函数本身不是private；它的名字是。

因此，函数不能在类范围之外命名，例如来自main。但是，您仍然可以通过 public 的名称（即被覆盖的基类的虚函数）或尽管有 private 限定符但可以访问函数名称的范围（例如该类的成员函数）来执行此操作)。

这就是它的工作原理。

Answer 4

C++ 标准有一个确切的例子：

11.5 访问虚函数 [class.access.virt]

1 虚函数的访问规则（第 11 条）由它的 声明并且不受稍后的函数规则的影响 覆盖它。 [例子：

class B { 
public:
  virtual int f();
};

class D : public B { 
private: 
  int f(); 
}; 

void f() { 
  D d; 
  B* pb = &d; 
  D* pd = &d; 
  pb->f();     // OK: B::f() is public, 
               // D::f() is invoked
  pd->f();     // error: D::f() is private
} 

-- 结束示例]

无法解释清楚。

Answer 5

struct 的成员默认为公开，class 的成员默认为私有。 所以 B 中的f() 是公共的，当它派生到 D 时，因为你没有明确声明它是公共的，所以根据派生规则，它变成了私有的。

Answer 6

访问说明符仅适用于函数名，它们对如何或何时可以通过其他方式调用函数没有任何限制。如果私有函数通过其名称以外的其他方式（例如，函数指针）可用，则可以在类外部调用它。

对于使用class 关键字声明的类，默认访问说明符是private。您的代码与以下内容相同：

// ...
class D: public B
{
private:
  int f() { return 2; }
};

如您所见，f 在D 中是私有的。访问说明符与B 中具有相同名称的任何函数无关。请记住，B::f() 和 D::f() 是两个不同的函数。

virtual 关键字的效果是，如果在引用 D 对象的 B 引用上调用不带范围限定符的 f()，那么即使它解析为 B::f()，实际上也是 @而是调用 987654335@。

这个过程仍然使用B::f()的访问说明符：在编译时检查访问；但调用哪个函数可能是运行时问题。

Answer 7

给出的答案说明了正在做什么，但你为什么要这样做，基类调用private 虚函数？

嗯，有一种称为template method pattern 的设计模式使用这种技术，即在派生类中拥有一个调用私有虚函数的基类。

struct B 
{
    virtual ~B() {};
    int do_some_algorithm()
    {
       do_step_1();
       do_step_2();
       do_step_3();
    }

    private:
          virtual void do_step_1() {}
          virtual void do_step_2() {}
          virtual void do_step_3() {}
};

class D : public B 
{ 
   void do_step_1() 
   {
      // custom implementation
   }
   void do_step_2() 
   {
      // custom implementation
   }

   void do_step_3() 
   {
      // custom implementation
   }
};

int main()
{
   D dInstance;
   B * pB = &dInstance;
   pB->do_some_algorithm();
}

这允许我们不将D 类的自定义步骤暴露给public 接口，但同时允许B 使用public 函数调用这些函数。