如何在C++中实现可变长度的类指针动态数组？

你的问题核心是未先为指针数组本身分配有效内存：A** classes_a = nullptr;仅声明了一个指向指针的指针，但它没有指向任何可访问的内存空间，直接访问classes_a[i]会触发未定义行为。下面提供两种可靠的实现方式：

方法一：手动管理原生动态内存 #

需要先分配存储指针的数组，再逐个创建A对象，同时必须在析构时释放所有资源避免内存泄漏，还要遵循三法则处理拷贝逻辑：

class A {
};

class B {
private:
    A** classes_a = nullptr;
    size_t arr_length; // 记录数组长度
public:
    // 构造函数，支持传入自定义长度
    B(size_t length) : arr_length(length) {
        // 第一步：分配存储A指针的数组内存
        classes_a = new A*[arr_length];
        // 第二步：逐个创建A对象
        for (size_t i = 0; i < arr_length; ++i) {
            classes_a[i] = new A();
        }
    }

    // 析构函数，按顺序释放资源
    ~B() {
        // 先释放每个A对象
        for (size_t i = 0; i < arr_length; ++i) {
            delete classes_a[i];
        }
        // 再释放指针数组本身
        delete[] classes_a;
        classes_a = nullptr;
    }

    // 拷贝构造函数（深拷贝，避免浅拷贝导致的重复释放）
    B(const B& other) : arr_length(other.arr_length) {
        classes_a = new A*[arr_length];
        for (size_t i = 0; i < arr_length; ++i) {
            classes_a[i] = new A(*other.classes_a[i]); // 依赖A的拷贝构造函数
        }
    }

    // 赋值运算符重载
    B& operator=(const B& other) {
        if (this != &other) {
            // 先释放当前对象的资源
            for (size_t i = 0; i < arr_length; ++i) {
                delete classes_a[i];
            }
            delete[] classes_a;

            // 拷贝新对象的资源
            arr_length = other.arr_length;
            classes_a = new A*[arr_length];
            for (size_t i = 0; i < arr_length; ++i) {
                classes_a[i] = new A(*other.classes_a[i]);
            }
        }
        return *this;
    }
};

使用示例：

B b1(8);  // 创建包含8个A对象的数组
B b2(12); // 创建包含12个A对象的数组

方法二：使用std::vector+智能指针（推荐） #

借助C++标准库容器可以自动管理内存，结合智能指针能彻底避免手动释放的繁琐和内存泄漏风险：

#include <vector>
#include <memory>

class A {
};

class B {
private:
    std::vector<std::unique_ptr<A>> classes_a;
public:
    // 构造函数，传入自定义长度
    B(size_t length) {
        for (size_t i = 0; i < length; ++i) {
            // 直接创建并插入智能指针包裹的A对象
            classes_a.emplace_back(std::make_unique<A>());
        }
    }

    // 无需手动编写析构函数，std::unique_ptr和std::vector会自动释放所有资源
};

这种方式无需关注内存释放、拷贝逻辑等细节，是C++中最安全简洁的实现方案。

内容的提问来源于stack exchange，提问作者Lucas