Thread: overloading operators for vector addition

Hello everyone,

I'm trying to overload some operators for the vector class but my attempts don't seem to do anything. They compile fine, they just won't add/subtract/multiply...

Here's a sample for the + operator.

Code:

template <class T1, class T2>
vector<T1> &operator+(vector<T1>& v1, vector<T2>& v2)
{
  for(UINT i = 0; i < v1.size(); i++)
        v1[i] += v2[i];
  return v1;
}

The when I call it, it's like this

Code:

vector<int> v1, v2;
v1.assign(4, 4);
v2.assign(4, 6);

v1 = v1 + v2;

Then when I look in v1, the values are still {4, 4, 4, 4}.

So, how do you do it?

Well, I didn't post my actual code. It's

Code:

template <class T1, class T2>
vector<T1> &operator+(vector<T1>& v1, vector<T2>& v2)
{
  for(UINT i = 0; i < v1.size(); i++)
    {
      if(!v2.at(i))
        v1[i] += v2[i];
      else
        break;
    }
  return v1;
}

I did this so I could add vectors of different length. I wonder if that could have been the problem. And tried adding the const keyword to the two parameters (you are talking about something like this:

Code:

vector<T1> &operator+(const vector<T1>& v1, const vector<T2>& v2)

right?)

Well, adding the const gave a compile error.

Code:

perceptron.cpp:37: error: assignment of read-only location
perceptron.cpp:41: error: invalid initialization of reference of type '
   std::vector<float, std::allocator<float> >&' from expression of type 'const
   std::vector<float, std::allocator<float> >'

Anyway, you add two vectors and the value in the first vector does not change.

Creating operators on standard library containers isn't really a good idea except perhaps for learning purposes.

However, for this you can make a copy of v1 and then add v2's elements to the copy's elements. The easiest way to do this is to make the first parameter a non-const non-reference. Or you can copy construct a new vector inside the function and pass v1 to it.

Your check of v2.at() probably won't do what you want. You probably meant to check i against v2.size().

I'm not that experienced in c++ so could you explain why creating operators for standard containers is not a good idea? I'd rather avoid any mishaps now than have my project blow up in my face in a few weeks.

Oh, and I fixed the operators by getting rid of the useless at() function. Thanks a million.
The code now works fine without that range checking. I guess I should have used it in a try catch statement but I didn't really want to look up sample code for doing that.

Thanks for the warning. And I'll look into transform. At the moment, however, I'm trying to get the vectors to work like mathematical vectors. And it'll be for just this project, so I guess I'll chance it.

Well, the stl is full of surprises!

I've changed all my code so that it uses transform instead of my overloaded operators:

Code:

transform(v2.begin(), v2.end(), v1.begin() + 1, v1.begin() +1, plus<int>());

That solves the problem of the two vectors not being equal in length as well.

A new question. I would like to multiply a vector by a number, e.g. 0.3 * (1, 2, 3, 4) would be (0.3, 0.6, 0.9, 1.2). If that 0.3 were a constant, I wouldn't have any problem but it has to change with every iteration. So the standard invocation is:

Code:

void multiply(float& elem)
{
   return elem *= 0.3;
}

...

for_each(v1.begin(), v1.end(), multiply);

I tried changing it so that the 0.3 would actually be a variable, which the compiler just spit back out with relish:

Code:

void multiply(float& elem, float f_arg)
{
   return elem *= f_arg;
}

...

for_each(v1.begin(), v2.end(), multiply(??????????)); //so how is this taken care of.

If neither for_each nor transform is the solution, could you point me to one?