【C++干货基地】C++继承攻略：实现多态基础与代码复用的利器

class Person
{
public:
 void Print()
 {
 cout << "name:" << _name << endl;
 cout << "age:" << _age << endl;
 }
protected:
 string _name = "peter"; // 姓名
 int _age = 18;  // 年龄
};
// 继承后父类的Person的成员（成员函数+成员变量）都会变成子类的一部分
class Student : public Person
{
protected:
 int _stuid; // 学号
};

class Person
{
protected :
 string _name; // 姓名
    string _sex;  // 性别
    int _age; // 年龄
};
class Student : public Person
{
public :
 int _No ; // 学号
};
void Test ()
{
 Student sobj ;
 // 1.子类对象可以赋值给父类对象/指针/引用
 Person pobj = sobj ;
 Person* pp = &sobj;
 Person& rp = sobj;
    
 //2.基类对象不能赋值给派生类对象
    sobj = pobj;
    
    // 3.基类的指针可以通过强制类型转换赋值给派生类的指针
    pp = &sobj
    Student* ps1 = (Student*)pp; // 这种情况转换时可以的。
    ps1->_No = 10;
    
    pp = &pobj;
 Student* ps2 = (Student*)pp; // 这种情况转换时虽然可以，但是会存在越界访问的问
题
    ps2->_No = 10;
}

// Student的_num和Person的_num构成隐藏关系，可以看出这样代码虽然能跑，但是非常容易混淆
class Student : public Person
{
public:
	void func()
	{
		cout << _name << endl;
		Print();
	}
protected:
	int _stuid; // 学号
};
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; // 学号
};
void Test()
{
	Student s1;
	s1.Print();
};

// B中的fun和A中的fun不是构成重载，因为不是在同一作用域
// B中的fun和A中的fun构成隐藏，成员函数满足函数名相同就构成隐藏。
class A
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
};
class B : public A
{
public:
	void fun(int i)
	{
		A::fun();
		cout << "func(int i)->" << i << endl;
	}
};
void Test()
{
	B b;
	b.fun(10);
};

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;
	}
protected:
	string _name; // 姓名
};

class Student : public Person
{
public:
	// 父类+自己，父类的调用父类构造函数初始化（复用）
	Student(int num, const char* str, const char* name)
		:Person(name)
		, _num(num)
		, _str(str)
	{
		cout << "Student()" << endl;
	}

	Student(const Student& s)
		:Person(s)
		, _num(s._num)
		, _str(s._str)
	{}

protected:
	int _num;	 //学号
	string _str;
	/ 父类成员，当成一个整体的一个自定义类型成员
	// 子类的成员(跟以前一样)
	// a、内置类型
	// b、自定义类型
};

int main()
{
	Student s1(1, "xxxx", "张三");
}

// s2(s1)
	Student(const Student& s)
		:Person(s)//这里有隐式类型转换 （切片）
		,_num(s._num)
		,_str(s._str)
	{}

Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);
			_num = s._num;
			_str = s._str;
		}
		return *this;
	}

Student& operator=(const Student& s)
	{
		if (this != &s)
		{
			Person::operator=(s);//要注意这里一定要显示调用基类operator=
			_num = s._num;       // 否者子类和父类构成隐藏，导致无限递归
			_str = s._str;
		}
		return *this;
	}

// 子类的析构也会隐藏父类
	// 因为后续多态的需要，析构函数名字会被统一处理成destructor
	~Student()
	{
		// 显示写无法先子后父
		//Person::~Person();

		cout << _name << endl;
		cout << "~Student()" << endl;

		// 注意，为了析构顺序是先子后父，子类析构函数结束后会自动调用父类析构
	}