C++如何使类不能被继承

最新推荐文章于 2024-06-23 22:55:37 发布

Allen-PengYe

最新推荐文章于 2024-06-23 22:55:37 发布

阅读量1.8k

点赞数

分类专栏： C++ 文章标签：定义不能被继承的类

C++ 专栏收录该内容

9 篇文章 0 订阅

订阅专栏

如何使类不能被继承？

如果大家熟悉java的话应该知道java中有一种类不能被继承,那就是final类.这种类有很多用处,尤其是在大的项目中控制类的继承层次. 使子类数量不至于爆炸.在使用了多继承的类层次中这也是防止出现菱形继承层次结构的一个好办法. 要实现一个不能被继承的类有很多方法.

　　主要的思路就是使子类不能构造父类的部分,这样子类就没有办法实例化整个子类.这样就限制了子类的继承. 所以我们可以将父类的构造函数声明成为私有的,但是这样父类不就不能实例化.我想可以添加一个静态帮助函数来进行构造. 虽然这样很简陋.但是这的确是一种解决方法.
　　可是如果只有这个方法能够解决,那么C++实在是太不灵活了.而且这也不值得写一片文章出来!有没有办法解决上面的方法中的那些问题呢?
　　我们可以利用友员不能被继承的特性!
　　首先假设已经有一个类CXX.这是某一个类层次的分支,我们现在要从CXX继承一个Final子类CParent来,也就是CParent不能够被继承. 我们可以充分利用友员不能被继承的特点,也就是说让CParent是某一个类的友员和子类,CParent可以构造,但是CParent的子类 CChild确不能继承那个友员特性,所以不能被构造.所以我们引入一个CFinalClassMixin.
　　我们对这个类的功能是这么期望的:
　　任何类从它继承都不能被实例化
　　同时这个类本身我们也不希望它被实例化.
　　如何实现这个类那?很简单!那就是实现一个构造函数和析构函数都是private的类就行了.同时在这类里面将我们的CParent声明为友员. 代码如下:
　　class CFinalClassMixin
　　{
　　friend class CParent;
　　private:
　　CFinalClassMixin(){}
　　~CFinalClassMixin(){}
　　};
　　>//我们的CParent代码应该如下:
　　class CParent:publicCXXX
　　{
　　public:
　　CParent(){}
　　~CParent(){}
　　};
　　它是从CXXX扩展的一个类(注,此时它还是能够被继承).现在我们需要它不能被继承.那么只要将代码改成
　　class CParent:public CFinalClassMixin, public CXXX
　　{
　　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 CXXX
　　{
　　public:
　　CParent(){}
　　CParent(){}
　　};
　　现在试试,行了.
　　但是可能有些人会对多继承心有余悸!但是我们这里并没有必要这么担心!为什么?因为我们的CFinalClassMixin类是纯的!pure! 也就是说它根本没有成员变量!那么我们就根本不用担心多继承带来的最大问题.菱形继承产生的数据冗余.以及二义性.
　　现在还有个不足!那就是我们不能每次使用这个CFinalClassMixin类就在里面加上对某个类的友员声明啊!这多麻烦啊! 虽然不是什么大问题,但是我觉的还是要解决,因为我充分信任C++!
　　解决的方法也很简单!那就是使用模板!具体描述就省略了,给出代码大家一看就知道了
　　下面是我得测试程序的完整代码(其中的CFinalClassmixin已经改成模板)
　　// finaltest.cpp : Defines the entry point for the console application.
　　//
　　#include "stdafx.h"
　　#include <iostream>
　　using namespace std;
　　template<class T>
　　class CFinalClassMixin
　　{
　　friend T;
　　private:
　　CFinalClassMixin(){}
　　~CFinalClassMixin(){}
　　};
　　class CXXX
　　{
　　public:
　　CXXX(){cout << "I am CXXX" << endl;}
　　~CXXX(){}
　　};
　　class CParent:virtual public CFinalClassMixin<CParent>, public CXXX
　　{
　　public:
　　CParent(){}
　　~CParent(){}
　　};
　　class CChild:public CParent{};
　　int main(int argc, char* argv[])
　　{
　　CParent a; // 可以构造
　　//CChild b; //不能构造
　　return 0;
　　}
　　现在只要对不想被继承的类加入一个CFinalClassMixin混合类做父类就行了.

　　通过限制构造函数,我们就达到了限制继承的目的.但是这对有些还是个例外,比如全是静态函数的类.这些类本身就不需要构造. 所以我们对它没有办法.但是在大多数情况下,一个全是静态函数的类多少暗示了程序本身的设计可能是需要斟酌的.

那构造函数和析构函数都被定义为private时，如何创建，释放对象？

（1）构造函数定义private
      当我们在程序中声明一个对象时，编译器为调用构造函数(如果有的话)，而这个调用将通常是外部的，也就是说它不属于class对象本身的调用，假如构造函数是私有的，由于在class外部不允许访问私有成员，所以这将导致编译出错。
      然而，对于class本身，可以利用它的static公有成员，因为它们独立于class对象之外，不必产生对象也可以使用它们。
      此时因为构造函数被class私有化，所以我们要创建出对象，就必须能够访问到class的私有域；这一点只有class的成员可以做得到；但在我们建构出其对象之前，怎么能利用它的成员呢？static公有成员，它是独立于class对象而存在的，“我们”可以访问得到。假如在某个static函数中创建了该class的对象，并以引用或者指针的形式将其返回（这里不以对象返回，主要是构造函数是私有的，外部不能创建临时对象），就获得了这个对象的使用权。
      下面是例子：
class OnlyHeapClass
{
public:
   static OnlyHeapClass* GetInstance()
       {
              // 创建一个OnlyHeapClass对象并返回其指针
              return (new OnlyHeapClass);
       }
   void Destroy();
private:
       OnlyHeapClass() { }
       ~OnlyHeapClass() {}
};

int main()
{
       OnlyHeapClass *p = OnlyHeapClass::GetInstance();
       ... // 使用*p
       delete p;
       return 0;
}

