4.6 继承

4.6.1 继承的基本语法

4.6.2 继承方式

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

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; //父类中的私有成员， 子类访问不到
	}
};

void test01()
{
	Son1 s1;
	s1.m_A = 100; //公有权限，类内，类外都可以访问
	//s1.m_B = 100;//保护权限类内可以访问，类外不可以访问
}


//保护继承
class Son2 : protected Base1
{
public:
	void func()
	{
		m_A = 100;//父类中公有权限到子类中变成保护权限
		m_B = 100;//同上
		//m_C = 100; //父类中私有成员，子类访问不到
	}
};

void test02()
{
	Son2 s1;
	//s1.m_A = 100;//保护权限在类外访问不到
}

//私有继承
class Son3 : private Base1
{
public:
	void func()
	{
		m_A = 100;//父类中私有权限到子类中变成私有权限
		m_B = 100;//同上
		//m_C = 100; //父类中私有成员，子类访问不到
	}
};

void test03()
{
	Son3 s1;
	s1.m_A = 100; //私有权限 类外不能访问
}


//孙子继承儿子
class GrandSon3 : public Son3
{
public:
	void func()
	{
		//m_A = 100;//Son3的属性都是 私有的，所以孙子都访问不到
		//m_B = 100;
		//m_C = 100;
	}	
}

4.6.3 继承中的对象模型

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

class Base
{
public:
	int m_A;
protected:
	int m_B;
private:
	int m_C;
};

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

//结果是16， 不管父类中是什么  非静态的 属性属性，都会被子类继承下去
//之不过在子类中被 编译器隐藏了，因此访问不到
void test01()
{
	cout << "size of son = " << sizeof(Son) << endl;
}

4.6.4 继承中构造和析构顺序

子类继承父类后，当创建子类对象，也会调用父类的构造函数
问题: 父类和子类的构造 和析构的顺序是 ?

• 先构造父类，后构造子类
• 先析构子类，后析构父类

4.6.5 同名成员处理

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

//同名成员函数处理
void test02()
{
	Son s1;
	//如果子类没有func函数，那下面调用的就是父类中的func函数
	//如果子类实现了 func函数，那么下面调用的就是子类中的func函数
	s1.func();
	//如何调用父类的同名成员函数呢?
	s.Base::func();
	//如果子类中 和父类有同名函数，那么子类会隐藏父类中的所有同名成员函数，包括重载函数，父类的重载同名函数 需要加作用域
	s.Base::func(100);
}

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

问题: 继承中同名的静态成员在子类对象上如何进行访问?
静态成员和非静态成员出现同名，处理方式一致

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

class Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Base 下 static func调用" << endl;
	}
};
int Base::m_A = 100;

class Son
{
public:
	static int m_A;
	static void func()
	{
		cout << "Son 下 static 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 << "通过类名访问: " << endl;
	cout << "Son 下 m_A = " << Son::m_A << endl;
	//第一个:: 代表通过类名方式访问  第二个代表访问父类作用域下
	cout << "Base 下 m_A = " << Son::Base::m_A << endl;
}

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

	//2、通过类名访问
	cout << "通过类名访问" << endl;
	Son::func();
	Son::Base::func();
}

4.6.7 多继承语法

c++允许一个类继承多了个类
语法:

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

多继承可能会引发父类中同名成员出现，需要加作用域区分
c++实际开发汇总不建议使用多继承

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

class Base2
{
public:
	Base2()
	{
		m_A = 105;
		m_B = 200;
	}
	int m_A;
	int m_B;
};

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

//当两个父类中有同名成员,需要加作用域
void test01()
{
	Son s1;
	cout << "Base1::m_A = " << s.Base1::m_A;
	cout << "Base:2:m_A = " << s.Base2::m_A;
}

4.6.8 菱形继承

菱形继承的概念:
两个派生类继承同一个基类
又有某个类同时继承 这两个派生类