Question

我创建了一个存储指向动态2D数组的指针的类，我重载了'+'运算符，以便它返回两个矩阵的加法：

class matrix
{
    int * mat, row, col;
public:
    matrix(int r, int c)
    {
        row = r;
        col = c;
        mat = new int[row * col];
    }

    matrix operator + (matrix m)
    {
        matrix result(row, col);
        for (int i = 0; i < row; i++)
        {
            for (int j = 0; j < col; j++)
            {
                result.mat[i * result.col + j] = mat[i * col + j] + m.mat[i * m.col + j]
            }
        }
        //result.display(); //result contains expected values i.e. added values
        return result;
    }

    matrix(matrix &m)
    {
      this->mat = m.mat;
      this->row = row;
      this->col = col;
    }


  ~matrix()
   {
     delete[] mat;
   }

  void operator = (matrix m)
{
    if (row != m.row || col != m.col)
    {
        cerr << "Incompatible Matrix Assignment";
        return;
    }

    else
    {
        for(int i = 0; i < row; i++)
        {
            for(int j = 0; j <col; j++)
            {
                mat[i * col + j] = m.mat[i * m.col + j];
            }
        }
    }

    return;
} 

};

int main()
{
    matrix m1(2, 2); //m1.input(); //input has been taken
    matrix m2(2, 2); //m2.input(); //input has been taken
    matrix m3(2, 2);
    m3 = m1 + m2;
    //m3.output;
}

类中的

'+'函数返回一个局部矩阵变量'result'它包含期望值但是当函数返回结果时，mat的前两个值（矩阵类的数据成员）包含垃圾，即m [0] [ 0]和m [0] [1]，其余的数组变量都有预期的值。使数组大小为3X3或4X4它不会产生差异只有前两个变量包含垃圾。

Answer 1

遵循0/3/5的规则。在这种情况下，0的规则是最好的。

在这5个特殊成员函数中：

析构函数
copy assign / ctor
移动assign / ctor

手动实现0,3或5个（dtor和assign / ctor对，全部为5或无）。有时=delete可以替代手动实现它们。如果您实现了dtor并且无法对移动/复制ctors执行任何操作，则您的代码可能会被破坏。

到目前为止最简单的方法是遵循零规则。

std::vector<int> mat;

然后代替mat = new int[row * col];：

mat.resize(row * col);

最后不要写一个dtor（析构函数）。

通过让资源管理类（向量）管理您的资源，您可以使您的业务逻辑类（矩阵）不会充满容易出错的资源管理代码。

重载运算符返回的对象正在丢失c ++中的数据

1 个答案: