C++创建不可继承类

防止父类被子类继承

原理： 当子类继承父类时，子类会初始化父类的构造函数，我们只要禁止掉这个初始过程，就能实现子类在继承父类的时候编译出错；

方式： 将父类的构造函数和析构函数私有化 实现方式有二

其一

class Myclass
{
public:
    static Myclass* Creat_obj()
    {
        return new Myclass();
    }
    static void Delete_obj(Myclass* _Myclass)
    {
        delete  _Myclass;
    }
    //定义一个共有的静态函数，返回new出的对象 （堆区的对象）
    
private:
    Myclass()
    {}
    ~Myclass()
    {}
    //构造函数和析构函数被同时定义为私有，
};
class Child :public Myclass
{
public:
    Child()
    {}
    ~Child()
    {}
};

但上面这种方法只能在堆区创建对象 ，使用类名.Creat_obj()

方法二 在将父类的构造函数和析构函数私有化的基础上

先看一个容易理解版本的

#include <iostream>
using namespace std;

template <class T>
class Base
{
    friend T;//模板参数类型作为友元函数
private:
    Base()
    {}
    ~Base()
    {}
};
//MyClass作为Base的友元，可以访问Base的私有成员
class MyClass:virtual public Base<MyClass>
{
public:
    MyClass()
    {}
    ~MyClass()
    {}
};


//TestClass继承于Base类
//由于是虚拟继承，派生类会访问基类的构造函数和析构函数
//但是由于基类的构造函数是私有所以无法访问
class TestClass: public MyClass
{
public:
    TestClass()
    {}//这里会报错
    ~TestClass()
    {}//这里会报错
};
int main()
{
    MyClass *p = new MyClass;
    MyClass fc;
    TestClass tc;//报错
    return 0;
}

Myclass 继承Base基类的同时，也将自己的类名传入的Base 中,并作为Base的友元类，

Myclass 友元类能访问Base基类的任何成员

对于Myclass 而言可以创建栈对象和堆对象，是因为其初始化父类构造函数时可以使用到 父类的构造函数。

对于Test 而言，由于Test 不是Base的友元函数，不能访问到Base基类的构造函数，自然报错

若要使用到基类Base的功能，只能像Myclass那样 把自己的类名传入基类中，成为基类的友员类。

现在来看一个复杂一点点的版本

template< typename TDerive, typename TProvider > //传入两个模板参数
class  CFobidDeriveProviderBase
{
    friend TDerive;
    friend TProvider;            //模板参数作友元

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

/*
* 提供禁止派生的功能,需要此功能的类可以从CFobidDeriveProvider派生,并将类名作为模板参数传递
*/
template< typename TDerive >
class  CFobidDeriveProvider : virtual public CFobidDeriveProviderBase< TDerive, CFobidDeriveProvider<TDerive>>
{
public:
    CFobidDeriveProvider(){}
    ~CFobidDeriveProvider(){}
};

/*
* 测试类,该类不可被继承
*/
class  CNoDerive : public CFobidDeriveProvider< CNoDerive >
{
public:
    CNoDerive(){}
    ~CNoDerive(){}

    void  Alert()
    {
        AtlMessageBox( NULL, _T("Alert") );
    }
};

若有类从CNoDerive派生：

class  CSomeDerive : public CNoDerive
{
public:
    CSomeDerive(){}
    ~CSomeDerive(){}
};

CFobidDeriveProvider 类 继承 CFobidDeriveProviderBase的同时 传入了自己的类名和一个其他类名，

这个其他类名是留给其他也想成为Base友元类（使用Base类功能的类）使用的 也就是上文的 CNoDerive 类。

正如 上文的 需要此功能的类（Base）可以从CFobidDeriveProvider派生,并将类名作为模板参数传递。

完成上面那步，CFobidDeriveProvider 和扩展类 CNoDerive 就成为了CFobidDeriveProviderBase 的友元函数了。

再谈使用虚继承的目的，原因就是基类 CFobidDeriveProviderBase 可能被多个其他类所继承，虚继承可以共享内存，避免内存开销

同时当我们使用虚拟继承构造一个类的时候，这样就会使得一个类可以在堆上建立对象也可以在栈上建立对象，这样也避免了方法一中出现的无法在栈上建立对象了。可以使用栈空间的原因就是我们可以使用到父类的析构函数了

引用知识

另外如何保证只能在堆上new一个新的类对象呢？只需把析构函数定义为私有成员。
原因是C++是一个静态绑定的语言。在编译过程中，所有的非虚函数调用都必须分析完成。即使是虚函数，也需检查可访问性。因些，当在栈上生成对象时，对象会自动析构，也就说析构函数必须可以访问。而堆上生成对象，由于析构时机由程序员控制，所以不一定需要析构函数。保证了不能在栈上生成对象后，需要证明能在堆上生成它。

构造函数私有化的类的设计可以保证只能用new命令在堆中来生成对象，只能动态的去创建对象，这样可以自由的控制对象的生命周期。但是，这样的类需要提供创建和撤销
的公共接口。
另外重载delete，new为私有可以达到要求对象创建于栈上的目的，用placement new也可以创建在栈上。

例如

#include <iostream>
using namespace std;

class Test
{
public:
    Test()
    {
        cout << "调用了构造函数"<<endl;
    }

private:
    ~Test() {}
};

int main()
{
    // Test b;  创建栈空间变量会报错

    Test *bb = new Test(); //创建堆空间则不会报错
}

附言

这里使用到了模板参数作为友元的方法，请参阅我的 模板参数作友元

欢迎加入我的编程交流群829810543