看到“C++实例——数组类封装”这个题目，很多刚开始学C++的朋友第一反应是：这不就是把一个原生数组塞进class里吗？有什么好封装的？我当初也是这个想法，直到自己动手完整写了一遍才发现，真正把这个类写清楚，等于把构造与析构、深拷贝、运算符重载、内存管理这几座大山全爬了一遍。项目看起来小，信息密度却高得吓人。

这篇文章就按照我完整跑通这个项目的经历来讲：怎么设计接口、每段核心代码到底在防什么、练习过程中我遇到过的经典崩溃，以及封装完之后还能往哪个方向继续加码。不管你是学校作业做到一半，还是想补一补面向对象基础，照着这份思路敲一遍，收获会比闷头啃语法书实在很多。

1. 为什么要做数组类封装：原生数组的三个硬伤

1.1 原生数组到底哪里不方便

用原生数组写几行代码很容易，int arr[10];声明完就能用。但真正把数组丢进函数、传给类、或者想动态扩容的时候，它的短板一个接一个冒出来。

第一个痛点是越界访问完全不设防。C++标准对越界的定义是“未定义行为”，编译器通常不报错，运行时也不一定立刻崩溃。我见过一个程序在 Release 模式下跑得很欢，某次往arr[10]写了个值，把紧挨在内存里的另一个变量给覆盖了，程序的行为变得莫名其妙，查了三天才定位到是越界写。一个没有边界检查的数组，就像一扇不上锁的门，看似能用，其实隐患一直躺在那里。

第二个痛点是数组大小一旦定死就不能变。int arr[10]今后只能装10个元素，想装第11个，就得去改代码重新编译。运行时需要动态增长的场景，原生数组完全帮不上忙，只能自己拿new[]和delete[]去管理一块堆内存，而且所有用到它的地方都得同步记住“这块内存是谁申请的、谁来释放”。

第三个痛点是数组名会退化为指针。void func(int arr[])里的arr其实不是数组，而是指针。在函数内部sizeof(arr)得到的是指针大小而不是数组大小，所以每次传数组都得额外带一个长度参数。一旦忘记带，或者长度传错，程序轻则取错数据，重则越界崩溃。这几个痛点单看都不算致命，合在一起就非常折磨人。封装的目的就是把这些麻烦全部吸收进一个类里，让使用者只面对一个干净、安全的对象。

1.2 封装到底封的是什么

封装这个词听起来抽象，放在这个例子里其实特别好理解：把数组的指针和长度这两份数据，连同对它们的所有操作，打包成一个类。外部调用者不再直接碰指针，不再自己传长度，只用arr[0]、arr.size()这种直观的接口。

这背后是面向对象里“不变量”的思想。原生数组里，数组首地址和长度是两回事，程序员必须自己在心里维护它们的一致性。而封装后，类内部可以保证“m_data 一定指向一块长度为 m_size 的合法内存”，只要所有修改数据的入口都经过类的方法，这个保证就一直成立。使用者不需要关心内部细节，只需要相信这个类不会坑自己。

这个练习还有一个更实际的意义：它是学习 C++ 资源管理的最佳入口。类里有指针成员，意味着我们要处理构造函数、析构函数、拷贝控制。这些内容单独学的时候很枯燥，但把它们放进一个“数组类”的实例里，一切变得非常具体——什么时候申请内存，什么时候释放内存，拷贝对象时怎么复制数据，全都一目了然。这也是为什么很多教材和课程都爱拿数组类封装当教学项目，它几乎是一把能打开 C++ 面向对象大门的钥匙。

2. 接口设计：动手前先列一份“愿望清单”

2.1 从使用方的视角倒推接口

写类之前先别急着敲代码，先想想：如果我是这个类的使用方，我希望它长什么样？

我理想中的用法是这样的：

IntArray arr(5); // 创建一个能装5个元素的数组 arr[0] = 42; // 写数据，像原生数组一样自然 int v = arr[0]; // 读数据 int n = arr.size(); // 随时知道当前大小 IntArray copy = arr; // 拷贝一个新对象，互不影响

这个愿望清单很简单，但每一句话背后都是一个必须实现的函数。IntArray arr(5)需要构造函数，arr[0]需要重载operator[]，arr.size()需要成员函数，IntArray copy = arr需要拷贝构造函数，剩下的析构函数虽然不会直接被调用，但它负责回收内存，缺了它整个类就是漏水的桶。

