How to design a class that can't be inherited(C++)

封装性，继承性和多态是面向对象的三大特征，最近思考了一下，怎么设计一个不能继承性的类呢？

      C++要实现一个不能被继承的类有不少方法.使用友元、私有构造函数、虚继承等方式可使一个类不能被继承，但是为何必须是虚继承？背后的原理又是什么?

~的构造函数设置为私有的就okay。

由于那样的话，子类就没有办法访问基类的构造函数，从而就阻止了进行子类构造对象的任务实现，也就达到了不可继承的目的。

可是，假设那样，这个类咱们在其它地方怎么使用呢？那这样子给咱们的利用也形成了必定的障碍。

好了。你是否是也想到了，定义静态方法，在方法内部实现一个对象，而后返回它的指针。

Ok？那怎么释放掉呢？再照样设计一个释放内存函数，问题就会迎刃而解。

OK。按照这个逻辑分析。示例代码以下：

点击(此处)折叠或打开

1. #include<iostream>
   
2.  using namespace std;
   
3.   class A
   
4.   {
   
5.   public:
   
6.      static A * Construct(int n)
   
7.       {
   
8.           A *pa = new A;
   
9.           pa->num= n;
   
10.           cout<<"num is:"<<pa->num<<endl;
    
11.           return pa;
    
12.      }
    
13.      static void Destruct(A * pIntance)
    
14.      {
    
15.          delete pIntance;
    
16.          pIntance = NULL;
    
17.      }
    
18.      private:
    
19.              A(){}
    
20.              ~A(){}
    
21.      public:
    
22.              int num;
    
23.  };
    
24.  void main()
    
25.  {
    
26.      A *f = A::Construct(9);
    
27.      cout<<f->num<<endl;
    
28.      A::Destruct(f);
    
29.  }

好了，这个类就这样子。按照咱们的理论分析，咱们的实践结果是彻底成立的。

可是，这个题，它比较有挑战性，什么意思呢？难道你没有发现，我们这水平也就仅仅有面试资格，还不能够破格录用的。

怎么啦？你可能会反问我。难道你真的没有看明白？肯定没有看明白？若是是真的话，那我就告诉你吧！

我们的类不能够实如今栈上建立对象。也就是说，仅仅只能够在堆上构建任何的一个对象，而在栈上就无能为力了。

私有的构造函数极大的局限性就这样尽收眼底了。

好吧！咱们修改它，也就是所谓的为它打“补丁吧”，请看示例代码：

点击(此处)折叠或打开

#include<iostream>

 using namespace std;

template <typename T>

class Base

 {

friend T;

private:

  Base(){}

~Base(){}

 };

class Finalclass : virtual public Base<Finalclass>

{

 public:

Finalclass(){}

~Finalclass(){}

};

void main()

{

 Finalclass *p = new Finalclass; //堆上对象

 Finalclass fs; //栈上对象

 }

OK。如今看看咱们的Finalclass类。

继承于Base，Base为虚基类，由于它是Base的友元，因此，它能够访问基类的私有构造函数，以及析构函数。编译运行时是正确的。

也就是说，能够建立堆上的对象，而且能够构建栈上的对象。

能否继承？假如它做为一个基类被一个类继承，在编译时是彻底能够经过的。

这一点没有什么疑问，问题就出在运行时：

当子类在构造对象时，由于是虚继承，因此子类的构造函数会直接去调用Base类的构造函数，而Base的构造函数是私有的。运行错误error！！！


这就是一个真正不能被继承的类。

