C++设计一个类：不能被继承

C++如何设计一个不能被继承的类？

我们首先想到，不能被继承，那把构造函数和析构函数设计成私有的不就行了，这样的话子类不能访问父类的构造函数和析构函数，也就无法继承了。

然而这样一来，这个类在其他地方也就不能实例化了，没有存在的意义了。

这时候我们应该想到静态方法，我们可以通过静态方法来返回类的实例，然后通过另一个静态方法来释放该类对象。

看如下代码：

class A
{
public:
    static A* getInstance(int n)
    {
        A* pa = new A();
        pa->num = n;
        return pa;
    }
    static void destructInstance(A* pInstance)
    {
        delete pInstance;
        pInstance = NULL;
    }
private:
    A(){cout << "construct A" << endl;}
    ~A(){cout << "destruct A" << endl;}
public:
    int num;
};

那么？为什么必须返回指针而不返回对象的引用呢？
看下面代码：

class B
{
public:
    static B& getInstance(int n)
    {
        B pb;
        pb.num = n;
        return pb;
    }

    static void destructInstance(B& pInstance)
    {
        pInstance.~B();
    }

private:
    B()
    {
        cout << "construct B" << endl;
    }
    ~B()
    {
        cout << "destruct B" << endl;
    }
public:
    int num;
};

上面的代码是返回引用，我们做一个测试：

void test()
{
    cout << " return pointer " << endl;
    A *sa = A::getInstance(9);
    cout << "num is:" << sa->num << endl;
    A::destructInstance(sa);

    cout << " return reference " << endl;
    B &sb = B::getInstance(9);
    cout << "num is:" << sb.num << endl;
    B::destructInstance(sb);
}

观察结果：
这里写图片描述
可以看出：
当返回引用时，在输出num之前，对象就已经被析构了。
这是因为在static B& getInstance()函数中声明的对象B pb是局部变量，当函数运行完，该变量就会被释放掉，而返回的却是已经被释放掉的对象的引用，这无疑会造成内存泄漏。
所以，只能通过new来动态申请堆上的内存，然后返回指针，而不能返回引用。

如果这样的话，类A虽然不能被继承，但却只能在堆上创建对象，而不能在栈上创建对象。
若我们只想创建一个临时对象，使用栈空间会更高效方便一些。

如何能使我们的类既不能被继承，又能够在堆和栈上都可以创建对象呢？

我们考虑到友元，友元可以访问类的私有成员。

因此，我们可以创建一个基类，使其构造函数和析构函数为私有成员，然后让我们设计的非继承类成为基类的友元。

看下面的代码：

template <typename T>
class Base
{
    friend T; // 这种写法好像是C++11才支持的
private:
    Base()
    {
        cout << "construct Base" << endl;
    }
    ~Base()
    {
        cout << "destruct Base" << endl;
    }
};

class finalClass: virtual public Base<finalClass>
{
public:
    finalClass():num(0)
    {
        cout << "construct finalClass" << endl;
    }
    finalClass(int n):num(n)
    {
        cout << "construct finalClass" << endl;
    }
    ~finalClass()
    {
        cout << "destruct finalClass" << endl;
    }
    int num;
};

看测试代码：

void testFriend()
{
    cout << "--------------object on heap-----------------" << endl;
    finalClass *pfc = new finalClass(9); // 堆上的对象
    cout << "num is: " << pfc->num << endl;
    delete pfc;
    cout << "-------------Object on stack-----------------" << endl;
    finalClass fc(9);  // 栈上的对象
    cout << "num is: " << fc.num << endl;
}

观察结果：
这里写图片描述

无论在堆上创建对象，还是在栈上创建对象都可以。
这里需要说明的是，finalClass对Base的继承必须是虚继承，这样一来当derivedClass继承finalClass时就会去直接调用Base的构造函数，但由于Base的构造函数是私有的，而derivedClass不是Base的友元，因此会报出编译错误。

于是，我们设计的类finalClass就是一个完整的不能被继承的类。

另外需要说明的是，友元关系不具有传递性。finalClass是Base的友元，即使derivedClass继承了finalClass， derivedClass也不是Base的友元。
即：友元关系不能继承，基类的友元对派生类的成员没有访问权限，如果基类被授予友元关系，则只有基类具有特殊访问权限，该基类的派生类不能访问授予友元关系的类。

现在，C++11中已经像java一样有了final关键字，被final关键字修饰的虚函数（只能是虚函数）不能被重载，被final修饰的类不能被继承。

C++设计一个类：不能被继承

C++如何设计一个不能被继承的类？

猜你喜欢