博客

4.6 继承

继承是面向对象三大特性之一

当下级的成员除了拥有上一级的共性，还有自己的特性，此时利用继承的技术，可以减少重复代码

4.6.1 继承的基本语法

语法：

class子类:继承方式 父类


#include<iostream>
using namespace std;
//继承实现页面
class BasePage {
public:
	void header() {
		cout << "首页" << endl;
	}
	void footer() {
		cout << "帮助中心" << endl;
	}
	void left() {
		cout << "Java、Python、C++..." << 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 << "CPP学科视频" << endl;
	}
};
void test01() {
	cout << "Java页面如下：" << endl;
	Java j;
	j.header();
	j.left();
	j.content();
	j.footer();
	cout << "Python页面如下：" << endl;
	Python p;
	p.header();
	p.left();
	p.content();
	p.footer();
	cout << "CPP页面如下：" << endl;
	CPP c;
	c.header();
	c.left();
	c.content();
	c.footer();
}
int main() {
	test01();
	return 0;
}

子类中的成员：

• 从父类继承过来的，表现其共性
• 自己增加的成员，表现其个性

4.6.2 继承方式

继承的语法：

class 子类:继承方式 父类


继承方式一共有三种：

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

#include<iostream>
using namespace std;
class Base1 {
public:
	int a;
protected:
	int b;
private:
	int c;
};
class Son1 : public Base1 {
public:
	void func() {
		a = 10;//父类中的公共权限成员，到子类中依然是公共权限
		b = 20;//父类中的保护权限成员，到子类中依然是保护权限
		//c = 30;父类中的私有权限成员，子类不可访问
	}
};
class Son2 : protected Base1 {
public:
	void func() {
		a = 10;//父类中的公共权限成员，到子类中变为保护权限
		b = 20;//父类中的保护权限成员，到子类中依然是保护权限
		//c = 30;父类中的私有权限成员，子类不可访问
	}
};
class Son3 : private Base1 {
public:
	void func() {
		a = 10;//父类中的公共权限成员，到子类中变为私有权限
		b = 20;//父类中的保护权限成员，到子类中变为私有权限
		//c = 30;父类中的私有权限成员，子类不可访问
	}
};
class GrandSon3 : public Son3 {
public:
	void func() {
		//a = 10;//Son3类中变为了私有权限成员，子类不可访问
		//b = 20;//Son3类中变为了私有权限成员，子类不可访问
		//c = 30;Son3类中变为了私有权限成员，子类不可访问
	}
};
void test01() {
	Son1 s1;
	s1.a = 100;
	//s1.b = 200;在Son1 中 b是保护权限，类外访问不到
	
	Son2 s2;
	//s2.a = 100;在Son2 中 a是保护权限，类外访问不到
	//s2.b = 200;在Son2 中 b是保护权限，类外访问不到
	
	Son3 s3;
	//s3.a = 100;//在Son2 中 a是私有权限，类外访问不到
	//s3.b = 200;在Son2 中 b是私有权限，类外访问不到
}
int main() {
	test01();
	return 0;
}

4.6.3 继承中的对象模型

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

父类中所有非静态成员属性都会被子类继承下去

#include<iostream>
using namespace std;
class Base1 {
public:
	int a;
protected:
	int b;
private:
	int c;
};
class Son : public Base1 {
public:
	int d;
};

void test01() {
	//父类中所有非静态成员属性都会被子类继承下去
	cout << "size of Son =" << sizeof(Son) << endl;//16,一共4个成员

	//父类中私有成员属性 是被编译器隐藏了，因此访问不到，但被子类继承下去了
}
int main() {
	test01();
	return 0;
}

4.6.4 继承中构造和析构顺序

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

问题：父类和子类的构造和析构顺序是谁先谁后？

继承中的构造和析构顺序：


构造：先构造父类，再构造子类

析构：先析构子类，再析构父类

#include<iostream>
using namespace std;
class Base {
public:
	Base() {
		cout << "Base构造函数" << endl;
	}
	~Base() {
		cout << "Base析构函数" << endl;
	}
};
class Son : public Base {
public:
	Son() {
		cout << "Son构造函数" << endl;
	}
	~Son() {
		cout << "Son析构函数" << endl;
	}
};

void test01() {
	Son s1;
}
int main() {
	test01();
	return 0;
}

4.6.5 继承同名成员处理方式

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

#include<iostream>
using namespace std;
class Base {
public:
	Base() {
		a = 100;
	}
	void func() {
		cout << "Base-func" << endl;
	}
	int a;
};
class Son : public Base {
public:
	Son() {
		a = 200;
	}
	void func() {
		cout << "Son-func" << endl;
	}
	int a;
};

