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修饰的类不能被继承。