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 = "张三"; // 姓名
	int _age = 18; // 年龄
	string _address; // 地址
	string _tel; // 电话
	string _title; // 职称
};


//我们看到没有继承之前我们设计了两个类Student和Teacher，Student和Teacher都有姓名 / 地址 /
//电话 / 年龄等成员变量，都有identity⾝份认证的成员函数，设计到两个类⾥⾯就是冗余的。
//继承方式把两个类中的公有成员提取出来，设计成一个类，在继承这个类
class Person
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
	void identity()
	{
		// ...
	}

protected:
	string _name = "peter"; // 姓名
	string _address; // 地址
	string _tel; // 电话
	int _age = 18; // 年龄
};

class Student :public Person
{
public:
	// 学习
	void study()
	{
		// ...
	}
protected:
	int _stuid; // 学号

};

class Teacher :public Person
{
public:
	// 授课
	void teaching()
	{
		//...
	}
protected:
	string _title; // 职称
};

//1基类中的private(私有成员)不管与什么继承方式都在派生类中不可见，
// 但是不一定是不能使用，可以在基类中设计一个公有函数进行访问。例如父亲的私房钱虽然不可见，但是可以通过简介的方式得到(全部告诉妈妈)。
//2基类中的其他类型成员在派生类中的限制是，基类中成员变量的访问限定符和派生类的继承方式两种访问限定符种更小的一个


class Person
{
public:
	// 进⼊校园/图书馆/实验室刷⼆维码等⾝份认证
	void identity()
	{
		// ...
	}
	//为了满足基类中的私有成员可以在派生类中可见，在基类中设计一个公有函数进行访问。
	void func()
	{
		++_age;
	}

protected:
	string _name = "peter"; // 姓名
	string _address; // 地址
	string _tel; // 电话
private:
	int _age = 18; // 年龄
};

class Student :public Person
{
public:
	// 学习
	void study()
	{
		// ...
		_name = "张三";
	}
protected:
	int _stuid; // 学号
};

class Teacher :public Person
{
public:
	// 授课
	void teaching()
	{
		//...
		//_age++;基类中的(private)私有成员，不管与哪种方式继承，都是在派生类中不可见
	}
protected:
	string _title; // 职称
};

int main()
{
	Student s;
	Teacher t;
	//s._name;基类中的(protected)保护成员，通过tublic(公有继承)是派生类中的保护成员,在类外不可见，在类中可将
	s.identity();//基类中的公有成员，通过tublic(公有继承)是派生类中的公有成员;
	s.func();//对基类中的私有成员进行访问;
	t.identity();
	return 0;
}

//原来实现一个栈是一个组合(类中有一个类)后面会讲
template<class T,class Container>
class Stack
{

private:
	Container _con;
};

//继承-模板继承
//私有模板继承私有一个栈
namespace wzy
{
	
	// 
	template<class T>
	class stack : public std::vector<T>//如果展开了std就不用指定
	{
	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()
{
	wzy::stack<int> st;
	st.push(1);
	st.push(2);
	st.push(3);
	while (!st.empty())
	{
		cout << st.top() << " ";
		st.pop();
	}
	return 0;
}

int main()
{
//为什么i加引用，不加const会报错.
//原因在于赋值转化时，首先会将变量d转化为int类型并将结果存在一个临时变量里
//所以这里引用绑定的对象实际是这个临时变量，所以必须加const,否则会编译报错。
	double d = 1.2;
	//int& i = d; //error
	const int& i = d;
	return 0;
}

class Person
{
protected:
	string _name; // 姓名
	string _sex; // 性别
	int _age; // 年龄
};
class Student : public Person
{
public:
	int _No; // 学号
};
int main()
{
	Student sobj;
	//派⽣类对象可以赋值给基类的指针/引⽤,并且中间不会产生临时变量
//将派生类对象赋值给 基类的指针 / 基类的引⽤，从而可以得到派⽣类中基类(两者共有）那部分叫切⽚或者切割。
	Person* pp = &sobj;
	Person& rp = sobj;
	
	return 0;
}

//基类和派⽣类间的转换-建立在公有(public)继承的方式条件下
//将派生类对象赋值给 基类的指针 / 基类的引⽤，从而可以得到派⽣类中基类那部分叫切⽚或者切割。
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;
 

//像类型转化之间会产生临时对象，所以要用const修饰；
//而将派生类对象赋值给基类的指针/基类的引⽤，虽然它们之间类型比特但是它们之间进行转换是不会产生临时对象
int i = 1;
const double& d = i;
	return 0;
}

//1成员变量形成隐藏,怎么访问基类中的成员变量-通过指定命名空间
class Person
{
protected:
	string _name = "wdefg"; // 姓名
	int _num = 111; // ⾝份证号
};
class Student : public Person
{
public:
	void Print()
	{
		cout << "姓名:" << _name << endl;
		cout << "身份证号:" << Person ::_num<< endl;//要想访问基类中的_num成员变量，由于和派生类中的变量_num形成隐藏，所以要指定命名空间访问
		cout << "学号:" <<_num<< endl;//就像我们前面讲的全局/和局部中有同名变量一样，先从局部中找局部没有才会到全局中找，
		//只有指定命名空间才会在其他地方查找（就近原则)，这里也是默认在派生类中找，只有指定在基类才会在基类中查找
	}
protected:
	int _num = 999; // 学号
};
int main()
{
	Student s1;
	s1.Print();
	return 0;
};

//成员函数形成隐藏,怎么访问基类中的成员函数-通过指定命名空间
// 注意基类和派生类之间成员函数之间形成隐藏与函数重载之间的区分
// 函数重载要建立在同一个作用域中(不在同一个作用域不用函数重载之说)，并且保证函数参数不同;
// 而基类和派生类之间成员函数之间形成隐，只需要保证函数名相同即可
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};

