C++定义不能被继承的类

红太狼 2022-08-02 09:36 150阅读 0赞

在C++中，子类的构造函数会自动调用父类的构造函数子类的析构函数也会自动调用父类的析构函数。

**方法一**：

要想一个类不能被继承，最简单的方式：把它的构造函数和析构函数都定义为私有函数。

那么当一个类试图从它那继承的时候，必然会由于试图调用构造函数、析构函数而导例致编译错误。但是这样的话，通过private的构造函数与析构函数无法得到该类的实例。

**方法二**：

可以通过**定义公有的静态函数来创建和释放类的实例**，这样，该类不能被继承但是可以被实例化。

程序来自这篇文章：[文章][Link 1]

#include<iostream>
    using namespace std;
    
    class SealedClass
    {
    private:                      // 私有成员
    	SealedClass() {  };       // 构造函数
    	~SealedClass() {  };      // 析构函数
    public:
    	int m_number;
    	static SealedClass* GetInstance(int number)              // 用于构造的函数
    	{
    		SealedClass * pInstance = new SealedClass();
    		pInstance->m_number = number;
    		return pInstance;
    	}
    	static void DeleteInstance(SealedClass* pInstance)       // 用于析构的函数
    	{
    		delete pInstance;
    		pInstance = 0;
    	}
    };
    
    int main(void)
    {
    	SealedClass * p = SealedClass::GetInstance(9);
    	cout<<"m_number is : "<<p->m_number<<endl;
    	SealedClass::DeleteInstance(p);
    	cout<<"m_number is : "<<p->m_number<<endl;
    	
        return 0;
    }

上面方法也存在一些问题：只能创建位于堆上面的实例，需要程序员手动释放创建的实例；无法创建位于栈上的实例。

**方法三**：

class MakeFinal {
           friend class FinalClass;
    private:
           int a;
           MakeFinal() {}
           ~MakeFinal() {}
    };
    
    
    //FinalClass是一个不能被继承的类，同时，可以在
    //堆和栈上产生该类的实例
    class FinalClass: virtual public MakeFinal {
    public:
           void test() {cout << a << endl;}
           FinalClass() {}
           ~FinalClass() {}
    };
    
    
    //这里尝试继承FinalClass的行为会引发编译错误:
    //FinalClass不能被继承
    class Try: public FinalClass {
    public:
          Try() {}
          ~Try() {}
    };
    
    
    int main() {
           FinalClass *f1;
           FinalClass obj;
    }

如上的程序：将类FinalClass设置为类MakeFinal的友元类，这样，FinalClass就可以使用MakeFinal的私有构造函数和析构函数了。而且，FinalClass是虚继承类MakeFinal，那么如果某个类试图继承FinalClass，就会绕过FinalClass的构造函数，直接调用虚基类MakeFinal的构造函数，而后者是private，因此，这个类无法继承FinalClass；而且还保证了FinalClass可以在堆、栈上进行实例化。

**上述代码还可以写成模板的形式**：

template<typename T>
    class MakeFinal {
    	friend T;
    private:
    	int a;
    	MakeFinal() {}
    	~MakeFinal() {}
    };
    
    //FinalClass是一个不能被继承的类，同时，可以在
    //堆和栈上产生该类的实例
    class FinalClass: virtual public MakeFinal<FinalClass> {
    public:
    	void test() {cout << a << endl;}
    	FinalClass() {}
    	~FinalClass() {}
    };
    
    //这里尝试继承FinalClass的行为会引发编译错误:
    //FinalClass不能被继承
    class Try: public FinalClass {
    public:
    	Try() {}
    	~Try() {}
    };
    
    int main() {
    	FinalClass *f1;
    	FinalClass obj;
    }

参考文章：

[http://www.cnblogs.com/Braveliu/archive/2013/01/03/2842739.html][http_www.cnblogs.com_Braveliu_archive_2013_01_03_2842739.html]  
  
[http://blog.163.com/xiangzaihui@126/blog/static/166955749201182295845689/][http_blog.163.com_xiangzaihui_126_blog_static_166955749201182295845689]

[Link 1]: http://blog.csdn.net/hackbuteer1/article/details/6550777
[http_www.cnblogs.com_Braveliu_archive_2013_01_03_2842739.html]: http://www.cnblogs.com/Braveliu/archive/2013/01/03/2842739.html
[http_blog.163.com_xiangzaihui_126_blog_static_166955749201182295845689]: http://blog.163.com/xiangzaihui@126/blog/static/166955749201182295845689/