【C++】从零开始认识继承二）-阿里云开发者社区

4 继承与友元

一句话：友元关系不能继承！！！
一句话：友元关系不能继承！！！
一句话：友元关系不能继承！！！

就是说基类友元不能访问子类私有和保护成员，打个比方：爸爸的朋友，能说成是你的朋友吗？

来个看个样例：

#include<iostream>
#include<string>

using namespace std;

class Son;
class Dad 
{
public:
  Dad(int money = 100  , const char* house = "homeless")
    :_money(money)
    ,_house(house)
  {}

  friend void show(const Dad& d, const Son& s);

protected:
  int _money;
  string _house;
};

class Son : public Dad
{
public:
  Son(int homework = 100  )
    :_homework(homework)
  {}
  //friend void show(const Dad& d, const Son& s);
protected:
  int _homework;;
};

void show(const Dad& d , const Son& s)
{
  cout << d._money << endl;
  cout << d._house << endl;
}

int main()
{
  Dad d(10000, "翻斗花园");
  Son s(12);
  show(d,s);
  return 0;
}

这里友元函数可以访问Dad类的变量：

但是如果要访问Son的变量就会报错：

在Son同样设置一个友元就可以解决这个问题了。

5 继承与静态变量

注意：基类定义了static静态成员，则整个继承体系里面只有一个这样的成员。无论派生出多少个子类，都只有一个static成员实例！！

我们可以来验证一下：

#include<iostream>
using namespace std;
class A
{
public:
  static int _a ;
};
int A::_a = 1;

class B : public A
{
public:

protected:
  int b;
};

int main()
{
  B b1;
  B b2;
  B b3;
  cout << &b1._a << endl;
  cout << &b2._a << endl;
  cout << &b3._a << endl;

  return 0;
}

运行一下会发现，他们的地址都是一致的：

也就说明他们共用一个_a变量，所以无论派生出多少个子类，都只有一个static成员实例

这个特性可以用来统计一个又多少个类被实例化，也就可以统计数量,只需在构造函数中加入一个增加该静态变量的语句即可：

#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; // 学号
};

void TestPerson()
{
  Student s1;
  Student s2;
  Student s3;

  cout << " 人数 :" << Person::_count << endl;
  Student::_count = 0;
  cout << " 人数 :" << Person::_count << endl;
}

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

运行一下：

我们就可以知道有多少个该继承体系中实例化了多少个类了！！！

6 复杂的菱形继承及菱形虚拟继承

首先说明一下，由于C++的历史缘故，其一致行走在语言发展的前端，一直在尝试新的内容。在发展过程中，有些内容加入到C++的时候，还没有发现其弊端。而后来发现的时候，为了向上兼容，只能打补丁，所以不开避免的不会有一些弊端，会有复杂的语法和复杂的特性。但这也是C++语言 “我不入地狱,谁入地狱!!! ”的豪迈气息。总要有先驱者走前前面，而C++就是！！！

单继承
单继承很好理解，即继承关系是单线的：

这样的继承关系就叫做单继承！！！
多继承
多进程也很好理解，应该类具有多个属性，就可以使用多继承：

而什么是菱形继承呢？？？就是形成一个类似菱形关系的继承关系：

定睛一看，好像不会出什么错误。

但是菱形继承存在这样的问题：从下面的对象成员模型构造，可以看出菱形继承有数据冗余和二义性的问题。

在SDU的对象中university成员会有两份,存在二义性和数据冗余的问题！！！

访问的时候就无法确定变量到底属于那一个了：

#include<iostream>
#include<string>

using namespace std;

class university
{
public:
  string _name; // 大学名字
};

class uni211 : public university
{
protected:
  int _num; //编号
};
class uni985 : public university
{
protected:
  int _id; // 编号
};
class  SDU : public uni211, public uni985
{
protected:
  string _address;
};
void Test()
{
  // 这样会有二义性无法明确知道访问的是哪一个
  SDU a;
  a._name = "peter";
  // 需要显示指定访问哪个父类的成员可以解决二义性问题，但是数据冗余问题无法解决
  a.uni211::_name = "xxx";
  a.uni985::_name = "yyy";
}

这样虽然可以解决二义性的问题，但是数据冗余的问题没有解决啊！？一个大学不需要两个名字啊！！！

那这怎么解决呢？？？虚拟继承这不就来了吗！！！

虚拟继承（virtual）可以解决菱形继承的二义性和数据冗余的问题。如上面的继承关系，在uni985和uni211的继承university时使用虚拟继承，即可解决问题。需要注意的是，虚拟继承不要在其他地方去使用!!!

#include<iostream>
#include<string>

using namespace std;

class university
{
public:
  string _name; // 大学名称
};

class uni211 : virtual public university
{
protected:
  int _num; //编号
};
class uni985 : virtual public university
{
protected:
  int _id; //编号
};
class  SDU : public uni211, public uni985
{
protected:
  string _address;//地址
};
void Test()
{
  // 这样就只有一个_name了，不存在二义性的问题了
  SDU a;
  a._name = "peter";
}

这是什么原理呢？？？

这里需要我们打开内存窗口来查看了，非常的巧妙！！！

我们先来看不使用虚拟继承的情况

#include<iostream>
#include<string>

using namespace std;

class A
{
public:
  int _a;
};
 class B : public A
