封装性，继承性和多态是面向对象的三大特征，最近思考了一下，怎么设计一个不能继承性的类呢？
C++要实现一个不能被继承的类有很多方法.使用友元、私有构造函数、虚继承等方式可以使一个类不能被继承，可是为什么必须是虚继承？背后的原理又是什么?
~的构造函数设置为私有的就okay。
因为那样的话，子类就没有办法访问基类的构造函数，从而就阻止了进行子类构造对象的任务实现，也就达到了不可继承的目的。
但是，假设那样，这个类我们在其它地方怎么使用呢？那这样子给我们的利用也造成了一定的障碍。
好了。你是不是也想到了，定义静态方法，在方法内部实现一个对象，然后返回它的指针。
Ok？那怎么释放掉呢？再照样设计一个释放内存函数，问题就会迎刃而解。
OK。按照这个逻辑分析。示例代码如下：
点击(此处)折叠或打开
- #include<iostream>
- using namespace std;
- class A
- {
- public:
- static A * Construct(int n)
- {
- A *pa = new A;
- pa->num= n;
- cout<<"num is:"<<pa->num<<endl;
- return pa;
- }
- static void Destruct(A * pIntance)
- {
- delete pIntance;
- pIntance = NULL;
- }
- private:
- A(){}
- ~A(){}
- public:
- int num;
- };
- void main()
- {
- A *f = A::Construct(9);
- cout<<f->num<<endl;
- A::Destruct(f);
- }
好了，这个类就这样子。按照我们的理论分析，我们的实践结果是完全成立的。
但是，这个题，它比较有挑战性，什么意思呢？难道你没有发现，咱们这水平也就仅仅有面试资格，还不可以破格录用的。
怎么啦？你可能会反问我。难道你真的没有看明白？确定没有看明白？如果是真的话，那我就告诉你吧！
咱们的类不可以实现在栈上创建对象。也就是说，仅仅只可以在堆上构建任何的一个对象，而在栈上就无能为力了。
私有的构造函数极大的局限性就这样一览无余了。
好吧！我们修改它，也就是所谓的为它打“补丁吧”，请看示例代码：
点击(此处)折叠或打开
#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等等.就不多说了. 我想说明的是大家可能对多继承比较反感.但是过分否定也是得不偿失的.现在对多继承到底应不应该使用还处在争论阶段. 我觉得一个方法是否使用得当,关键还是在于使用的人.
How to design a class that can't be inherited(C++)