C++核心编程——4.6 继承

最新推荐文章于 2024-05-20 15:29:54 发布

箫遥面具

最新推荐文章于 2024-05-20 15:29:54 发布

阅读量1.3k

点赞数 33

分类专栏： C++ 文章标签：开发语言 c++

本文链接：https://blog.csdn.net/2301_81926399/article/details/138257308

版权

C++ 专栏收录该内容

20 篇文章 1 订阅

订阅专栏

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

4.6.1 继承的概念和作用

定义：

继承(inheritance)机制允许在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）。

作用：可以减少重复的代码

语法：

class A : public B;

A 类称为子类或派生类

B 类称为父类或基类

注： 派生类中的成员，包含两大部分：

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

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

//公共属性
class Base
{
public:
	void header()
	{
		cout << "公共属性的内容" << endl;
	}

};

//特有属性1:test1
class test1 : public Base
{
public:
	void content()
	{
		cout << "特有属性1:test1" << endl;
	}
};

//特有属性2:test2
class test2 : public Base
{
public:
	void content()
	{
		cout << "特有属性2:test2" << endl;
	}
};

void test01()
{
	//特有属性1
	cout << "特有属性1页面如下： " << endl;
	test1 t1;
	t1.header();
	t1.content();
	cout << "--------------------" << endl;

	//特有属性2
	cout << "特有属性2页面如下： " << endl;
	test2 t2;
	t2.header();
	t2.content();
	cout << "--------------------" << endl;

}

int main() {

	test01();

	system("pause");

	return 0;
}

4.6.2 继承的方式

	父类——class A
继承方式语法：class 子类:public 父类	public 类内/外可访问	protected 只类内可访问	private
公共继承语法：class B:public A	public	protected	不可访问
保护继承语法：class B:protected A	protected
私有继承语法：class B:private A	private
嵌套继承	原来的子类（现在的父类）继承的对象按如上的规则作为自己的访问权限被另一个子类继承

class father
{
public:
	int m_a;
protected:
	int m_b;
private:
	int m_c;
};

class son1 : public father
{
	void function()
	{
		m_a = 10;
		m_b = 10;    //父类中的公共属性和保护属性类内可以访问
	    //m_c = 10; //父类中的私有属性类内不可访问
	}
};

class son2 : protected father
{
	void function()
	{
		m_a = 10;
		m_b = 10;    //父类中的公共属性和保护属性类内可以访问
	    //m_c = 10; //父类中的私有属性类内不可访问
	}
};

class son3 : private father
{
	void function()
	{
		m_a = 10;
		m_b = 10;    //父类中的公共属性和保护属性类内可以访问
	    //m_c = 10; //父类中的私有属性类内不可访问
	}
};

void test01()
{
	son1 s1;
	s1.m_a = 20;   //父类中的公共属性类外可以访问
	//s1.m_b = 20;
	//s1.m_c = 20;   //父类中的保护属性和私有属性类外可以访问

	son2 s2;
	//s2.m_a = 20;
	//s2.m_b = 20;
	//s2.m_c = 20;  //父类中的公共属性、保护属性和私有属性类外可以访问

	son3 s3;
	//s3.m_a = 20;
	//s3.m_b = 20;
	//s3.m_c = 20;  //父类中的公共属性、保护属性和私有属性类外可以访问

};

//继承嵌套
class GrandSon : public son3    //原先的子类现在成员父类
{
	     //m_a = 10;
		//m_b = 10;    
	    //m_c = 10;    //三个变量都是son3采用private方式从father中继承的，已经变成son3中的private
};

int main()
{
	test01();
	system("pause");
	return 0;
}

4.6.3 继承中的对象模型

父类中的私有成员是被编译器隐藏了访问不到，但是会被继承

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C; //私有成员只是被隐藏了，但是还是会继承下去
};

//公共继承
class Son :public Base
{
public:
	int m_D;
};

