《C++ 继承》三大面向对象编程——继承：代码复用与功能扩展的核心机制

class Student
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
	void identity()
	{
		// ...
	}
	// 学习 
	void study()
	{
		// ...
	}
protected:
	string _name = "peter"; // 姓名 
	string _address; // 地址 
	string _tel; // 电话 
	int _age = 18; // 年龄 
	int _stuid; // 学号 
};
class Teacher
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证 
	void identity()
	{
		// ...
	}
	// 授课 
	void teaching()
	{
		//...
	}
protected:
	string _name = "Cx330"; // 姓名 

class Person
{
public:
	//进入校园/图书馆/实验室刷二维码等身份认证
	void identity()
	{
		cout << "void indetity" << _name << endl;
	}
	void func()
	{
		cout << _age << endl;
	}
protected:
	string _name = "Cx330";
	string _address;//地址
	string _tel;//电话
private:
	int _age = 18;
};

class Student :public Person
{
public:
	void study()
	{
		//...学习
		//基类私有成员，派生类不可见,语法上限制不能直接使用
		//cout << _age << endl;
		
		//但是可以间接使用
		func();
	}
protected:
	int _stuid;//学号
};

class Teacher : public Person
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
	void identity()
	{
		// ...
	}
	// 授课
	void teaching()
	{
		//...
	}
protected:
	string _title; // 职称
};

int main()
{
	Student s;
	Teacher t;
    
    s.identity();   
    s.study();

	return 0;
}

namespace Cx330
{
	template<class T>
	class stack : public vector<T>
	{
	public:
		void push(const T& x)
		{
			// 但是模版是按需实例化的，调用了哪个成员函数，就实例化哪个
			// push_back等成员函数未实例化，所以找不到
			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()
{
	Cx330::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << endl;
		st.pop();
	}
 
	//// 但是模版是按需实例化的，调用了哪个成员函数，就实例化哪个
	//// 构造/析构/push_back会实例化,其他成员函数就不会实例化
	//vector<int> v;
	//v.push_back(1);
 
	return 0;
}

int i=l；
const double&d = i;

class Person
{
protected:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};

class Student : public Person
{
public:
	int _No; // 学号
};

int main()
{
	int i = 1;
	double d = i;
	const double& rd = i;

	string s1 = "11111";
	const string& rs = "11111";

	Student s;
	Person p = s;
	
	//特殊处理
	Person& rp = s;
	Person* ptr = &s;

	//不支持(p = s)父不能传子
	//s = (Student)p;

	return 0;
}

//派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问
class Person
{
protected:
	string _name = "⼩李⼦"; // 姓名 
	int _num = 111; // ⾝份证号 
};

class Student : public Person
{
public:
	void Print()
	{
		cout << _num << endl;
		cout <<Person:: _num << endl;
	}
protected:
	int _num = 999; // 学号 
};

//隐藏
//需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏,参数是否相同不重要
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		cout << "func(int i)" << i << endl;
	}
};

int main()
{
	//Student s;
	//s.Print();//999

	B b;
	b.fun(10);
	//b.fun();//error
	b.A::fun();//解决方案

	return 0;
}

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名 
};

class Student : public Person
{
public:
	Student(const char* name = "张三", int num = 18, string address = "郑州")
		:Person(name)
		,_num(num)
		,_address(address)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		:Person(s)
		,_num(s._num)
		,_address(s._address)
	{
		//深拷贝，需要自己实现
	}

	//隐藏基类的赋值重载
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			_num = s._num;
			_address = s._address;
		}
		return *this;
		//深拷贝，需要自己实现
	}

	~Student()
	{
		//因为多态中⼀些场景析构函数需要构成重写，
		//那么编译器会对析构函数名进⾏特殊处理，处理成destructor()，
		// 所以基类析构函数不加virtual的情况下，派⽣类析构函数和基类析构函数构成隐藏关系
		//不要显示调用基类析构，编译器会在派生类析构结束后自动调用基类析构
		//Person::~Person();
		cout << "~Student()" << endl;
	}
	//构造先父后子，析构先子后父，如果显式调用，无法保证先子后父的析构顺序
protected:
	int _num; //学号 
	string _address;//地址
};

#include<iostream>
#include<vector>
#include<list>
using namespace std;

//class Person
//{
//public:
//	//进入校园/图书馆/实验室刷二维码等身份认证
//	void identity()
//	{
//		cout << "void indetity" << _name << endl;
//	}
//	void func()
//	{
//		cout << _age << endl;
//	}
//protected:
//	string _name = "Cx330";
//	string _address;//地址
//	string _tel;//电话
//private:
//	int _age = 18;
//};
//
//class Student :public Person
//{
//public:
//	void study()
//	{
//		//...学习
//		//基类私有成员，派生类不可见,语法上限制不能直接使用
//		//cout << _age << endl;
//		
//		//但是可以间接使用
//		func();
//	}
//protected:
//	int _stuid;//学号
//};
//
//class Teacher : public Person
//{
//public:
//	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
//	void identity()
//	{
//		// ...
//	}
//	// 授课
//	void teaching()
//	{
//		//...
//	}
//protected:
//	string _title; // 职称
//};
//
//int main()
//{
//	Student s;
//	Teacher t;
//
//	s.identity();
//	s.study();
//
//	return 0;
//}

