在动态数组类的实现中查找Bug。在构建字符串列表后崩溃

在动态数组类的实现中遇到崩溃问题，通常是由于内存管理不当或边界条件处理不正确导致的。以下是一些可能的原因和解决方法：

可能的原因

内存分配失败：在动态扩展数组时，内存分配可能失败，导致程序崩溃。
越界访问：访问数组元素时超出了数组的有效范围。
重复释放内存：多次释放同一块内存会导致未定义行为，可能引发崩溃。
未初始化指针：使用未初始化的指针进行操作。
逻辑错误：在添加、删除或查找元素时的逻辑错误。

解决方法

1. 内存分配失败

确保在动态扩展数组时正确处理内存分配失败的情况。

void resize(int newSize) {
    int* newArray = new (std::nothrow) int[newSize];
    if (!newArray) {
        // 处理内存分配失败的情况
        std::cerr << "Memory allocation failed!" << std::endl;
        return;
    }
    // 复制旧数组的数据到新数组
    for (int i = 0; i < size; ++i) {
        newArray[i] = array[i];
    }
    delete[] array;
    array = newArray;
    capacity = newSize;
}

2. 越界访问

在访问数组元素时，始终检查索引是否在有效范围内。

int get(int index) {
    if (index < 0 || index >= size) {
        throw std::out_of_range("Index out of range");
    }
    return array[index];
}

3. 重复释放内存

确保每个内存块只释放一次。

~DynamicArray() {
    delete[] array;
}

4. 未初始化指针

在使用指针之前，确保它已经被正确初始化。

DynamicArray() : array(nullptr), size(0), capacity(0) {}

5. 逻辑错误

仔细检查添加、删除或查找元素的逻辑。

void add(int value) {
    if (size == capacity) {
        resize(capacity == 0 ? 1 : capacity * 2);
    }
    array[size++] = value;
}

void remove(int index) {
    if (index < 0 || index >= size) {
        throw std::out_of_range("Index out of range");
    }
    for (int i = index; i < size - 1; ++i) {
        array[i] = array[i + 1];
    }
    --size;
}

示例代码

以下是一个简单的动态数组类实现，包含了上述检查和解决方法：

#include <iostream>
#include <stdexcept>

class DynamicArray {
private:
    int* array;
    int size;
    int capacity;

public:
    DynamicArray() : array(nullptr), size(0), capacity(0) {}

    ~DynamicArray() {
        delete[] array;
    }

    void add(int value) {
        if (size == capacity) {
            int newCapacity = capacity == 0 ? 1 : capacity * 2;
            int* newArray = new (std::nothrow) int[newCapacity];
            if (!newArray) {
                std::cerr << "Memory allocation failed!" << std::endl;
                return;
            }
            for (int i = 0; i < size; ++i) {
                newArray[i] = array[i];
            }
            delete[] array;
            array = newArray;
            capacity = newCapacity;
        }
        array[size++] = value;
    }

    int get(int index) {
        if (index < 0 || index >= size) {
            throw std::out_of_range("Index out of range");
        }
        return array[index];
    }

    void remove(int index) {
        if (index < 0 || index >= size) {
            throw std::out_of_range("Index out of range");
        }
        for (int i = index; i < size - 1; ++i) {
            array[i] = array[i + 1];
        }
        --size;
    }
};

int main() {
    DynamicArray list;
    list.add(1);
    list.add(2);
    list.add(3);
    std::cout << list.get(1) << std::endl; // 输出 2
    list.remove(1);
    std::cout << list.get(1) << std::endl; // 输出 3
    return 0;
}

通过上述方法和示例代码，可以有效排查和解决动态数组类实现中的崩溃问题。