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 = "張三"; // 姓名 
 int _age = 18; // 年齡 
 string _address; // 地址 
 string _tel; // 電話 
 string _title; // 職稱 
};
int main()
{
 return 0;
}

class Person
{
public:
 // 進⼊校園/圖書館/實驗室刷⼆維碼等⾝份認證 
 void identity()
 {
 cout << "void identity()" <<_name<< endl;
 }
protected:
 string _name = "張三"; // 姓名 
 string _address; // 地址 
 string _tel; // 電話 
 int _age = 18; // 年齡 
};

class Student : public Person
1{
public:
 // 學習 
 void study()
 {
 // ...
 }
protected:
 int _stuid; // 學號 
};


class Teacher : public Person
{
public:
 // 授課 
 void teaching()
 {
 //...
 }
protected:
 string title; // 職稱 
};
int main()
{
 Student s;
 Teacher t;
 s.identity();
 t.identity();
 return 0;
}

namespace bit
{
 //template<class T>
 //class vector
 //{};
 // stack和vector的關係，既符合is-a，也符合has-a 
 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()
{
 bit::stack<int> st;
 st.push(1);
 st.push(2);
 st.push(3);
 while (!st.empty())
 {
 cout << st.top() << " ";
 st.pop();
 }
 return 0;
}

class Person
{
protected :
 string _name; // 姓名 
 string _sex; // 性別 
 int _age; // 年齡 
};
class Student : public Person
{
public :
 int _No ; // 學號 
};
int main()
{
 Student sobj ;
 // 1.派⽣類對象可以賦值給基類的指針/引⽤ 
 Person* pp = &sobj;
 Person& rp = sobj;
 
 // 派⽣類對象可以賦值給基類的對象是通過調⽤後⾯會講解的基類的拷⻉構造完成的 
 Person pobj = sobj;
 
 //2.基類對象不能賦值給派⽣類對象，這⾥會編譯報錯 
 sobj = pobj;
 
 return 0;
}

// Student的_num和Person的_num構成隱藏關係，可以看出這樣代碼雖然能跑，但是⾮常容易混淆 
class Person
{
protected :
 string _name = "⼩李⼦"; // 姓名 
 int _num = 111; // ⾝份證號 
};
class Student : public Person
{
public:
 void Print()
 {
 cout<<" 姓名:"<<_name<< endl;
 cout<<" ⾝份證號:"<<Person::_num<< endl;
 cout<<" 學號:"<<_num<<endl;
 }
protected:
 int _num = 999; // 學號 
};
int main()
{
 Student s1;
 s1.Print();
 
 return 0;
};

class Person
{
public:
	Person(const char* name)
		:_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, const char* 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()
	{
		//// 不用顯示調用基類析構，編譯器會在派生類析構結束之後自動調用析構
		//Person::~Person();
		//// ...
		// 隱式原因：為了安全性
		cout << "~Student()" << endl;
	}
 
protected:
	int _num; // 學號
	string _address; // 地址
	//int* _ptr;
};