C++ 继承

1、继承的基本语法

//继承的好处  减少重复的代码
//语法：class子类：继承方式 父类
//子类 也称为 派生类
//父类 也称为 基类

#include <iostream>
using namespace std;

//继承实现页面
//继承的好处  减少重复的代码
//语法：class子类：继承方式 父类
//子类 也称为 派生类
//父类 也称为 基类

class Base
{
public:
	void header()
	{
		cout << "首页、登录" << endl;
	}

	void footer()
	{
		cout << "找回密码、帮助" << endl;
	}

	void left()
	{
		cout << "Java、Python、C++" << endl;
	}
};

//Java页面
class Jave :public Base
{
public:
	void content()
	{
		cout << "Java系统学习" << endl;
	}
};

//Python页面
class Python :public Base
{
public:
	void content()
	{
		cout << "Python系统学习" << endl;
	}
};

//C++页面
class CPP :public Base
{
public:
	void content()
	{
		cout << "C++系统学习" << endl;
	}
};

void test()
{
	Jave ja;
	ja.footer();
	ja.header();
	ja.left();
	ja.content();
	Python py;
	py.footer();
	py.header();
	py.left();
	py.content();
	CPP cpp;
	cpp.footer();
	cpp.header();
	cpp.left();
	cpp.content();
}

int main()
{
	test();

	return 0;
}

2、继承方式

#include <iostream>
using namespace std;

//继承的三种方式

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

//1、公共继承
class Son1:public Base
{
public:
	void func()
	{
		m_A = 10;//父类中公共权限成员 到子类中依然是公共权限
		m_B = 20;//父类中保护权限成员 到子类中依然是保护权限
		//m_C = 30;//父类中私有权限成员 不可以访问
	}
};

void test1()
{
	Son1 son1;
	son1.m_A = 100;
	//son1.m_B = 100;//Son1中的保护权限在类外访问不到
}

//2、保护继承
class Son2 :protected Base
{
public:
	void func()
	{
		m_A = 10;//父类中公共权限成员 到子类中是保护权限
		m_B = 20;//父类中保护权限成员 到子类中依然是保护权限
		//m_C = 30;//父类中私有权限成员 不可以访问
	}
};

void test2()
{
	Son2 son2;
	//son2.m_A = 100;//Son2中的保护权限在类外访问不到
	//son2.m_B = 100;//Son2中的保护权限在类外访问不到
}

//3、私有继承
class Son3 :private Base
{
public:
	void func()
	{
		m_A = 10;//父类中公共权限成员 到子类中是私有权限
		m_B = 20;//父类中保护权限成员 到子类中是私有权限
		//m_C = 30;//父类中私有权限成员 不可以访问
	}
};

void test3()
{
	Son3 son3;
	son3.m_A = 100;//Son3中的私有权限在类外访问不到
	son3.m_B = 100;//Son3中的私有权限在类外访问不到
}

class GrandSon:public Son3
{
public:
	void func()
	{
		m_A = 100;//到了Son3中 m_A m_B变为私有 即使是GrandSon也是访问不到
		m_B = 100;
	}
};

3、继承中的对象类型

#include <iostream>
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()
{
	Son son;
	//16
	//父类中所有非静态成员属性都会被子类继承下去
	//父类中所有私有成员属性 是被编译器给隐藏了 因此是访问不到 但确实是继承下去了
	cout << "sizeof(son) = " <<sizeof(son)<< endl;
}

int main()
{
	test();

	return 0;
}

4、继承中的构造和析构顺序

#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 son;

}

int main()
{
	test();

	return 0;
}

结果如下图所示：

5、继承同名处理方式

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

	int m_A;
};

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

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

	
	int m_A;
};

void test()
{
	Son son;
	cout << "Son下m_A = " << son.m_A << endl;
	//如果通过子类对象 访问到父类中同名成员 需要加上作用于
	cout << "Base下m_A = " << son.Base::m_A << endl;

	son.func();//子类func函数调用
	son.Base::func();//父类func函数调用
	son.Base::func(100);//如果子类中出现和父类同名的成员函数 子类的同名成员函数会隐藏掉父类中所有的同名成员函数  如果想要访问父类中隐藏的同名成员函数 需要加作用域
	       
}

int main()
{
	test();

	return 0;
}

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

#include <iostream>
using namespace std;

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

class Base
{
public:
	static int m_A;//静态成员类内定义 

	static void func()
	{
		cout << "Base下的静态成员函数的调用" << endl;
	}

	static void func(int a)
	{
		cout << "Base下的静态成员函数func(int a)的调用" << endl;
	}

};

int Base::m_A = 100;//类外初始化

class Son:public Base
{
public:
	static int m_A;
	static void func()
	{
		cout << "Son下的静态成员函数的调用" << endl;
	}
};

int Son::m_A = 200;

void test()
{
	cout << "通过对象来访问：" << endl;
	Son son;
	cout << "Son中的m_A = " << son.m_A << endl;
	cout << "Base中的m_A = " << son.Base::m_A << endl;

	cout << "通过类名来访问:" << endl;
	cout << "Son中的m_A = " << Son::m_A << endl;
	cout << "Base中的m_A = " <<Son::Base::m_A << endl;
	//第一个::表示通过类名的方式访问 第二个::代表访问父类作用域下

	cout << "通过对象来访问：" << endl;
	son.func();
	son.Base::func();

	cout << "通过类名来访问:" << endl;
	Son::func();
	Son::Base::func();

	//如果子类中出现和父类同名的成员函数 子类的同名成员函数会隐藏掉父类中所有的同名成员函数  如果想要访问父类中隐藏的同名成员函数 需要加作用域
	son.Base::func(100);

}

int main()
{
	test();

	return 0;
}

7、多继承语法

#include <iostream>
using namespace std;

//多继承语法
//C++允许一个类继承多个类  但不建议

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

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

	int m_A;
};

//子类继承Base1和Base2
class Son:public Base1,public Base2 
{
public:
	Son()
	{
		m_C = 300;
		m_D = 400;
	}
	int m_C;
	int m_D;
};

void test()
{
	Son son;
	cout << "sizeof(Son)" << sizeof(Son) << endl;//16

	cout << "Base1下的m_A = " << son.Base1::m_A<< endl;
	cout << "Base2下的m_A = " << son.Base2::m_A << endl;

}

int main()
{
	test();

	return 0;
}

8、菱形继承

#include <iostream>
using namespace std;

//菱形继承

//动物类
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 test()
{
	SheepTuo st;
	st.Sheep::m_Age = 10;
	st.Tuo::m_Age = 20;
	//当菱形继承 两个父类拥有相同的数据 需要加以区分
	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;//都是20
    //对于我们来说 我们只需要一份数据就可以了 菱形继承导致数据有两份 资源浪费
}

int main()
{
	test();

	return 0;
}