前言 🚀

    “特殊类设计”这一章看起来内容不多，但背后其实在讨论一个很典型、也很有代表性的 C++ 设计问题：类到底能不能限制对象的创建位置，能不能强制某个对象只能在堆上创建，或者只能在栈上创建。 这不是语法技巧题，而是对象模型、访问控制和运算符重载共同配合后的结果。

    在默认情况下，C++ 类对象既可以定义成局部变量放在栈上，也可以通过 new 放在堆上。语言本身并不会替你加限制。如果业务场景确实需要“只能堆上”或者“只能栈上”，就必须主动从构造、析构、拷贝、new 操作这些入口动手，把不允许的那条路堵住。

    所以这一章真正要建立起来的主线很简单：对象创建位置并不是类天然属性，而是通过接口设计和访问控制人为约束出来的。 顺着这条线去看“只在堆上创建”和“只在栈上创建”两类设计，思路会非常清楚。

---

一. 为什么类对象默认既能在栈上，也能在堆上 🧠

    先抓住默认语义。对于一个普通类来说：

• 写成局部变量，就是在栈上创建
• 写成 new T，就是在堆上创建

例如：

class A
{
};

int main()
{
    A obj;        // 栈上对象
    A* ptr = new A; // 堆上对象
}

    这说明对象到底创建在什么位置，并不是由“类名”决定的，而是由创建方式决定的。也正因为如此，如果想强行限制某种创建方式，本质上就是要让对应的创建路径无法走通。

---

二. 让类对象只能在堆上创建：核心思路是什么 🔍

    “只能堆上创建”的意思并不是“这个类和堆有某种天然绑定”，而是：

禁止外部直接定义栈对象，只保留堆分配路径。

2.1 为什么普通写法会允许栈对象

HeapOnly obj;

    这行代码本质上做了两件事：

1. 调用构造函数创建对象
2. 在离开作用域时自动调用析构函数销毁对象

    所以要禁止这种写法，就得从“构造能不能直接调到”或“析构能不能在作用域结束时被正常访问”这两条路上动手。

---

三. 方案一：把析构函数设为私有，为什么能挡住栈对象 🧱

3.1 基本写法

class HeapOnly
{
public:
    void Destory()
    {
        delete this;
    }

private:
    ~HeapOnly()
    {
        cout << "~HeapOnly()" << endl;
    }
};

3.2 为什么这会让栈对象无法成立

    若你写：

HeapOnly obj;

那么离开作用域时编译器必须生成对析构函数的调用。但此时析构函数是私有的，外部作用域无权访问，于是代码无法通过编译。

3.3 为什么 new 仍然能创建对象

    因为这里并没有把构造函数私有化，所以：

HeapOnly* ptr = new HeapOnly;

仍然可以成功。对象被创建在堆上后，外部不能直接 delete ptr，因为析构函数不可访问，于是类内部提供一个成员函数：

void Destory()
{
    delete this;
}

由对象自己完成释放。

3.4 这种写法的关键点

• 外部不能定义栈对象
• 外部也不能直接 delete
• 对象销毁必须经过类内部提供的接口

3.5 这种方式的注意点

    delete this 并不是可以随便用的技巧，它要求对象确实是通过 new 创建出来的。若对象本来不在堆上，调用 delete this 就会出问题。所以这类设计必须和“只能堆上创建”的整体约束一起成立。

💡 避坑指南：
析构私有并不是为了“神秘封装”，而是为了切断作用域结束时自动析构这条路。
一旦自动析构无法访问，栈对象就没法合法存在。

---

四. 方案二：把构造函数设为私有，再开放工厂接口 💻

4.1 基本写法

class HeapOnly
{
public:
    static HeapOnly* createObj()
    {
        return new HeapOnly;
    }

    HeapOnly(const HeapOnly& hp) = delete;

private:
    HeapOnly()
    {
        cout << "HeapOnly()" << endl;
    }
};

4.2 为什么这也能禁止栈上创建

    因为无论是：

HeapOnly obj;

还是：

HeapOnly other(obj);

本质上都需要访问构造函数。可一旦构造函数私有化，类外就无法直接创建对象。

4.3 为什么还要提供 createObj

    因为类自己内部有权限访问私有构造函数，所以可以通过静态成员函数统一放开“合法创建入口”：

HeapOnly* ptr = HeapOnly::createObj();

这就把对象创建这件事收口到了一个固定接口上。

4.4 为什么还要禁用拷贝

HeapOnly(const HeapOnly& hp) = delete;

    若不禁用拷贝，就可能通过已有对象再间接构造出新对象，从而绕开原本的限制思路。把拷贝构造删掉，语义会更彻底。

