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;
}

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

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

1 个答案: