【C++继承】赋值兼容转换&&作用域&&派生类的默认成员函数

1.继承的概念

 继承(inheritance)机制是面向对象程序设计使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称派生类(或子类)。继承呈现了面向对象程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用，继承是类设计层次的复用。

#include <iostream>
 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的成员。
// 下⾯我们使⽤监视窗⼝查看Student和Teacher对象，可以看到变量的复⽤。调⽤Print可以看到成员函数的复⽤。
class Student: public Person{
 protected:
 int _stuid;//学号
};
 class Teacher: public Person{
 int _jobid;//⼯号
};
 int main(){
 Student s;
 Teacher t;
 s.Print();
 t.Print();
 }
输出结果：
name:peter
 age:18
 name:peter
 age:18
 Program ended with exit code: 0

继承的父类的成员(成员变量+成员函数)，不过是把父类的成员变量拷贝给子类，并不指向同一个，子类中可以使用父类的成员变量，在子类里的改变不影响父类，但是成员函数是同一个。

1.2继承的定义

1.2.1定义的格式

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

1.2.2继承关系和访问限定符

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

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

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

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

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

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

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

1.2.4总结

1.基类private成员在派⽣类中⽆论以什么⽅式继承都是不可⻅的，这⾥的不可⻅是指基类的私有成员还是被继 承到了派⽣类对象中，但是语法上限制派⽣类对象不管在类⾥⾯还是类外⾯都不能去访问它。

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

3.实际上⾯的表格我们进⾏⼀下总结会发现，基类的私有成员在⼦类都是不可⻅的。基类的其他成员在⼦类的 访问⽅式 == Min（成员在基类的访问限定符，继承⽅式），public > protected > private。

4.使⽤关键字class时默认的继承⽅式时private，使⽤struct时默认的继承⽅式是public，不过最好显示的写出 继承⽅式

5.在实际运⽤中⼀般使⽤都是public继承，⼏乎很少使⽤protected/private继承，也不提倡使⽤ protected/private继承，因为protected/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;
}

2.基类和派生类对象赋值兼容转换

派⽣类对象 可以赋值给 基类的对象/基类的指针/基类的引⽤（⼦类可以赋值给⽗类）。这⾥有个形象的说法 叫切⽚或者切割。寓意把派⽣类中⽗类那部分切来赋值过去。

基类对象不能赋值给派⽣类对象

基类的指针或者引⽤可以通过强制类型转换赋值给派⽣类的指针或者引⽤。但是必须是基类的指针是指向派 ⽣类对象时才是安全的。这⾥基类如果是多态类型，可以使⽤RTTI（Run- Time Type Information）的dynamic cast 来进⾏识别后进⾏安全转换。（ps：这个我们后期再讲解，这⾥先了解⼀下）

//基类对象不能赋值给派生类对象
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;//error
					
	return 0;
}

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

3.继承中的作⽤域

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

4.派生类的默认成员函数

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

4.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)
{}

4.2拷贝构造

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

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

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

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

4.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.4析构函数

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

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

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

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

class Person
 {
 public:
 //Person(const char* name = "")
 Person(const char* name = "")
  : 
_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;
        delete[] _str;
    }
 protected:
    string _name; // 姓名
    char* _str = new char[10]{ 'x','y','z'};
 };
 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;
    }
    // 由于多态，析构函数的名字会被统⼀处理成destructor()
    // ⽗类析构不能显示调⽤，因为显示调⽤不能保证先⼦后⽗
    ~Student()
    {
// 析构函数会构成隐藏，所以这⾥要指定类域
//Person::~Person();
 cout << "~Student()" << endl;
 // delete [] _ptr;
 cout << _str << endl;
  }
 protected:
 int _x = 1;
 string _address = "⻄安⾼新区";
 string _name;
 //int* _ptr = new int[10];
 };
 // ⼦类默认⽣成的构造
