深入剖析【C++继承】：单一继承与多重继承的策略与实践，解锁代码复用和多态的编程精髓，迈向高级C++编程之旅

#include<iostream>
using namespace std;

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

#include<iostream>
using namespace std;
//Person

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

//学生
class Student:Person//继承Person
{
public:
	// 学习 
	void study()
	{
		// ...
	}

protected:
	int _stuid;             // 学号 

};

//老师
class Teacher:Person//继承Person
{
public:


	// 授课 
	void teaching()
	{
		//...
	}

protected:
	string _title;         // 职称 

};

int main()
{

	return 0;
}

namespace bit
{
	template<class T>
	//继承vector,直接调用vector的成员函数，来完成stack栈
	class stack : 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 size()
		{
			return vector<T>::size();
		}
	};
}


int main() 
{
	bit::stack<int> s1;
	s1.push(1);
	s1.push(2);
	s1.push(3);
	s1.push(4);
	cout << "size:" << s1.size() << endl;
	while (!s1.empty())
	{
		cout << s1.top() << endl;
		s1.pop();
	}

	return 0;
}

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是⾮常容易混淆 
class Person
{
protected:
	string _st = "李4"; // 姓名 
	int _num = 99;      //年龄
};

class Student : public Person
{
public:
	void print()
	{
		cout << "姓名:" << _st << endl;
		cout << "年龄:" << _num << endl;
	}
protected:
	int _num = 10; //年龄
};
int main()
{
	Student s1;
	s1.print();
	return 0;
}

class Person
{
public:
	void print()
	{
		cout << "您好" << endl;
	}
protected:
	string _st = "李4"; // 姓名 
	int _num = 99;      //年龄
};

class Student : public Person
{
public:
	void print()
	{
		cout << "姓名:" << _st << endl;
		cout << "年龄:" << Person::_num << endl;
	}
protected:
	int _num = 10; //年龄
};
int main()
{
	Student s1;
	s1.Person::print();

	return 0;
}

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()
{
 B b;
 b.fun(10);
 b.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)
		: Person(name)
		, _num(num)
	{
		cout << "Student()" << endl;
	}
	Student(const Student& s)
		: Person(s)
		, _num(s._num)
	{
		cout << "Student(const Student& s)" << endl;
	}
	Student& operator = (const Student& s)
	{
		cout << "Student& operator= (const Student& s)" << endl;
		if (this != &s)
		{
			// 构成隐藏，所以需要显⽰调⽤
			Person::operator =(s);
			_num = s._num;
		}
		return *this;
	}
	~Student()
	{
		cout << "~Student()" << endl;
	}
protected:
	int _num; //学号
};
int main()
{
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
	return 0;
}

// C++11的⽅法
class Base final
{
public:
	void func5() { cout << "Base::func5" << endl; }
protected:
	int a = 1;
private:
	// C++98的⽅法
	/*Base()
	{}*/
};
class Derive :public Base
{
	void func4() { cout << "Derive::func4" << endl; }
protected:
	int b = 2;
};

int main()
{
	Base b;
	Derive d;
	return 0;
}

class Student;

class Person
{
public:

	friend void Display(const Person& p, const Student& s);

protected:
	string _name; // 姓名
};

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

void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;
	cout << s._stuNum << endl;
}

int main()
{
	Person p;
	Student s;
	// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员
	// 解决⽅案：Display也变成Student 的友元即可
	Display(p, s);
	return 0;
}

class Person
{
public:
	string  _name; // 姓名 

};

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

class Teacher: public Person
{
protected:
	int _id; // 职⼯编号 

};
class Assistant:public Student,public Teacher
{
protected:
	string _majorCourse; // 主修课程 
};
int main()
{
	// 编译报错：error C2385: 对“_name”的访问不明确 
	Assistant a;
	a._name = "aaaaa";

	// 需要显⽰指定访问哪个基类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决 
	a.Student::_name = "xxxx";
	a.Teacher::_name = "yyyy";

	return 0;
}

template<class CharT, class Traits = std::char_traits<CharT>>
class basic_ostream : virtual public std::basic_ios<CharT, Traits>
{};
template<class CharT, class Traits = std::char_traits<CharT>>
class basic_istream : virtual public std::basic_ios<CharT, Traits>
{};

class Base1 { public: int _b1; };
class Base2 { public: int _b2; };
class Derive : public Base1, public Base2 { public: int _d; };
int main()
{
 Derive d;
 Base1* p1 = &d;
 Base2* p2 = &d;
 Derive* p3 = &d;
 
 return 0;
}

// Tire(轮胎)和Car(⻋)更符合has-a的关系 
class Tire {
protected:
	string _brand = "Michelin"; // 品牌 
	size_t _size = 17; // 尺⼨ 
};
class Car {
protected:
	string _colour = "⽩⾊"; // 颜⾊ 
	string _num = "陕ABIT00"; // ⻋牌号 
	Tire _t1; // 轮胎 
	Tire _t2; // 轮胎 
	Tire _t3; // 轮胎 
	Tire _t4; // 轮胎 
};
class BMW : public Car {
public:
	void Drive() { cout << "好开-操控" << endl; }
};
// Car和BMW/Benz更符合is-a的关系 
class Benz : public Car {
public:
	void Drive() { cout << "好坐-舒适" << endl; }
};
template<class T>
class vector
{};
// stack和vector的关系，既符合is-a，也符合has-a 
template<class T>
class stack : public vector<T>
{};
template<class T>
class stack
{
public:
	vector<T> _v;
};
int main()
{
	return 0;
}