只能在堆（或栈）上生成对象的类

看到这样的题目，我们首先必须明白的是，哪些变量或者说是对象是在堆上，哪些不是在堆上，这个问题，在前边的文章中已经分享过，这里，再次分享~请看图~

知道了这些之后，我们开始分析这次分享的主题~

---

1.写出一个只能在堆上生成对象的类。
想法一：要想只能在堆上生成对象，也就是说，局部对象，静态对象，全局对象都不能生成，那么我们可以将构造函数写成私有或者保护（类外不可以直接访问的），通过new来构造出一个堆上的对象，我们知道new和delete的底层是调用构造和析构的，所以在类外直接new也是不可取的。既然类外不能使用new是因为无法调用构造，那么我们不妨在类的内部写一个公有方法来生成对象。
实现代码如下：

class B
{
private:
    B(int a)
        :_a(a)
    {}
public:
    ~B()
    {}
    static B* GetObject(const int& a)
    {
        return new B(a);
    }
    static void Destroy(B* p)//可以定义成静态，也可以是非静态
    {
        delete p;
    }
private:
    int _a;
};
void test()
{
    //B b;   //不通过
    B* p = B::GetObject(10);
    B::Destroy(p);
}

由于我们没有公有的构造函数，所以GetObject方法只能是类的静态成员函数（属于类不属于对象），那么GetObject方法必须是静态方法，在函数前边加个static。
想法二;将类的析构函数设为私有。每次定义一个对象的时候，系统都会检查是否会有析构，如果没有，没关系，系统提供；如果有，那就使用自己定义的，如果定义成私有，那就没有办法定义对象了。下边给出实现代码：

class C
{
public:
    C(int a)
        :_a(a)
    {}
    void Destroy()
    {
        delete this;
    }
private:
    ~C()
    {}
private:
    int _a;
};
void test()
{
    C* p = new C(5);
    p->Destroy();
}

想法三（有点问题的想法，请继续往下读）：我们知道malloc开辟的空间也是在堆上，它与new不同的就是：malloc在开辟空间的时候不会调用构造函数，代码如下：

class D
{
public:
    ~D()
    {}
    void Destroy()
    {
        free(this);
    }
private:
    D(int a)
        :_a(a)
    {}
private:
    int _a;
};
void test()
{
    D* p = (D*)malloc(sizeof(D));
    p->Destroy();
}

当写完这段代码，发现测试各方面都正确的时候，才看到，malloc并不会给对象的成员进行初始化。new的底层是调用malloc申请空间的，所以，这个方法三是不对的~
new/delete和malloc/free的区别和联系：
1）他们都是动态管理内存的入口。
2）malloc/free是c/c++标准库函数，new/delete是c++操作符。
3）malloc/free只进行内存的分配和回收；而new/delete还会调用构造和析构函数；
4）malloc/free需要手动计算类型大小，并且会返回void*；new/delete可以自己计算类型的大小，返回对应类型的指针。

---

2.写出一个只能在栈上生成对象的类。
想法一：要想只在栈上定义对象，就不能使用new，也不能定义全局和静态变量，我们可以通过以下的方式实现~
将构造函数设为私有或者保护，然后写一个公有方法去获取对象，代码如下：

class A
{
public:
    static A GetObject(int a)
    {
        return A(a);
    }
    int Get_a()
    {
        return _a;  
    }
private:
    A(int a)
        :_a(a)
    {}
private:
    int _a;
};
void test()
{
    A ret = A::GetObject(10);
    cout<<ret.Get_a()<<endl;
}

注意：GetObject函数中并不能返回引用。如果以值的形式进行返回的话，是将返回的对象以值的形式复制到函数的调用处，此时仍然不能避免定义静态变量和全局变量，这仍然是一种不太严谨的解决办法。

想法二：只能在栈上构造对象，那就是不能再堆上生成对象，看以下代码：

class E
{
public:
    E(int e)
        :_e(e)
    {}
    ~E()
    {}
private:
    void* operator new(size_t size);//只要给出声明就行
    void operator delete(void * ptr);
private:
    int _e;
};
void test()
{
    E e(10);
    //E* p = new E(20);
}

这时候，如果你回头看上边的图片的时候，你将会发现：不在堆上的对象还有可能在静态区，即就是可能是静态变量和全局变量，所以，想法二是不严谨的。
关于第二道题目，如果你有好的想法，清告诉我，我将很感激~
关于第一道题目，如果有问题，请留言~~