C++ 公共、保护和私有继承

提示

1. 继承访问模式：在C++继承中，可以使用public、protected和private关键字以不同的访问模式从基类派生子类。这些关键字被称为访问指定符。
2. 不同继承对成员访问的影响：public继承使基类的public成员在派生类中仍为public，protected成员仍为protected。protected继承使基类的public和protected成员在派生类中均变为protected。private继承则使基类的public和protected成员在派生类中均变为private。
3. 访问控制和成员覆盖：基类的private成员在派生类中始终不可访问。派生类可以通过重写成员函数来修改基类行为。派生类中的函数将覆盖基类中的同名函数。

在 C++ 继承 中，我们可以以不同的访问模式从基类派生子类。例如，

class Base {
.... ... ....
};

class Derived : public Base {
.... ... ....
};

注意代码中的关键字 public

class Derived : public Base

这意味着我们以公开模式从基类创建了派生类。另外，我们也可以以保护或私有模式派生类。

这三个关键字（public、protected 和 private）在 C++ 继承中被称为访问说明符。

C++ 中的 public、protected 和 private 继承

公开、保护和私有继承具有以下特点：

• 公开继承使基类的 public 成员在派生类中变为 public，基类的 protected 成员在派生类中保持 protected。
• 保护继承使基类的 public 和 protected 成员在派生类中都变为 protected。
• 私有继承使基类的 public 和 protected 成员在派生类中都变为 private。

注意：基类的 private 成员对派生类不可访问。

class Base {
 public:
 int x;
 protected:
 int y;
 private:
 int z;
};

class PublicDerived: public Base {
 // x 是公开的
 // y 是受保护的
 // z 从 PublicDerived 不可访问
};

class ProtectedDerived: protected Base {
 // x 是受保护的
 // y 是受保护的
 // z 从 ProtectedDerived 不可访问
};

class PrivateDerived: private Base {
 // x 是私有的
 // y 是私有的
 // z 从 PrivateDerived 不可访问
};

示例 1：C++ 公开继承

// C++ 程序演示公开继承的工作原理

#include <iostream>
using namespace std;

class Base {
 private:
 int pvt = 1;

 protected:
 int prot = 2;

 public:
 int pub = 3;

 // 函数访问私有成员
 int getPVT() {
 return pvt;
 }
};

class PublicDerived : public Base {
 public:
 // 函数访问 Base 的受保护成员
 int getProt() {
 return prot;
 }
};

int main() {
 PublicDerived object1;
 cout << "私有 = " << object1.getPVT() << endl;
 cout << "受保护 = " << object1.getProt() << endl;
 cout << "公开 = " << object1.pub << endl;
 return 0;
}

输出

Private = 1
Protected = 2
Public = 3

在这里，我们从 Base 类以公开模式派生出了 PublicDerived。

因此，在 PublicDerived 中：

• prot 被继承为 protected。
• pub 和 getPVT() 被继承为 public。
• pvt 是无法访问的，因为它在 Base 中是 private。

由于 private 和 protected 成员不能从 main() 中直接访问，我们需要创建公共函数 getPVT() 和 getProt() 来访问它们：

// 错误：成员 "Base::pvt" 是不可访问的
cout << "Private = " << object1.pvt;

// 错误：成员 "Base::prot" 是不可访问的
cout << "Protected = " << object1.prot;

请注意，getPVT() 函数在 Base 内定义。但 getProt() 函数是在 PublicDerived 内定义的。

这是因为在 Base 中作为 private 的 pvt 对 PublicDerived 来说是无法访问的。

然而，由于公开继承，prot 对 PublicDerived 是可访问的。因此，getProt() 可以从 PublicDerived 内部访问 protected 变量。

公开继承中的访问性

访问性	private 成员	protected 成员	public 成员
基类	是	是	是
派生类	否	是	是

示例 2：C++ protected 继承

// C++ 程序演示 protected 继承的工作原理

#include <iostream>
using namespace std;

class Base {
 private:
 int pvt = 1;

 protected:
 int prot = 2;

 public:
 int pub = 3;

 // 函数访问私有成员
 int getPVT() {
 return pvt;
 }
};

class ProtectedDerived : protected Base {
 public:
 // 函数访问 Base 中的 protected 成员
 int getProt() {
 return prot;
 }

 // 函数访问 Base 中的 public 成员
 int getPub() {
 return pub;
 }
};

int main() {
 ProtectedDerived object1;
 cout << "Private 无法访问。" << endl;
 cout << "Protected = " << object1.getProt() << endl;
 cout << "Public = " << object1.getPub() << endl;
 return 0;
}

输出

Private 无法访问。
Protected = 2
Public = 3

在这里，我们以保护模式从 Base 派生出了 ProtectedDerived。

因此，在 ProtectedDerived 中：

• prot、pub 和 getPVT() 被继承为 protected。
• pvt 是无法访问的，因为它在 Base 中是 private。

我们知道，protected 成员不能直接从类外部访问。因此，我们不能从 ProtectedDerived 中使用 getPVT()。

这也是为什么我们需要在 ProtectedDerived 中创建 getPub() 函数以访问 pub 变量。

// 错误：成员 "Base::getPVT()" 是不可访问的
cout << "Private = " << object1.getPVT();

// 错误：成员 "Base::pub" 是不可访问的
cout << "Public = " << object1.pub;

保护继承中的访问性

访问性	private 成员	protected 成员	public 成员
基类	是	是	是
派生类	否	是	是（作为 protected 变量继承）

示例 3：C++ private 继承

// C++ 程序演示 private 继承的工作原理

#include <iostream>
using namespace std;

class Base {
 private:
 int pvt = 1;

 protected:
 int prot

 = 2;

 public:
 int pub = 3;

 // 函数访问私有成员
 int getPVT() {
 return pvt;
 }
};

class PrivateDerived : private Base {
 public:
 // 函数访问 Base 中的 protected 成员
 int getProt() {
 return prot;
 }

 // 函数访问私有成员
 int getPub() {
 return pub;
 }
};

int main() {
 PrivateDerived object1;
 cout << "Private 无法访问。" << endl;
 cout << "Protected = " << object1.getProt() << endl;
 cout << "Public = " << object1.getPub() << endl;
 return 0;
}

输出

Private 无法访问。
Protected = 2
Public = 3

在这里，我们以私有模式从 Base 派生出了 PrivateDerived。

因此，在 PrivateDerived 中：

• prot、pub 和 getPVT() 被继承为 private。
• pvt 是无法访问的，因为它在 Base 中是 private。

我们知道，私有成员不能直接从类外部访问。因此，我们不能从 PrivateDerived 中使用 getPVT()。

这也是为什么我们需要在 PrivateDerived 中创建 getPub() 函数以访问 pub 变量。

// 错误：成员 "Base::getPVT()" 是不可访问的
cout << "Private = " << object1.getPVT();

// 错误：成员 "Base::pub" 是不可访问的
cout << "Public = " << object1.pub;

私有继承中的访问性

访问性	private 成员	protected 成员	public 成员
基类	是	是	是
派生类	否	是（作为 private 变量继承）	是（作为 private 变量继承）