父与子亲密有间：子类对父类成员的访问权限
无论通过什么方式（public、protected、private）继承：
在子类内部均可访问父类中的public、protected成员，
private成员不可访问（如果想要子类能够访问，就定义为protected）
继承方式只影响外界通过子类对父类成员的访问权限。
public继承，父类成员的访问权限全部保留至子类；
protected继承，父类public成员的访问权限在子类中降至protected；
private继承，父类public、protected成员的访问权限在子类中均降至private。
世家的生而不同：子类的构造函数
class Son : public Father {
public:
// 在子类的构造函数中，显式调用父类的构造函数
Son(const char *name, int age, const char *game)
:Father(name, age) {
this->game = game;
}
// 没有显式的调用父类的构造函数，那么会自动调用父类的默认构造函数
Son(const char *name, const char *game){
this->game = game;
}
......
};
子类和父类的构造函数的调用顺序
当创建子类对象时, 构造函数的调用顺序：
静态数据成员的构造函数 -> 父类的构造函数 -> 非静态的数据成员的构造函数 -> 自己的构造函数
注意:
无论创建几个对象, 该类的静态成员只构建一次, 所以静态成员的构造函数只调用1次!!!
Demo
#include <iostream>
#include <Windows.h>
using namespace std;
class M {
public:
M() {
cout << __FUNCTION__ << endl;
}
};
class N {
public:
N() {
cout << __FUNCTION__ << endl;
}
};
class A {
public:
A() {
cout << __FUNCTION__ << endl;
}
};
class B : public A {
public:
B() {
cout << __FUNCTION__ << endl;
}
private:
M m1;
M m2;
static N ms;
};
N B::ms; //静态成员
int main(void) {
B b;
system("pause");
}
/*
执行结果：
N::N 静态数据成员的构造函数
A::A 父类的构造函数
M::M 非静态数据成员的构造函数
M::M 非静态数据成员的构造函数
B::B 自己的构造函数
*/
子类的析构函数
子类的析构函数的调用顺序，和子类的构造函数的调用顺序相反！！！
记住，相反即可。
Demo
#include <iostream>
#include <Windows.h>
using namespace std;
class M {
public:
M() {
cout << __FUNCTION__ << endl;
}
~M() {
cout << __FUNCTION__ << endl;
}
};
class N {
public:
N() {
cout << __FUNCTION__ << endl;
}
~N() {
cout << __FUNCTION__ << endl;
}
};
class A {
public:
A() {
cout << __FUNCTION__ << endl;
}
~A() {
cout << __FUNCTION__ << endl;
}
};
class B : public A {
public:
B() {
cout << __FUNCTION__ << endl;
}
~B() {
cout << __FUNCTION__ << endl;
}
private:
M m1;
M m2;
static N ms;
};
N B::ms; //静态成员
int main(void) {
{
B b;
cout << endl;
}
system("pause");
}
/*
执行结果：
N::N
A::A
M::M
M::M
B::B
B::~B
M::~M
M::~M
A::~A
静态对象在程序终止时被销毁，所以：
静态成员的析构函数，在程序结束前，是不会被调用的！
这里我们用system("pause");使程序暂停了所以看不到。
*/
花木兰替父从军：子类型关系
什么是子类型
公有继承时，派生类（子类）的对象可以作为基类（父类）的对象处理，派生类是基类的子类型。
当B类public继承A类时，此时B类就是A类的子类型.
#include <iostream>
using namespace std;
class A {
public:
A() {}
~A() {}
void kill() { cout << "A kill." << endl; }
};
class B : public A {
public:
B(){}
~B(){}
void kill() { cout << "B kill." << endl; }
};
void test(A a) {
a.kill(); //调用的是A类对象的kill方法
}
int main(void) {
A a;
B b;
test(a);
test(b);
system("pause");
return 0;
}
/*
最后结果：
A kill.
A kill.
这个结果大家应该会疑问test(b);
我明明传的是B b啊怎么还是会调用父类中的函数，
不是应该调用B b自己的kill方法吗？
所以我们说子类型代替父类时，
是花木兰替父从军，
花木兰在军营中不能被发现是女儿身，所以自己的一些行为要装成
男子的行为，也就我们的B b进入test(b)这个军营当中，b的方法也要
使用其父类的方法。
*/
小结：
子类型关系具有单向传递性。
C类是B类的子类型
B类是A类的子类型
子类型的作用：
在需要父类对象的任何地方， 可以使用”公有派生”的子类的对象来替代，
从而可以使用相同的函数统一处理基类对象和公有派生类对象
即：形参为基类对象时，实参可以是派生类对象
#include <iostream>
#include <sstream>
using namespace std;
class Father {
public:
void play() {
cout << "KTV唱歌！" << endl;
}
};
class Son : public Father {
public:
void play() {
cout << "今晚吃鸡！" << endl;
}
};
void party(Father *f1, Father *f2) {
f1->play();
f2->play();
}
int main(void) {
Father yangKang;
Son yangGuo;
party(&yangKang, &yangGuo);
system("pause");
return 0;
}
/*
结果：
KTV唱歌！
KTV唱歌！
*/
注意：
如果把Son改为protected继承，或private继承，就会导致编译失败！
子类型的应用
1.基类（父类）的指针，可以指向这个类的公有派生类（子类型）对象。
Son yangGuo;
Father * f = &yangGuo;
2.公有派生类（子类型）的对象可以初始化基类的引用
Son yangGuo;
Father &f2 = yangGuo;
3.公有派生类的对象可以赋值给基类的对象
Son yangGuo;
Father f1 = yangGuo;
注意：以上的应用，反过来就会编译失败！
显赫世家：多重继承
什么是多重继承
多继承/多重继承:
一个派生类可以有两个或多个基类(父类)。
多重继承在中小型项目中较少使用，在Java、C#等语言中直接取消多重继承, 以避免复杂性.
多重继承的用法
将多个基类用逗号隔开.
例如已声明了类A、类B和类C，那么可以这样来声明派生类D：
class D: public A, private B, protected C{
//类D自己新增加的成员
/*
D 是多继承形式的派生类，
D 有3个父类(基类)
它以公有的方式继承 A 类，
以私有的方式继承 B 类，
以保护的方式继承 C 类。
D 根据不同的继承方式获取 A、B、C 中的成员.
*/
};
多继承的构造函数
多继承形式下的构造函数和单继承形式基本相同.
以上面的 A、B、C、D 类为例，D 类构造函数的写法为：
D(形参列表): A(实参列表), B(实参列表), C(实参列表){
//其他操作
}
说明：
多继承的构造函数的调用顺序
基类构造函数的调用顺序和和它们在派生类构造函数中出现的顺序无关，
而是和声明派生类时基类出现的顺序相同。
多重继承的弊端: 二义性
当继承的父类中有同名的方法，此时我们的子类对象或者是子类内部需要调用该方法时，编译器就会出现错误。编译器也不知道应该调用哪一个方法，所以这个时候我们需要对要调用的方法进行限定。
int main(void) {
Son son();
// 解决多重继承的二义性的方法1:
// 使用 "类名::" 进行指定, 指定调用从哪个基类继承的方法!
son.Father::dance();
son.Mother::dance();
// 解决多重继承的二义性的方法2:
// 在子类中重新实现这个同名方法, 并在这个方法内部, 使用基类名进行限定,
// 来调用对应的基类方法
son.dance();
system("pause");
return 0;
}
虚拟的祖先：虚基类
多重继承在”菱形继承”中的重大缺点
Demo
#include <iostream>
#include <string>
#include <Windows.h>
using namespace std;
// 电话类
class Tel {
public:
Tel() {
this->number = "未知";
}
protected:
string number; //电话号码;
};
// 座机类
class FixedLine : public Tel {
};
// 手机类
class MobilePhone :public Tel {
};
// 无线座机
class WirelessTel :public FixedLine, public MobilePhone {
public:
void setNumber(const char *number) {
//this->number = number; //错误, 指定不明确
this->FixedLine::number = number; //this可以省略
}
string getNumber() {
//return MobilePhone::number;
return MobilePhone::number;
}
};
int main(void) {
WirelessTel phone;
phone.setNumber("13243879166");
cout << phone.getNumber() << endl; //打印未知
system("pause");
return 0;
}
查看内存分布：
通过内存分布我们可以看到目前子类继承了两个相同且独立的number
所以我们对FixedLine::number赋值，getNumber()方法中返回MobilePhone::number的值会和我们预想的不一样。
解决方案
使用虚基类和虚继承.
#include <iostream>
#include <string>
#include <Windows.h>
using namespace std;
// 电话类
class Tel { //虚基类
public:
Tel() {
this->number = "未知";
}
protected:
string number; //电话号码;
};
// 座机类
class FixedLine : virtual public Tel { //虚继承
};
// 手机类
class MobilePhone : virtual public Tel { //虚继承
};
// 无线座机
class WirelessTel :public FixedLine, public MobilePhone {
public:
void setNumber(const char *number) {
this->number = number; //直接访问number
}
string getNumber() {
return this->number; //直接访问number
}
};
int main(void) {
WirelessTel phone;
phone.setNumber("13243879166");
cout << phone.getNumber() << endl;
system("pause");
return 0;
}
此时的内存分布：
此时子类继承的是其“祖父”类Tel的数据成员
一点小建议：
尽量不要使用多重继承(多继承)
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