为什么要以“使用方视角”开始设计？因为很多初学者常犯的毛病是往类里塞了一堆方法，结果真正用起来别别扭扭。接口不是越多越好，而是越贴合使用直觉越好。如果你写出这个类之后，用它的地方代码读起来不像在操作一个数组，那封装就失败了。

接口清单确定之后，我还会顺带想一想哪些接口暂时没必要加。比如getData()返回内部指针、setData()修改内部数据，这类方法我会刻意避开。内部指针一旦暴露出去，外部代码随时可以拿着指针乱改，封装提供的安全保障就全被绕过了。真正需要原始指针的场景，可以在内部处理，而不是直接交给调用方。

2.2 成员方案与关键取舍

类的成员怎么定，是这个项目第一个需要做决策的地方。

最直接的两个成员是：指向堆内存的指针int* m_data和数组长度int m_size。有这个组合，就已经能支撑“动态大小”和“长度随时可取”这两个核心能力了。可能有人会问，为什么不直接定义一个int m_data[100]当成员？那样确实不用手动管理内存，但数组大小被写死成了100，如果创建对象时传入50，剩下的50个位置全是浪费；如果传入200，直接装不下。这等于只把数组换了个地方存放，最核心的“定长”问题根本没解决。所以成员必须用指针。

也有同学问，为什么不用std::vector直接替代？问这个问题说明已经理解了 vector 的价值，但在这个练习里我们偏偏要“不用”，因为封装的本质就是复刻一个迷你 vector。只有亲手把 vector 底层的机制实现一遍，以后再看到std::vector的源码、看各种容器的文档，才会有一种“原来如此”的通透感。

构造函数要不要加explicit关键字，也是一个值得想一下的小点。如果不加，IntArray a = 5;这种写法是合法的，它会自动调用IntArray(int)构造出一个临时对象。听起来没什么，但如果在函数参数里出现了隐式转换，很容易产生歧义或造成意料之外的临时对象。加上explicit之后，这种隐式转换被禁止，构造函数必须显式调用。初学者可能觉得这是小题大做，但工程上这是一个非常实际的防护。

至于要不要提供默认构造函数，我的建议是提供。一个能创建size为0的空数组的默认构造函数，可以方便地先声明一个数组变量，后续再通过resize或push_back填充内容。很多实际代码里，对象声明和初始化是分离的，这个默认构造函数能少写很多判断逻辑。

3. 核心代码逐段拆解：每一行都在防什么

3.1 构造与析构：成对出现的资源守护

类的骨架和构造函数，我先给出完整的第一版代码，后面再逐行解释。

#include <iostream> #include <cassert> class IntArray { public: explicit IntArray(int size = 0) : m_size(size), m_data(nullptr) { if (m_size > 0) { m_data = new int[m_size](); } } ~IntArray() { delete[] m_data; } int size() const { return m_size; } private: int m_size; int* m_data; };

构造函数里最关键的一行是new int[m_size]()。注意这里的括号，它不是可有可无的装饰，而是“值初始化”的标志。如果不写这对括号，new int[m_size]只分配内存、不初始化元素，数组里的每个 int 都是随机值。直接遍历输出会看到一堆乱七八糟的数字。加了括号之后，内置类型会被初始化为0，也就是说新数组默认是干净的。

析构函数用delete[] m_data释放内存。这里有两个细节：第一，必须用带方括号的delete[]，因为m_data是用new[]分配的；第二，当m_size == 0时，m_data是nullptr，而delete[] nullptr是完全合法的，不会出问题，所以不需要额外判断。

如果这个类没有析构函数会怎样？对象生命周期结束时，指针成员会被丢弃，但m_data指向的那块堆内存不会被回收，这就造成了内存泄漏。最麻烦的是，内存泄漏不会让程序直接报错，而是在程序长时间运行后内存不断膨胀，最终在某次大分配时突然崩溃。很多同学第一版代码跑完没看到任何报错，就以为写对了，其实内存早就漏了一地。

3.2 拷贝控制：深拷贝的完整细节

只有构造和析构的类是不完整的。因为编译器会默认生成一个拷贝构造函数和赋值运算符，而它们的默认行为是“浅拷贝”——只是把m_data指针的值复制一份。这样一来，新对象和原对象会指向同一块内存。

