C++一些特殊的类的设计

一、设计一个只能在栈上分配空间的类

重写类的opeator new 操作，并声明为private，一个大概的代码如下：

class StackOnly
{
    public:
        StackOnly(){/*constructor*/}
        ~StackOnly(){/*destructor*/};
    private:
        void *operator new(size_t size);
};

int main()
{
    StackOnly s; //正确用法，自动变量在栈上分配内存

    StackOnly * ps = new StackOnly(); //错误，全局new操作符无法调用operator new操作分配堆上内存
    return 0;
}

这是一个面试题，考察的是反应速度和对知识掌握的熟悉程度，不过这个题目也有些让人迷惑，很多人想得到要改写new operator，但是却会陷入new opeator的底层怎么实现这个死循环中，误认为这个类的使用方法跟其他类一样，只是底层获取内存的方式变了，但是实际上只是不准客户使用new 这种声明方式。

二、设计一个只能在堆上分配内存的类

这题和设计一个只能在栈上分配空间的类是一样的思路，只能在堆上分配空间意味着只能以A * pa = new A(…)；这种形式来获取内存，而不能通过A a；这种形式来获取。它的思路是这样的：将析构函数声明为protected 或者private ，这样的话，如果用A a ;这种内存获取方式，会导致析构函数调用出错。于是，相应的代码如下：

class HeapOnly
{
    public:
        HeapOnly(){/*constructor*/};
        void destroy(){/*do things ought to be done by destructor*/}
    private:
        ~HeapOnly(){/*destructor*/}
};

int main()
{
    HeapOnly h ; //错误用法，无法调用析构函数
    HeapOnly *ph = new HeapOnly(); //正确用法
    ph->destroy(); //因为无法调用析构函数，所以要自行释放内存
}

三、设计一个不能被继承的类

很容易想到的一个思路就是将此类的构造函数私有化，那么子类就无法调用父类的构造函数了，自然无法构建父类部分，但是这样的话就不能够正常使用这个类了，因为无法正常地构造函数，只能按照如下的方法来实现一个类：

class NoInheritance
{
    public:
        static NoInheritance * getInstance(){return new NoInheritance();}
        static void destroy(NoInheritance * pN){delete pN; };
    private:
        NoInheritance();
        ~NoInheritance();
};

int main()
{
    NoInheritance *ni = NoInheritance.getInstance();
    NoInheritance.destroy(ni);
    return 0;
}

以上的确是个可行的方案，可惜就是用起来不太方便，利用友元的概念可以实现一个很好的不能被继承的类，如下：

class NoHeritance
{
    private:
        NoHeritance();
        ~NoHeritance();
        friend class CBase;
};

class CBase:virtual public NoHeritance
{
    public:
        CBase();
        ~CBase();
    private:
        //members
}

虚基类最终只能由最终子类构造，CBase作为虚基类NoHeritance的友元，是可以调用其private函数的，但是友元性质不能被继承，如果Child想要继承CBase ,需要调用NoHeritance 的构造函数，这是行不通的，于是我们就构造了一个不能被继承的类。（参考：http://blog.csdn.net/doudou745/article/details/7277164）

四、设计一个只能有一个实例的类

这是典型的设计模式，单例模式。如果不考虑多线程安全，大概的代码如下：

#include<iostream>
using namespace std;

class Singleton
{
public:
    static Singleton * GetInstance()//通过静态公有函数获得该类的实例对象
    {
        if(m_pInstance==NULL)
        m_pInstance=new Singleton();
        return m_pInstance;
    }

private:
    Singleton(){}//构造函数私有化的目的是为了防止从别处实例化该类对象
    static Singleton * m_pInstance;
    class Garbo//删除Singleton实例的对象
    {
    public:
        ~Garbo()
        {
            if(Singleton::m_pInstance)
            {
                delete Singleton::m_pInstance;
            }
        }
    };
    static Garbo gb;//在程序结束时，系统会调用它的析构函数
};
Singleton * Singleton::m_pInstance=NULL;//初始化静态数据成员

int main()
{
    Singleton *sl=Singleton::GetInstance();
    return 0;
}