由上面我们可以看到Person是父类，也称作基类。Student是子类，也称作派生类。

1.2.2继承关系和访问限定符

💞访问限定符：

 C++类的访问限定符用于控制类的成员（包括成员变量和成员函数）在类的外部的可访问性。   C++中有以下三种访问限定符：

• public: 公共访问限定符，任何地方都可以访问公共成员。可以在类的外部使用对象名和成员名直接访问公共成员。

• private: 私有访问限定符，只有类内部的其他成员函数可以访问私有成员。类的外部无法直接访问私有成员，但可以通过公共成员函数间接访问私有成员。

• protected: 保护访问限定符，只有类内部的其他成员函数和派生类的成员函数可以访问保护成员。类的外部无法直接访问保护成员，但可以通过公共成员函数或派生类的成员函数间接访问保护成员。

需要注意的是，访问限定符只在类的内部起作用，在类的外部没有直接的影响。同时，访问限定符可以用于类的成员变量和成员函数的声明中，默认情况下，成员变量和成员函数的访问限定符是private。

💞继承方式：

C++类的继承方式有以下几种：

• 公有继承（public inheritance）：使用关键字"public"表示的继承方式。在公有继承中，基类的公有成员和保护成员都可以在派生类中访问，私有成员不能在派生类中直接访问。

• 保护继承（protected inheritance）：使用关键字"protected"表示的继承方式。在保护继承中，基类的公有成员和保护成员在派生类中都变为保护成员，私有成员不能在派生类中直接访问。

• 私有继承（private inheritance）：使用关键字"private"表示的继承方式。在私有继承中，基类的公有成员和保护成员在派生类中都变为私有成员，私有成员不能在派生类中直接访问。

class Base {
public:// 公有成员
protected:// 保护成员
private:// 私有成员
};
class Derived : public Base {// 公有继承
}class Derived : protected Base {// 保护继承
};class Derived : private Base {// 私有继承
};

1.2.3 继承基类成员访问方式的变

总结如下：

①基类private成员在派生类中无论以什么方式继承都是不可见的。这里的不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。

②基类private成员在派生类中是不能被访问，如果基类成员不想在类外直接被访问，但需要在派生类中能访问，就定义为protected。可以看出保护成员限定符是因继承才出现的。

③基类的其他成员在子类的访问方式 == Min(成员在基类的访问限定符，继承方式)，public > protected > private

这些继承方式可以根据具体的需求选择合适的方式

④ 使用关键字class时默认的继承方式是private，使用struct时默认的继承方式是public，不过最好显示的写出继承方式。

⑤在实际运用中一般使用都是public继承，几乎很少使用protetced/private继承，也不提倡使用protetced/private继承，因为protetced/private继承下来的成员都只能在派生类的类里面使用，实际中扩展维护性不强。

class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;}
protected:string _name = "Peter"; //名字int _age = 18;  //年龄
private://父类定义私有的本质：不想被子类继承//但是在子类中有这个成员，不能直接使用，可以间接使用int _tel = 110;
};//基类的private成员,子类继承后在类外或在类中都不能访问
class Student : public Person
{
public:void Func(){//子类用不了(不可见)//cout << _tel << endl;//子类可以用cout << _name << endl;cout << _age << endl;}
protected:int _stuid; // 学号
};class Teacher : public Person
{
protected:int _jobid; // 工号
};int main()
{Student s;s.Print();Person p;p.Print();return 0;
}

✨父类私有，子类对象不能直接访问使用，但是可以调用父类成员函数间接使用。

二，基类和派生类对象赋值兼容转换

(1) 派生类对象可以赋值给基类的对象 / 基类的指针 / 基类的引用。这里有个形象的说法叫切片或者切割。寓意把派生类中父类那部分切来赋值过去。

💞如下图所示：

(2) 基类对象不能赋值给派生类对象。

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; // 学号
};class Teacher : public Person
{
protected:int _jobid; // 工号
};int main()
{Student s;Person p;// 1.子类对象可以赋值给父类对象/指针/引用//基类和派生类的赋值兼容转换p = s;Person* Ptr = &s;//指向子类当中父类的那一部分//引用的是子类当中父类的那一部分,//引用后这两者指向同一个东西，子类改变父类也变Person& ref = s;//2.基类对象不能赋值给派生类对象s = p;//errorreturn 0;
}

✨注意：这里的赋值兼容转换与C语言里的类型截断，提升毫无关系，意义也完全不同。

C语言中的类型截断，提升本质是类型转换，转换过程中会产生临时变量。而赋值兼容转换是一种特殊的语法规则，中间没有产生临时变量。

三，继承中的作用域

(1) 在继承体系中基类和派生类都有独立的作用域。

(2) 子类和父类中有同名成员，子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，也叫重定义。（在子类成员函数中，可以使用 基类::基类成员 显示访问）

• 如果要访问被隐藏的父类的同名成员，可以在子类成员函数中，使用 父类::父类成员来显示访问

(3) 需要注意的是如果是成员函数的隐藏，只需要函数名相同就构成隐藏，不管参数和返回值。子类和父类中可以有同名成员变量，因为它们属不同的类域，同一类里不可以。

