【C++】你不得不爱的——继承
【C++】你不得不爱的——继承
凡是面向对象的语言，都有三大特性，继承，封装和多态，但并不是只有这三个特性，是因为者三个特性是最重要的特性，那今天我们一起来看继承！
1.继承的概念及定义
1.概念
继承(inheritance)机制是面向对象程序设计 使代码可以复用的最重要的手段，它允许程序员在 保
持原有类特性的基础上进行扩展，增加功能，这样产生新的类，称 派生类。（子类）
继承 呈现了面向对象 程序设计的层次结构，体现了由简单到复杂的认知过程。以前我们接触的复用都是函数复用， 继 承是类设计层次的复用。
那到底是什么意思呢？举个例子：
class Person
{
protected:
char* _name;
int _old;
};
class student :public Person
{
private:
char* _id;
};
int main()
{
student s;
}
当好多类都需要写Person类中的成员时 ，为了避免数据冗余，就可以使用类的继承，使代码复用，继承是让每一个派生类中，都有一份基类（父类）的成员。
2.继承的定义
继承的方式：（当然继承的目的就是为了让子类可以拥有父类的成员，并访问，所以一般情况下，我们只会进行公有继承：public：）
那么我们来看一下，继承方式和访问之间的关系：
首先必须知道的一点是：基类中有私有成员时，子类中继承的父类的私有成员不可见。
（不可见是指基类的私有成员还是被继承到了派生类对象中，但是语法上限制派生类对象不管在类里面还是类外面都不能去访问它。）
其次就是，基类成员的权限和继承方式的权限，谁的权限更小，在子类中继承的成员就是更小的那个权限。public > protected> private。
如上图所示：
2.基类和派生类对象赋值转换
首先得回想起赋值转换这个过程：
不同的类型相互赋值时，中间会产生临时变量，通过临时变量进行赋值转换。
但是若子类和父类进行赋值交换时，并不产生中间的临时变量，而是天然的一个赋值。
（只能向上转换，即子类赋值给父类，字可以给父，父不可以给子）
看下面代码：
class Person
{
protected:
string _name; // 姓名
string _sex; // 性别
public:
int _age; // 年龄
};
class Student : public Person
{
public:
int _No; // 学号
};
int main()
{
int i = 1;
double d = 2.2;
//中间会产生一个临时变量，临时变量具有常性，不可以改变。
i = d;
//所以此时ri是中间的临时变量的引用，而不是d的引用，如果不加const，就会放大权限
const int& ri = d;
//但父类和子类之间的赋值就不会产生中间的临时变量
Person p;
Student s;
// 中间不存在类型转换，天然的一个赋值
p = s;
Person& rp = s;//对s的引用，可以访问和修改成员变量
rp._age = 1;
Person* ptrp = &s;
ptrp->_age++;
return 0;
}派生类对象 可以赋值给 基类的对象 / 基类的指针 / 基类的引用。 这里有个形象的说法叫切片
或者切割。寓意把派生类中父类那部分切来赋值过去。
切片的具体过程，我们画图来了解：
只能向上转换，即子类赋值给父类，字可以给父，父不可以给子
3.继承中的作用域
我们知道，一个类他就是一个域（作用域）。同一作用域不能定义同名的两个变量，但不同作用域它可以定义两个同名变量。所以父类，子类中都有同名的成员变量时，默认会自动访问子类的成员，因为就近原则，若想访问父类的成员，那就可以指定作用域！
同一作用域，定义两个同名函数，且参数不同叫做函数重载；
不同作用域，定义两个同名函数，叫做重定义；
1. 在继承体系中 基类和 派生类都有 独立的作用域。
2. 子类和父类中有同名成员， 子类成员将屏蔽父类对同名成员的直接访问，这种情况叫隐藏，
也叫重定义。（在子类成员函数中，可以 使用 基类::基类成员 显示访问）
3. 需要注意的是如果是成员函数的隐藏， 只需要函数名相同就构成隐藏。
4. 注意在实际中在 继承体系里面最好 不要定义同名的成员
举例说明：
class A
{
public:
void fun()
{
cout << "A::func()" << endl;
}
};
class B : public A
{
public:
void fun(int i)
{
cout << "B::func(int i)->" << i << endl;
}
};
void Test()
{
B b;
b.fun(10);
};这中情况，函数构成什么？？？函数重载？？ 重定义（隐藏）？？编译错误？？？
首先我们知道两个类中的同名函数，在不同作用域，这就构成了重定义（隐藏）！
若访问父类成员函数即：b.A::fun()；
4.派生类的默认成员函数
1.构造和拷贝构造，赋值
先回顾一下，默认成员函数（无参，全缺省，编译器自己生成）
具体分析：
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;
}
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)
{}
Student(const Student& s)
//子类显示拷贝构造时，父类不可以直接访问进行初始化，必须调用父类自己的显示拷贝构造函数
:Person(s)
, _num(s._num)
{}
Student& operator=(const Student& s)
{
if (this != &s)
{
//赋值的运算符重载，两个同名函数构成了隐藏，需要指定作用域
Person::operator=(s);
_num = s._num;
}
return *this;
}
protected:
int _num; //学号
};
int main()
{
Student s1("张三", 18);
Student s2(s1);
Student s3("李四", 20);
s1 = s3;
return 0;
}最重要的一句话：父类成员必须调用父类自己的构造函数，拷贝构造完成初始化或拷贝。
或者说：子类中的父类那部分成员由父类自己的构造或者拷贝构造实现初始化或者拷贝。
2.析构函数的两怪！
直接看代码：
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;
}
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[] p;
}
protected:
string _name; // 姓名
int* p = new int[10];
};
class Student : public Person
{
public:
Student(const char* name)
:Person(name)
, _num(1)
{}
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;
}
// 第一怪：1、子类析构函数和父类析构函数构成隐藏关系。（由于多态关系需求，所有析构函数都会特殊处理成destructor函数名）
// 第二怪：子类先析构，父类再析构。子类析构函数不需要显示调用父类析构，子类析构后会自动调用父类析构
~Student()
{
//Person::~Person();
cout << "~Student()" << endl;
}
protected:
int _num; //学号
};
int main()
{
Student s("张三");
return 0;
}
1、子类析构函数和父类析构函数构成隐藏关系。（由于多态关系需求，所有析构函数都会特殊处理成destructor函数名） 2.子类先析构，父类再析构。子类析构函数不需要显示调用父类析构，子类析构后会自动调用父类析构
构造顺序：先父类，再子类；析构顺序：先子类，再父类。
5.继承与友元
友元关系不能继承！
若子类对象也想访问友元函数，那只能在子类中也加上友元！（但不建议使用友元，会破坏继承关系）
6. 继承与静态成员
子类继承父类，不是继承父类这个对象，而是会有一份父类的模型。父类有的成员变量，子类也会有一份，互不干扰。
但静态成员就不一样了，他们是同一份；静态成员属于整个类和类的所有对象。同时也属于所有派生类及派生类的对象。
class Person
{
public:
//friend void Display(const Person& p, const Student& s);
protected:
string _name; // 姓名
public:
static int _num;
};
int Person::_num = 0;
class Student : public Person
{
protected:
int _stuNum; // 学号
};
void test()
{
Student s;
Person p;
cout << p._num << endl;
p._num++;
cout << p._num << endl;
s._num++;
cout << s._num << endl;
cout << &s._num << endl;
cout << &p._num << endl;
}
基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子
类，都只有一个static成员实例
重点：
Person* ptr = nullptr;
ptr->Print();
cout << ptr->_num << endl;
cout << ptr->_name << endl;
cout << (*ptr)._num << endl;
(*ptr).Print();对象里面只存成员变量，成员函数在代码段中，所以以上代码哪个不对呢？
我们知道空指针不能解引用，解引用意思是，这里是去访问指针指向对象的内部成员，那看一看哪个访问了内部的成员呢？
函数不在内部，在代码段，可以！
_num为对象内部成员变量，不能解引用访问，不可以！
(*ptr)是解引用了吗？我们不能凭借解引用符号来判断是否解引用，我们需要看内部的访问情况，(*ptr)->Print();并没有访问内部成员，可以！
(*ptr)->_num;也可以，_num是静态成员，不在成员里面。
7.多继承
7.1继承分类
单继承：一个子类只有一个直接父类
多继承：一个子类有两个或两个以上的父类
菱形继承：是多继承的一种特殊情况，会产生数据冗余和二义性！
（person类的中的成员，会在student和teacher中都有一份，assistant继承student和teacher时，assistant中会有两份person，造成了数据冗余和二义性）
解决方法： 解决二义性：
可以通过访问限定符来指定访问哪一个成员。 那如何解决二义性的问题呢？ 此时虚继承就上线了！ 虚继承在腰部继承，谁引发的数据冗余，谁就进行虚继承（解决冗余）
由此可见，加上virtual，变为虚继承以后，确实解决了数据的冗余 那么到底如何解决的呢？？具体下面分析！
7.2 菱形继承 &&菱形虚拟继承
为了研究虚拟继承原理，我们给出了一个简化的菱形继承继承体系，再借助 内存窗口观察对象成
员的模型。
1.解决二义性的过程（指定作用域）
（菱形继承）
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 = 1;
d._c = 2;
d._d = 3;
d.B::_a = 4;
d.C::_a = 5;
}
2.解决数据冗余（需要虚继承）
（菱形虚拟继承）
class A
{
public:
int _a;
};
class B:virtual public A
{
public:
int _b;
};
class C:virtual public A
{
public:
int _c;
};
class D:public B,public C
{
public:
int _d;
};
int main()
{
D d;
d._b = 1;
d._c = 2;
d._d = 3;
d.B::_a = 4;
d.C::_a = 5;
}
那如果遇到这种情况呢？？？父子类的赋值转换（切片）
class A
{
public:
int _a;
};
class B:virtual public A
{
public:
int _b;
};
class C:virtual public A
{
public:
int _c;
};
class D:public B,public C
{
public:
int _d;
};
int main()
{
D d;
d._b = 1;
d._c = 2;
d._d = 3;
d._a = 4;
d._a = 5;
B b;
b._a = 1;
b._b = 3;
B* ptr = &b;
ptr->_a = 2;
ptr = &d;
ptr->_a = 6;
}
从b对象可以看的出来，只要是虚继承以后，就会把虚基类放到最下面；
就像切片这种情况，ptr指向不同，那么距离虚基类的距离就不同，所以就必须要有虚基表的地址，来访问虚基表继而找到偏移量，然后访问到虚基类！
我们通常使用下，很忌讳出现菱形继承，但可以多继承。
可以看得出，虚继承在时间上确实有损耗，过程比较复杂，但是如果虚基类比较大时，就可以很大程度上节省内存。
8.继承和组合（都是一种复用）
public继承是一种 is-a（是一个）的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种 has-a（有一个）的关系。假设B组合了A，每个B对象中都有一个A对象。
我们会说低耦合高内聚有，意思就是相互的联系比较小，不会因为改动一个，而很大的影响另一个；
在组合中，两个类中的成员变量一般都是私有，那么就无法访问，那么修改也不会相互影响到；
在继承中，因为要继承，所以父类成员一般子类都可以访问的，那么修改的话，彼此相互影响就比较大！
那么组合其实就是很好的低耦合。
就比如我们平时举例说到的：person，student，这就是继承关系，学生是一个人；
那再举一个，头有一双眼睛（这就是组合）
事实上，哪个适合就用哪个，都适合就先用组合！
总结：
一口气说了这么多，你学会了吗？细节还是比较多的，我们应该下去多多自己琢磨，反复调试，去感受过程，从而理解的更深刻！下期再见！
腾讯云开发者
