C++成员函数的重载，继承，覆盖和隐藏 - 文章 - 伯乐在线
& C++成员函数的重载，继承，覆盖和隐藏
一、 C++成员函数的重载
C++中的成员函数有四种，分别是普通成员函数，virtual虚函数，const成员函数。
(1) void func(int a);
(2) virtual void func(int a);
(3) void func(int a)
如果在一个类中，声明这四种函数，哪是重复定义？哪些是重载？
其中(1)(2)是重复定义，故编译不能通过，而(3)与(1)(2)是不同类型的函数，是重载。
成员函数被重载的特征是：
(1)具有相同的作用域(即同一个类定义中)；
(2)函数名字相同
(3)参数类型，顺序 或 数目不同(包括const参数和非const函数)
(4)virtual关键字可有可无。
从成员函数的重载特征中，可以知道(1)(2)是重复定义。那么(3)为什么和(1)(2)不同呢？
因为类中的函数，都会自动添加一个自身类指针this，所以
void func(int a) ==== void func(Base * this, int a)
virtual func(int a) ==== virtual func(Base *this, int a)
void func(int a)const === void func(const Base *this, int a) const
所以(3)可以与(1)(2)发生重载，因为参数有一个const。
二 、C++成员函数的继承
#include &iostream&
class Base {
void f(int a){
cout && "Base::f(int a)" &&
virtual void g(int a) {
cout && "virtual Base::g(int a)" &&
class Derived : public Base
void h(int a) {
cout && "Derivd::h(int a)" &&
int main()
#include &iostream&
class Base {
void f(int a){
cout && "Base::f(int a)" &&
virtual void g(int a) {
cout && "virtual Base::g(int a)" &&
class Derived : public Base
void h(int a) {
cout && "Derivd::h(int a)" &&
int main()
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869
#include &iostream& using namespace std;
class Base { public: &&&&void f(int a){ &&&&&&&&cout && "Base::f(int a)" && endl; &&&&} &&&&virtual void g(int a) { &&&&&&&&cout && "virtual Base::g(int a)" && endl; &&&&} };
class Derived : public Base { public: &&&&void h(int a) { &&&&&&&&cout && "Derivd::h(int a)" && endl; &&&&} };
int main() { &&&&Base b; &&&&b.f(3); &&&&b.g(4);
&&&&Derived d; &&&&d.f(3); &&&&d.g(4); &&&&d.h(3); } &#include &iostream&using namespace std;&class Base {public: void f(int a){&&cout && "Base::f(int a)" && endl; } virtual void g(int a) {&&cout && "virtual Base::g(int a)" && endl; }};&class Derived : public Base{public: void h(int a) {&&cout && "Derivd::h(int a)" && endl; }};&&int main(){ Base b; b.f(3); b.g(4);&& Derived d; d.f(3); d.g(4); d.h(3);}
Base b的对象模型：
Derived d的对象模型：
则在子类Derived d中继承了父类中的virtual void g(int a) ; void f(int a);
运行结果为：
三、C++成员函数的覆盖
覆盖是指派生类重新实现(或者改写)了基类的成员函数，其特征是：
(1)不同的作用域(非别位于派生类和基类中)；
(2)函数名称相同
(3)参数列表完全相同；
(4)基类函数必须是虚函数。
从(4)中我们得知覆盖只是针对虚函数的。
#include &iostream&
class Base {
void f(int a){
cout && "Base::f(int a)" &&
virtual void g(int a) {
cout && "virtual Base::g(int a)" &&
class Derived : public Base
void h(int a) {
cout && "Derivd::h(int a)" &&
virtual void g(int a) {
cout && "virtual Derived::g(int a)" &&
int main()
#include &iostream&
class Base {
void f(int a){
cout && "Base::f(int a)" &&
virtual void g(int a) {
cout && "virtual Base::g(int a)" &&
class Derived : public Base
void h(int a) {
cout && "Derivd::h(int a)" &&
virtual void g(int a) {
cout && "virtual Derived::g(int a)" &&
int main()
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071
#include &iostream& using namespace std;
class Base { public: &&&&void f(int a){ &&&&&&&&cout && "Base::f(int a)" && endl; &&&&} &&&&virtual void g(int a) { &&&&&&&&cout && "virtual Base::g(int a)" && endl; &&&&} };
class Derived : public Base { public: &&&&void h(int a) { &&&&&&&&cout && "Derivd::h(int a)" && endl; &&&&} &&&&virtual void g(int a) { &&&&&&&&cout && "virtual Derived::g(int a)" && endl; &&&&} };
int main() { &&&&Base b; &&&&b.f(3); &&&&b.g(4);
&&&&Derived d; &&&&d.f(3); &&&&d.g(4); &&&&d.h(3); } &#include &iostream&using namespace std;&class Base {public: void f(int a){&&cout && "Base::f(int a)" && endl; } virtual void g(int a) {&&cout && "virtual Base::g(int a)" && endl; }};&class Derived : public Base{public: void h(int a) {&&cout && "Derivd::h(int a)" && endl; } virtual void g(int a) {&&cout && "virtual Derived::g(int a)" && endl; }};&int main(){ Base b; b.f(3); b.g(4);& Derived d; d.f(3); d.g(4); d.h(3);}
Derived d对象模型如下：
其中Derived中重新定义了基类的虚成员函数virtual void g(int a)；
四、C++成员函数的隐藏
隐藏是指派生类的成员函数遮蔽了与其同名的基类成员函数，具体规则如下：
(1) 派生类的函数与基类的函数同名，但是参数列表有所差异。此时，不论有无virtual关键字，基类的函数在派生类中将被隐藏。(注意别与重载混合)
(2)派生类的函数与基类的函数同名，参数列表也相同，但是基类函数没有virtual关键字。此时，基类的函数在派生类中将被吟唱。(注意别与覆盖混合)
判断下面哪些函数是覆盖，哪些函数是隐藏？
#include &iostream&
class Base {
virtual void f(float x) {
cout && "virtual Base::f(float) " && x &&
void g(float x) {
cout && "Base::g(float) " && x &&
void h(float x) {
cout && "Base::h(float) " && x &&
class Derived : public Base{
virtual void f(float x) {
cout && "virtual Derived::f(float) " && x &&
void g(int x) {
cout && "Derived::g(int) " && x &&
void h(float x) {
cout && "Derived::h(float) " && x &&
int main(void)
Base *pb = &d;
Derived *pd = &d;
pb-&f(3.14f);
pd-&f(3.14f);
pb-&g(3.14f);
pd-&g(3.14f);
pb-&h(3.14f);
pd-&h(3.14f);
#include &iostream&
class Base {
virtual void f(float x) {
cout && "virtual Base::f(float) " && x &&
void g(float x) {
cout && "Base::g(float) " && x &&
void h(float x) {
cout && "Base::h(float) " && x &&
class Derived : public Base{
virtual void f(float x) {
cout && "virtual Derived::f(float) " && x &&
void g(int x) {
cout && "Derived::g(int) " && x &&
void h(float x) {
cout && "Derived::h(float) " && x &&
int main(void)
Base *pb = &d;
Derived *pd = &d;
pb-&f(3.14f);
pd-&f(3.14f);
pb-&g(3.14f);
pd-&g(3.14f);
pb-&h(3.14f);
pd-&h(3.14f);
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889
#include &iostream& using namespace std;
class Base { public: &&&&virtual void f(float x) { &&&&&&&&cout && "virtual Base::f(float) " && x && endl; &&&&} &&&&void g(float x) { &&&&&&&&cout && "Base::g(float) " && x && endl; &&&&} &&&&void h(float x) { &&&&&&&&cout && "Base::h(float) " && x && endl; &&&&} };
class Derived : public Base{ public: &&&&virtual void f(float x) { &&&&&&&&cout && "virtual Derived::f(float) " && x && endl; &&&&} &&&&void g(int x) { &&&&&&&&cout && "Derived::g(int) " && x && endl; &&&&} &&&&void h(float x) { &&&&&&&&cout && "Derived::h(float) " && x && endl; &&&&} };
int main(void) { &&&&Derived d; &&&&Base *pb = &d; &&&&Derived *pd = &d;
&&&&pb-&f(3.14f); &&&&pd-&f(3.14f);
&&&&pb-&g(3.14f); &&&&pd-&g(3.14f);
&&&&pb-&h(3.14f); &&&&pd-&h(3.14f); } &#include &iostream&using namespace std;&class Base {public: virtual void f(float x) {&&cout && "virtual Base::f(float) " && x && endl; } void g(float x) {&&cout && "Base::g(float) " && x && endl; } void h(float x) {&&cout && "Base::h(float) " && x && endl; }};&class Derived : public Base{public: virtual void f(float x) {&&cout && "virtual Derived::f(float) " && x && endl; } void g(int x) {&&cout && "Derived::g(int) " && x && endl; } void h(float x) {&&cout && "Derived::h(float) " && x && endl; }};&int main(void){ Derived d; Base *pb = &d; Derived *pd = &d;& pb-&f(3.14f); pd-&f(3.14f);& pb-&g(3.14f); pd-&g(3.14f);& pb-&h(3.14f); pd-&h(3.14f);}
其中子类Derived中 vitual void f(float x)
是覆盖，而void g(int x) 和void h(float x)都是隐藏。
运行结果：
再看一个例子：
#include &iostream&
class Base
virtual void f(int a) {
cout && "virtual Base::f(int a)" &&
void f(double d) {
cout && "Base::f(double d)" &&
class Derived : public Base
void f(double d) {
cout && "Derivd::f(double d)" &&
int main()
Derived *pd = new Derived();
pd-&f(2.5);
Base *pBase = new Derived();
pBase-&f(5);
pBase-&f(3.5);
#include &iostream&
class Base
virtual void f(int a) {
cout && "virtual Base::f(int a)" &&
void f(double d) {
cout && "Base::f(double d)" &&
class Derived : public Base
void f(double d) {
cout && "Derivd::f(double d)" &&
int main()
Derived *pd = new Derived();
pd-&f(2.5);
Base *pBase = new Derived();
pBase-&f(5);
pBase-&f(3.5);
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
#include &iostream& using namespace std;
class Base { public: &&&&virtual void f(int a) { &&&&&&&&cout && "virtual Base::f(int a)" && endl; &&&&}
&&&&void f(double d) { &&&&&&&&cout && "Base::f(double d)" && endl;&&&&&&} };
class Derived : public Base { public:
&&&&void f(double d) { &&&&&&&&cout && "Derivd::f(double d)" && endl; &&&&} };
int main() { &&&&Derived d; &&&&d.f(3); &&&&d.f(2.5);
&&&&Derived *pd = new Derived(); &&&&pd-&f(3); &&&&pd-&f(2.5);
&&&&Base b; &&&&b.f(5); &&&&b.f(3.5);
&&&&Base *pBase = new Derived(); &&&&pBase-&f(5); &&&&pBase-&f(3.5); } &#include &iostream&using namespace std;&class Base{public: virtual void f(int a) {&&cout && "virtual Base::f(int a)" && endl; }& void f(double d) {&&cout && "Base::f(double d)" && endl; }};&class Derived : public Base{public:& void f(double d) {&&cout && "Derivd::f(double d)" && endl; }};&int main(){ Derived d; d.f(3); d.f(2.5);& Derived *pd = new Derived(); pd-&f(3); pd-&f(2.5);& Base b; b.f(5); b.f(3.5);& Base *pBase = new Derived(); pBase-&f(5); pBase-&f(3.5);}
其中父类中的void f(double d)隐藏了子类的virtual void f(int a),
void f(double d)函数。
所以在主函数中
Derived *pd = new Derived();
pd-&f(2.5);
Derived *pd = new Derived();
pd-&f(2.5);只要通过Derived对象或者Derived指针执行f()函数，都只执行void Derived::f(double d)该函数。
Base *pBase = new Derived();
pBase-&f(5);
pBase-&f(3.5);
Base *pBase = new Derived();
pBase-&f(5);
pBase-&f(3.5);
12345678910111213141516171819202122232425
Derived d; d.f(3); d.f(2.5);
Derived *pd = new Derived(); pd-&f(3); pd-&f(2.5); &Derived d;d.f(3);d.f(2.5);&Derived *pd = new Derived();pd-&f(3);pd-&f(2.5);只要通过Derived对象或者Derived指针执行f()函数，都只执行void Derived::f(double d)该函数。&&[html]Base *pBase = new Derived(); pBase-&f(5); pBase-&f(3.5); &Base *pBase = new Derived();pBase-&f(5);pBase-&f(3.5);
在调用pBase-&f(5)时，首先要去pBase类中找到对应需要执行的函数，因为Base类中有两个函数virtual void f(int a) 和 void f(double)重载，因为该实参是5，为int类型，所以要调用virtual void f(int a)函数，因为该f(int a)是一个虚函数，所以再去判断pBase所指向的具体对象，具体对象为Derived子类，再去Derived子类的虚函数表中找到void f(int a)函数。因为Derived子类继承了父类Base的虚函数vitural void f(int a)，所以输出 virtual Base::f(int a);
在调用pBase-&f(3.5)时，首先要去pBase类中找到对应需要执行的函数，因为因为Base类中有两个函数virtual void f(int a) 和 void f(double)重载，因为该实参是3.5，为double类，所以要调用void f(double d)函数，因为该函数是一个普通成员函数，故直接输出。 void Base::f(double d);
再举一个例子：
#include &iostream&
class Base
virtual void f(int a) {
cout && "virtual Base::f(int a)" &&
void f(double d) {
cout && "Base::f(double d)" &&
class Derived : public Base
void f(int a) {
cout && "virtual Derived::f(int a)" &&
int main()
Derived *pd = new Derived();
pd-&f(2.5);
Base *pBase = new Derived();
pBase-&f(5);
pBase-&f(3.5);
#include &iostream&
class Base
virtual void f(int a) {
cout && "virtual Base::f(int a)" &&
void f(double d) {
cout && "Base::f(double d)" &&
class Derived : public Base
void f(int a) {
cout && "virtual Derived::f(int a)" &&
int main()
Derived *pd = new Derived();
pd-&f(2.5);
Base *pBase = new Derived();
pBase-&f(5);
pBase-&f(3.5);
12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485
#include &iostream& using namespace std;
class Base { public: &&&&virtual void f(int a) { &&&&&&&&cout && "virtual Base::f(int a)" && endl; &&&&}
&&&&void f(double d) { &&&&&&&&cout && "Base::f(double d)" && endl;&&&&&&} };
class Derived : public Base { public:
&&&&void f(int a) { &&&&&&&&cout && "virtual Derived::f(int a)" && endl; &&&&} };
int main() { &&&&Derived d; &&&&d.f(3); &&&&d.f(2.5);
&&&&Derived *pd = new Derived(); &&&&pd-&f(3); &&&&pd-&f(2.5);
&&&&Base b; &&&&b.f(5); &&&&b.f(3.5);
&&&&Base *pBase = new Derived(); &&&&pBase-&f(5); &&&&pBase-&f(3.5); } &#include &iostream&using namespace std;&class Base{public: virtual void f(int a) {&&cout && "virtual Base::f(int a)" && endl; }& void f(double d) {&&cout && "Base::f(double d)" && endl; }};&class Derived : public Base{public:& void f(int a) {&&cout && "virtual Derived::f(int a)" && endl; }};&int main(){ Derived d; d.f(3); d.f(2.5);& Derived *pd = new Derived(); pd-&f(3); pd-&f(2.5);& Base b; b.f(5); b.f(3.5);& Base *pBase = new Derived(); pBase-&f(5); pBase-&f(3.5);}
子类Derived中的void f(int a)既覆盖了基类Base的虚函数virtual void f(int a)，也隐藏了基类的virtual void f(int a),
void f(double d)函数。
Derived *pd = new Derived();
pd-&f(2.5);
Derived *pd = new Derived();
pd-&f(2.5);
123456789101112131415
Derived d; d.f(3); d.f(2.5);
Derived *pd = new Derived(); pd-&f(3); pd-&f(2.5); &Derived d;d.f(3);d.f(2.5);&Derived *pd = new Derived();pd-&f(3);pd-&f(2.5);
同理所有用子类对象或者子类指针来调用f()函数时，都只执行virtual void f(int a)，输出virtual Derived::f(int a)
view plaincopyprint?Base *pBase = new Derived();
pBase-&f(5);
pBase-&f(3.5);
Base *pBase = new Derived();
pBase-&f(5);
pBase-&f(3.5);
view plaincopyprint?Base *pBase = new Derived(); pBase-&f(5); pBase-&f(3.5); &Base *pBase = new Derived();pBase-&f(5);pBase-&f(3.5);
pBase-&f(5)，首先去Base类中寻找相应的函数，同理Base类中的两个函数virtual void f(int a)和void f(double d)是重载函数，因为实参为5,为int类型，所以我们要调用virtual void f(int a)虚函数，因为该函数是虚函数，所以要去判断pBase指向的具体对象，因为pBase指向的是一个子类的对象，所以需要去子类的虚函数表中取找virtual void f(int a)函数，找到之后，执行该函数，故输出virtual Derived::f(int a)。
pBase-&f(3.5),首先去Base类中寻找相应的函数，同理Base类中的两个函数virtual void f(int a)和void f(double d)是重载函数，因为实参为3.5,为double类型，所以我们要调用void f(double d)，因为该函数为普通成员函数，故执行输出： void Base::f(double d);
可能感兴趣的话题
关于伯乐在线博客
在这个信息爆炸的时代，人们已然被大量、快速并且简短的信息所包围。然而，我们相信：过多“快餐”式的阅读只会令人“虚胖”，缺乏实质的内涵。伯乐在线内容团队正试图以我们微薄的力量，把优秀的原创文章和译文分享给读者，为“快餐”添加一些“营养”元素。
新浪微博：
推荐微信号
（加好友请注明来意）
– 好的话题、有启发的回复、值得信赖的圈子
– 分享和发现有价值的内容与观点
– 为IT单身男女服务的征婚传播平台
– 优秀的工具资源导航
– 翻译传播优秀的外文文章
– 国内外的精选文章
– UI,网页，交互和用户体验
– 专注iOS技术分享
– 专注Android技术分享
– JavaScript, HTML5, CSS
– 专注Java技术分享
– 专注Python技术分享
& 2018 伯乐在线博客访问： 271495
博文数量： 118
博客积分： 5157
博客等级： 大校
技术积分： 1570
注册时间：
分类： C/C++ 12:00:43
C++支持多继承，给我们带来方便的同时，也带来了使用上的困惑，如：
&A() {printf("A\n");}
class AA : public A
&AA() {printf("AA\n");}
class&AB : public A
&AB() {printf("AB\n");}
class C : public AB,AA
&C() {printf("C\n");}
这种情况下，创建C的对象，会导致基类A的构造函数被重复调用。
解决办法：使用虚基类
典型的需要用虚基类的情况如下： &&&&&&&&&&&&A &&&&&&&&&&&/&\ &&&&&&&&&&B&&&C &&&&&&&&&&&\&/ &&&&&&&&&&&&D 其中D继承自BC,BC分别继承自A,所以A要分别被BC虚拟继承 程序嘛………… class&A&{ &&public: &&&&void&printA()&{cout<<"this&is&A\n";} }; class&B:virtual&public&A; class&C:virtual&public&A; class&D:public&B,public&C; 这样在D构造出来后，它的存储区域中只有一个A，不会有二义性问题 比如：D&d=new&D; 此时若使用D.printA();不会有问题；但若B和C不是虚继承自A，就会有二义性问题
阅读(1074) | 评论(0) | 转发(0) |
给主人留下些什么吧！~~
请登录后评论。在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。
问题对人有帮助，内容完整，我也想知道答案
问题没有实际价值，缺少关键内容，没有改进余地
请教一下类的继承（虚继承和模板继承）导致内存变化的问题。
面试题一：假设现在有个基类叫Student学生，又有个派生类叫Graduate研究生（它比基类多了一个叫pay的成员，因为研究生一般有点工资）：
class Student
protected: //派生类可以访问protected成员
　Student(int n, string m, float s) //构造函数
　void display() {} //一般函数
class Graduate: public Student //声明public继承
Student(int n, string m, float s, float p) //这样的构造函数正确吗？
Graduate(int n, string m, float s, float p): Student(n,m,s), pay(p) {} //这样的构造函数正确吗？
void display() {} //一般函数
int main()
Student stud1(1001,"Zhang",87);
　Graduate grad1(2001,"Wang",98, 1000);
　Student *pt = &stud1; //定义指向基类对象的指针变量pt
　pt-&display();
　pt = &grad1; //pt改为指向派生类对象…… 但是真的可以这样改变指向吗？
　pt-&display(); //虽然pt指向派生类对象，但是运行结果没有派生类的数据成员pay！需要虚化。
问题1：构造函数Student(4个形参)和Graduate(依旧4个形参)的写法是否正确？
问题2：内存布局。基类Student比派生类Graduate少了一个叫pay的成员。那么是不是说，派生类Graduate的内存布局和基类Student一模一样，都是int n, string m, float s, void display()这样连续的内存挨在一起，只不过派生类Graduate多了一段由pay产生的内存？另外，函数void display()不同于int或者string等等数据成员，它又该占用多大内存呢？
问题3：虚函数的内存。为了解决上面的指针的问题，在Student类中声明display函数时，把函数void display()虚化成virtual void display()。那么是不是说，vtable这时候跳到了内存区间的第一位，内存布局从原来int n, string m, float s, void display()这样的布局，变成了虚化之后的vtable, int n, string m, float s这样的布局？vtable的内存是否已经包含了display()函数的内存呢？
面试题二：：
template &typename T& class Foo
Foo(T t): tVar(t) {}
class Foo_Derived: public Foo&std::string& {};
int main()
Foo_Derived class_d; return 1;
问题4：请问这个对于模板的继承，哪里错了？应该怎么改呢？
我在书上真没看到太多相关知识。恳请大家指点。谢谢了先！
答案对人有帮助，有参考价值
答案没帮助，是错误的答案，答非所问
Student(int n, string m, float s, float p) //这样的构造函数正确吗？
这行是干嘛的？可以删掉.
Graduate(int n, string m, float s, float p): Student(n,m,s), pay(p) {} //这样的构造函数正确吗？
pt = &grad1; //pt改为指向派生类对象…… 但是真的可以这样改变指向吗？
如果想要支持多态(即pt-&display()调用的是对象grad1的结果)，需要对函数进行虚化.+virtual
内存布局。基类Student比派生类Graduate少了一个叫pay的成员。那么是不是说，派生类Graduate的内存布局和基类Student一模一样，都是int n, string m, float s, void display()这样连续的内存挨在一起，只不过派生类Graduate多了一段由pay产生的内存？另外，函数void display()不同于int或者string等等数据成员，它又该占用多大内存呢？
这块的理解是不对的，成员函数不占用类实例的空间.
问题4：请问这个对于模板的继承，哪里错了？应该怎么改呢？
你定义的这个类对象 Foo_Derived 构造函数是需要入参. 你提供个空的构造函数，或者把当前的构造函数删了都行.
分享到微博？
关闭理由：
删除理由：
忽略理由：
推广（招聘、广告、SEO 等）方面的内容
与已有问题重复（请编辑该提问指向已有相同问题）
答非所问，不符合答题要求
宜作评论而非答案
带有人身攻击、辱骂、仇恨等违反条款的内容
无法获得确切结果的问题
非开发直接相关的问题
非技术提问的讨论型问题
其他原因（请补充说明）
我要该，理由是：
在 SegmentFault，学习技能、解决问题
每个月，我们帮助 1000 万的开发者解决各种各样的技术问题。并助力他们在技术能力、职业生涯、影响力上获得提升。面向对象程序设计中最重要的一个概念是继承。继承允许我们依据另一个类来定义一个类，这使得创建和维护一个应用程序变得更容易。这样做，也达到了重用代码功能和提高执行时间的效果。
当创建一个类时，您不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。这个已有的类称为基类，新建的类称为派生类。
继承代表了 is a 关系。例如，哺乳动物是动物，狗是哺乳动物，因此，狗是动物，等等。
一个类可以派生自多个类，这意味着，它可以从多个基类继承数据和函数。定义一个派生类，我们使用一个类派生列表来指定基类。类派生列表以一个或多个基类命名，形式如下：
class derived-class: access-specifier base-class
其中，访问修饰符 access-specifier 是 public、protected 或 private 其中的一个，base-class 是之前定义过的某个类的名称。如果未使用访问修饰符 access-specifier，则默认为 private。
假设有一个基类 Shape，Rectangle 是它的派生类，如下所示：
#include &iostream&
using namespace std;
class Shape
void setWidth(int w)
width = w;
void setHeight(int h)
height = h;
protected:
int width;
int height;
class Rectangle: public Shape
int getArea()
return (width * height);
int main(void)
Rectangle Rect;
Rect.setWidth(5);
Rect.setHeight(7);
cout && &Total area: & && Rect.getArea() && endl;
当上面的代码被编译和执行时，它会产生下列结果：
Total area: 35
派生类可以访问基类中所有的非私有成员。因此基类成员如果不想被派生类的成员函数访问，则应在基类中声明为 private。
我们可以根据访问权限总结出不同的访问类型，如下所示：
访问publicprotectedprivate
同一个类yesyesyes
派生类yesyesno
外部的类yesnono
一个派生类继承了所有的基类方法，但下列情况除外：
基类的构造函数、析构函数和拷贝构造函数。
基类的重载运算符。
基类的友元函数。
当一个类派生自基类，该基类可以被继承为 public、protected 或
private 几种类型。继承类型是通过上面讲解的访问修饰符 access-specifier 来指定的。
我们几乎不使用 protected 或
private 继承，通常使用 public 继承。当使用不同类型的继承时，遵循以下几个规则：
公有继承（public）：当一个类派生自公有基类时，基类的公有成员也是派生类的公有成员，基类的保护成员也是派生类的保护成员，基类的私有成员不能直接被派生类访问，但是可以通过调用基类的公有和保护成员来访问。
保护继承（protected）： 当一个类派生自保护基类时，基类的公有和保护成员将成为派生类的保护成员。
私有继承（private）：当一个类派生自私有基类时，基类的公有和保护成员将成为派生类的私有成员。
多继承即一个子类可以有多个父类，它继承了多个父类的特性。
C++ 类可以从多个类继承成员，语法如下：
class &派生类名&:&继承方式1&&基类名1&,&继承方式2&&基类名2&,&
&派生类类体&
其中，访问修饰符继承方式是 public、protected 或 private 其中的一个，用来修饰每个基类，各个基类之间用逗号分隔，如上所示。现在让我们一起看看下面的实例：
#include &iostream&
using namespace std;
class Shape
void setWidth(int w)
width = w;
void setHeight(int h)
height = h;
protected:
int width;
int height;
class PaintCost
int getCost(int area)
return area * 70;
class Rectangle: public Shape, public PaintCost
int getArea()
return (width * height);
int main(void)
Rectangle Rect;
Rect.setWidth(5);
Rect.setHeight(7);
area = Rect.getArea();
cout && &Total area: & && Rect.getArea() && endl;
cout && &Total paint cost: $& && Rect.getCost(area) && endl;
当上面的代码被编译和执行时，它会产生下列结果：
Total area: 35
Total paint cost: $2450
9个月前 (08-15)
感谢您的支持，我会继续努力的!
扫码打赏，你说多少就多少
记住登录状态
重复输入密码