如何处理和修复垃圾数据？

Question

问题状态

我有一个名为

Group

的模板类，它可以访问内存中未经授权的位置。成员变量

Group<T>::Items

指向堆上存储一系列数据的位置的丝氨酸，例如

std::vector<T>

（C++内置结构体）。可以操纵数据以适应动态大小；成员函数

Group<T>::push(T)

用于添加新项目，成员函数

Group& Group<T>::operator*(int)

可以通过传递特定参数

Group<T >::Items

（如

scalar

中的

list()

）来复制并将其存储在

python

中，否则应该可以工作这边走。

这是代码中的类层次结构：

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]; // allcatoin new heep's place for data 
        for(int i=0; i<length; i++) BufferAddress[i] = Items[i]; // copy data to the new place from the current.
        /* add the new item to the new place, then make it the current place.*/
        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<Group<int>>::operator*(int)

应用于嵌套（

Group<Group<int>>&

）对象时（它类似于数组或列表 2d 的主要思想），当我运行可执行文件时，它会以

segmentation fault

错误终止有时它会返回一个原始的

Group<Group<int>>&

对象，该对象在与我的程序和命令无关的第一个位置存储垃圾。实际上不常见的是，此后执行的所有操作（如果程序没有错误地通过）都是正确的，这使得更糟糕的是，显然这意味着存在内存分配错误，当然我猜

Group<Group<int>>::Items

在输入

Group& Group<Group<int>>::operator*(int)

后存储了错误的数据位置。

我已经多次调试代码，试图找出是什么导致内存或

Group<Group<int>>::Items

表现出这种方式。

这是错误代码：

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; // now B = [[- <Lablablala>, <Lablablala>, - <Lablablala>, <Lablablala>, ...],
               //          [1, 2, 3, 1, 2, 3, 1, 2, 3], 
               //          [1, 2, 3, 1, 2, 3, 1, 2, 3]] or it raise an error
}

我已经多次调试代码，试图找出是什么导致内存或

Group<Group<int>>::Items

表现出这种方式。

所以我想这样做：

B = B * 3;

std::cout << "<B>:[[" << B[0][0] << ',' << B[0][1] << ',' << B[0][2] << "]," << std::endl;
          << "     [" << B[1][0] << ',' << B[1][1] << ',' << B[1][2] << "]," << std::endl;
          << "     [" << B[2][0] << ',' << B[2][1] << ',' << B[2][2] << "]]" << std::endl;

<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]]

Answer 1

真巧，我终于找到了解决办法。 我必须创建一个复制构造函数，因为如果编译器找不到用户定义的构造函数，它会将其设置为默认值，这不会像这样修改我们的成员：

（小组课）

    Group(Group& source) : Group()
    {
        for(int i=0; i<source.length; i++)
            push(source.Items[i]);
    }

现在很好，但是如果你看到

Group<Group<int>>::operator*(int)

中的第1行，你应该看到指针正在使用赋值运算符来交换数据，所以我们应该为我们的类创建一个......
或者编译器会这样做。

（小组课）

void operator=(Group& source)
    {
        length = 0;
        for(int i=0; i<source.length; i++)
            push(source.Items[i]);
    }

在开始之前将

Group<T>::length

设置为0很重要，否则它将包含垃圾数据。

所以，解决你的错误代码真是太棒了。
小心编译器，他可能很狡猾。