使用 C++ 重载运算符：具有指针数据成员的类

Question

我正在尝试使用运算符重载执行基本矩阵运算的程序。下面是我的代码：-

保存矩阵的类

class matrix {
    int r, c;
    int *data;

    public :
    matrix()  //default contstructor
    {
        r=0; c=0;
        data = NULL;
    }

    matrix(int a, int b)   //general matrix constructor.
    {
        r = a; c = b;
        data = new int[sizeof(int) * r * c];;
    }

    //Overloading + operator.
    matrix operator +(matrix & M);

             //Overloading = operator.
    void operator =(matrix & M);
};

然后我创建了一个临时全局对象，如下所示。

matrix temp;

我已经重载了 + 运算符，如下所示。请注意，我必须使用上面创建的全局对象“temp”来保存并返回结果矩阵，因为我的数据成员是 int* 并且我无法返回具有本地范围的对象。

// Addition of matrix
matrix matrix :: operator+(matrix & M)
{
         if(M.r != r || M.c != c) {
           cout<<"Addition is not possible!";
           return temp;
         }
         temp.r = r;
         temp.c = c;
         temp.data = new int(sizeof(int) * r * c);

         for(int i=0; i<r; i++)
         for(int j=0; j<c; j++)
          *(temp.data +(i*c +j)) = *(data +(i*c +j)) + *(M.data +(i*c +j));

     return temp;
}

好的，该程序运行良好...但我的问题是是否有任何有效的替代这个外部“临时”对象？

Answer 1

这个外部“临时”对象有什么有效的替代方法吗？

是的（而且代码中存在一些问题）。

矩阵求和应该通过两种方式实现：

class matrix {
    // ...

    //Overloading + operator.
    matrix& operator +=(const matrix& M); // << notice difference in signature
};

// Addition of matrix
matrix& matrix::operator +=(const matrix& M)
{
     if(M.r != r || M.c != c) {
         cout<<"Addition is not possible!"; // this should throw an exception
                                            // because client code should not have to
                                            // be forced to check the contents of
                                            // std::cout to validate that the operation
                                            // succeeded

         return *this;                      // returning *this
     }

     // this is not necessary
     // temp.r = r;
     // temp.c = c;
     // temp.data = new int(sizeof(int) * r * c);

     for(int i=0; i<r; i++)
         for(int j=0; j<c; j++)
             *(data +(i*c +j)) = *(data +(i*c +j)) + *(M.data +(i*c +j));

     return *this;                          // returning *this
}

这是连接 (+=) 运算符，它很高效，因为它不会创建新的/临时对象。它的问题是它改变了左边的操作数。

第二次实现（和第一次一样高效，并完成上面的代码）：

matrix operator +(const matrix& x, const matrix& y) {
    matrix result(x); // you will need a copy constructor
    result += y;      // use operator defined above
    return result;
}

第二个实现使用第一个为矩阵添加加法语义，它不需要是成员。