数组作为类成员的使用方式，静态数组与动态数组的管理方法

在C++中，类成员数组可分为静态数组和动态数组，静态数组在编译时固定大小并随对象分配在栈上，无需手动管理内存，访问高效但不灵活，适用于大小已知的场景；动态数组在堆上分配，运行时确定大小，需手动管理内存并遵循三法则（析构、拷贝构造、赋值操作符）以避免资源泄漏和浅拷贝问题；现代C++推荐使用std::array替代静态数组，std::vector替代动态数组，两者均提供自动内存管理、边界检查和STL兼容性，其中std::array适用于固定大小，std::vector支持动态扩容且具有移动语义优化，是更安全、高效的选择，因此在绝大多数情况下应优先使用标准库容器而非原生数组。

在C++中，数组作为类成员是常见的需求，根据使用方式不同，可以分为静态数组（固定大小）和动态数组（运行时确定大小）。两者的管理方式不同，尤其在内存管理、构造和析构时需要特别注意。

静态数组作为类成员

静态数组在编译时确定大小，直接在类的内存布局中分配空间，无需手动管理内存。

class StaticArrayExample {
private:
    int data[10];  // 静态数组，大小固定为10
    int size;

public:
    StaticArrayExample() : size(10) {}

    void setValue(int index, int value) {
        if (index >= 0 && index < size) {
            data[index] = value;
        }
    }

    int getValue(int index) const {
        if (index >= 0 && index < size) {
            return data[index];
        }
        return -1;  // 错误值
    }
};

特点：

• 数组内存与对象一同分配，无需 new 或 delete
• 访问速度快，无额外开销
• 大小固定，不灵活
• 若数组较大，可能增加对象体积，影响性能（如栈上创建大对象）

适用场景：
数据大小已知且固定，如缓冲区、矩阵（3x3）、状态表等。

动态数组作为类成员

动态数组在堆上分配内存，大小可在运行时决定，需要手动管理资源。

class DynamicArrayExample {
private:
    int* data;
    int size;

public:
    // 构造函数：动态分配内存
    DynamicArrayExample(int s) : size(s) {
        data = new int[size];  // 分配堆内存
    }

    // 析构函数：释放内存
    ~DynamicArrayExample() {
        delete[] data;
    }

    // 拷贝构造函数
    DynamicArrayExample(const DynamicArrayExample& other) 
        : size(other.size) {
        data = new int[size];
        for (int i = 0; i < size; ++i) {
            data[i] = other.data[i];
        }
    }

    // 赋值操作符
    DynamicArrayExample& operator=(const DynamicArrayExample& other) {
        if (this != &other) {
            delete[] data;  // 释放旧内存
            size = other.size;
            data = new int[size];
            for (int i = 0; i < size; ++i) {
                data[i] = other.data[i];
            }
        }
        return *this;
    }

    void setValue(int index, int value) {
        if (index >= 0 && index < size) {
            data[index] = value;
        }
    }

    int getValue(int index) const {
        if (index >= 0 && index < size) {
            return data[index];
        }
        return -1;
    }
};

关键点：

• 必须实现析构函数释放 new[] 分配的内存
• 需要实现拷贝构造函数和赋值操作符，避免浅拷贝问题（否则多个对象指向同一块内存，导致重复释放）
• 遵循“三法则”（C++11后扩展为“五法则”）

现代C++建议：
优先使用智能指针或标准容器，避免手动管理。

推荐做法：使用 std::array 和 std::vector

1. std::array 替代静态数组

#include <array>

class ArrayExample {
private:
    std::array<int, 10> data;  // 固定大小，但更安全

public:
    void setValue(size_t index, int value) {
        if (index < data.size()) {
            data.at(index) = value;  // 可选边界检查
        }
    }

    int getValue(size_t index) const {
        return data.at(index);
    }
};

• 编译时大小固定
• 支持 STL 操作，可拷贝，无需手动管理
• 比原生数组更安全、更现代

2. std::vector 替代动态数组

#include <vector>

class VectorExample {
private:
    std::vector<int> data;

public:
    VectorExample(int size) : data(size) {}  // 自动管理内存

    void setValue(int index, int value) {
        if (index >= 0 && index < data.size()) {
            data[index] = value;
        }
    }

    int getValue(int index) const {
        return data.at(index);
    }

    // 无需写析构、拷贝构造、赋值——vector 自动处理
};

• 动态大小，自动扩容
• 自动内存管理，避免泄漏
• 移动语义优化，性能好
• 是动态数组成员的首选方案

总结对比

基本上就这些。
如果必须用原生数组，静态的简单直接，动态的要小心资源管理。但在现代C++中，std::array 和 std::vector 几乎总是更好的选择，代码更安全、简洁，也更容易维护。