C++ 公共、保护和私有继承
提示
- 继承访问模式:在C++继承中,可以使用
public
、protected
和private
关键字以不同的访问模式从基类派生子类。这些关键字被称为访问指定符。 - 不同继承对成员访问的影响:
public
继承使基类的public
成员在派生类中仍为public
,protected
成员仍为protected
。protected
继承使基类的public
和protected
成员在派生类中均变为protected
。private
继承则使基类的public
和protected
成员在派生类中均变为private
。 - 访问控制和成员覆盖:基类的
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 成员 |
---|---|---|---|
基类 | 是 | 是 |