[C++核心编程]（八）：类和对象——继承**

盖世汤猿

已于 2024-03-14 14:14:46 修改

阅读量622

点赞数 18

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

于 2024-03-12 09:43:01 首次发布

本文链接：https://blog.csdn.net/weixin_43430048/article/details/136640613

版权

C++打怪升级专栏收录该内容

22 篇文章 0 订阅

订阅专栏

目的：减少重复的代码

基本语法：class 子类(派生类)：继承方式父类(基类)

继承方式

继承方式：公共继承、保护继承、私有继承

任何继承方式，子类都无法访问父类中的私有属性
公共继承时，父类中成员属性在子类中属性一致
保护继承时，父类中成员属性在子类中属性均变为保护属性
私有继承时，父类中成员属性在子类中属性均变为私有属性

继承中的对象模型

父类中所有非静态成员属性都会被子类继承下去，私有成员只是被编译器隐藏了无法访问。

#include <iostream>
#include <string>

using namespace std;

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

class Son :public Base {
public:
	int m_D;
};

void test(void)
{
	cout << "size of son :" << sizeof(Son) << endl;
}

int main(void)
{
	test();
	return 0;
}

构造和析构顺序

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

结论---->先构造父类，再构造子类，析构的顺序与构造的顺序相反

#include <iostream>
#include <string>

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 test(void)
{
	Son s;
}

int main(void)
{
	test();
	return 0;
}

同名成员处理方式

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

同名静态成员处理

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

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

#include <iostream>
#include <string>

using namespace std;

class Base {
public:
	int m_A;
	static int m_B;
	Base()
	{
		m_A = 100;
	}
	void func(void);
	void func(int a);
	static void func1(void);
	static void func1(int a);
};

int Base::m_B = 100;

void Base::func(int a)
{
	cout << "Base_func(int a)函数调用" << endl;
}
void Base::func(void)
{
	cout << "Base_func函数调用" << endl;
}
void Base::func1(void)
{
	cout << "static Base_func函数调用" << endl;
}
void Base::func1(int a)
{
	cout << "static Base_func()函数调用" << endl;
}

class Son :public Base {
public:
	int m_A;
	static int m_B;
	Son()
	{
		m_A = 200;
	}
	void func();
	static void func1();
};

int Son::m_B = 200;

void Son::func1()
{
	cout << "static Son_func函数调用" << endl;
}

void Son::func()
{
	cout << "Son_func函数调用" << endl;
}

void test(void)
{
	Son s;
	s.func(); //调用子类中的成员函数
	s.Base::func(); //通过子类对象访问父类的同名成员函数需要加作用域
	s.Base::func(100);//要加作用域

	cout << "Son m_A:" << s.m_A << endl; //调用子类中的成员
	cout << "Base m_A:" << s.Base::m_A << endl;//通过子类对象访问父类的同名成员需要加作用域

	//1.通过对象访问 static
	s.func1();
	s.Base::func1();
	cout << "Son static m_B:" << s.m_B << endl; 
	cout << "Base static m_B:" << s.Base::m_B << endl;
	//2. 通过类名访问
	Son::func1();
	Son::Base::func1();
	Son::Base::func1(100);
	cout << "Son static m_B:" << Son::m_B << endl;
	cout << "Base static m_B:" << Son::Base::m_B << endl; //通过类名Son访问Base作用域下的m_B
}

int main(void)
{
	test();
	return 0;
}

多继承语法

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

注意：多继承可能会引发父类中有同名成员出现，需要加作用域区分，因此不建议使用

#include <iostream>
#include <string>

using namespace std;

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

class Base2 {
public:
	int m_B;
	int m_M;
	Base2()
	{
		m_B = 200;
		m_M = 9000;
	}
};

class Son :public Base1, public Base2 {
public:
	int m_C;
	int m_D;
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
};

void test(void)
{
	Son s;
	cout << "sizeof:" << sizeof(s) << endl;

	cout << "m_A=" << s.m_A << endl;
	//加作用域才能访问父类的同名成员，不建议
	cout << "Base1::m_M=" << s.Base1::m_M << endl;
	cout << "Base2::m_M=" << s.Base2::m_M << endl;
}

int main(void)
{
	test();
	return 0;
}

推荐文章：[C++核心编程]（七）：类和对象——运算符重载*