C++ 超详细梳理继承的概念与使用

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}

protected:
	string _name = "peter"; 
	int _age = 18; 
};

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

int main()
{
	Student s;
	s.Print();

	return 0;
}

#define _CRT_SECURE_NO_WARNINGS
#include <iOStream>
using namespace std;

class Person
{
public:
	void Print()
	{
		cout << "name:" << _name << endl;
		cout << "age:" << _age << endl;
	}

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

class Person
{
public:
	void fun()
	{
		cout << "func()" << endl;
	}
protected:
	string _name; 
	int _num; 
};

class Student : public Person
{
public:
	void fun(int i)
	{
		cout << "func(int i)->" << i << endl;
	}

	void Print()
	{
		cout << "num:" << _num << endl;
	}

protected:
	int _num = 10;
};

void Test()
{
	Student s1;
	s1.Print();
	s1.fun(1);
}

class Person
{
public:
	Person(const char* name = "perter")
		:_name(name)
	{
		cout << "Person()" << endl;
	}

	Person(const Person& p)
	{
		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;
};

void Test()
{
	Student s1("jack", 18);
	Student s2(s1);
	Student s3("rose", 17);
	s1 = s3;
}

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

class Person
{
public:
	Person()
	{
		++_count;
	}

protected:
	string _name;
public:
	static int _count;
};

int Person::_count = 0;

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

class Graduate : public Student
{
protected:
	string _course;
};

void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << "人数：" << Person::_count << endl;
	Student::_count = 0;
	cout << "人数：" << Person::_count << endl;
}

int main()
{
	TestPerson();

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

void Test()
{
	//有二义性，无法明确知道访问的是哪一个
	Assistant a;
	//a._name = "Peter";

	//需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
	a.Student::_name = "xxx";
	a.Teacher::_name = "yyy";
}

class Student :virtual public Person
class Teacher :virtual public Person

class A
{
public:
	int _a;
};

class B : public A
{
public:
	int _b;
};

class C : public A
{
public:
	int _c;
};

class D :public B, public C
{
public:
	int _d;
};

int main()
{
	D d;
	d.B::_a = 1;
	d.C::_a = 2;
	d._b = 3;
	d._c = 4;
	d._d = 5;

	return 0;
}