(4) 注意在实际中在继承体系里面最好不要定义同名的成员。

如下面的代码中，此时s里就有两个_num，默认访问的是自己的，如果想访问父类的，指定作用域即可：

class Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;cout << "num:" << _num << endl;}
protected:string _name = "Peter"; //名字int _age = 18;  //年龄int _num = 999;
};class Student : public Person
{
public:void Print(){cout << "name:" << _name << endl;cout << "age:" << _age << endl;cout << "num:" << _num << endl;//指定cout << "num:" << Person::_num << endl;}
protected:int _stuid; // 学号int _num = 111;};class Teacher : public Person
{
protected:int _jobid; // 工号
};//继承中的作用域//子类和父类中可以有同名成员变量，因为它们属不同的类域
//同一类里不可以
//此时s里就有两个_num，默认访问的是自己的(隐藏/重定义)，
// 如果想访问父类的，指定作用域即可//如果是成员函数的隐藏，函数名相同就是隐藏，不管参数和返回值int main()
{Student s;//子类对象调用Print，先去子类里找，没有，再去父类中找s.Print();return 0;
}

四，派生类的默认成员函数

✨6个默认成员函数，“默认”的意思就是指我们不写，编译器会变我们自动生成一个，那么在派生类中，这几个成员函数是如何生成的呢？

这里重点介绍构造函数，拷贝构造，赋值拷贝和析构函数。

在讨论这个问题时，需要划分成下面三块：

父类成员（整体）
子类自己的内置成员
子类自己的自定义成员

先给出基类：

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; // 姓名
};

🔥1、构造函数

子类默认生成的构造：
(1) 父类成员（整体） – 调父类的默认构造
(2) 子类自己的内置成员 – 一般不做处理
(3) 子类自己的自定义成员 – 默认构造

父类的成员变量不能在子类中构造，规定只能调用父类的构造。

注意：
(1) 构造初始化时，要先父后子，因为子类构造初始化可能会用父类成员。若没有初始化父类，父类成员就是随机值，此时再用它构造子类就会出问题。

(2) 成员变量的初始化顺序和初始化列表的顺序无关，而是与变量的声明顺序有关。在C++的初始化列表中，是默认先走父类构造初始化的。

Student(const char* name = "", int x = 0, const char* address = "")//:_name(name) //规定了不能直接碰父类成员//: Person(name)//父类构造显示调用，可以保证先父后子:_x(x),_address(address),_name(Person::_name+'x'),Person(name)
{}

🔥2、拷贝构造

子类默认生成拷贝构造
(1) 父类成员（整体） – 调父类的拷贝构造
(2) 子类自己的内置成员 – 值拷贝
(3) 子类自己的自定义成员 – 调用自己的拷贝构造

注意：
(1) 一般不需要自己写，当子类成员涉及深拷贝时，就必须自己实现。

(2) 调用父类的拷贝构造时，直接传子类对象过去，会自然的切割，赋值兼容转换。

Student(const Student& st):Person(st)   //调用父类的拷贝构造,_x(st._x),_address(st._address)
{}

🔥3、赋值拷贝

子类默认生成赋值拷贝
(1) 父类成员（整体） – 调父类的赋值拷贝
(2) 子类自己的内置成员 – 值拷贝
(3) 子类自己的自定义成员 – 调用自己的赋值拷贝

注意：
(1) 一般不需要自己写，当子类成员涉及深拷贝时，就必须自己实现。

(2)由于子类与父类的operator=()是隐藏关系，这里要指定类域，防止子类一直调用自己的，造成死循环。

Student& operator=(const Student &st)
{if (this != &st){//operator = (st); //错误Person::operator= (st);//指定_x = st._x;_address = st._address;}return *this;
}

🔥4、析构函数

子类默认生成的析构
(1) 父类成员（整体） – 调父类的析构
(2) 子类自己的内置成员 – 不做处理
(3) 子类自己的自定义成员 – 调用自己的析构

注意：
父类析构不能显示调用，因为显示调用不能保证先子后父。析构时要先子后父，因为子类析构是可能会用到父类成员的。若先父后子，则父类成员会先析构一次，子类再析构就出问题了。

因此父类析构不是自己显式调用的，会在子类析构结束后自动调用。

//显示写析构
// 由于多态，析构函数的名字会被统一处理为destructor()
~Student()// 析构时先子后父
{//父类析构不能显示调用，因为显示调用不能保证先子后父// 析构函数会构成隐藏，因此要统一处理//Person::~Person();cout << "~Student()" << endl;
}

最后代码综合分析：

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
{
public:Student(const char* name = "", int x = 0, const char* address = ""):_x(x),_address(address),_name(Person::_name+'x'),Person(name){}Student(const Student& st):Person(st)   ,_x(st._x),_address(st._address){}Student& operator=(const Student &st){if (this != &st){Person::operator= (st);_x = st._x;_address = st._address;}return *this;}~Student()// 析构时先子后父{//Person::~Person();cout << "~Student()" << endl;}protected :int _x = 1;string _address = "湖南";string _name;
};void Test2()
{Student s1; Student s2("张三", 18, "长沙");Student2 s3 = s2; s1 = s3;}