Concatenate two std::vectors in one line using C++11

Question

Is there a way, using C++11, to concatenate two std::vectors in one code line, with the first defined in a local variable, the second returned from a function:

#include <vector>
#include <iostream>
#include <iterator>

std::vector<int> getNewVector()
{
    return {4,5,6};
}

int main(int argc, char** argv)
{
  std::vector<int> dest;
  std::vector<int> src{1,2,3};

  dest = src + getNewVector(); //Error: no operator "+" matches these operands

  return 0;
}

EDIT: differently from this question, that is not using C++11, I would like to know if the new C++11 standard give some useful functionality that would help my task. As an example, I've used the + operator even if it's not working, but just to give an idea of what I'm looking for.

Possible duplicate of [Inserting a std::vector as returned from a function](https://stackoverflow.com/questions/27041660/inserting-a-stdvector-as-returned-from-a-function) — Rakete1111, Jul 03 '17 at 13:43
This is not a duplicate of the above question. The '+' operator is undefined for std::vector. Concatenation is done with the `insert` method. I.e. `dest.insert(dest.end(),src.begin(),src.end()); ` — Gavin Portwood, Jul 03 '17 at 13:49
@GavinPortwood `dest.insert(dest.end(),getNewVector().begin(),getNewVector()‌.end());` is UB, due to the iterators `getNewVector().begin()`, and `getNewVector()‌.end()` not belonging to the same container. — Algirdas Preidžius, Jul 03 '17 at 13:51
True but my point is you can't combine two vectors with the `+` operator — Gavin Portwood, Jul 03 '17 at 13:54
@21koizyd What? Please elaborate on your question, since, as it's written, I fail to understand what are you asking about. — Algirdas Preidžius, Jul 03 '17 at 13:56
You could create a new class that inherits from std::vector and overload the + operate to concatenate 2 vectors. (Granted inheriting from std::vector is seen as bad practice)... check out the answer here: https://stackoverflow.com/questions/14420209/overloading-operators-for-vectordouble-class — AresCaelum, Jul 03 '17 at 13:56
Or, you could just define a global `operator+` that takes two standard vectors as input without using any derived class. — Remy Lebeau, Jul 04 '17 at 03:17
Does this answer your question? [Concatenating two std::vectors](https://stackoverflow.com/questions/201718/concatenating-two-stdvectors) — Henke, Jan 01 '21 at 15:15

Maxim Egorushkin · Answer 1 · 2017-07-05T13:18:59.410

You can do that pretty easily using boost::range library.

Ranges are going to be a part of C++ standard library. See Ranges for the Standard Library for more details.

Bonus point: only one memory allocation for the resulting vector.

#include <vector>
#include <boost/range/join.hpp>

int main() {
    std::vector<int> a{1,2,3};
    std::vector<int> b{4,5,6};
    auto c = boost::copy_range<std::vector<int>>(boost::join(a, b));
}

Or, generalize it to more than two input sequences and types:

template<class T, class U>
auto join(T const& a, U const& b) -> decltype(boost::join(a, b)) {
    return boost::join(a, b);
}

template<class T, class U, class... Args>
auto join(T const& a, U const& b, Args const&... args) -> decltype(boost::join(a, join(b, args...))) {
    return boost::join(a, join(b, args...));
}

int main() {
    std::vector<int> a{1,2,3};
    std::list<int> b{4,5,6};
    std::set<int> c{7,8,9};
    auto d = boost::copy_range<std::vector<int>>(join(a, b, c)); 
}

Again, it does only one memory allocation in boost::copy_range<std::vector<int>> because the input sequences lengths are known.

wally · Answer 2 · 2017-07-03T14:36:50.637

1

We could exploit the fact that an l-value and r-value are being passed to the operator+:

#include <vector>
#include <iostream>
#include <iterator>
#include <algorithm>

std::vector<int> getNewVector()
{
    return {4, 5, 6};
}

template <class T>
T operator+(const T& l, T&& r)
{
    T c{};
    c.reserve(l.size() + r.size());
    auto bi = std::back_inserter(c);
    std::copy(l.begin(), l.end(), bi);
    std::move(r.begin(), r.end(), bi);
    return c;
}

int main()
{
    std::vector<int> dest;
    std::vector<int> src{1, 2, 3};
    dest = src + getNewVector(); //uses operator "+"
    return 0;
}

edited Jul 03 '17 at 14:36

answered Jul 03 '17 at 14:00

wally

10,717
5
39
72

You should move the elements into `c` instead of copying them. – Rakete1111 Jul 03 '17 at 14:08
There is an unnecessary memory reallocation in this implementation of `operator+`. – Maxim Egorushkin Jul 03 '17 at 14:11
@Rakete1111 Yes, a move would be better. Wouldn't make a difference for `int`, but would be better for a template. – wally Jul 03 '17 at 14:16
@21koizyd `std:move` is in `` – Blastfurnace Jul 03 '17 at 14:20
1

@21koizyd Standard library headers are allowed to include other headers. There's no guarantee it will work without ``, so include what you use. – Blastfurnace Jul 03 '17 at 14:25
@MaximEgorushkin Good point, the sizes are known so we could reserve up front. – wally Jul 03 '17 at 14:29
1

@rex I'm concerned that if you're passing in `std::vector>` your code will suck the guts out of the left-hand argument. That's a surprising side effect. – Blastfurnace Jul 03 '17 at 14:33
@Blastfurnace Oops. Got a little trigger happy with the `std::move`. A copy from the l-value is what I really wanted. :) – wally Jul 03 '17 at 14:38

21koizyd · Answer 3 · 2017-07-04T03:00:02.950

overloaded operator + takes 2x vectors, solution without library boost

#include <vector>
#include <iostream>
template<typename T>
std::vector<T> operator+(std::vector<T> vec1, const std::vector<T>&& vec2)
{
    vec1.insert(vec1.end(), vec2.begin(), vec2.end());
    return vec1;
}
std::vector<int> getNewVector()
{
    return{ 4,5,6 };
}
template<typename T>
void displayVectors(const std::vector<T>& src, const std::vector<T>& dest, const std::vector<T>&& getNewVector)
{
    std::cout << "src { ";
    for (const auto& itr : src)
        std::cout << itr << " ";
    std::cout << "}" << std::endl;
    std::cout << "getNewVector() { ";
    for (const auto& itr : getNewVector)
        std::cout << itr << " ";
    std::cout << "}" << std::endl;
    std::cout << "dest { ";
    for (const auto& itr : dest)
        std::cout << itr << " ";
    std::cout << "}" << std::endl;
}
int main(int argc, char** argv)
{
    std::vector<int> dest;
    std::vector<int> src{ 1,2,3 };
    displayVectors(src, dest, getNewVector());
    dest = src + getNewVector();
    std::cout << "After operation" << std::endl;
    displayVectors(src, dest, getNewVector());
    return 0;
}

or with move sematics

#include <vector>
#include <iostream>
#include <algorithm>
#include <iterator>
template<typename T>
std::vector<T> operator+(std::vector<T> vec1, const std::vector<T>&& vec2)
{
    std::move(vec2.begin(), vec2.end(), std::back_inserter(vec1));
    return vec1;
}
std::vector<int> getNewVector()
{
    return{ 4,5,6 };
}
template<typename T>
void displayVectors(const std::vector<T>& src, const std::vector<T>& dest)
{
    std::cout << "src { ";
    for (const auto& itr : src)
        std::cout << itr << " ";
    std::cout << "}" << std::endl;
    std::cout << "dest { ";
    for (const auto& itr : dest)
        std::cout << itr << " ";
    std::cout << "}" << std::endl;
}
int main(int argc, char** argv)
{
    std::vector<int> dest;
    std::vector<int> src{ 1,2,3 };
    displayVectors(src, dest);
    dest = src + getNewVector();
    std::cout << "After operation" << std::endl;
    displayVectors(src, dest);
    return 0;
}

Yakk - Adam Nevraumont · Answer 4 · 2017-07-04T02:42:20.730

namespace named_operator {
  template<class D>struct make_operator{make_operator(){}};

  template<class T, char, class O> struct half_apply { T&& lhs; };

  template<class Lhs, class Op>
  half_apply<Lhs, '+', Op> operator+( Lhs&& lhs, make_operator<Op> ) {
    return {std::forward<Lhs>(lhs)};
  }

  template<class Lhs, class Op, class Rhs>
  auto operator+( half_apply<Lhs, '+', Op>&& lhs, Rhs&& rhs )
  -> decltype( named_invoke( std::forward<Lhs>(lhs.lhs), Op{}, std::forward<Rhs>(rhs) ) )
  {
    return named_invoke( std::forward<Lhs>(lhs.lhs), Op{}, std::forward<Rhs>(rhs) );
  }
}

boilerplate library first, then:

namespace ops {
  struct concat_t:named_operator::make_operator<concat_t>{};
  static const concat_t concat{};
  template<class T, class A, class A2>
  std::vector<T,A> named_invoke( std::vector<T,A> lhs, concat_t, std::vector<T,A2> const& rhs){
    lhs.insert(lhs.end(), rhs.begin(), rhs.end());
    return std::move(lhs);
  }
}
using ops::concat;

writes the +concat+ operator. End use looks like:

int main(){
   std::vector<int> a{1,2,3};
   std::vector<int> b{7,8,9};

  for( auto x: a +concat+ a +concat+ b )
    std::cout <<x<<'\n';
}

Live example.

Overloading naked + is illegal in std and fragile/dangerous in root namespace. Fragile due to "in a subnamespace doea not work", dangerous if you make it too greedy. concat_t tag type avoids both.

And who wants to call a function. Prefix notation with ()s annoying to chain.

The above copies the left hand side (unless lhs is a temporary), then concatinates the rhs. Adding move-contents to rhs is juat another named invoke function in namespace ops. So a+a+b copies a, then extends the copy twice.

An expression template version could avoid hacing to resize more than once, for the usual issues.

`static const concat_t concat{};` is a bit of tautology, since `const` is enough to make it `static`. — Maxim Egorushkin, Jul 05 '17 at 09:15

prasadmadanayake · Answer 5 · 2017-07-11T14:35:48.450

-1

as per Maxim Egorushkin suggesion

a.insert(a.end(), b.begin(), b.end());

will be more efficient.

use std::transform,below code if you want to modify values of 'b' and insert into into 'a'

std::transform( b.begin(), b.end(), std::back_inserter(a), [](int i)->int   { return i + delta; } );

complete code

int main()
{
    std::vector<int> a = {1,2,3,4,5};
    std::vector<int> b = {11,22,33,44,55};   

//to copy
 a.insert(a.end(), b.begin(), b.end());

//to transform
    std::transform( b.begin(), b.end(), std::back_inserter(a), [](int i)->int   { return i + delta; } );

    return 0;
}

edited Jul 11 '17 at 14:35

answered Jul 05 '17 at 12:58

prasadmadanayake

1,415
15
23

1

Why bother with `std::transform` if you aren't going to "transform" the values? Wouldn't `std:copy` make more sense? – Blastfurnace Jul 05 '17 at 13:23
1

`a.insert(a.end(), b.begin(), b.end());` is both more efficient and shorter to type and read. – Maxim Egorushkin Jul 06 '17 at 16:41

Concatenate two std::vectors in one line using C++11

5 Answers5