Question

I want to overload the operator + in a class which has a vector as member variable, so as to carry out the merging of vectors of two different objects. In other words I would like a new object to be created which has as vector both the elements of the vectors of the two initial vectors in a row. I try the following code and I receive an error in operator+ regarding std::copy. What is the problem?

class TestVector
{
    std::vector<int> myVector;

public:
    TestVector(){};
    TestVector(std::vector<int>);
    std::vector<int> getVector();
    TestVector operator +(TestVector);

};

std::vector<int> TestVector::getVector()
{
   return myVector;
}

TestVector TestVector::operator+(TestVector param)
{

    std::vector<int> tempVector;
    std::vector<int> paramVector = param.getVector();

    std::copy(paramVector.begin(), paramVector.end(), tempVector);
    std::copy(myVector.begin(), myVector.end(), tempVector.end());

    TestVector TestVector1(tempVector);

    return TestVector1;

}

Moreover, is the second copy statement valid to merge two vectors in general?

Update: I got an error at execution time saying that iterators are inompatible at this statement. What is wrong?
tempVector.insert(tempVector.end(),param.getVector().begin(), param.getVector().end());

Answer 1

The third argument to std::copy must be an iterator, not a container. You can use std::back_inserter thus:

std::copy(paramVector.begin(), paramVector.end(), std::back_inserter(tempVector));

The second copy will compile, since std::end() returns an iterator, but it will break because the iterator simply points to the end of the vector. It won’t grow the vector when std::copy tries to assign to it; it will simply invoke undefined behaviour. Again, std::back_inserter solves the problem.

In any event you don’t need std::copy at all, since std::vector provides the necessary semantics directly:

TestVector TestVector::operator+(const TestVector& v)
{
    std::vector<int> t(myVector);
    t.insert(t.end(), v.myVector.begin(), v.myVector.end());
    return TestVector(t);
}

And remember to use const &… to avoid so much copying. For instance, the second constructor copies the input vector unnecessarily, and getVector() copies the internal vector unnecessarily.

Even the above solution copies the temporary vector at least once, which can be avoided with a purpose-built constructor:

class TestVector
{
    std::vector<int> myVector;

public:
    TestVector() { }
    TestVector(const std::vector<int>& v) : myVector(v) { }
    const std::vector<int>& getVector() const { return myVector; }
    TestVector operator+(const TestVector& v) const {
        return TestVector(op_add(), *this, v);
    }

private:
    struct op_add { };
    TestVector(op_add, const TestVector& a, const TestVector& b) : myVector(a) {
        myVector.insert(myVector.end(), b.myVector.begin(), b.myVector.end());
    }
};