4.5 这种方案和析构私有方案相比有什么区别

方案	限制点	特点
析构私有	堵住栈对象的销毁路径	需要额外设计释放接口
构造私有	堵住对象的直接创建路径	更像“工厂控制创建”

    两种方式都能实现“只能堆上创建”，只是切入点不同。

---

五. 让类对象只能在栈上创建：本质上要堵哪条路 ⚠️

    和“只能堆上”相反，“只能栈上创建”真正要做的是：

禁止外部使用 new。

5.1 为什么只靠私有构造函数还不够

    因为如果你只是把构造函数私有化，那不仅 new 不行，连栈对象也都不行了。可“只能栈上”并不是“哪里都不能创建”，而是要保留一条合法的栈对象生成路径。

---

六. 只在栈上创建：构造私有 + 工厂返回对象值 🧩

6.1 基本写法

class StackOnly
{
public:
    static StackOnly createObj()
    {
        StackOnly obj;
        return obj;
    }

private:
    StackOnly()
    {
        cout << "HeapOnly()" << endl;
    }

    void* operator new(size_t size) = delete;
};

6.2 为什么 createObj() 能返回对象

    因为静态成员函数属于类内部，有权限调用私有构造函数，所以它可以在函数内部先创建一个局部对象：

StackOnly obj;

然后再按值返回出去。外部接收时：

StackOnly obj = StackOnly::createObj();

最终拿到的是一个正常对象值，而不是堆对象指针。

6.3 为什么 operator new = delete 是关键

void* operator new(size_t size) = delete;

    这行代码直接把类专属的 new 路径禁掉，于是下面这种写法会在编译期报错：

StackOnly* ptr = new StackOnly;

这样一来，外部就只能通过返回对象值的方式获得实例，而不能在堆上显式分配。

6.4 这类设计的真正语义

• 创建入口被收口到类内部
• 外部不能 new
• 只能拿到对象值
• 因而对象更自然地落在自动存储期语义中

💡 避坑指南：
“只能栈上创建”并不是把对象硬塞进栈里，而是把堆分配路径删掉。
外部无法 new，自然就只剩下按值对象这条路。

---

七. 为什么“只在堆上 / 只在栈上”本质上都是接口约束 🗺️

    看到这里，其实可以把两类设计统一起来理解：

• 想只在堆上创建，就要禁掉“外部直接生成栈对象”这条路
• 想只在栈上创建，就要禁掉“外部 new”这条路

7.1 关键控制点其实就那几个

1. 构造函数权限
   控制外部能不能直接建对象

2. 析构函数权限
   控制对象能不能合法结束生命周期

3. 拷贝 / 赋值
   防止通过旁路语义继续生成新对象

4. operator new / operator delete
   控制堆分配入口是否存在

7.2 这说明了什么

    说明对象创建位置从来不是“类的固有属性”，而是通过类接口的可见性与语义组合出来的结果。这也是 C++ 设计里非常典型的一种思想：语言给出机制，规则由类自己决定。

---

八. 这类设计为什么不算日常高频，但很值得理解 📌

    实际业务开发里，“必须只能堆上”或“必须只能栈上”的类并不是遍地都是，但这类设计仍然很值得学，因为它能帮助建立几个很重要的对象模型认知：

• 构造函数和析构函数不仅负责“初始化 / 清理”，还会影响对象能否被合法创建和销毁
• = delete 不只是禁用函数，更是在明确表达类的语义边界
• operator new / operator delete 也是类接口的一部分
• 工厂函数不仅能隐藏创建细节，还能强制创建策略

    换句话说，这一章表面在讲“创建位置限制”，本质上是在训练一种更底层的类设计能力：类不只是数据和函数的集合，它还可以主动规定自己该怎样被创建、怎样被销毁、怎样被使用。

---

总结 📝

    “特殊类设计”这一章最值得抓住的主线，其实非常统一：

对象默认既能在栈上也能在堆上；若想限制创建位置，就必须主动切断不允许的那条创建路径。

    围绕这条主线，两类设计就顺理成章了：

• 只在堆上创建：
  要么让栈对象无法合法析构，要么让外部无法直接调用构造，只保留类内部控制的堆分配入口。

• 只在栈上创建：
  要保留对象值语义，同时禁掉 new，让外部无法从堆上分配。

    所以这一章最终不是在背几个技巧，而是在建立一个更成熟的认识：

类的使用方式，本身也是类设计的一部分。

    当这条认识建立起来之后，后面再看单例模式、工厂模式、资源句柄类、不可拷贝类、只能移动类等设计时，就会自然发现：它们和这一章本质上都在做同一件事——通过接口约束去表达类的真实语义。