（2）类和对象——继承

继承

面向对象三大特性之一

定义某些类时，下级别的成员除了拥有上一级的共性，还有自己的特性。

利用继承技术，减少重复代码。

继承的基本语法

//利用继承写多个页面
class BasePage {//公共页面类
public:
	void header() {//公共头部
		cout << "首页、公开课、登录、注册……（公共头部）" << endl;
	}
	void footer() {//公共底部
		cout << "帮助中心、交流合作、站内地图……（公共底部）" << endl;
	}
	void left() {//左侧公共分类列表
		cout << "java、Python、C/C++、PHP……（公共分类列表）" << endl;
	}
};
class Java : public BasePage {
public:
	void content() {//变化部分
	cout << "java程序设计" << endl;
    }
};
class Python : public BasePage {
public:
	void content() {//变化部分
		cout << "python程序设计基础" << endl;
	}
};
class CPP : public BasePage {
public:
	void content() {//变化部分
		cout << "C++程序设计基础" << endl;
	}
};
void test01() {
    cout << "Java学习课程展示页面：" << endl;
	Java ja;
	ja.header();
	ja.footer();
	ja.left();
	ja.content();
	cout << "-----------------------------" << endl;
	cout << "Python学习课程展示页面：" << endl;
	Python py;
	py.header();
	py.footer();
	py.left();
	py.content();
	cout << "-----------------------------" << endl;
	cout << "C++学习课程展示页面：" << endl;
	CPP cpp;
	cpp.header();
	cpp.footer();
	cpp.left();
	cpp.content();
}
int main() {
	test01();
	system("pause");
	return 0;
}

总结：

继承的好处：减少重复代码

class A : public B;

A类称为子类或派生类

B类称为父类或基类

派生类中成员包含两部分：

一类是从基类继承过来的，一类是自己增加的成员

从基类继承过来的表现其共性，新增的成员体现其个性

继承方式

继承的语法：class 子类：继承方式 父类

继承方式有三种：

• 公共继承
• 保护继承
• 私有继承