      这个例子使用了私有构造函数，GetInstance()作为OnlyHeapClass的静态成员函数来在内存中创建对象：由于要跨函数传递并且不能使用值传递方式，所以我们选择在堆上创建对象，这样即使getInstance()退出，对象也不会随之释放，可以手动释放。

      构造函数私有化的类的设计保证了其他类不能从这个类派生或者创建类的实例，还有这样的用途：例如，实现这样一个class：它在内存中至多存在一个，或者指定数量个的对象（可以在class的私有域中添加一个static类型的计数器，它的初值置为0，然后在GetInstance()中作些限制：每次调用它时先检查计数器的值是否已经达到对象个数的上限值，如果是则产生错误，否则才new出新的对象，同时将计数器的值增1.最后，为了避免值复制时产生新的对象副本，除了将构造函数置为私有外，复制构造函数也要特别声明并置为私有。
      如果将构造函数设计成Protected，也可以实现同样的目的，但是可以被继承。

(2)析构函数private

　　另外如何保证只能在堆上new一个新的类对象呢？只需把析构函数定义为私有成员。
      原因是C++是一个静态绑定的语言。在编译过程中，所有的非虚函数调用都必须分析完成。即使是虚函数，也需检查可访问性。因些，当在栈上生成对象时，对象会自动析构，也就说析构函数必须可以访问。而堆上生成对象，由于析构时机由程序员控制，所以不一定需要析构函数。保证了不能在栈上生成对象后，需要证明能在堆上生成它。这里OnlyHeapClass与一般对象唯一的区别在于它的析构函数为私有。delete操作会调用析构函数。所以不能编译。
       那么如何释放它呢？答案也很简单，提供一个成员函数，完成delete操作。在成员函数中，析构函数是可以访问的。当然detele操作也是可以编译通过。
void OnlyHeapClass::Destroy() {
        delete this;
}
    构造函数私有化的类的设计可以保证只能用new命令在堆中来生成对象，只能动态的去创建对象，这样可以自由的控制对象的生命周期。但是，这样的类需要提供创建和撤销的公共接口。
    另外重载delete，new为私有可以达到要求对象创建于栈上的目的，用placement new也可以创建在栈上。

---------------------------------------------------------------------------------------------------------------------------------
还是不懂啊：
1.为什么要自己调用呢？对象结束生存期时不就自动调用析构函数了吗？什么情况下需要自己调用析构函数呢？
　　比如这样一种情况，你希望在析构之前必须做一些事情，但是用你类的人并不知道，
那么你就可以重新写一个函数，里面把要做的事情全部做完了再调用析构函数。
这样人家只能调用你这个函数析构对象，从而保证了析构前一定会做你要求的动作。

2.什么情况下才用得着只生成堆对象呢？
  　　堆对象就是new出来的，相对于栈对象而言。什么情况下要new，什么情况下在栈里面
提前分配，无非就是何时该用动态，何时该用静态生成的问题。这个要根据具体情况
具体分析。比如你在一个函数里面事先知道某个对象最多只可能10个，那么你就可以
定义这个对象的一个数组。10个元素，每个元素都是一个栈对象。如果你无法确定数
字，那么你就可以定义一个这个对象的指针，需要创建的时候就new出来，并且用list
或者vector管理起来。

---------------------------------------------------------------------------------------------------------------------------------
类中“私有”权限的含义就是：私有成员只能在类域内被访问，不能在类域外进行访问。

把析构函数定义为私有的，就阻止了用户在类域外对析构函数的使用。这表现在如下两个方面：

1. 禁止用户对此类型的变量进行定义，即禁止在栈内存空间内创建此类型的对象。要创建对象，只能用 new 在堆上进行。

2. 禁止用户在程序中使用 delete 删除此类型对象。对象的删除只能在类内实现，也就是说只有类的实现者才有可能实现对对象的 delete，用户不能随便删除对象。如果用户想删除对象的话，只能按照类的实现者提供的方法进行。

可见，这样做之后大大限制了用户对此类的使用。一般来说不要这样做；通常这样做是用来达到特殊的目的，比如在 singleton 的实现上。楼主可查找 singleton 的资料来了解它是怎么一回事。