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

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

};

class Teacher : public Person
{
protected:
	int _jobid; // 工号
};
int main()
{
	Student s;
	Teacher t;
	// 由于这个S是自定义类型，没有做操作符重载，没法用cout
	s.Print();
	cout << "====================" << endl;
	t.Print();
	return 0;
}

我们先不要管他继承的格式，后面会讲继承的格式，这段代码就是告诉大家，从运行结果可以看出显然子类继承了父类的特性，注意这里的的protected和private    protected其实是被保护的数据，在子类或者说继承类里面可以访问，private是私有的，在子类访问不了，如果感兴趣可以把上面的数据改成private，这时候你就发现void test_protected_private()报错了。

运行结果

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

class Person
{
public:
	Person(const char* name = "peter") // 构造函数
		: _name(name)
	{
		cout << this << "Person()" << endl;
	}

	Person(const Person& p) // 拷贝构造函数
		: _name(p._name)
	{
		cout << this << "Person(const Person& p)" << endl;
	}

	Person& operator=(const Person& p) // 这一步是重载了操作符
	{
		cout << this << "Person operator=(const Person& p)" << endl;
		if (this != &p)
			_name = p._name;

		return *this;
	}

	~Person() //析构函数
	{
		cout << this << "~Person()" << endl;
	}
protected:
	string _name; // 姓名
};

class Student : public Person
{
public:
	Student(const char* name, int num)
		: Person(name)
		, _num(num)
	{
		cout << this << "Student()" << endl;
	}

	Student(const Student& s)
		: Person(s)
		, _num(s._num)
	{
		cout << this << "Student(const Student& s)" << endl;
	}

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

	~Student()
	{
		cout <<this <<"~Student()" << endl;
	}
protected:
	int _num; //学号
};

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

int main()
{
	Test();
	return 0;
}

这个大致分析写在了代码注释里，其实就是想说个子类和父类默认函数执行顺序的事情，大家可以粘过去试一试运行。运行结果如下：

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

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 _seminarCourse; // 研究科目
};
void TestPerson()
{
	Student s1;
	Student s2;
	Student s3;
	Graduate s4;
	cout << " 人数 :" << Person::_count << endl;// 打印出来是4
	Student::_count = 0;
	cout << " 人数 :" << Person::_count << endl;// 打印出来是0
}
int main()
{
	TestPerson();
	return 0;
}

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

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

int main()
{
	Test();
	return 0;
}

那么虚拟继承的原理是什么呢？

其实有很多底层的东西，但是我们简单一点有助于大家理解来说的话就是，他会有一个偏移值，自动映射到最初的成员变量，就不会导致冗余数据了，但是这仅是我们初学者这样理解，底层远比者复杂的多，大家先了解，后续有机会了再深入了解。

#include <iostream>
#include <string>
using namespace std;
// Car和BMW Car和Benz构成is-a的关系
class Car {
protected:
	string _colour = "白色"; // 颜色
	string _num = "陕ABIT00"; // 车牌号
};

class BMW : public Car {
public:
	void Drive() { cout << "好开-操控" << endl; }
};

class Benz : public Car {
public:
	void Drive() { cout << "好坐-舒适" << endl; }
};

// Tire和Car构成has-a的关系

class Tire {
protected:
	string _brand = "Michelin"; // 品牌
	size_t _size = 17; // 尺寸

};

class Car {
protected:
	string _colour = "白色"; // 颜色
	string _num = "陕ABIT00"; // 车牌号
	Tire _t; // 轮胎
};