Adding 2 vectors using overloaded + in C++

Question

I am trying to add 2 vectors using overloaded + operator. https://stackoverflow.com/a/4421719/9329547 answer shows

inline X operator+(X lhs, const X& rhs)
{
  lhs += rhs;
  return lhs;
}

My case is I want to pass 2 vectors to class, then a function will modify them and will add using another method and return it. Here is the code.

class VO
{
private:

const std::vector<double> &vec1;
const std::vector<double> &vec2;

public:
VO (const std::vector<double> &x, const std::vector<double> &y): vec1(x), vec2(y) {}

std::vector<double> operator + (const std::vector<double> &, const std::vector<double> &) {}

std::vector<double> foo(....) 
{ 
//vectors vec1, vec 2 are modified here then want to add them
std::vector<double> v3 = vec1 + vec2;
return v3;
}
};

int main()
{
std::vector<double> a={1,2,3,4,5}, b={9,8,7,6,5},c;
VO obj(a,b);
c=obj.foo();
return 0;
}

In this case, I am not sure how can I use this to add 2 vectors.

Edit:

I can create vectorAdd method in the class, pass 2 vectors and get addition. But I want to use operator + for that. Operator + is overloaded in many scientific libraries to add vectors (arrays).

Edit 2:

If I use my original code, I get error error C2804 binary operator + has too many parameters. I am trying to add 2 vectors such that if a={1,2,3,4,5}, b={9,8,7,6,5}, then a+b = {1+9, 2+8, 3+7, 4+6, 5+5} = {10,10,10,10,10}

Answer 1

It's not entirely clear what you're trying to achieve, but you seem pretty confused about how and why to use operator overloading.

I am trying to add 2 vectors using overloaded + operator

OK, the purpose of this overloaded operator is that you can type

vector<double> a, b, c;
// ... populate a and b ...
c = a + b;

as if vector<double> were a primitive type like int or a simple double.

The whole point is to get the same syntax for built-in and user-defined types, so that later we can write generic code that works identically for both. For example, std::plus and std::accumulate work for any type with operator+ defined, whether you're adding integers or vectors or something else.

For this to work (and operator overloading to be worthwhile), your custom operator+ must be found by the usual name lookup rules when you write a + b.

Then you say

I want to pass 2 vectors to class, then a function will modify them and will add using another method

but using a class method instead of a free function doesn't satisfy the requirements above. V0::operator+ won't be found when you type a + b. (In fact V0::operator+ can anyway only be a method for adding something to a V0, because it must be non-static if it is a method, and so the left-hand-side will always be a V0 object).

If you still want addition to be a method of V0, there's no reason to call it operator+, because the syntax won't be the same anyway.

Conversely if you do want the same syntax, it should be a free function in order for the name lookup to work.

You say you want to overload the operator because it is overloaded in many scientific libraries, but that doesn't explain wanting it to be a method of a class other than the type you're adding

• if you want to use one of those libraries and provide it an operator+ to use, then putting the operator inside an unrelated class won't achieve anything. How will the library know it's supposed to call V0::operator+ when adding two vector<double>? That's not the way anything works
• if you want to imitate the style of those libraries, the only operator+ associated with your V0 type would be used to add V0 instances. And it should still be a free function.

Answer 2

Here is a possible implementation of vector addition, using the guidelines you linked:

#include <iostream>
#include <vector>
#include <exception>

template<typename T>
std::vector<T>& operator+=(std::vector<T> &lhs, const std::vector<T> &rhs) {
    typedef std::vector<T>::size_type size_type;
    if (lhs.size() != rhs.size())
        throw std::length_error("vectors must be same size to add");

    for (size_type i = 0; i < lhs.size(); ++i)
        lhs[i] += rhs[i];
    return lhs;
}

template<typename T>
std::vector<T> operator+ (std::vector<T> lhs, const std::vector<T> &rhs) {
    typedef std::vector<T>::size_type size_type;
    if (lhs.size() != rhs.size())
        throw std::length_error("vectors must be same size to add");
    return lhs += rhs;
}

int main()
{
    std::vector<double> a = { 1,2,3,4,5 }, b = { 9,8,7,6,5 }, c;
    c = a + b;
    for (auto x : c)
        std::cout << x << ' ';
    return 0;
}

Output:

10 10 10 10 10

You could define a math vector class which has-a std::vector (because no virtual destructor), and define the math operators on that, so that you can't accidentally call this operator on std::vectors which are not intended to be math vectors. Personally, I would just get one of those math libraries you mentioned, and use it. No need to reinvent the wheel.

Answer 3

A vector is a fixed type. You should not add + to it.

You can extend vector like this:

template<class T>
struct my_vector:std::vector<T> {
  using std::vector<T>::vector; // get vector's constructors

  my_vector& operator+=( my_vector const& rhs )& {
    if (size() < rhs.size()) resize(rhs.size());
    for (std::size_t i = 0; i < rhs.size(); ++i)
      (*this)[i] += rhs[i];
    return *this;
  }
  friend my_vector operator+( my_vector lhs, my_vector const& rhs ) {
    lhs += rhs;
    return lhs;
  }
  my_vector& operator*=( my_vector const& rhs )& {
    if (size() < rhs.size()) resize(rhs.size());
    for (std::size_t i = 0; i < rhs.size(); ++i)
      (*this)[i] *= rhs[i];
    return *this;
  }
  friend my_vector operator*( my_vector lhs, my_vector const& rhs ) {
    lhs *= rhs;
    return lhs;
  }
};

Now, use my_vector<double> instead of std::vector<double>.

Now, you could add this operator+ in the namespace where you are doing the work, but that generally isn't a good idea. Operations on types should be part of the type or in the type's namespace to avoid surprises.