1、只能在堆上分配对象

为了只能在堆上分配对象，可以通过将构造函数和析构函数声明为private 防止自动调用构造函数和析构函数。同时使用静态工厂的方式，在类内调用私有的构造函数，以达到只能使用new的方式创建对象。代码如下：

#include <iostream>

class HeapObj
{

public:
    static HeapObj *create()
    {
        return new HeapObj();
    }

    void destory()
    {
        delete this;
    }

    void doSomething()
    {
        std::cout << "只能在堆上创建对象，不能在栈上创建对象" << std::endl;
    }

private:
    // 私有构造函数和析构函数，禁止栈上分配
    HeapObj() {}
    ~HeapObj() {}

    HeapObj(const HeapObj &) = delete;
    HeapObj &operator=(const HeapObj &) = delete;
};

int main()
{
    HeapObj *obj = HeapObj::create();
    obj->doSomething();
    obj->destory();

    // HeapObj obj1;  // 报错
}

关键的：

• 构造函数和析构函数设为private，禁止直接调用。

• 提供静态方法（如create()）和成员方法（如destroy()）管理堆内存。

• 可选禁用拷贝构造函数和赋值运算符（根据需求）。

2、只能在栈上分配对象

禁止堆上分配（即禁止使用new运算符），通过将operator new和operator delete设为private

/*禁用在堆上创建对象，只能在栈上创建对象*/
#include <iostream>

class StackObj
{

public:
    StackObj() = default;
    ~StackObj() = default;

    void doSomething()
    {
        std::cout << "禁用在堆上创建对象，只能在栈上创建对象" << std::endl;
    }

private:
    // 禁用 new 和 delete
    static void *operator new(size_t) = delete;
    static void operator delete(void *) = delete;

    StackObj(const StackObj &) = delete;
    StackObj &operator=(const StackObj &) = delete;
};

int main()
{
    StackObj obj;
    obj.doSomething();

    // StackObj obj1 = new StackObj(); // 会报错
    // obj1->doSomething();

    return 0;
}

需要注意的是，static void *operator new(size_t) = delete; static void operator delete(void *) = delete; 需要传入相应的参数。