設計一個只能在堆上或棧上實例化的類

一道C++筆試題：設計一個只能在堆內存上實例化的類和一個只能在棧內存上實例化的類

只能在堆內存上實例化的類：將析構函數定義為private，在棧上不能自動調用析構函數，只能手動調用。也可以將構造函數定義為private，但這樣需要手動寫一個函數實現對象的構造。

只能在棧內存上實例化的類：將函數operator new和operator delete定義為private，這樣使用new操作符創建對象時候，無法調用operator new，delete銷毀對象也無法調用operator delete。

#include <iostream>
using namespace std;

//只能在堆內存上實例化的類
class CHeapOnly
{
public:
    CHeapOnly()
    {
        cout << "Constructor of CHeapOnly!" << endl;
    }

    void Destroy() const
    {
        delete this;
    }

private:
    ~CHeapOnly()
    {
        cout << "Destructor of CHeapOnly!" << endl;
    }
};

//只能在棧內存上實例化的類，就是不能使用new來構造類，把operator new私有化
class CStackOnly
{
public:
    CStackOnly()
    {
        cout << "Constructor of CStackOnly!" << endl;
    }

    ~CStackOnly()
    {
        cout << "Destrucotr of CStackOnly!" << endl;
    }

private:
    void* operator new(size_t size)
    {
    }

    void operator delete(void * ptr)
    {
    }
};

int main()
{
    //use of CHeapOnly
    CHeapOnly* pHeap = new CHeapOnly;
    pHeap->Destroy();

    //error use of CHeapOnly
    //CHeapOnly objHeap;

    //use of CStackOnly
    CStackOnly objStack;

    //error use of CStackOnly
    //CStackOnly* pStack = new CStackOnly;

    return 0;
}

 下面一個類也只能在堆內存上生成，將構造函數和析構函數都定義為private，但是可以通過類的static函數創建對象，不過這個對象是不能被繼承的。

#include <iostream>
using namespace std;

//只能在堆內存上實例化的類
class FinalClass
{
public :
    static FinalClass* GetInstance()
    {
        cout<<"Constructor of the class"<<endl;
        return new FinalClass;
    }

    static void DeleteInstance(FinalClass* pInstance)
    {
        cout<<"Destructor of the class"<<endl;
        delete pInstance;
        pInstance = 0;
    }

private :
    FinalClass() {}
    ~FinalClass() {}
};

int main()
{
    //use of CHeapOnly
    FinalClass* fc = FinalClass::GetInstance();
    FinalClass::DeleteInstance(fc);

    return 0;
}