class Base1 {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son1 :public Base1 {//公共继承
public:
	void func() {
		m_A = 10;//父类中公共，子类中依旧公共
		m_B = 10;//父类中保护，子类中依旧保护
		//m_C = 10;//父类私有，子类访问不到，会报错
	}
};
class Son2 :protected Base1 {//保护继承
public:
	void func() {
		m_A = 100;//父类中公共，子类中变为保护
		m_B = 100;//父类中保护，子类中依旧保护
		//m_C = 10;//父类私有，子类访问不到，会报错
	}
};
class Son3 :private Base1 {//私有继承
public:
	void func() {
		m_A = 100;//父类中公共，子类中变为私有
		m_B = 100;//父类中保护，子类中变为私有
		//m_C = 10;//父类私有，子类访问不到，会报错
	}
};
class GrandSon3 :public Son3 {//孙类
public:
	void func() {
		//m_A = 1000;//Son3私有继承后，m_A变为私有，其子类访问不到，会报错
	}
};
void test01() {
	Son1 s1;
	s1.m_A = 100;
	//s1.m_B = 100;//Son1公共继承后，m_B依旧是保护，类外访问不到，会报错
	Son2 s2;
	//s2.m_A = 1000;//Son2保护继承后，m_A变为保护，类外访问不到，会报错，m_B同样
	Son3 s3;
	//s3.m_A = 10000;//Son3私有继承后，m_A变为私有，类外访问不到，会报错，m_B同样
}
int main() {
	test01();
	system("pause");
	return 0;
}

继承中的对象模型

问题：从父类继承过来的成员，哪些属于子类对象

class Base {
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son :public Base {
public:
	int m_D;
};
//利用开发人员命令提示工具查看对象模型
//1、跳转盘符  F: + 回车
//2、跳转文件路径  cd + 1空格 + 文件夹具体路径
//3、查看命名
//4、c1 + 1空格 + /d1 + 1空格 + reportSingleClassLayout类名 + 1空格 + 文件名
void test01() {
	//父类中所有非静态成员属性都会被子类继承
	//父类中的私有属性是被编译器隐藏了，因此会访问不到，但确实是被继承下来了
	cout << "size of Son = " << sizeof(Son) << endl;//size of Son = 16
}
int main() {
	test01();
	system("pause");
	return 0;
}

结论：

父类中私有成员也是被子类继承下去了，只是由编译器给隐藏后访问不到

继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类构造函数

总结：

继承中先调用父类构造函数，在调用子类构造函数，析构顺序与构造相反

继承同名成员处理方式

• 访问子类同名成员，直接访问
• 访问父类同名成员，要加作用域

class Base {
public:
	int m_A;
	Base() {
		m_A = 100;
	}
	void func() {
		cout << "Base func() 函数调用" << endl;
	}
	void func(int a) {
		cout << "Base func(int a) 函数调用" << endl;
	}
};
class Son :public Base {
public:
	int m_A;
	Son() {
		m_A = 200;
	}
	void func() {
		cout << "Son func() 函数调用" << endl;
	}
};
void test01() {//同名成员属性
	Son s;
	cout << "Son m_A = " << s.m_A << endl;
	cout << "Base m_A = " << s.Base::m_A << endl;//通过子类对象访问父类同名成员，需加作用域
}
void test02() {
	Son s;
	s.func();
	s.Base::func();
	s.Base::func(100);
	//如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
	//如果想访问父类中被隐藏的同名函数，需要加作用域
}
int main() {
	//test01();
	test02();
	system("pause");
	return 0;
}

总结：

• 子类对象可以直接访问到子类中同名成员
• 子类对象加作用域可以访问到父类同名成员
• 当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名成员函数

同名静态成员处理方式

静态成员和非静态成员出现同名，处理方式一致

• 访问子类同名成员，直接访问
• 访问父类同名成员，要加作用域

静态成员类内声明，类外初始化，访问时有两种访问方式：分通过对象访问和通过类名访问

多继承语法

C++允许一个类继承多个类

语法：class 子类 : 继承方式 父类1 ，继承方式 父类2……

多继承可能会引发父类中有同名成员出现，需要加作用域区分

C++实际开发中不建议用多继承

class Base1 {
public:
	Base1() {
		m_A = 100;
	}
	int m_A;
};
class Base2 {
public:
	Base2() {
		m_A = 200;
	}
	int m_A;
};
class Son :public Base1, public Base2{
public:
	Son() {
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};
void test01() {
	Son s;
	cout << "size of Son = " << sizeof(s) << endl;//size of Son = 16
	cout << " Base1 m_A = " << s.Base1::m_A << endl;// Base1 m_A = 100
	cout << " Base2 m_A = " << s.Base2::m_A << endl;//Base2 m_A = 200
}
int main() {
	test01();
	system("pause");
	return 0;
}

菱形继承

概念：

• 两个派生类继承同一个基类
• 又有某个类同时继承两个派生类
• 这种继承被称为菱形继承，或者钻石继承

 问题：

• 杨继承了动物的数据，驼也继承了动物的数据，当草泥马使用数据时，就会产生二义性
• 草泥马继承自动物的数据继承了两份，其实我们应该清楚，我们只需要一份

解决菱形继承问题：

加关键字 virtual 变为虚继承

class Animal{//动物类
public:
	int m_Age;
};
//利用虚继承解决菱形继承问题
//继承前 加上关键字 virtual 变为虚继承
//Animal类 称为 虚基类
class Sheep:virtual public Animal{//羊类

};
class Tuo :virtual public Animal {//驼类

};
class SheepTuo:public Sheep,public Tuo{

};
void test01() {
	SheepTuo st;
	st.Sheep::m_Age = 18;
	st.Tuo::m_Age = 28;
	//菱形继承，两个父类拥有相同数据，要加上作用域区分
	cout << "st.Sheep::m_Age = " << st.Sheep::m_Age << endl;
	cout << "st.Tuo::m_Age = " << st.Tuo::m_Age << endl;
	cout << "st.m_Age = " << st.m_Age << endl;
	//加上关键字 virtual后，只有一份数据，因此无需区分
}
int main() {
	test01();
	system("pause");
	return 0;
}