class B :public A
{
public:
	void fun(int i)
	{
		cout << "func(int i)" << endl;
	}
};

int main()
{
	B b;
	b.fun(1);//访问派生类中的成员函数
	b.A::fun();//访问基类中的成员函数
}

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
{
	//对于4大默认成员函数，其中默认构造函数一般都是自己手动写的，
	// 编译器自动生成的一般不能满足需求,当然你不想写，只要简单的实现也可以在声明的地方给缺省值
	//而对于拷贝构造，赋值重载，析构函数，一般都是同时出现的，只有深拷贝是才要手动的写(有资源管理)
	
	//这里我们主要学习怎么写派生类中的4大默认成员函数，这里我们只需要把基类当成以前的自定义类型一样处理，规则和前面讲的一样
public:
	//1默认构造
	//如果基类中有默认构造函数，和以前的自定义类型一样，就会自动调用对应的默认构造函数
	//那如果要自己手动写，此时就要调用基类中的默认构造函数，那怎么调用呢？通过基类名(参数)调用
	Student(const char* name, const char* address, int num)
		:Person(name)//自己手动写，此时就要调用基类中的默认构造函数，那怎么调用呢？通过基类名(参数)调
		,_address(address)
		,_num(num)
	{ }

	//拷贝构造
	//如果基类中有拷贝构造函数，和以前的自定义类型一样，就会自动调用对应的构造函数
	//那如果要自己手动写，此时就要调用基类中的拷贝构造函数，那怎么调用呢？通过基类名(参数)调用
	//此时就有一个问题怎么传参了(怎么通过派生类得到基类中的成员），由于基类中的拷贝构造函数是一个引用，所以这里可以使用前面的切⽚
	//将派生类对象赋值给 基类的指针 / 基类的引⽤，从而可以得到派⽣类中基类那部分。这也是为什么拷贝构造参数有引用的原因之一。
	Student(const Student& s)
		:Person(s)//显⽰调⽤基类的拷贝构造函数，可以通过切⽚进行传参
		,_address(s._address)
		,_num(s._num)
	{}

	//赋值重载
	//如果基类中有拷贝函数，和以前的自定义类型一样，就会自动调用对应的赋值函数
	//那如果要自己手动写，此时就要调用基类中的默认构造函数，那怎么调用呢？
	//由于基类和派生类中的赋值重载函数和基类中的赋值重载函数形成隐藏，所以显⽰调⽤基类的operator=，需要指定基类作⽤域
	Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//显⽰调⽤基类的operator=，需要指定基类作⽤域
			_address = s._address;
			_num = s._num;
		}
		return *this;
	}
	
	~Student()
	{
		//Person::~Person();//这里不显示调用基类的析构函数，由于编译器会对析构函数名进⾏特殊处理，处理成destructor()，所以派⽣类析构函数和基类析构函数构成隐藏关系
		//所以要调用基类的析构函数需要指定空间。而这里不显示调用基类的析构函数的原因是为了保证先子后父(由于基类中的成员可能在子类中会被用到，如果先析构父的就会出错）的析构顺序，
		// 编译器会在结束后在后面自动call基类的析构函数， 如果此时我们还显示调用就调用了两次就会出问题【核心还是编译器不放心程序员】
		//delete[] _ptr;
	}
protected:
	string _address = "李四";
	int _num = 1; //学号

	//资源管理
	//int* _ptr = new int[10];
};

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

// 前置声明
class Student;

class Person
{
public:
	friend void Display(const Person& p, const Student& s);
protected:
	string _name; // 姓名
};

// 友元关系不能继承
class Student : public Person
{
	friend void Display(const Person& p, const Student& s);
protected:
	int _stuNum; // 学号
};

//问题一如果将友元函数定义在基类中，此时找不到派生类；如果将派生类定义在基类之前此时派生类有找不到基类(这就是相互依赖关系）。
// 此时可以在基类前加一个派生类的声明，此时解决了问题1
//那怎么解决问题2怎么访问派生类中的私有成员，由于友元函数不能继承，所以只能在派生类中在定义成友元函数
void Display(const Person& p, const Student& s)
{
	cout << p._name << endl;//问题1
	//cout << s._stuNum << endl;//问题2
}

int main()
{
	Person p;
	Student s;

	// 编译报错：error C2248: “Student::_stuNum”: 无法访问 protected 成员
	// 解决方案：Display也变成Student 的友元即可
	Display(p, s);

	return 0;
}

class Person
{
public:
	string _name;
	static int _count;
};

int Person::_count = 0;

class Student : public Person
{
protected:
	int _stuNum;
};

int main()
{
	Person p;
	Student s;
	// 这里的运行结果可以看到非静态成员_name的地址是不一样的
	// 说明派生类继承下来了，父派生类对象各有一份，说明普通成员变量继承会生成副本
	cout << &p._name << endl;
	cout << &s._name << endl;

	// 这里的运行结果可以看到静态成员_count的地址是一样的
	// 说明派生类和基类共用同一份静态成员，说明静态成员变量继承不会生成副本
	cout << &p._count << endl;
	cout << &s._count << endl;


	Student s1;
	Person p1;
	cout << " 人数 :" << Person::_count << endl;
	Student s2;
	Student s3;
	cout << " 人数 :" << Person::_count << endl;


	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; // 主修课程
};

a.Student::_name = "wzy";
a.Teacher::_name = "wzz";

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

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

class Teacher : virtual public Person
{
protected:
	int _id; // 职工编号
};

class Assistant : public Student, public Teacher
{
protected:
	string _majorCourse; // 主修课程
};

void Test()
{
	Assistant a;
	a._name = "peter";
}

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