1.继承方式

首先引入继承的语法：class 子类 : 继承方式 父类

1.1继承方式有三种：

1.public（公共继承）

2.protected（保护继承）

3.private（私有继承）

1.2三种继承方式的不同

1.public（公共继承）：

子类继承父类的属性的时：

父类的public到子类依旧为public

父类的protected到子类依旧为protected

父类的private到子类依旧为private

2.protected（保护继承）：

子类继承父类的属性的时：

父类的public到子类变为protected

父类的protected到子类依旧为protected

父类的private到子类依旧为private

3.private(私有继承）：

子类继承父类的属性的时：

父类的public到子类变为protected

父类的protected到子类变为privat

父类的private到子类依旧为private

//我认为以上是最简洁明了的解释

1.3三种继承方式的子类对象在类外访问权限的不同

其实这个内容主要还是与“1.2三种继承方式的不同”有关：

1.若是public继承：

子类可以访问父类中public和protected的属性，不可访问父类中的private；

 子类的对象可以访问父类中public和protected的属性，不可访问父类中的private；
2.若是protected继承：

子类可以访问父类中public和protected的属性，不可访问父类中的private；

 子类的对象不可访问父类中public和protected的属性，也不可访问父类中的private；

3.若是private继承：

子类不可以直接访问父类中的任何属性。

子类的对象不可以直接访问父类中的任何属性。

eg：

#include 
using namespace std;
class Base1
{
public: 
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

//公共继承
class Son1 :public Base1
{
public:
	void func()
	{
		m_A; //可访问 public权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};

void myClass()
{
	Son1 s1;
	s1.m_A; //其他类只能访问到公共权限
}

//保护继承
class Base2
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son2:protected Base2
{
public:
	void func()
	{
		m_A; //可访问 protected权限
		m_B; //可访问 protected权限
		//m_C; //不可访问
	}
};
void myClass2()
{
	Son2 s;
	//s.m_A; //不可访问
}

//私有继承
class Base3
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};
class Son3:private Base3
{
public:
	void func()
	{
		m_A; //可访问 private权限
		m_B; //可访问 private权限
		//m_C; //不可访问
	}
};
class GrandSon3 :public Son3
{
public:
	void func()
	{
		//Son3是私有继承，所以继承Son3的属性在GrandSon3中都无法访问到
		//m_A;
		//m_B;
		//m_C;
	}
};

2.继承中构造和析构的顺序

继承中：

先调用父类构造函数，再调用子类构造函数。

先调用子类析构函数，再调用父类析构函数。

eg：

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

int main() {

	test01();

	system("pause");

	return 0;
}