//namespace Cx330
//{
//	template<class T>
//	class stack : public std::vector<T>
//	{
//	public:
//		void push(const T& x)
//		{
//			// 基类是类模板时，需要指定⼀下类域，
//			// 否则编译报错:error C3861: “push_back”: 找不到标识符
//			// 因为stack<int>实例化时，也实例化vector<int>了
//			// 但是模版是按需实例化，push_back等成员函数未实例化，所以找不到
//			// 调用了哪个，才实例化哪个
//			vector<T>::push_back(x);
//			//push_back(x);
//		}
//		void pop()
//		{
//			vector<T>::pop_back();
//		}
//		const T& top()
//		{
//			return vector<T>::back();
//		}
//		bool empty()
//		{
//			return vector<T>::empty();
//		}
//	};
//}
//
//int main()
//{
//	Cx330::stack<int> st;
//	st.push(1);
//	st.push(2);
//	st.push(3);
//	while (!st.empty())
//	{
//		cout << st.top() << " ";
//		st.pop();
//	}
//
//	// 但是模板是按需实例化，调用哪个成员函数，就实例化哪个
//	// 构造/析构/push_back()
//	vector<int> v;
//	v.push_back(1);
//
//	return 0;
//}

//class Person
//{
//protected:
//	string _name; // 姓名
//	string _sex; // 性别
//	int _age; // 年龄
//};
//
//class Student : public Person
//{
//public:
//	int _No; // 学号
//};
//
//int main()
//{
//	int i = 1;
//	double d = i;
//	const double& rd = i;
//
//	string s1 = "11111";
//	const string& rs = "11111";
//
//	Student s;
//	Person p = s;
//	
//	//特殊处理
//	Person& rp = s;
//	Person* ptr = &s;
//
//	//不支持(p = s)父不能传子
//	//s = (Student)p;
//
//	return 0;
//}

//派⽣类和基类中有同名成员，派⽣类成员将屏蔽基类对同名成员的直接访问
//class Person
//{
//protected:
//	string _name = "⼩李⼦"; // 姓名 
//	int _num = 111; // ⾝份证号 
//};
//
//class Student : public Person
//{
//public:
//	void Print()
//	{
//		cout << _num << endl;
//		cout <<Person:: _num << endl;
//	}
//protected:
//	int _num = 999; // 学号 
//};

//隐藏
//需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏,参数是否相同不重要
//class A
//{
//public:
//	void fun()
//	{
//		cout << "func()" << endl;
//	}
//};
//class B : public A
//{
//public:
//	void fun(int i)
//	{
//		cout << "func(int i)" << i << endl;
//	}
//};
//
//int main()
//{
//	//Student s;
//	//s.Print();//999
//
//	B b;
//	b.fun(10);
//	//b.fun();//error
//	b.A::fun();//解决方案
//
//	return 0;
//}

class Person
{
public:
	Person(const char* name = "peter")
		: _name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
		: _name(p._name)
	{
		cout << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p)
	{
		cout << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person()
	{
		cout << "~Person()" << endl;
	}
protected:
	string _name; // 姓名 
};
//
class Student : public Person
{
public:
	Student(const char* name = "张三", int num = 18, string address = "郑州")
		:Person(name)
		,_num(num)
		,_address(address)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		:Person(s)
		,_num(s._num)
		,_address(s._address)
	{
		//深拷贝，需要自己实现
	}

	//隐藏基类的赋值重载
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			_num = s._num;
			_address = s._address;
		}
		return *this;
		//深拷贝，需要自己实现
	}

	~Student()
	{
		//因为多态中⼀些场景析构函数需要构成重写，
		//那么编译器会对析构函数名进⾏特殊处理，处理成destructor()，
		// 所以基类析构函数不加virtual的情况下，派⽣类析构函数和基类析构函数构成隐藏关系
		//不要显示调用基类析构，编译器会在派生类析构结束后自动调用基类析构
		//Person::~Person();
		cout << "~Student()" << endl;
	}
	//构造先父后子，析构先子后父，如果显式调用，无法保证先子后父的析构顺序
protected:
	int _num; //学号 
	string _address;//地址
};

//继承的基类成员变量（整体对象）+自己的成员变量(遵循普通的规则，跟类和对象部分一样)

//本质可以把派生类当作多了一个自定义类型成员变量（基类）的普通类，跟普通类原则基本一样
//派生类一般要自己实现构造，不需要显示写析构、拷贝、赋值重载，除非派生类由深拷贝的资源需要处理

int main()
{
	Student s1;
	//Student s2("小明", 10);
	//Student s3(s2);

	//s1 = s3;

	return 0;
}