思路二：主要的思路就是使子类不能构造父类的部分,这样子类就没有办法实例化整个子类.这样就限制了子类的继承. 因此咱们能够将父类的构造函数声明成为私有的,可是这样父类不就不能实例化，继续思考、、、
　　 咱们能够利用友员不能被继承的特性!
　 　首先假设CParent不可以被继承. 让CParent是某一个类的友员和子类,CParent能够构造,可是CParent的子类 CChild却不能继承那个友员特性,因此不能被构造.因此咱们引入一个CFinalClassMixin.
　　咱们对这个类的功能是这么指望的:
　　任何类从它继承都不能被实例化，同时这个类自己咱们也不但愿它被实例化.
　　实现一个构造函数和析构函数都是private的类就好了.同时在这类里面将咱们的CParent声明为友员. 代码以下:
　　class CFinalClassMixin
　　{
　　friend class CParent;
　　private:
　　 CFinalClassMixin(){}
　　~CFinalClassMixin(){}
　　};
　　//咱们的 CParent代码应该以下:
　　class CParent
　　{
　　public:
　　 CParent(){}
　　~CParent(){}
　　};
　　这个类(注,此时它仍是可以被继承)，如今咱们须要它不能被继承.那么只要将代码改为
　　class CParent:public CFinalClassMixin
　　{
　　public:
　　CParent(){}
　　~CParent(){}
　　};
　　就好了.如今从CParent继承一个子类试试
　　class CChild:public CParent{};
　　编译一下代码试试,发现:居然没有做用!!
　　如今再回想一下咱们这么操做的缘由,也就是这个方案的原理,那就是让父类能够访问Mixin类的构造函数,可是子类不能访问.
　　如今看看咱们的代码,发现父类是CFinalClassMixin类的友员,能够访问它的构造函数.由于友员不能继承,因此CChild不能访问CFinalClassMixin的构造函数.因此应该不能被实例化.
　　CChild的确不能访问 CFinalClassMixin的构造函数,可是它却没必要调用它!我想这就是问题的缘由所在.CChild是经过CParent来构造 CFinalClassMixin的,因此这个友员对他并无什么用处!
　　如今问题找到了.要解决很简单.只要让CChild必须调用 CFinalClassMixin的构造函数就好了,怎么才能达到目的呢?
　　还记得虚继承吗?虚继承的一个特征就是虚基类的构造函数由最终子类负责构造!因此将CParent从CFinalClassMixin继承改为从CFinalClassMixin虚继承就能够了.代码以下:
　　class CParent:virtual public CFinalClassMixin
　　{
　　 public:
　　CParent(){}
　　CParent(){}
　　};
　　如今试试,行了.
　　可是可能有些人会对多继承心有余悸!可是咱们这里并无必要这么担忧!为何?由于咱们的CFinalClassMixin类是纯的!pure! 也就是说它根本没有成员变量!那么咱们就根本不用担忧多继承带来的最大问题.菱形继承产生的数据冗余.以及二义性.
　　如今还有个不足!那就是 咱们不能每次使用这个CFinalClassMixin类就在里面加上对某个类的友员声明啊!这多麻烦啊!虽然不是什么大问题,可是我觉的仍是要解决,由于我充分信任C++!
　　解决的方法也很简单!那就是使用模板!具体描述就省略了,给出代码你们一看就知道了
　　下面是个人测试程序的完整代码(其中的CFinalClassmixin已经改为模板)

#include "stdafx.h"
#include <iostream>
using namespace std;

template<class T>   //应用模板
class CFinalClassMixin
{
 friend T;

 private:
 CFinalClassMixin(){}
    ~CFinalClassMixin(){}
};

  
class CParent:virtual public CFinalClassMixin<CParent>  //虚继承
{
 public:
   CParent(){}
   ~CParent(){}
};

class CChild:public CParent{}; //子类继承父类

int main(int argc, char* argv[])
{
 CParent a; // 能够构造
 CChild b; //不能构造
 return 0;
}

如今只要对不想被继承的类加入一个CFinalClassMixin混合类作父类就好了.
　　经过限制构造函数,咱们就达到了限制继承的目的 .可是这对有些仍是个例外,好比全是静态函数的类.这些类自己就不须要构造. 因此咱们对它没有办法.可是在大多数状况下,一个全是静态函数的类多少暗示了程序自己的设计多是须要斟酌的.
　 　其实这只是Mixin类(混合类)使用的一个小小例子.还有不少其余的用处,好比UnCopiale等等.就很少说了. 我想说明的是你们可能对多继承比较反感.可是过度否认也是得不偿失的.如今对多继承到底应不该该使用还处在争论阶段. 我以为一个方法是否使用得当,关键仍是在于使用的人.