浅拷贝的后果非常严重：两个对象指向同一块堆内存，任何一个对象生命周期结束时都会delete[]这块内存，另一个对象再析构时就变成“二次释放”，程序直接崩溃。要解决这个问题，必须自己实现拷贝控制，也就是深拷贝。

IntArray(const IntArray& other) : m_size(other.m_size), m_data(nullptr) { if (m_size > 0) { m_data = new int[m_size]; for (int i = 0; i < m_size; ++i) { m_data[i] = other.m_data[i]; } } } IntArray& operator=(const IntArray& other) { if (this != &other) { delete[] m_data; m_size = other.m_size; m_data = nullptr; if (m_size > 0) { m_data = new int[m_size]; for (int i = 0; i < m_size; ++i) { m_data[i] = other.m_data[i]; } } } return *this; }

拷贝构造函数的逻辑很直白：先申请一块和源对象一样大的内存，再逐个元素把数据复制过来。需要注意的是临时对象也可能触发拷贝构造，比如函数按值返回对象时，或者IntArray b = a;这种声明初始化时，所以参数必须用const IntArray&，既能接收左值也能接收临时对象，还避免了按值传参时又拷贝一次的死循环。

赋值运算符比拷贝构造多了一步：先delete[] m_data释放掉当前对象已经占用的旧内存，再申请新内存复制数据。如果忘记释放旧内存，每次赋值都会漏掉一块内存，程序跑的时间越长，泄漏越严重。

赋值里还有一个特别容易忽略的判断：if (this != &other)。试想一下a = a;这种自赋值场景，如果没有这个判断，代码会先释放掉a的内存，然后用已经释放掉的内存去复制数据，结果a变成了一堆垃圾数据。实际代码里自赋值出现的概率不高，不过程序员必须防住这种情况，因为引用别名的存在让a = b在底层可能确实指向同一个对象。

这里再补充一个进阶写法。上面的朴素赋值写法在new抛出异常时会让对象处于“旧资源已释放、新资源未分配”的破碎状态。如果希望代码更健壮，可以用“拷贝并交换”的技巧：

IntArray& operator=(IntArray tmp) { std::swap(m_size, tmp.m_size); std::swap(m_data, tmp.m_data); return *this; }

这个写法的原理是：函数参数按值传递，会调用拷贝构造函数生成一个临时副本；然后只要交换指针，当前对象就拥有了副本的数据，而临时对象析构时会带走原本的旧数据。这个技巧在异常安全和代码简洁性上都很出色，是很多专业 C++ 库的实现思路。初学者如果暂时读不透，可以先放着，等把朴素写法跑通之后再来琢磨。

3.3 下标重载：让数组行为像原生数组

数组最自然的操作就是arr[index]，这个能力来自operator[]的重载。为了让读和写都顺畅，我需要两个版本。

int& operator[](int index) { assert(index >= 0 && index < m_size); return m_data[index]; } const int& operator[](int index) const { assert(index >= 0 && index < m_size); return m_data[index]; }

第一个版本返回int&，这样arr[1] = 10才能成功赋值。如果返回普通的int，它只是一个临时副本，赋值操作改的是副本，数组里的数据根本没变，而且编译期还不会报错，属于非常隐蔽的坑。第二个版本给 const 对象用，保证在只读场景下也能访问元素，并且不会意外修改数据。

两个版本里的assert是边界检查。这是原生数组最缺的东西，也是封装最直观的价值之一。需要注意assert只有在 Debug 模式下生效，Release 模式下这行检查会被预处理器去掉，越界访问照样畅通无阻。所以教学项目里用assert没问题，但如果你把这个类用于真实业务，我更建议直接抛异常：

int& operator[](int index) { if (index < 0 || index >= m_size) { throw std::out_of_range("IntArray index out of range"); } return m_data[index]; }

抛异常的好处是 Release 模式下同样有效，调用方可以通过try-catch捕获错误。代价是每次访问多了一个分支判断，性能上会有一点损失。怎么取舍，取决于这个数组用在什么地方——教学练习用assert保持代码精简，生产环境我倾向抛异常。

到这里，一个能用的数组类就成型了。可以用下面的代码验证一下：

