How to add element by element of two STL vectors?

Question

The question is quite dumb, but I need to do it in a very efficient way - it will be performed over an over again in my code. I have a function that returns a vector, and I have to add the returned values to another vector, element by element. Quite simple:

vector<double> result; vector<double> result_temp for(int i=0; i< 10; i++) result_temp.push_back(i);  result += result_temp //I would like to do something like that. for(int i =0; i< result_temp.size();i++)result[i] += result_temp[i]; //this give me segfault 

The mathematical operation that I'm trying to do is

u[i] = u[i] + v[i] for all i

What can be done?

Thanks

EDIT: added a simple initialization, as that is not the point. How should result be initialized?

Answer 1

It sure looks like the problem is accessing values of result that don't exist. tzaman shows how to initialize result to 10 elements, each with value 0.

Now you need to call the transform function (from <algorithm>), applying the plus function object (from <functional>):

std::transform(result.begin(), result.end(), result_temp.begin(),                result.begin(), std::plus<double>()); 

This iterates over result and result_temp, applies plus that adds doubles, and writes the sum back to result.

Answer 2

If you are trying to append one vector to another, you can use something like the following. These are from one of my utilities libraries--two operator+= overloads for std::vector: one appends a single element to the vector, the other appends an entire vector:

template <typename T> std::vector<T>& operator+=(std::vector<T>& a, const std::vector<T>& b) {     a.insert(a.end(), b.begin(), b.end());     return a; }  template <typename T> std::vector<T>& operator+=(std::vector<T>& aVector, const T& aObject) {     aVector.push_back(aObject);     return aVector; } 

If you are trying to perform a summation (that is, create a new vector containing the sums of the elements of two other vectors), you can use something like the following:

#include <algorithm> #include <functional>  template <typename T> std::vector<T> operator+(const std::vector<T>& a, const std::vector<T>& b) {     assert(a.size() == b.size());      std::vector<T> result;     result.reserve(a.size());      std::transform(a.begin(), a.end(), b.begin(),                     std::back_inserter(result), std::plus<T>());     return result; } 

You could similarly implement an operator+= overload.