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

吃饭时与“大姐”讨论问题，他问道“C++如何设计一个不能被继承的类”？不能被继承，那把构造函数和析构函数设计成私有的不就行了，这样一来子类不能访问父类的构造函数和析构函数，也就无法继承了。然而这样一来，这个类在其他地方也就不能实例化了，没有存在的意义了。

这时候你是不是想到了静态方法，是啊，我们可以通过静态方法来返回类的实例，然后通过另一个静态方法来释放该类对象。代码如下：

//static function
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 AR
{
public:
    static AR& getInstance(int n)
    {
        AR par;
        par.num = n;
        return par;
    }
    static void destructInstance(AR& pInstance)
    {
        pInstance.~AR();
    }
private:
    AR(){cout << "construct AR" << endl;}
    ~AR()
    {
        cout << "destruct AR" << endl;
    }
public:
    int num;
};

我写了一段测试代码，来测试返回指针和返回引用时的效果：

void testStatic()
{
    cout << "---------------A: return pointer-------------" <<  endl;
    A *sa = A::getInstance(9);
    cout << "num is: " << sa->num << endl;
    A::destructInstance(sa);
    cout << "-------------AR: return reference------------" <<  endl;
    AR &ra = AR::getInstance(9);
    cout << "num is: " << ra.num << endl;
    AR::destructInstance(ra);
}

输出如下：

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

可是这样一来，类A虽然不能被继承，但却只能在堆上创建对象，而不能在栈上创建对象。要知道很多时候，我们只想创建一个临时对象，使用栈空间会更高效方便一些。（关于栈空间和堆空间，这里有一篇不错的博文http://www.cnblogs.com/kevinGaoblog/archive/2012/03/23/2413102.html）如何才能使我们的类既不能被继承，又能够在堆和栈上都可以创建对象呢？

考虑一下友元，友元可以访问类的私有成员，因此，我们可以创建一个基类，使其构造函数和析构函数为私有成员，然后让我们设计的非继承类成为基类的友元，这样一来，问题不就解决了。看下代码：

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
{
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;
}

// test
class derivedClass: public finalClass
{
public:
    derivedClass(){cout << "construct derivedClass" << endl;}
    ~derivedClass(){cout << "destruct derivedClass" << endl;}
};

其中testFriend()的输出如下：

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

如果不是虚继承的话，derivedClass不会直接调用基类的构造函数，它只会调用父类finalClass的构造函数，而finalClass在构造时调用基类Base的构造函数是没有任何问题的。关于单一继承、多重继承与虚继承，推荐博文http://blog.csdn.net/haoel/article/details/3081328 ， http://blog.chinaunix.net/uid-16723279-id-3568748.html。

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

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

struct Base
{
    virtual void foo();
};

struct A : Base
{
    virtual void foo() final; // A::foo is final
    void bar() final; // Error: non-virtual function cannot be final
};

struct B final : A // struct B is final
{
    void foo(); // Error: foo cannot be overridden as it's final in A
};

struct C : B // Error: B is final
{
};