【C++ 进阶】继承（上）：解锁代码复用的核心密码，体会代码复用的魅力！

class Student
{
public :
	// 身份验证
	void identity()
	{} 

	// 学习
	void study()
	{
		cout << _name << "：正在学习" << endl;
	}
protected:
	string _name = "张三"; // 姓名
	string _address; // 地址
	string _tel; // 电话
	int _age = 18; // 年龄
	int _stuid; // 学号
};

class Teacher
{
	public :
	// 省份验证
	void identity()
	{}

	// 授课
	void teaching()
	{
		cout << _name << ":正在授课" << endl;
	}
protected:
	string _name = "李四"; // 姓名
	int _age = 25; // 年龄
	string _address; // 地址
	string _tel; // 电话
	string _title; // 职称
};

//定义一个person类定义共同特性
class Person
{
public:
	//身份验证
	void identity()
	{
		cout << "void identity()" << _name << endl;
	}
protected:
	string _name = "张三"; // 姓名
	string _address; // 地址
	string _tel; // 电话
	int _age; // 年龄
};
//定义一个student类继承person类
class Student : public Person
{
public:
	void print()
	{
		_name = "李四";
		_age = 18;
		cout << "姓名:" << _name << endl;
		cout << "学号:" << _stuid << endl;
	}
	// 学习
	void study()
	{
		cout << _name << ":正在学习" << endl;
	}
protected:
	int _stuid=241610101; // 学号
};
//定义一个teacher类继承person类
class Teacher : public Person
{
public:
	void print()
	{
		_name = "王五";
		_age = 25;
		cout <<"姓名:" << _name << endl;
		cout << "职称:" << _title << endl;
	}
	// 授课
	void teaching()
	{
		cout << _name << "：正在授课中" << endl;
	}

protected:
	string _title="老师"; // 职称
};

int main()
{
	Student s;
	s.print();
	s.study();

	Teacher t;
	t.print();
	t.teaching();

	return 0;
}

#include<iostream>
#include<vector>
using namespace std;
//继承/组合
namespace my_stack
{
//=========================
//类模板:stack<T>
//继承自std::vector<T>的模板
//使用vector的特定来模拟栈
//=========================
	template<class T>
	class stack : public std::vector<T>
	{
		//不写public公有 默认就是私有 私有的话类外面访问不到
	public:
	
		void push(const T& x)
		{
			//C++中栈的底层是使用vector来实现的 所以是栈继承了vector
			//当基类(父类)是模板时，派生类(子类)在使用父类的函数时就要指定类域
			//否则就会编译报错说push_back找不到标识符
			// 因为stack<int>实例化时，也实例化vector<int>了
			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
			//push_back(x);
			vector<T>::push_back(x);

		}

		void pop()
		{
			vector<T>::pop_back();
		}

		const T& top()
		{
			return vector<T>::back();
		}

		bool empty()
		{
			return vector<T>::empty();
		}
	};
}

int main()
{
	bit::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	} 
	return 0;
}

int a=1;
const double& b=a;//不加const编译报错！

#include <iostream>
using namespace std;

// 基类
class Base {
public:
	int base_data;
};

// 派生类
class Derived : public Base {
public:
	int derived_data;

};

int main() {

	Derived d;
	d.base_data = 10;
	d.derived_data = 20;

	Base b;
	b = d;//发生切片
	cout << b.base_data << endl;//基类b只能看到base_data这一成员！！

	return 0;
}

Base& ref = d;  // 通过引用访问，保留派生类完整性
Base* ptr = &d; // 通过指针访问，保留派生类完整性

class Person
{
public:
	void Display()
	{
		cout << "姓名" << _name << endl;
		cout << "年龄" << _age << endl;
	}
protected:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};
class Student : public Person
{
public:
	void study()
	{
		_name = "张三";
		cout << _name << "正在学习" << endl;
	}
public:
	int _No; // 学号
};
int main()
{
	Student sobj;

	//基类指针/引用指向/引用派生类对象
	Person* p= &sobj; //基类指针指向 student
	Person& rp = sobj;//引用绑定到 student

	//=========基类的指针访问派生类=========
	p->Display();//✅只能访问派生类中基类部分的成员
	//p->stduy();//❌语法上看不到派生类特有的部分

	//=========基类引用访问派生类===========
	rp.Display();//✅同上
	//rp.study();//❌

	//==============赋值问题==============

	// 派生类对象可以赋值给基类的对象是通过调用
	//Person pobj = sobj;

	//2.基类对象不能赋值给派生类对象，这里会编译报错
	//sobj = pobj;
	return 0;
}

class Person
{
protected:
	string _name = "张三"; // 姓名
	int _age = 20; // 年龄
};
class Student : public Person
{
public:
	void print()
	{
		cout << "姓名:" << _name << endl;
		//=================隐藏==============
		cout << "年龄:" << _age << endl;//这里的_age与派生类的_age就构成了隐藏关系 默认访问的是派生类的
		cout << "年龄:" << Person::_age << endl;//想要访问基类的_age 指定类域！！
	}
protected:
	int _stuid = 241610101; // 学号
	int _age = 18;
};
int main()
{
	Student t;
	t.print();
	return 0;
}