C++ Group模板类嵌套运算出现段错误与垃圾数据的修复求助

云原生阿岚

2026-6-25

问题：自定义Group模板类的非法内存访问与数据异常

问题背景

我实现了一个名为Group的模板类，用来模拟std::vector的动态序列功能，但存在非法内存访问问题。成员变量Group<T>::Items指向堆上的连续内存，push(T)用于添加元素，operator*(int)的设计目标是像Python列表那样复制元素，生成包含副本的新Group对象。

类的实现代码如下：

template <typename T>
class Group
{
private:
    T* Items; int length;
public:
    Group() : length(0)
    {
        Items = new(std::nothrow) T[0];
    }
    ~Group()
    {
        delete[] Items; Items = nullptr;
    }

    void push(T ValuetoPush)
    {
        T* BufferAddress = new(std::nothrow) T[length + 1]; // 分配新的堆内存
        for(int i=0; i<length; i++) BufferAddress[i] = Items[i]; // 复制旧数据到新内存
        // 添加新元素并更新当前内存指针
        BufferAddress[length++] = ValuetoPush; Items = BufferAddress;
    }

    Group& operator*(int scalar)
    {
        Group* result = new Group;
        for(int i=0; i<scalar; i++)
        {
            for(int j=0; j<length; j++) result->push(Items[j]);
        }
        return *result;
    } 
};

问题现象

当对嵌套的Group<Group<int>>对象调用operator*(int)时，程序有时会触发段错误，有时会返回包含垃圾数据的对象——初始位置的数据完全不符合逻辑。如果程序没崩溃，后续操作倒是正常，显然是内存分配或指针处理错误导致Group存储了无效的内存地址。

触发问题的测试代码：

int main()
{
    Group<int> A;
    A.push(1); A.push(2); A.push(3);
    
    Group<Group<int>> B;
    B.push(A * 3);
    B = B * 3; // 此时B要么是[[垃圾数据, ...], [1,2,3,...], [1,2,3,...]]，要么直接崩溃
}

期望结果

执行B = B * 3;后，B应该包含3个与原B元素相同的副本，每个元素都是[1,2,3,1,2,3,1,2,3]，输出如下：

<B>:[[1, 2, 3, 1, 2, 3, 1, 2, 3],
     [1, 2, 3, 1, 2, 3, 1, 2, 3],
     [1, 2, 3, 1, 2, 3, 1, 2, 3]]

问题分析与修复

核心错误点

operator*返回堆分配对象的引用，导致内存泄漏与浅拷贝灾难
operator*中用new创建Group对象后返回引用，赋值时B = B * 3;会生成指向堆对象的临时引用，随后调用默认赋值运算符——默认赋值只会拷贝Items指针和length，不仅会导致堆对象内存泄漏，还会在嵌套场景下引发指针悬空：比如B.push(A*3)时，拷贝的Group<int>对象会共享原堆对象的Items指针，当原堆对象后续被意外释放（或因为泄漏长期存在但逻辑上已失效），访问B内的元素就会触发非法内存访问。
缺失拷贝构造函数与赋值运算符
C++默认的拷贝构造和赋值运算符是浅拷贝，对于持有堆内存指针的类来说，这会导致多个对象共享同一块堆内存，析构时重复释放内存，或出现悬空指针。这是嵌套场景下数据异常的核心原因。
未处理new(std::nothrow)返回nullptr的情况
如果内存分配失败，BufferAddress会是nullptr，后续访问BufferAddress[length++]会直接触发段错误。

修复后的代码

#include <stdexcept>

template <typename T>
class Group
{
private:
    T* Items;
    int length;

public:
    // 默认构造函数
    Group() : length(0), Items(nullptr)
    {
        // 避免分配0长度数组，直接设为nullptr更安全
    }

    // 拷贝构造函数：深拷贝
    Group(const Group& other) : length(other.length)
    {
        if (length > 0)
        {
            Items = new T[length];
            for (int i = 0; i < length; ++i)
            {
                Items[i] = other.Items[i];
            }
        }
        else
        {
            Items = nullptr;
        }
    }

    // 赋值运算符：深拷贝，遵循RAII
    Group& operator=(const Group& other)
    {
        if (this != &other)
        {
            // 先释放当前内存
            delete[] Items;

            length = other.length;
            if (length > 0)
            {
                Items = new T[length];
                for (int i = 0; i < length; ++i)
                {
                    Items[i] = other.Items[i];
                }
            }
            else
            {
                Items = nullptr;
            }
        }
        return *this;
    }

    // 析构函数
    ~Group()
    {
        delete[] Items;
        Items = nullptr;
        length = 0;
    }

    void push(T ValuetoPush)
    {
        T* BufferAddress = new T[length + 1]; // 去掉nothrow，分配失败抛出异常，方便排查
        for (int i = 0; i < length; ++i)
        {
            BufferAddress[i] = Items[i];
        }
        BufferAddress[length] = ValuetoPush;
        // 释放旧内存
        delete[] Items;
        Items = BufferAddress;
        ++length;
    }

    // 修改operator*返回对象而非引用，避免堆分配泄漏
    Group operator*(int scalar) const
    {
        Group result;
        if (scalar <= 0)
        {
            return result;
        }
        for (int i = 0; i < scalar; ++i)
        {
            for (int j = 0; j < length; ++j)
            {
                result.push(Items[j]);
            }
        }
        return result;
    }

    // 添加下标运算符，方便访问元素
    T& operator[](int index)
    {
        if (index < 0 || index >= length)
        {
            throw std::out_of_range("Index out of bounds");
        }
        return Items[index];
    }

    const T& operator[](int index) const
    {
        if (index < 0 || index >= length)
        {
            throw std::out_of_range("Index out of bounds");
        }
        return Items[index];
    }

    // 获取长度的成员函数
    int size() const
    {
        return length;
    }
};

修复说明

移除new(std::nothrow)：内存分配失败时抛出std::bad_alloc异常，比静默返回nullptr更易排查问题，符合C++常规做法。
实现深拷贝的拷贝构造与赋值运算符：确保每个Group对象拥有独立的堆内存，彻底解决指针悬空和重复释放问题。
修改operator*返回值为Group对象：不再使用堆分配，利用C++返回值优化（RVO）避免拷贝开销，同时彻底解决内存泄漏。
优化默认构造函数：直接将Items设为nullptr，而非分配0长度数组，更简洁安全。
添加下标运算符与size()函数：方便访问元素和获取长度，匹配测试代码的需求。

测试代码验证

修改后的main函数可以正常运行并输出期望结果：

#include <iostream>

int main()
{
    Group<int> A;
    A.push(1);
    A.push(2);
    A.push(3);

    Group<Group<int>> B;
    B.push(A * 3);
    B = B * 3;

    std::cout << "<B>:[" << std::endl;
    for (int i = 0; i < B.size(); ++i)
    {
        std::cout << "     [";
        for (int j = 0; j < B[i].size(); ++j)
        {
            if (j > 0)
                std::cout << ",";
            std::cout << B[i][j];
        }
        std::cout << "]," << std::endl;
    }
    std::cout << "]" << std::endl;

    return 0;
}

输出：

<B>:[
     [1,2,3,1,2,3,1,2,3],
     [1,2,3,1,2,3,1,2,3],
     [1,2,3,1,2,3,1,2,3],
]

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

C++ Group模板类嵌套运算出现段错误与垃圾数据的修复求助

问题背景 #

问题现象 #

期望结果 #

问题分析与修复 #

核心错误点 #

修复后的代码 #

修复说明 #

测试代码验证 #