void test01()
{
	cout << "sizeof Son = " << sizeof(Son) << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

对用的继承对象模型如下图所示：

4.6.4 继承中构造和析构顺序

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

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 s;
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.6.5 继承同名成员处理方式

访问子类同名成员		访问父类同名成员
成员对象	成员函数	成员对象	成员函数
直接访问（不用写明作用域）		语法：s.Base::m_A 其中s为子类创建的类对象，Base为父类的类名（作用域）	语法：s.Base::func() 其中s为子类创建的类对象，Base为父类的类名（作用域）
没有作用域访问子类，有作用域访问作用域
注：当子类与父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加作用域可以访问到父类中同名函数

class Base {
public:
	Base()
	{
		m_A = 100;
	}

	void func()
	{
		cout << "Base - func()调用" << endl;
	}

	void func(int a)  //函数的重载
	{
		cout << "Base - func(int a)调用" << endl;
	}

public:
	int m_A;
};


class Son : public Base {
public:
	Son()
	{
		m_A = 200;
	}

	//当子类与父类拥有同名的成员函数，子类会隐藏父类中所有版本的同名成员函数
    
	//如果想访问父类中被隐藏的同名成员函数，需要加父类的作用域
	void func()
	{
		cout << "Son - func()调用" << endl;
	}
public:
	int m_A;
};

void test01()
{
	Son s;

	cout << "Son下的m_A = " << s.m_A << endl;
	cout << "Base下的m_A = " << s.Base::m_A << endl;

	s.func();
	s.Base::func();
	s.Base::func(10);
    //如果子类中有func()父类中有func()和func(int a)
 //当只是调用s.func(10);时候子类会隐藏父类中的所有同名成员函数（包括func()和func(int a)），此时会报错
}
int main() {

	test01();

	system("pause");
	return EXIT_SUCCESS;
}

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

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

class Base {
public:
	static void func()
	{
		cout << "Base - static void func()" << endl;
	}
	static void func(int a)
	{
		cout << "Base - static void func(int a)" << endl;
	}

	static int m_A;
};

int Base::m_A = 100;

class Son : public Base {
public:
	static void func()
	{
		cout << "Son - static void func()" << endl;
	}
	static int m_A;
};

int Son::m_A = 200;

//同名成员属性
void test01()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	cout << "Son  下 m_A = " << s.m_A << endl;
	cout << "Base 下 m_A = " << s.Base::m_A << endl;

	//通过类名访问
	cout << "通过类名访问： " << endl;
	cout << "Son  下 m_A = " << Son::m_A << endl;
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
    //两个冒号含义不同，第一个表示通过类名son的方式访问数据，第二个冒号表示在Base（父类）的作用域
}

//同名成员函数
void test02()
{
	//通过对象访问
	cout << "通过对象访问： " << endl;
	Son s;
	s.func();
	s.Base::func();

	cout << "通过类名访问： " << endl;
	Son::func();
	Son::Base::func();
	//出现同名，子类会隐藏掉父类中所有同名成员函数，需要加作作用域访问
	Son::Base::func(100);
}
int main() {

	//test01();
	test02();

	system("pause");

	return 0;
}

4.6.7 多态继承语法

作用：一个类继承多个

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

注：多继承中如果父类中出现了同名情况，子类使用时候要加作用域

class Base1 {
public:
	Base1()
	{
		m_A = 100;
	}
public:
	int m_A;
};

class Base2 {
public:
	Base2()
	{
		m_A = 200;  //开始是m_B 不会出问题，但是改为mA就会出现不明确
	}
public:
	int m_A;
};

//语法：class 子类：继承方式 父类1 ，继承方式 父类2 
class Son : public Base2, public Base1 
{
public:
	Son()//构造函数
	{
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C;
	int m_D;
};


//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员
void test01()
{
	Son s;
	cout << "sizeof Son = " << sizeof(s) << endl;
	cout << s.Base1::m_A << endl;
	cout << s.Base2::m_A << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

4.6.8 菱形继承

概念：

两个派生类继承同一个基类，同时又有某个类同时继承者两个派生类，这种继承被称为菱形继承，或者钻石继承，作用图如下图所示：

案例：

问题：

羊继承了动物的数据，驼同样继承了动物的数据，当草泥马使用数据时，就会产生二义性；
草泥马继承自动物的数据继承了两份，而这份数据只需要一份就可以；

解决方案：

虚拟继承（解决继承两份相同数据的问题，防止资源浪费）

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 = 100;
	st.Tuo::m_Age = 200;
//虚继承之后相当于只有一份数据，大家共享，输出可以不用加作用域
	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;
}


int main() {

	test01();

	system("pause");

	return 0;
}

虚拟继承的底层原理如下图所示：

虚拟继承的本质是继承两个指针（vptr虚基类指针），该指针指向的是对应的类表（vbtable虚基类表），在虚基类表中记录的是对象的类中的偏移量（sheep的偏移量为8，tuo的偏移量为4，原来的地址是0，在sheep类中0（原始sheep类的位置） + 8 （偏移量） = 8 ；在tuo类中4（原始tuo类的位置） + 4 （偏移量） = 8 ，最终两者指向的是同一块为8 的地址，解决了继承两份相同数据的问题。

箫遥面具

关注

33
点赞
踩
23

收藏

觉得还不错? 一键收藏
0
评论
C++核心编程——4.6 继承

介绍C++核心编程第四篇第六章，主要包括C++三大特征之一的继承，继承的概念定义、继承方式、对象模型、构造析构顺序、同名（静态）成员函数的处理方法，多态继承以及菱形继承等的C++核心知识和内容
复制链接

扫一扫