C++类实现列表指定位置插入元素时末尾出现垃圾值问题排查

核心问题分析 #

你的List类主要有4处逻辑错误，直接导致了垃圾值输出：

• 数组未重新分配内存：insertAt里直接capacity++，但原数组是初始化时分配的固定大小内存，没有申请更大空间，访问超出原数组长度的位置属于越界操作，会读取垃圾值。
• 元素移动逻辑错误：循环起始位置用了capacity，但当前实际存储的元素个数是counter，操作未初始化的内存区域会引入无效值。
• 未维护元素计数：插入元素后没有将counter加1，无法正确跟踪实际元素数量。
• print遍历范围错误：遍历capacity而非实际元素数counter，会输出未初始化的数组位置。

修正后的代码 #

#include<iostream>
using namespace std;
template<typename T>
class List
{
public:
    T *values;
    int capacity;
    int counter;
public:
    List()
    {
        values = NULL;
        capacity = 0;
        counter = 0;
    }
    List(int cap)
    {
        capacity = cap;
        values = new T[cap];
        counter = 0;
    }
    bool insert(T item)
    {
        if (!isFull())
        {
            values[counter] = item;
            counter++;
            return true;
        }
        return false;
    }
    bool insertAt(T item, int index)
    {
        // 检查索引合法性：允许插在0到counter之间（含末尾）
        if (index < 0 || index > counter)
            return false;

        // 数组已满时扩容，避免越界
        if (isFull())
        {
            int newCapacity = capacity == 0 ? 1 : capacity * 2;
            T* newValues = new T[newCapacity];
            // 复制原数组元素
            for (int i = 0; i < counter; i++)
                newValues[i] = values[i];
            // 释放原内存
            delete[] values;
            values = newValues;
            capacity = newCapacity;
        }

        // 从最后一个元素的下一位开始向后移动，给新元素腾位置
        for (int i = counter; i > index; i--)
            values[i] = values[i - 1];
        
        values[index] = item;
        counter++; // 维护实际元素计数
        return true;
    }
    bool isFull()
    {
        return counter == capacity;
    }
    void print()
    {
        // 只遍历实际存在的元素
        for (int i = 0; i < counter; i++)
        {
            cout << values[i] << " ";
        }
        cout << endl;
    }

    // 添加析构函数释放内存，避免泄漏
    ~List()
    {
        delete[] values;
    }
};
int main()
{
    List<int> obj1(5);
    obj1.insert(1); 
    obj1.insert(2); 
    obj1.insert(3); 
    obj1.insert(4); 
    
    obj1.insertAt(3, 1);
    obj1.print(); // 输出：1 3 2 3 4 
}

关键修改说明 #

1. 内存扩容逻辑：当数组已满时，重新分配更大的内存空间，复制原元素后释放旧内存，彻底解决越界问题。
2. 索引合法性校验：允许在列表末尾插入元素，同时拦截负数索引，避免非法操作。
3. 元素移动修正：从counter开始向后移动元素，确保只操作已初始化的有效数据。
4. 维护元素计数：插入后counter++，保证counter始终等于实际元素数量。
5. print函数修正：遍历counter次，只输出有效元素，不再打印未初始化的垃圾值。
6. 添加析构函数：释放动态分配的内存，防止内存泄漏。

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