// ⽗类成员（整体） -- 默认构造
// ⼦类⾃⼰的内置成员 -- ⼀般不处理
// ⼦类⾃⼰的⾃定义成员 -- 默认构造
// ⼦类默认⽣成的拷⻉构造  赋值重载跟拷⻉构造类似
// ⽗类成员（整体） -- 调⽤⽗类的拷⻉构造
// ⼦类⾃⼰的内置成员 -- 值拷⻉
// ⼦类⾃⼰的⾃定义成员 -- 调⽤他的拷⻉构造
// ⼀般就不需要⾃⼰写了，⼦类成员涉及深拷⻉，就必须⾃⼰实现
// ⼦类默认⽣成的析构
// ⽗类成员（整体） -- 调⽤⽗类的析构
// ⼦类⾃⼰的内置成员 -- 不处理
// ⼦类⾃⼰的⾃定义成员 -- 调⽤析构
//
 int main()
 {
 Student s1;
 Student s2("张三", 1, "⻄安市碑林区");
 Student s3 = s2;
 s1 = s3;
 return 0;
 }

5.继承和友元

友元关系不能继承，也就是说基类友元不能访问⼦类私有和保护成员

6.继承与静态成员

基类定义了static静态成员，则整个继承体系⾥⾯只有⼀个这样的成员。⽆论派⽣出多少个⼦类，都只有⼀个static 成员实例。

class Person
 {
 public:
 Person() { ++_count; }
 protected:
 string _name; // 姓名
public:
 static int _count; // 统计⼈的个数。
};
 int Person::_count = 0;
 class Student : public Person
 {
 protected:
 int _stuNum; // 学号
};
int main()
 {
 Person p;
 Student s;
 cout << Person::_count << endl;
 cout << Student::_count << endl;
 cout << &Person::_count << endl;
 cout << &Student::_count << endl;
 return 0;
 }
输出结果：
2
 2
 0x100008000
 0x100008000

7.复杂的菱形继承及菱形虚拟继承

单继承：⼀个⼦类只有⼀个直接⽗类时称这个继承关系为 单继承

多继承：⼀个⼦类有两个或以上直接⽗类时称这个继承关系为 多继承

菱形继承的问题：从下⾯的对象成员模型构造，可以看出菱形继承有数据冗余和⼆义性的问题。在Assistant的对象 中Person成员会有两份

class Person
 {
 public:
 string _name; // 姓名
int _id;
 int _tel;
 int _address;
 };
 class Student : public Person
 {
 protected:
 int _num; //学号
};
 class Teacher : public Person
 {
 protected:
 int _id; // 职⼯编号
};
 class Assistant : public Student, public Teacher
{
 protected:
 string _majorCourse; // 主修课程
};
 int main()
 {
 // 这样会有⼆义性⽆法明确知道访问的是哪⼀个
Assistant a ;
 //  
  a._name = "peter";
 // 需要显示指定访问哪个⽗类的成员可以解决⼆义性问题，但是数据冗余问题⽆法解决
a.Student::_name = "⼩李";
 a.Teacher::_name = "李⽼师";
 cout << a.Student::_name << endl;
 cout << a.Teacher::_name << endl;
 return 0;
 }
输出结果：
⼩李
李⽼师

7.2解决办法

虚拟继承可以解决菱形继承的⼆义性和数据冗余的问题。如上⾯的继承关系，在Student和Teacher的继承 Person时使⽤虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地⽅去使⽤。

class Person
 {
 public:
 string _name; // 姓名
int _id;
 int _tel;
 int _adress;
 };
 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; // 主修课程
};
 int main()
 {
 // 数据冗余和⼆义性
Assistant a;
 a.Student::_name = "⼩李";
 a.Teacher::_name = "李⽼师";
 a._name = "李益达";
 cout << a.Student::_name << endl;
 cout << a.Teacher::_name << endl;
 cout << a._name << endl;
 return 0;
 }
输出结果：
李益达
李益达
李益达

实践中：最好不要用到菱形继承