//class B : virtual public A
{
public:
  int _b;
};
 class C : public A
//class C : virtual 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;
}

来看调试的过程：

通过这个逐语句调试的内存变化，我们可以确定大致的内存情况：

不使用虚拟继承就是这样的内存情况，也好理解为什么同名变量的两份是如何储存的了。

接下来我们来看虚拟继承下的菱形继承是怎么个情况：

看起来像是这样：

_a储存在最下面，而B,C部分的原有储存_a的位置现在是什么呢？？？

其实是个指针，那我们来看看指针指向的空间储存着什么吧：

？？？怎么对应位置是00 00 00 00为什么是零？哈哈往下看一个看看奥：

分别储存着16进制数字20 12，然后对应B,C原本的指针位置加上这个值（偏移量），都会指向到A _a的空间！！！这个00 00 00 00到多态的部分再来进行讲解，知道原地址加上下面的值就是A _a的空间就可以了！！！

这里是通过了B和C的两个指针，指向的一张表。这两个指针叫虚基表指针，这两个表叫虚基表。虚基表中存的偏移量。通过偏移量可以找到下面的A。

即原本B,C中_a的位置储存这一个指针，指针指向的位置有一个偏移量，原位置的地址加上偏移量就会指向A的空间！！！

那这样进行拷贝切片的时候是怎样的呢？一样是把D中B对象的部分切片，然后通过上述方式来找到_a。但这样也带来了一些代价：（PS：内存中的储存顺序就是声明的顺序，先继承谁，谁就在前面）

我们进行一个切片，如果我们执行以下操作：

B* pb = &d;
C* pc = &d;
pb->_a++;
pc->_a++;

这样每次访问都要进行寻找偏移量，加上偏移量才能找到_a进行操作。让操作就变得复杂了！！！

总结：实践中可以设计多继承，但是切记不要设计菱形继承！！！因为太复杂了，容易出各种问题！！！

如果B进行了虚拟继承，那么B的所有的实例类都会按照菱形继承中的方式进行访问！！！因为要保持一致，应该类不应出现两种访问方式。

7 继承的总结和思考

很多人说C++语法复杂，其实多继承就是一个体现。有了多继承，就存在菱形继承，有了菱形继承就有菱形虚拟继承，底层实现就很复杂。所以一般不建议设计出多继承，一定不要设计出菱形继承。否则在复杂度及性能上都有问题。
多继承可以认为是C++的缺陷之一，很多后来的很多语言都没有多继承，如Java。
继承和组合（优先使用组合）

public继承是一种is-a（谁是什么）的关系。也就是说每个派生类对象都是一个基类对象。
组合是一种has-a（谁有什么）的关系。假设B组合了A，每个B对象中都有一个A对象（也就是把A作为B的成员变量）。
继承允许你根据基类的实现来定义派生类的实现。这种通过生成派生类的复用通常被称为白箱复用(white-box reuse 能看见，不安全，耦合度高)。术语 “白箱”是相对可视性而言：在继承方式中，基类的内部细节对子类可见。继承一定程度破坏了基类的封装，基类的改变，对派生类有很大的影响。派生类和基类间的依赖关系很强，耦合度高。
对象组合是类继承之外的另一种复用选择。新的更复杂的功能可以通过组装或组合对象来获得。对象组合要求被组合的对象具有良好定义的接口。这种复用风格被称为黑箱复用(black-box reuse 不能能看见，安全，耦合度低)，因为对象的内部细节是不可见的。对象只以“黑箱”的形式出现。组合类之间没有很强的依赖关系，耦合度低。优先使用对象组合有助于你保持每个类被封装。
实际尽量多去用组合。组合的耦合度低，代码维护性好。不过继承也有用武之地的，有些关系就适合继承那就用继承，另外要实现多态，也必须要继承。类之间的关系可以用继承，可以用组合，就用组合。

8 有关继承的经典面试题

C++有多继承，为什么java等语言没有？

历史原因！C++是先驱者（人的直觉认为多继承很合理，我感觉正常人都会想到多继承），并且c++中的多继承处理起来十分复杂，访问基类变量的过程就会很复杂！！！java等后来发展的语言见到c++中多继承的复杂，就干脆放弃了。

什么是菱形继承？多继承的问题是什么？

菱形继承如字面意思（两个父类的父类是同一个类就会发生菱形继承），多继承本身没什么问题，真正的问题是有多继承就可能发生菱形继承。菱形继承就有问题了：变量的二义性和继承冗杂。解决办法很简单就是虚拟继承，但是这样就会大大降低效率。

继承和组合的区别？什么时候用继承？什么时候用组合？

继承：通过扩展已有的类来获得新功能的代码复用方法

组合：新类由现有类的对象合并而成的类的构造方式

如果二者间存在一个“是”的关系，并且一个类要对另外一个类公开所有接口，那么继承是更好的选择
如果二者间存在一个“有”的关系，那么首选组合
能用组合就用组合！！！能用组合就用组合！！！能用组合就用组合！！！

【C++】从零开始认识继承二）

4 继承与友元

5 继承与静态变量

6 复杂的菱形继承及菱形虚拟继承

7 继承的总结和思考

8 有关继承的经典面试题

Thanks♪(･ω･)ﾉ谢谢阅读！！！

下一篇文章见！！！1

热门文章

最新文章

相关课程

相关电子书

相关实验场景