int main() { IntArray a(5); for (int i = 0; i < a.size(); ++i) { a[i] = i * i; } IntArray b = a; // 调用拷贝构造函数 IntArray c(3); c = a; // 调用赋值运算符 c[0] = 100; // 只改 c 的数据 std::cout << a[0] << " " << b[0] << " " << c[0] << std::endl; return 0; }

输出结果是0 0 100，a 和 b 没有受到 c 的影响。这说明三个对象各自持有独立的内存，深拷贝真正生效了。

4. 高频坑与调试记录：这些崩溃我全见过

4.1 浅拷贝引发的 double free

这个坑几乎是这个练习里出现频率最高的，几乎每个第一次写数组类封装的同学都会踩一次。

我记得有位同学把类写完，测试的时候一运行就崩溃。他第一反应是检查构造函数，看哪儿指针用错了，折腾了一个下午也没查出来。我让他去看IntArray b = a;这行代码，他反问这行能有什么问题。问题恰恰在这里——他没有写拷贝构造函数，编译器默认生成的拷贝构造只是复制了指针。结果a和b的m_data指向同一块内存，函数结束时先析构b，把这块内存释放了，接着析构a，又对同一块内存执行了一次delete[]，这就是典型的 double free，也就是二次释放。

这种崩溃特别有迷惑性。它在 Debug 模式可能直接弹断言框，在 Release 模式可能表现为一堆乱码，甚至隔几行才崩。原因是二次释放属于未定义行为，具体表现取决于当时的堆内存状态。排查这类问题的利器是调试器，对比两个对象的m_data成员，如果发现它们指向同一个地址，基本就是浅拷贝无疑了。解决方案也很简单：把深拷贝的拷贝构造函数和赋值运算符补上，问题立刻消失。

4.2 赋值运算符漏掉的“先释放”

如果说 double free 的问题是“释放多了”，那么赋值忘释放就是“释放少了”。

假设现在这样写：

IntArray& operator=(const IntArray& other) { m_size = other.m_size; m_data = new int[m_size]; for (int i = 0; i < m_size; ++i) { m_data[i] = other.m_data[i]; } return *this; }

看上去挺合理，复制了长度和数据。但原来的m_data指向的内存没人管了。第一次赋值，漏一块；第二次赋值，再漏一块。如果这个数组对象在一个循环里反复被赋值，内存会以肉眼可见的速度膨胀。对于长期运行的服务，这种泄漏最终会引发程序整体崩溃，而且很难定位——因为崩溃发生的地点可能离真正的泄漏点十万八千里。

判断有没有内存泄漏，可以用调试器附带的诊断工具，或者一些内存检测工具。运行测试用例后，如果发现未释放的内存数量一直在增长，就要警惕赋值运算符了。正确写法永远要记得：先用delete[]释放旧资源，再申请新资源。这是“三步走”里不能省略的一步。

4.3 初始化、越界检查与 delete[] 的细节坑

这个项目里还有几个小坑，虽然不致命，但遇到一次就会影响对代码的信心。

第一个是初始化。new int[m_size]和new int[m_size]()的区别我前面已经说过。很多同学测试数组时直接打印元素，发现输出了一堆类似-842150451的魔数，第一反应是内存分配失败。其实不是，只是因为new int[m_size]不会自动清零。我已经踩过这个坑，所以代码里一直用带括号的写法。

第二个是越界检查“形同虚设”。assert在 Debug 模式下确实能拦截越界，但如果你用的是 Release 模式，或者编译器加了某些优化选项，assert会被直接移除。所以不要误以为写了assert就万事大吉。我自己的习惯是在这个练习阶段用assert保持简洁，同时在代码注释里标明“生产环境请换成异常”。

第三个是delete和delete[]的混用。有些同学从别的语言转过来，容易把二者混为一谈。对 int 这种内置类型来说，混用可能不会立刻触发错误，因为 int 没有析构函数需要调用，编译器只是简单地释放内存。但如果封装的是自定义类型，比如一个持有资源的类对象数组，混用delete会导致后续元素都不调用析构函数，泄漏和崩溃随之而来。这个细节不需要背，只需记住一个规则：new[]配delete[]，new配delete，永远不要混用。

我把这些坑整理成了一张速查表，写代码的时候对照会方便很多。

5. 封装完了不算完：扩展方向与工程价值

5.1 动态扩容：把一个定长数组改成迷你 vector

写到这里，数组类已经有了自动释放和越界检查，但它还是一个定长数组。下一步最自然的扩展就是加入push_back方法，让数组能动态增长，这样它就越来越像std::vector了。

动态扩容的核心是维护两个概念：m_size表示当前实际存放的元素个数，m_capacity表示已经分配的内存最多能装多少元素。当m_size == m_capacity时，就需要申请一块更大的内存，把旧数据搬过去，再释放旧内存。

void push_back(int value) { if (m_size == m_capacity) { int newCapacity = (m_capacity == 0) ? 1 : m_capacity * 2; int* newData = new int[newCapacity]; for (int i = 0; i < m_size; ++i) { newData[i] = m_data[i]; } delete[] m_data; m_data = newData; m_capacity = newCapacity; } m_data[m_size++] = value; }

这里的容量策略我选的是“翻倍”，也就是新容量等于旧容量的两倍。很多人会问，为什么不是每次加1？每次加1的时间复杂度是 O(n)，因为每塞入一个元素都可能触发整体搬迁；而翻倍扩容时，均摊到每个元素上的搬迁次数是常数，总复杂度是 O(1)。说白了，翻倍扩容用“偶尔一次大搬迁”换来了“绝大部分时间插入都很快”。这个策略也是标准库 vector 采用的做法之一，实现这个迷你版本之后，再看std::vector的扩容讨论，会非常容易理解。

5.2 模板化和迭代器：让数组装下任意类型

第二个很有价值的扩展方向是模板化。把IntArray里的int换成模板参数T，这个类就不再只是整数数组了。

template <typename T> class Array { public: explicit Array(int size = 0) : m_size(size), m_data(nullptr) { if (m_size > 0) { m_data = new T[m_size](); } } // 其余方法逻辑不变，把 int 换成 T 即可 private: int m_size; T* m_data; };

模板化看起来只是类型替换，但实际上对代码质量的要求更高了。比如原来的手动memcpy式复制，在模板类里最好改成循环赋值，因为T可能是 string、vector 这样有析构函数和自定义拷贝逻辑的类型，逐元素赋值才能保证语义正确。

如果再往前走一步，给类加上begin()和end()，让基于范围的 for 循环能直接遍历这个数组，它就和标准库容器更靠近了。实现也不复杂：

T* begin() { return m_data; } T* end() { return m_data + m_size; }

加上这两个方法后，for (auto x : arr)就能正常工作。不要小看这步操作，它让这个自定义类开始兼容标准库迭代器协议，以后如果想把它接入更多泛型算法，就有了基础。

5.3 这个练习在真实工程中的影子

做完这个例子，很多人会疑惑：代码就这么点，真的有什么工程价值吗？我的答案是：这个练习背后藏着的思想，几乎贯穿于所有现代 C++ 代码。

核心思想是 RAII，资源获取即初始化。数组类把“一块堆内存”和“一个对象生命周期”绑定起来：构造时获取资源，析构时自动释放。这个模式不仅适用于内存，还适用于文件句柄、锁、数据库连接等所有需要成对获取和释放的资源。很多真实项目的代码里，文件流、锁管理器、智能指针底层都是同一套逻辑：在构造函数中拿到资源，在析构函数中释放资源，并且通过禁用拷贝或实现深拷贝来防止误操作。

数组类封装的另一个价值是，它是理解标准库容器的最佳入口。std::vector的核心原理与这个练习几乎一致，只不过多做了内存分配器抽象、移动语义、异常安全等更精细的处理。自己动手写过一遍之后，再看std::vector的文档和源码，就不会觉得它是一个神奇的黑盒子，而是能看到它背后那个熟悉的骨架。

如果你把这个项目作为学习路径的起点，接下来可以试着把 push_back、模板化、迭代器全部整合到一个版本里，然后和标准库std::vector做对比，看看自己实现的版本在哪些地方有差距。这个过程本身就是一次高质量的深入学习。

最后说一点我个人的体会。数组类封装是我当年反复重写了很多遍的小项目，第一次是作业，第二次是为了搞懂深拷贝，第三次是改成模板加迭代器，第四次是仿照 vector 做动态扩容。每一次重写都能发现上一步留下的粗糙之处。如果你正在这个项目上卡着，别急着看别人的答案，先把自己写的版本跑起来，甚至可以故意制造几个 bug：故意不写拷贝构造，故意不检查自赋值，故意用错delete和delete[]，看看程序会怎样崩溃。崩着崩着，你对内存管理的理解就会从“记住规则”变成真正的肌肉记忆——这种记忆，比背多少条规则都管用。