C++ 继承：代码传承的魔法棒，开启奇幻编程之旅

class person
{
public:
	//……
protected:
	string _name;//姓名
	int _age;//年龄
	int _tel;//电环
	string _address;//地址
};

//其中person称为基类，又称为父类，student称为派生类，又称为子类。冒号后边跟上的publi称为继承方法
//在student类中就不需要实现关于人的成员变量、函数，复用了person类的成员
class student : public person
{
public:
	//
private:
	int _id;//学号
};

//还需要自己定义，自己实现相关的成员变量，成员函数，变得比较麻烦
class student
{
public:
	//
private:
	string _name;//姓名
	int _age;//年龄
	int _tel;//电环
	string _address;//地址

	int _id;//学号
};

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

template<class T>
class Stack : public vector<T>//继承模板
{
public:
	void push(const T& x)
	{
		//push_back(x); 
		vector<T>::push_back(x);//指定类域
	}
};

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

template<class T>
class Stack : public vector<T>//继承模板
{
public:
	void push_back(const T& x)
	{
        //在通过继承模板实现的栈类中，当 `Stack<int>`  实例化后 `vector<int>`也会进行实例化，但模板是按需实例化的，即你需要使用那部分的函数，编译器帮你实例化那部分，当调用基类中的成员函数时，它并未实例化，编译器并不会认识它。当指定类域后，编译器就会来指定的类域中实例化这个成员函数。
         push_back(x);
		vector<T>::push_back(x);//指定类域
	}
	const T& top()
	{
		vector<T>::back();
	}
	void pop()
	{
		vector<T>::pop_back();
	}
	bool empty()
	{
		return vector<T>::empty();
	}
};

template<class container>
void print(const container& c)
{
   	container::const_iterator it = c.begin();
	typename container::const_iterator it = c.begin();//使用typename指定，container::const_iterator是一个类型

	while (it != c.end())
	{
		cout << *it << " ";
		it++;
	}
	cout << endl;
}
int main()
{
	Stack<int> st1;
	st1.push_back(1);
	st1.push_back(2);
	st1.push_back(3);
	st1.push_back(4);
	st1.push_back(5);
	
	print(st1);
	return 0;
}

class person
{
public:
	person()
		: _name()
		, _age(18)
		, _tel(123123)
		, _address()
	{}
protected:
	string _name;//姓名
	int _age;//年龄
	int _tel;//电环
	string _address;//地址
};
class student : public person
{
public:
	student()
	{
		_name = "小晨";
		_age = 20;
		_tel = 666;
		_address = "csdn";
		_id = 987;
	}
private:
	int _id;//学号
};
int main()
{
	student stu;
	person* per1 = &stu;
	person& per2 = stu;

	person per3 = stu;
	return 0;
}

#include <iostream>
#include <string>

using namespace std;

class person
{
public:
	person(const char* name = " ")
	{
		cout << "constructor person" << endl;
	}
	person(const person& p1)
	{
		cout << "person(const person& p1)" << endl;
	}

	person& operator=(const person& p)
	{
		if (this != &p)
		{
			cout << "person& operator=(const person&)" << endl;
		}
		return *this;
	}

	~person()
	{
		cout << "destructor person" << endl;
	}


protected:
	string _name;//姓名
};

class student : public person
{
public:
	//student(const char* name = " ")
	//	:_name(name)      // 错误的初始化
	//	,_id(2024)  
	//{ //基类会被当作一个整体进行初始化，也就是说，编译器不会再派生类中一个一个的初始化基类成员变量
	//	cout << "constructor" << endl;
	//}

	student(const char* name = " ")
		:person(name)
		,_id(2024)
	{
		cout << "constructor student" << endl;
	}
	
	student(const student& s)//
		:person(s)//派生类对象赋值给基类的引用，发生了切片行为，切分出基类那份成员变量
	{
		cout << "student(const student& s)" << endl;
	}

	student& operator=(const student& p)
	{
        if (this != &p)
		{
			// operator=(p); //必须之类基类类域，同名函数发生了隐藏行为
			person::operator=(p);
			// 必须显示调用基类的赋值重载函数
			cout << "student& operator=(const student&)" << endl;
		}
		return *this;
	}

	~student()
	{
		cout << "destructor student" << endl;
	}

private:
	int _id = 1;//学号
};

int main()
{
	student s1;
	return 0;
}

#include <iostream>
#include <string>

using namespace std;

class person final
{
protected:
	string _name;//姓名
};

class student : public person
{
private:
	int _id = 1;//学号
};
int main()
{
	student s1;
	return 0;
}

#include <iostream>
#include <string>

using namespace std;

class student;
class person
{
	friend void Fun(const person& per, const student& stu);
protected:
	string _name;//姓名
};
class student : public person
{

private:
	int _id;//学号
};
void Fun(const person& per, const student& stu)
{
	cout << per._name << endl;
	cout << stu._id << endl;//无法被访问。
    					  //解决：将Fun也变为student的友元即可被访问
}
int main()
{
	person per;
	student stu;

	Fun(per, stu);
	return 0;
}

#include <iostream>
#include <string>

using namespace std;

class person
{
public:
	string _name;
	static int _count;
};
int person::_count = 0;

class student : public person
{
private:
	int _id;
};

int main()
{
	person p1;
	student s1;

	cout << &p1._name << endl;
	cout << &s1._name << endl;

	cout << &s1._count << endl;
	cout << &p1._count << endl;
	return 0;
}

#include <iostream>
#include <string>

using namespace std;
class person
{
public:
	string _name;
};

class student : public person
{
protected:
	int _id;//学号
};

class teacher : public person
{
protected:
	int _job_num;//工号
};

class Classroom : public student, public teacher
{
protected:
	string _course;
};

int main()
{
	Classroom Class;

	//Class._name = "john";// error C2385: 对“_name”的访问不明确

	//指定访问解决二义性，但无法解决数据冗余
	Class.student::_name = "john";
	Class.teacher::_name = "sophia";
	return 0;
}

#include <iostream>

using namespace std;

class Animal
{
public:
	Animal()
	{
		cout << "Animal()" << endl;
	}
protected:
	bool _herbivore;//食草
};

// 虚继承animal
class bird : virtual public Animal
{
public:
	bird()
	{
		cout << "bird()" << endl;
	}
};
// 虚继承 继承animal
class fish : virtual public Animal
{
public:
	fish()
	{
		cout << "fish()" << endl;
	}
};
// 使用虚继承后就存在数据的二义性、冗余的问题
class flyingfish : public bird, public fish
{
public:
	flyingfish()
	{
		cout << "flyingfish()" << endl;
	}
};
int main()
{
	flyingfish ffish;
	ffish._herbivore = true;

	return 0;
}