C++动态数组类实现：封装与内存管理实践

贴娘饭

1. 项目概述

在C++开发中，数组是最基础的数据结构之一。但原生数组存在诸多局限性：长度固定、缺乏边界检查、不支持动态扩容等。这个项目就是要通过面向对象的方式，封装一个更安全、更易用的数组类。

我曾在多个项目中遇到过原生数组带来的问题：内存越界导致程序崩溃、手动管理内存繁琐易错、缺乏常用操作方法等。封装自定义数组类不仅能解决这些问题，还能让我们深入理解C++的核心特性——封装、运算符重载、内存管理等。

这个实现适合有一定C++基础的开发者学习，特别是想提升面向对象设计能力和理解底层机制的同行。我们将从需求分析开始，逐步实现一个功能完整的数组类，过程中会涉及诸多C++核心知识点。

2. 核心设计思路

2.1 需求分析

一个完善的数组类应该具备以下核心能力：

动态内存管理（支持运行时确定大小）
安全的边界检查
支持常用操作（查找、排序等）
提供类似原生数组的访问方式
完善的拷贝控制（深拷贝语义）

2.2 类接口设计

基于这些需求，我们设计如下类接口框架：

cpp复制class SmartArray {
public:
    // 构造函数/析构函数
    explicit SmartArray(size_t size);
    ~SmartArray();
    
    // 拷贝控制
    SmartArray(const SmartArray& other);
    SmartArray& operator=(const SmartArray& other);
    
    // 访问元素
    int& operator[](size_t index);
    const int& operator[](size_t index) const;
    
    // 实用方法
    size_t size() const;
    void sort();
    int find(int value) const;
    
private:
    int* m_data;
    size_t m_size;
};

注意：这里使用原始指针管理内存是为了教学目的。实际项目中建议优先使用智能指针。

3. 核心实现细节

3.1 内存管理实现

构造函数和析构函数是内存管理的关键：

cpp复制SmartArray::SmartArray(size_t size) 
    : m_size(size), m_data(new int[size]{}) 
{
    // 初始化所有元素为0
}

SmartArray::~SmartArray() {
    delete[] m_data;
}

这里有几个关键点：

使用new[]分配连续内存空间
初始化列表确保成员变量正确初始化
使用{}进行值初始化（所有元素设为0）
析构函数必须使用delete[]释放数组

3.2 拷贝控制实现

实现深拷贝是数组类的核心难点：

cpp复制SmartArray::SmartArray(const SmartArray& other)
    : m_size(other.m_size), m_data(new int[other.m_size])
{
    std::copy(other.m_data, other.m_data + m_size, m_data);
}

SmartArray& SmartArray::operator=(const SmartArray& other) {
    if (this != &other) {
        delete[] m_data;
        m_size = other.m_size;
        m_data = new int[m_size];
        std::copy(other.m_data, other.m_data + m_size, m_data);
    }
    return *this;
}

这里使用了copy-and-swap惯用法，确保：

自赋值安全
强异常安全保证
不重复代码

3.3 运算符重载实现

让自定义数组用起来像原生数组：

cpp复制int& SmartArray::operator[](size_t index) {
    if (index >= m_size) {
        throw std::out_of_range("Index out of bounds");
    }
    return m_data[index];
}

const int& SmartArray::operator[](size_t index) const {
    if (index >= m_size) {
        throw std::out_of_range("Index out of bounds");
    }
    return m_data[index];
}

关键点：

提供const和非const两个版本
进行边界检查
抛出标准异常

4. 实用方法实现

4.1 排序实现

cpp复制void SmartArray::sort() {
    std::sort(m_data, m_data + m_size);
}

这里直接使用标准库算法，避免重复造轮子。

4.2 查找实现

cpp复制int SmartArray::find(int value) const {
    const int* end = m_data + m_size;
    const int* pos = std::find(m_data, end, value);
    return pos != end ? pos - m_data : -1;
}

返回找到元素的索引，未找到返回-1。

5. 使用示例

5.1 基本使用

cpp复制SmartArray arr(10);
arr[0] = 42;  // 使用operator[]
std::cout << arr.size();  // 输出10

5.2 异常处理

cpp复制try {
    int val = arr[100];  // 越界访问
} catch (const std::out_of_range& e) {
    std::cerr << e.what() << std::endl;
}

6. 性能优化考虑

6.1 移动语义支持

现代C++应该支持移动语义：

cpp复制SmartArray(SmartArray&& other) noexcept
    : m_data(other.m_data), m_size(other.m_size) 
{
    other.m_data = nullptr;
    other.m_size = 0;
}

SmartArray& operator=(SmartArray&& other) noexcept {
    if (this != &other) {
        delete[] m_data;
        m_data = other.m_data;
        m_size = other.m_size;
        other.m_data = nullptr;
        other.m_size = 0;
    }
    return *this;
}

6.2 预留容量机制

如需支持动态扩容，可添加capacity概念：

cpp复制void reserve(size_t new_capacity) {
    if (new_capacity <= m_capacity) return;
    
    int* new_data = new int[new_capacity];
    std::copy(m_data, m_data + m_size, new_data);
    delete[] m_data;
    m_data = new_data;
    m_capacity = new_capacity;
}

7. 测试策略

7.1 单元测试要点

应重点测试：

边界条件（空数组、单元素数组）
拷贝语义（深拷贝验证）
异常抛出情况
移动语义后的对象状态

7.2 内存检查

使用Valgrind等工具确保：

无内存泄漏
无越界访问
正确释放内存

8. 扩展方向

这个基础实现可以进一步扩展：

模板化支持任意类型
添加迭代器支持
实现STL容器接口
线程安全版本

9. 常见问题与解决

9.1 为什么我的拷贝赋值运算符有问题？

常见错误模式：

cpp复制// 错误示例！
SmartArray& operator=(const SmartArray& other) {
    delete[] m_data;
    m_data = new int[other.m_size];
    m_size = other.m_size;
    std::copy(...);
    return *this;
}

问题在于：