复制构造函数内存泄漏-解网

问：

我正在尝试学习编写自定义构造函数的基础知识，但我无法弄清楚我做错了什么。我知道就我的目的而言，让编译器完成它的工作就足够了，但我很好奇如何修复我的定义。

#include <iostream>
#include <stdexcept>

class Matrix {
    public:
      Matrix(int rows, int cols);    //my custom constructor
     ~Matrix();                      //my custom destructor
      Matrix(const Matrix& m);       //my custom copy constructor
      Matrix& operator= (const Matrix& m);  //my custom assignment operator
    private:
      int rows_, cols_;
      double* data_;
    };


Matrix::Matrix(int rows, int cols): rows_ (rows), cols_ (cols){  
if (rows == 0 || cols == 0)
    throw std::out_of_range("Matrix constructor has 0 size");
data_ = new double[rows * cols];     
}
 
 
Matrix::~Matrix()       
{
    delete[] data_;
}


Matrix::Matrix(const Matrix& m) : rows_(m.rows_), cols_(m.cols_)
{
data_ = new double[rows_ * cols_];
data_=m.data_;
} 


Matrix& Matrix::operator=(const Matrix& m){     
if(this != &m){
        double* newdata_=new double[m.cols_*m.rows_];
        *newdata_=*data_;
        delete[] data_;
        data_=newdata_;
        rows_=m.rows_;
        cols_=m.cols_;
        }   
return *this;

}

然后在程序的主要部分：

int main(){

Matrix m1(2,2);//creating a matrix of size 2x2


Matrix m2=m1;  //this doesn't work
Matrix m3(m1); //nor this




return 0;
}

运行可执行文件时的错误是： free（）：在 tcache 2 中检测到双重释放

我认为复制构造函数和赋值运算符都不会导致调用析构函数是否正确？为什么？

C++ 析构函数复制构造函数

但基本上至少有三个问题：复制指针，而不是数组的值。也没有做数组的完整副本。在一些地方，您实际上从未复制过以下值：您的复制构造函数未在 LHS 中设置或，并且您永远不会在赋值运算符中访问。因此，您会发生内存泄漏和双重删除，因为您实际上并没有复制数组。data_ = m.data_;*newdata_ = *data_;mrows_cols_m.data_

1赞 PaulMcKenzie 3/20/2021

data_ = new double[rows_ * cols_]; data_=m.data_;-- 你连续行这样做。您已经在第一行中分配了数据，但第二行通过再次更改将所有这些数据擦除。所以很明显这是错误的。data_

0赞 JaMiT 3/20/2021

复制构造函数中的行是否与代码中实际包含的行相同？与您的副本作业相比，它看起来有点不一致。（并不是说复制分配是正确的，尽管它设法避免了双重释放......你希望这行代码能完成什么？data_=m.data_;*newdata_=*data_;

答：

2赞 PaulMcKenzie 3/20/2021 #1

基本问题是，在复制构造函数中分配内存后，您不会复制数据。

Matrix::Matrix(const Matrix& m) : rows_(m.rows_), cols_(m.cols_)
{
    data_ = new double[rows_ * cols_];
    data_ = m.data_;  // <-- This is wrong
}

带有注释的行不仅会擦除前一行（分配内存的位置），而且不会复制任何实际数据。它所做的只是复制指针值。所以你现在有和指向相同的内存，因此内存泄漏和双重删除错误。// <-- This is wrongdata_m.data_

解决方法是将数据实际复制到新分配的内存中。

另一个不容易发现的潜在错误是未能初始化所有数据。即使我们修复了此问题以执行复制，您也会遇到未定义的行为。

以下是对这两个问题的修复：

#include <algorithm>
//...
Matrix::Matrix(int rows, int cols): rows_ (rows), cols_ (cols)
{  
    if (rows == 0 || cols == 0)
        throw std::out_of_range("Matrix constructor has 0 size");
    data_ = new double[rows * cols](); // <-- Note the () to zero-initialize the data    
}

Matrix::Matrix(const Matrix& m) : rows_(m.rows_), cols_(m.cols_)
{
    data_ = new double[rows_ * cols_];
    std::copy_n(m.data_, m.rows_ * m.cols_, data_);
}

还有一个错误，那就是在赋值运算符中。您犯了同样的错误，错误地使用了复制，而不是在两个缓冲区之间复制数据的必要函数。=

Matrix& Matrix::operator=(const Matrix& m)
{     
    if(this != &m)
    {
        double* newdata_=new double[m.cols_*m.rows_];
        *newdata_=*data_; // <-- This does not copy the data
        //

该修复类似于在复制构造函数中使用完成的修复。但它是如此相似，以至于您实际上可以使用复制构造函数来完成所有这些工作，而不是使用重复的代码。这种在赋值运算符中使用复制构造函数的技术称为复制/交换惯用语。std::copy_n

Matrix& Matrix::operator=(const Matrix& m)
{     
  if(this != &m)
  {
     Matrix temp(m);  // <-- Copy is made
     std::swap(temp.data_, data_);
     std::swap(temp.rows_, rows_);
     std::swap(temp.cols_, cols_);
  }      
  return *this;
}

基本上，我们制作了一个副本，然后我们只是将当前对象的数据与副本的数据交换。然后，副本会随着旧数据一起消失。

上一个：什么是三分法则？

下一个：带有复制构造函数的析构函数

复制构造函数内存泄漏

Copy constructor memory leaks

评论