如何在 C++ 中创建动态大小的数组

简介

本全面教程探讨了C++ 中动态数组的创建技术，为开发者提供有效管理内存的关键技能。通过理解动态内存分配，程序员可以创建灵活的数据结构，以适应不断变化的运行时需求，从而提高C++ 应用程序的通用性和性能。

Skills Graph

动态内存基础

动态内存简介

在C++ 中，动态内存分配允许程序员在运行时创建内存空间，从而在管理内存资源方面提供了灵活性。与具有固定大小的静态数组不同，动态内存使你能够创建大小在运行时确定的数组。

内存分配机制

C++ 提供了几种动态内存分配机制：

基本内存分配示例

#include <iostream>

int main() {
    // 动态分配一个整数
    int* dynamicInt = new int(42);

    // 动态分配一个数组
    int* dynamicArray = new int[5];

    // 初始化数组元素
    for(int i = 0; i < 5; i++) {
        dynamicArray[i] = i * 10;
    }

    // 内存清理
    delete dynamicInt;
    delete[] dynamicArray;

    return 0;
}

内存分配工作流程

关键注意事项

1. 始终将new与delete匹配使用
2. 对使用new[]分配的数组使用delete[]
3. 通过正确释放内存避免内存泄漏
4. 在现代C++ 中考虑使用智能指针

常见陷阱

• 忘记释放内存
• 双重删除
• 删除后使用内存

性能与最佳实践

动态内存分配存在开销。对于小的、频繁使用的对象，考虑使用栈分配或内存池。在实验（Lab）编程环境中，高效的内存管理对于实现最佳性能至关重要。

动态数组技术

高级动态数组策略

1. 使用向量（Vector）的可调整大小数组

#include <vector>
#include <iostream>

class DynamicArrayManager {
public:
    void demonstrateVector() {
        std::vector<int> dynamicArray;

        // 动态添加元素
        dynamicArray.push_back(10);
        dynamicArray.push_back(20);
        dynamicArray.push_back(30);

        // 访问和修改
        dynamicArray[1] = 25;
    }
};

内存分配技术

2. 自定义动态数组实现

template <typename T>
class CustomDynamicArray {
private:
    T* data;
    size_t size;
    size_t capacity;

public:
    CustomDynamicArray() : data(nullptr), size(0), capacity(0) {}

    void resize(size_t newCapacity) {
        T* newData = new T[newCapacity];

        // 复制现有元素
        for(size_t i = 0; i < size; ++i) {
            newData[i] = data[i];
        }

        delete[] data;
        data = newData;
        capacity = newCapacity;
    }
};

动态数组分配策略

分配比较

性能考虑

3. 内存高效技术

#include <memory>

class MemoryEfficientArray {
public:
    void useSmartPointers() {
        // 用于动态数组的唯一指针
        std::unique_ptr<int[]> dynamicArray(new int[5]);

        // 无需手动删除
        for(int i = 0; i < 5; ++i) {
            dynamicArray[i] = i * 2;
        }
    }
};

高级分配模式

4. 定位新（Placement New）和自定义分配器

class CustomAllocator {
public:
    void* allocate(size_t size) {
        return ::operator new(size);
    }

    void deallocate(void* ptr) {
        ::operator delete(ptr);
    }
};

实验（LabEx）环境中的最佳实践

1. 优先使用标准库容器
2. 使用智能指针
3. 尽量减少手动内存管理
4. 分析并优化内存使用

错误处理与安全

• 始终检查分配是否成功
• 使用异常处理
• 实现资源获取即初始化（RAII）原则
• 利用智能指针机制

内存管理技巧

内存泄漏预防策略

1. 智能指针的使用

#include <memory>

class ResourceManager {
public:
    void preventMemoryLeaks() {
        // 唯一指针自动管理内存
        std::unique_ptr<int> uniqueResource(new int(42));

        // 具有引用计数的共享指针
        std::shared_ptr<int> sharedResource =
            std::make_shared<int>(100);
    }
};

内存管理工作流程

常见内存管理技术

高级内存管理模式

2. 自定义删除器实现

class ResourceHandler {
public:
    void customMemoryManagement() {
        // 用于复杂资源的自定义删除器
        auto customDeleter = [](int* ptr) {
            // 自定义清理逻辑
            delete ptr;
        };

        std::unique_ptr<int, decltype(customDeleter)>
            specialResource(new int(50), customDeleter);
    }
};

内存分配最佳实践

3. 异常安全分配

class SafeAllocator {
public:
    void exceptionSafeAllocation() {
        try {
            // 使用异常安全的分配方法
            std::vector<int> safeVector;
            safeVector.reserve(1000);  // 预分配内存

            for(int i = 0; i < 1000; ++i) {
                safeVector.push_back(i);
            }
        }
        catch(const std::bad_alloc& e) {
            // 处理分配失败
            std::cerr << "内存分配失败" << std::endl;
        }
    }
};

内存调试技术

4. Valgrind内存检查

## 编译并带有调试符号
g++ -g memory_test.cpp -o memory_test

## 运行Valgrind内存检查
valgrind --leak-check=full./memory_test

性能优化技巧

1. 尽量减少动态分配
2. 对频繁分配使用内存池
3. 尽可能优先使用栈分配
4. 使用移动语义

实验（LabEx）内存管理指南

• 利用现代C++内存管理技术
• 优先使用标准库容器
• 实现RAII原则
• 始终使用智能指针
• 分析并优化内存使用

错误处理策略

• 实现全面的错误检查
• 使用异常处理机制
• 提供优雅降级
• 记录与内存相关的错误

高级内存控制

5. 定位新（Placement New）技术

class AdvancedMemoryControl {
public:
    void placementNewDemo() {
        // 预分配的内存缓冲区
        alignas(int) char buffer[sizeof(int)];

        // 定位新
        int* ptr = new (buffer) int(100);
    }
};

总结

掌握C++ 中的动态数组技术，能使开发者编写出更灵活且内存高效的代码。通过实施恰当的内存管理策略、理解分配方法并避免常见陷阱，程序员可以开发出强大的解决方案，这些方案能在动态适应复杂编程挑战的同时，保持最佳的资源利用率。