C++学习笔记之继承/继承的学习/继承学习/学习继承

C++学习笔记之继承/继承的学习/继承学习/学习继承
继承是面向对象三大特性之一

//继承的语法： class 子类 ： 继承方式 父类
//继承的方式一共有三种
//1	公有继承
//2	保护继承
//3	私有继承
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;
	}
};

  有些类与类之间存在特殊的关系
父类中所有非静态成员属性都会被子类继承下去
父类中私有成员属性，是被编译器隐藏了，因此是访问不到，但是确实被继承了
继承中构造函数和析构函数的顺序
子类继承父类后，当创建子类对象，也会调用父类的构造函数
先构造父类，在构造子类，析构的顺序与构造的顺序相反

#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 test()
{
	//继承中 先调用父类的构造函数，在调用子类构造函数， 析构顺序与构造函数相反
	Son s;
}
int main()
{
	test();
	return 0;
}

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

继承同名成员处理方式
访问子类同名函数，直接访问即可。
访问父类同名成员，需要加作用域。
如果子类中出现和父类同名的成员函数，子类的同名成员会隐藏掉父类中所有同名成员函数
子类对象可以直接访问子类中同名成员
子类对象加作用域可以访问到父类同名成员
当子类和父类拥有同名的成员函数，子类会隐藏父类中同名成员函数，加个作用域可以访问到父类同名函数

#include <iostream>
using namespace std;
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);

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

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

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

#include <iostream>
using namespace std;

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 Base1, public Base2
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
public:
	int m_C;
	int m_D;
};
//多继承容易产生成员同名的情况
//通过使用类名作用域可以区分调用哪一个基类的成员

void test()
{
	Son s;
	cout << "sizeof Son " << sizeof(s) << endl;
	//cout << "s.m_A" << s.m_A << endl;
	cout << "s.Base1::m_A " << s.Base1::m_A << endl;
	cout << "s.Base2::m_A " << s.Base2::m_A << endl;
}
int main()
{
	test();
	return 0;
}
//总结：多继承如果父类中出现了同名情况，子类使用时要加作用域

菱形继承
菱形继承概念：
两个派生类继承同一个基类。
又有某个类同时继承两个派生类
这种继承被称为菱形继承，或者钻石继承
当菱形继承，两个父类拥有相同数据，需要加作用域区分
利用虚继承，解决菱形继承的问题
继承之前，加上关键字virtual变为虚继承

#include <iostream>
using namespace std;
class Animal
{
public:
	int m_Age;
};

//继承前virtual 关键字了，变为虚继承
//此时公共的父类Animal称为虚基类
class Sheep : virtual public Animal {};
class Tuo : virtual public Animal {};
//class Sheep :  public Animal {};
//class Tuo :  public Animal {};
class SheepTuo : public Sheep, public Tuo{};
void test()
{
	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()
{
	test();
	return 0;
}
//菱形继承带来的主要问题是子类继承两份相同的数据， 导致资源浪费以及毫无意义
//利用虚继承可以解决菱形继承的问题

C++学习笔记之继承/继承的学习/继承学习/学习继承