void test01() {
	Son s1;
	//同名变量调用
	cout << "Son   s1.a=" << s1.a << endl;//200
	cout << "Base  s1.a=" << s1.Base::a << endl;//100
	//同名成员函数调用
	cout << "Son   s1.func()="  << endl;
	s1.func();
	cout << "Base  s1.func()="  << endl;
	s1.Base::func();
}
int main() {
	test01();
	return 0;
}

1.子类对象可直接访问到子类中同名成员

2.子类对象加作用域可以访问到父类同名成员

3.如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数（包括重写的），若想访问，则需加作用域

4.6.6 继承同名静态成员处理方式

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

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

#include<iostream>
using namespace std;
//继承中的同名静态成员处理方式
class Base {
public:
	static int m_a;
	static void func() {
		cout << "Base void func()" << endl;
	}
	static void func(int a) {
		cout << "Base void func(int "<<a<<")" << endl;
	}

};
int Base::m_a = 100;
class Son:public Base {
public:
	static int m_a;
	static void func() {
		cout << "Son void func()" << endl;
	}
};
int Son::m_a = 200;

//同名静态成员变量
void test01() {
	//1.通过对象来访问
	Son s;
	cout << "Son m_a=" << s.m_a << endl;
	cout << "Base m_a=" << s.Base::m_a << endl;
	//2.通过类名来访问
	cout << "Son m_a=" << Son::m_a << endl;
	cout << "Base m_a=" << Son::Base::m_a << endl;
	//第一个::代表通过类名方式来访问，第二个::代表访问父类作用域下
}
//同名静态成员函数
void test02() {
	//1.通过对象来访问
	Son s;
	s.func();
	s.Base::func();

	//2.通过类名来访问
	Son::func();
	Son::Base::func();

	//子类出现和父类同名静态成员函数，也会隐藏父类中所有同名成员函数
	//如果像访问父类中被隐藏同名成员函数，需要加作用域
	Son::Base::func(100);
}
int main() {
	//test01();
	test02();
	return 0;
}

总结

：同名静态成员处理方式和非静态处理方式一样，只不过又两种访问的方式（通过对象和通过类名访问）

4.6.7 多继承语法

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

语法：

class 子类:继承方式 父类1,继承方式 父类2,...


示例：

#include<iostream>
using namespace std;

//多继承语法
class Base1 {
public:
	Base1() {
		m_a = 100;
	}
	int m_a;
};
class Base2 {
public:
	Base2() {
		m_b = 200;
	}
	int m_b;
};
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 << "sizeof Son=" << sizeof(s) << endl;//16，共有4个成员
}
int main() {
	test01();
	return 0;
}

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

#include<iostream>
using namespace std;

//多继承语法
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 << "Base1中的m_a" << s.Base1::m_a << endl;
	cout << "Base2中的m_a" << s.Base2::m_a << endl;

}
int main() {
	test01();
	return 0;
}

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

4.6.8 菱形继承

概念：

​ 两个子类继承同一个父类

​ 又有某个类同时继承这两个派生类

​ 这种继承方式被称为菱形继承，或者钻石继承

菱形继承问题：

1. 羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性
2. 草泥马继承自动物的数据继承了两份，导致资源浪费，有的数据只需要一份就可以

利用虚继承，解决菱形继承的问题

继承之前，加上关键字

virtual

变为

虚继承

#include<iostream>
using namespace std;
//动物类
class Animal {
public:
	int m_age;
};

//利用虚继承，解决菱形继承问题 
// 继承之前，加上关键字virtual变为 虚继承
// 此时Animal类 称为 虚基类
//羊类
class Sheep:virtual public Animal {

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

};
//羊驼
class Vicuna:public Sheep,public Camel{

};
void test01() {
	Vicuna v;
	//v.m_age = 10;指向不明确
	v.Sheep::m_age = 10;
	v.Camel::m_age = 12;

	//当出现菱形继承时，相当于两个父类拥有相同数据，需要加以作用域区分
	cout << "v.Sheep::m_age" << v.Sheep::m_age << endl;
	cout << "v.Camel::m_age" << v.Camel::m_age << endl;
	//这份数据只需要一份，但菱形继承导致数据有两份，浪费资源
    //通过虚继承解决这个问题
    cout << " v.m_age" << v.m_age << endl;
}
int main() {
	test01();
	return 0;
}

并不是继承了两个数据，而是继承了两个指针，通过偏移量找到唯一的数据