使用重载将两个矩阵相加的最佳方法是什么？

Question

I have defined one matrix class, and overloaded the + operator to be able to add instances of this class together.

class Matrix{
public:
vector<vector<int>> a;


Matrix & operator+(const Matrix& b)
{                
    vector<vector<int>>::const_iterator it0=b.a.begin();
    vector<vector<int>>::iterator it1=this->a.begin();
    vector<int>::iterator it2=it1->begin();
    vector<int>::iterator it3=it1->end();
    vector<int>::const_iterator it01=it0->begin();

    for(it1;it1!=this->a.end();it1++)
        {
        it2=it1->begin();
        it3=it1->end();
        it01=it0->begin();
        it0++;
             // a.begin(),a.end(),b.begin(),ret.begin()
        std::transform(it2,it3,it01,it2,std::plus<int>());
    }
            return  *this;
}

};

But then, there is also another way of doing this,

class Matrix{
public:
vector<vector<int> > a;

Matrix & operator + (const Matrix &y) {

 for (int m=0; m<y.a.size(); ++m) {
    for (int n=0; n<y.a[0].size(); ++n) {
        this->a[m][n] = this->a[m][n] + y.a[m][n];
    }
}

return *this;
}};

The second form is shorter, but uses arrays directly, while the first one uses iterators. Maybe it's possible to do this with iterators in a shorter way, I'm not sure. I've tested with simple cases and they seem to be equally efficient. What's the proper way of doing this?

Answer 1

For non-trivial classes (such as classes including a std::vector ), in-place operations are often cheaper than allocating a new object and then (presumably) destroying one or both of the arguments. However, aggressive use of rvalue reference overloads can somewhat mitigate this.

Note that regardless of which function implementation I used, I would not use nested std::vector s - I would either use a single std::vector or better a std::unique_ptr<T[]> and then calculate the index as y*w+x (remember to bounds-check first ).