Concatenating two std vectors

Question

How do I concatenate two std  vectors

User · Answer

If you want to be able to concatenate vectors concisely, you could overload the += operator.

template <typename T>
std::vector<T>& operator +=(std::vector<T>& vector1, const std::vector<T>& vector2) {
    vector1.insert(vector1.end(), vector2.begin(), vector2.end());
    return vector1;
}

Then you can call it like this:

vector1 += vector2;

User · Answer

There is an algorithm std  merge from C  17  which is very easy to use when the input vectors are sorted  Below is the example   include  lt iostream gt   include  lt vector gt   include  lt algorithm gt   int main           DATA     std  vector lt int gt  v1 2 4 6 8       std  vector lt int gt  v2 12 14 16 18          MERGE     std  vector lt int gt  dst      std  merge v1 begin    v1 end    v2 begin    v2 end    std  back inserter dst           PRINT     for auto item dst          std  cout lt  lt item lt  lt  quot   quot        return 0

User · Answer

vector1 insert  vector1 end    vector2 begin    vector2 end

User · Answer

If you are using C  11   and wish to move the elements rather than merely copying them  you can use std  move iterator along with insert  or copy     include  lt vector gt   include  lt iostream gt   include  lt iterator gt   int main int argc  char   argv      std  vector lt int gt  dest 1 2 3 4 5     std  vector lt int gt  src 6 7 8 9 10         Move elements from src to dest       src is left in undefined but safe-to-destruct state    dest insert        dest end          std  make move iterator src begin           std  make move iterator src end                 Print out concatenated vector    std  copy        dest begin          dest end          std  ostream iterator lt int gt  std  cout    n             return 0      This will not be more efficient for the example with ints  since moving them is no more efficient than copying them  but for a data structure with optimized moves  it can avoid copying unnecessary state    include  lt vector gt   include  lt iostream gt   include  lt iterator gt   int main int argc  char   argv      std  vector lt std  vector lt int gt  gt  dest  1 2 3 4 5    3 4      std  vector lt std  vector lt int gt  gt  src  6 7 8 9 10          Move elements from src to dest       src is left in undefined but safe-to-destruct state    dest insert        dest end          std  make move iterator src begin           std  make move iterator src end              return 0      After the move  src s element is left in an undefined but safe-to-destruct state  and its former elements were transfered directly to dest s new element at the end

User · Answer

Concatenate two std  vector-s with for loop in one std  vector      std  vector  lt int gt  v1  1  2  3     declare vector1     std  vector  lt int gt  v2  4  5     declare vector2     std  vector  lt int gt  suma    declare vector suma      for int i   0  i  lt  v1 size    i      for loop 1                suma push back v1 i               for int i   0  i lt  v2 size    i      for loop 2                suma push back v2 i               for int i   0  i  lt  suma size    i      for loop 3-output                std  cout  lt  lt  suma i

User · Answer

With C  11  I d prefer following to append vector b to a   std  move b begin    b end    std  back inserter a      when a and b are not overlapped  and b is not going to be used anymore     This is std  move from  lt algorithm gt   not the usual std  move from  lt utility gt

User · Answer

If your goal is simply to iterate over the range of values for read-only purposes  an alternative is to wrap both vectors around a proxy  O 1   instead of copying them  O n    so they are promptly seen as a single  contiguous one    std  vector lt int gt  A  1  2  3  4  5   std  vector lt int gt  B  10  20  30     VecProxy lt int gt  AB A  B       ---- gt  O 1    for  size t i   0  i  lt  AB size    i        std  cout  lt  lt  AB i   lt  lt           ---- gt  1 2 3 4 5 10 20 30   Refer to https   stackoverflow com a 55838758 2379625 for more details  including the  VecProxy  implementation as well as pros  amp  cons

User · Answer

If your goal is simply to iterate over the range of values for read-only purposes  an alternative is to wrap both vectors around a proxy  O 1   instead of copying them  O n    so they are promptly seen as a single  contiguous one    std  vector lt int gt  A  1  2  3  4  5   std  vector lt int gt  B  10  20  30     VecProxy lt int gt  AB A  B       ---- gt  O 1    for  size t i   0  i  lt  AB size    i        std  cout  lt  lt  AB i   lt  lt           ---- gt  1 2 3 4 5 10 20 30   Refer to https   stackoverflow com a 55838758 2379625 for more details  including the  VecProxy  implementation as well as pros  amp  cons

User · Answer

If what you re looking for is a way to append a vector to another after creation  vector  insert is your best bet  as has been answered several times  for example   vector lt int gt  first    13   const vector lt int gt  second    42    first insert first end    second cbegin    second cend       Sadly there s no way to construct a const vector lt int gt   as above you must construct and then insert     If what you re actually looking for is a container to hold the concatenation of these two vector lt int gt s  there may be something better available to you  if    Your vector contains primitives Your contained primitives are of size 32-bit or smaller You want a const container   If the above are all true  I d suggest using the basic string who s char type matches the size of the primitive contained in your vector  You should include a static assert in your code to validate these sizes stay consistent   static assert sizeof char32 t     sizeof int      With this holding true you can just do   const u32string concatenation   u32string first cbegin    first cend      u32string second cbegin    second cend       For more information on the differences between string and vector you can look here  https   stackoverflow com a 35558008 2642059  For a live example of this code you can look here  http   ideone com 7Iww3I

User · Answer

Try  create two vectors and add second vector to first vector  code  std  vector lt int gt  v1 1 2 3   std  vector lt int gt  v2 4 5    for int i   0  i lt v2 size   i           v1 push back v2 i       v1 1 2 3  Description  While i int not v2 size  push back element   index i in v1 vector

User · Answer

You can prepare your own template for   operator   template  lt typename T gt   inline T operator  const T  amp  a  const T  amp  b        T res   a      res insert res end    b begin    b end         return res      Next thing - just use     vector lt int gt  a 1  2  3  4   vector lt int gt  b 5  6  7  8   for  auto x  a   b      cout  lt  lt  x  lt  lt       cout  lt  lt  endl    This example gives output   1 2 3 4 5 6 7 8

User · Answer

I would use the insert function  something like   vector lt int gt  a  b    fill with data b insert b end    a begin    a end

User · Answer

vector1 insert  vector1 end    vector2 begin    vector2 end

User · Answer

I would use the insert function  something like   vector lt int gt  a  b    fill with data b insert b end    a begin    a end

User · Answer

You can do it with pre-implemented STL algorithms using a template for a polymorphic type use    include  lt iostream gt   include  lt vector gt   include  lt algorithm gt   template lt typename T gt   void concat std  vector lt T gt  amp  valuesa  std  vector lt T gt  amp  valuesb         for each valuesb begin    valuesb end      amp   int value   valuesa push back value         int main         std  vector lt int gt  values p  1 2 3 4 5       std  vector lt int gt  values s  6 7       concat values p  values s        for auto amp  it   values p            std  cout lt  lt it lt  lt std  endl             return 0      You can clear the second vector if you don t want to use it further  clear   method

User · Answer

With range v3  you may have a lazy concatenation   ranges  view  concat v1  v2    Demo

User · Answer

I ve implemented this function which concatenates any number of containers  moving from rvalue-references and copying otherwise  namespace internal       Implementation detail of Concatenate  appends to a pre-reserved vector  copying or moving if    appropriate template lt typename Target  typename Head  typename    Tail gt  void AppendNoReserve Target  target  Head amp  amp  head  Tail amp  amp     tail           Currently  require each homogenous inputs  If there is demand  we could probably implement a        version that outputs a vector whose value type is the common type of all the containers        passed to it  and call it ConvertingConcatenate      static assert              std  is same v lt                      typename std  decay t lt Target gt   value type                      typename std  decay t lt Head gt   value type gt                Concatenate requires each container passed to it to have the same value type        if constexpr  std  is lvalue reference v lt Head gt             std  copy head begin    head end    std  back inserter  target          else           std  move head begin    head end    std  back inserter  target              if constexpr  sizeof    Tail   gt  0            AppendNoReserve target  std  forward lt Tail gt  tail                template lt typename Head  typename    Tail gt  size t TotalSize const Head amp  head  const Tail amp     tail        if constexpr  sizeof    Tail   gt  0            return head size     TotalSize tail            else           return head size                   namespace internal      Concatenate the provided containers into a single vector  Moves from rvalue references  copies     otherwise  template lt typename Head  typename    Tail gt  auto Concatenate Head amp  amp  head  Tail amp  amp     tail        size t totalSize   internal  TotalSize head  tail          std  vector lt typename std  decay t lt Head gt   value type gt  result      result reserve totalSize       internal  AppendNoReserve  amp result  std  forward lt Head gt  head   std  forward lt Tail gt  tail           return result

User · Answer

I would use the insert function  something like   vector lt int gt  a  b    fill with data b insert b end    a begin    a end

User · Answer

You can do it with pre-implemented STL algorithms using a template for a polymorphic type use    include  lt iostream gt   include  lt vector gt   include  lt algorithm gt   template lt typename T gt   void concat std  vector lt T gt  amp  valuesa  std  vector lt T gt  amp  valuesb         for each valuesb begin    valuesb end      amp   int value   valuesa push back value         int main         std  vector lt int gt  values p  1 2 3 4 5       std  vector lt int gt  values s  6 7       concat values p  values s        for auto amp  it   values p            std  cout lt  lt it lt  lt std  endl             return 0      You can clear the second vector if you don t want to use it further  clear   method

User · Answer

I would use the insert function  something like   vector lt int gt  a  b    fill with data b insert b end    a begin    a end

User · Answer

Or you could use   std  copy source begin    source end    std  back inserter destination      This pattern is useful if the two vectors don t contain exactly the same type of thing  because you can use something instead of std  back inserter to convert from one type to the other

User · Answer

If what you re looking for is a way to append a vector to another after creation  vector  insert is your best bet  as has been answered several times  for example   vector lt int gt  first    13   const vector lt int gt  second    42    first insert first end    second cbegin    second cend       Sadly there s no way to construct a const vector lt int gt   as above you must construct and then insert     If what you re actually looking for is a container to hold the concatenation of these two vector lt int gt s  there may be something better available to you  if    Your vector contains primitives Your contained primitives are of size 32-bit or smaller You want a const container   If the above are all true  I d suggest using the basic string who s char type matches the size of the primitive contained in your vector  You should include a static assert in your code to validate these sizes stay consistent   static assert sizeof char32 t     sizeof int      With this holding true you can just do   const u32string concatenation   u32string first cbegin    first cend      u32string second cbegin    second cend       For more information on the differences between string and vector you can look here  https   stackoverflow com a 35558008 2642059  For a live example of this code you can look here  http   ideone com 7Iww3I

User · Answer

If you want to be able to concatenate vectors concisely, you could overload the += operator.

template <typename T>
std::vector<T>& operator +=(std::vector<T>& vector1, const std::vector<T>& vector2) {
    vector1.insert(vector1.end(), vector2.begin(), vector2.end());
    return vector1;
}

Then you can call it like this:

vector1 += vector2;

User · Answer

To be honest  you could fast concatenate two vectors by copy elements from two vectors into the other one or just only append one of two vectors   It depends on your aim   Method 1  Assign new vector with its size is the sum of two original vectors  size   vector lt int gt  concat vector   vector lt int gt     concat vector setcapacity vector A size     vector B size        Loop for copy elements in two vectors into concat vector   Method 2  Append vector A by adding inserting elements of vector B       Loop for insert elements of vector B into vector A with insert    function  vector A insert vector A  end    vector B cbegin    vector B cend

User · Answer

std  vector lt int gt  first  std  vector lt int gt  second   first insert first end    second begin    second end

User · Answer

There is an algorithm std  merge from C  17  which is very easy to use when the input vectors are sorted  Below is the example   include  lt iostream gt   include  lt vector gt   include  lt algorithm gt   int main           DATA     std  vector lt int gt  v1 2 4 6 8       std  vector lt int gt  v2 12 14 16 18          MERGE     std  vector lt int gt  dst      std  merge v1 begin    v1 end    v2 begin    v2 end    std  back inserter dst           PRINT     for auto item dst          std  cout lt  lt item lt  lt  quot   quot        return 0

User · Answer

You can prepare your own template for   operator   template  lt typename T gt   inline T operator  const T  amp  a  const T  amp  b        T res   a      res insert res end    b begin    b end         return res      Next thing - just use     vector lt int gt  a 1  2  3  4   vector lt int gt  b 5  6  7  8   for  auto x  a   b      cout  lt  lt  x  lt  lt       cout  lt  lt  endl    This example gives output   1 2 3 4 5 6 7 8

User · Answer

std  vector lt int gt  first  std  vector lt int gt  second   first insert first end    second begin    second end

User · Answer

Add this one to your header file   template  lt typename T gt  vector lt T gt  concat vector lt T gt   amp a  vector lt T gt   amp b        vector lt T gt  ret   vector lt T gt         copy a begin    a end    back inserter ret        copy b begin    b end    back inserter ret        return ret      and use it this way   vector lt int gt  a   vector lt int gt     vector lt int gt  b   vector lt int gt      a push back 1   a push back 2   b push back 62    vector lt int gt  r   concat a  b     r will contain  1 2 62

User · Answer

Or you could use   std  copy source begin    source end    std  back inserter destination      This pattern is useful if the two vectors don t contain exactly the same type of thing  because you can use something instead of std  back inserter to convert from one type to the other

User · Answer

I prefer one that is already mentioned    a insert a end    b begin    b end       But if you use C  11  there is one more generic way   a insert std  end a   std  begin b   std  end b        Also  not part of a question  but it is advisable to use reserve before appending for better performance  And if you are concatenating vector with itself  without reserving it fails  so you always should reserve     So basically what you need   template  lt typename T gt  void Append std  vector lt T gt  amp  a  const std  vector lt T gt  amp  b        a reserve a size     b size         a insert a end    b begin    b end

User · Answer

If you are interested in strong exception guarantee  when copy constructor can throw an exception    template lt typename T gt  inline void append copy std  vector lt T gt  amp  v1  const std  vector lt T gt  amp  v2        const auto orig v1 size   v1 size        v1 reserve orig v1 size   v2 size         try               v1 insert v1 end    v2 begin    v2 end               catch                    v1 erase v1 begin     orig v1 size  v1 end             throw            Similar append move with strong guarantee can t be implemented in general if vector element s move constructor can throw  which is unlikely but still

User · Answer

This solution might be a bit complicated  but boost-range has also some other nice things to offer    include  lt iostream gt   include  lt vector gt   include  lt boost range algorithm copy hpp gt   int main int  char          std  vector lt int gt  a     1 2 3        std  vector lt int gt  b     4 5 6        boost  copy b  std  back inserter a        for  auto amp  iter   a            std  cout  lt  lt  iter  lt  lt                 return EXIT SUCCESS      Often ones intention is to combine vector a and b just iterate over it doing some operation  In this case  there is the ridiculous simple join function     include  lt iostream gt   include  lt vector gt   include  lt boost range join hpp gt   include  lt boost range algorithm copy hpp gt   int main int  char          std  vector lt int gt  a     1 2 3        std  vector lt int gt  b     4 5 6        std  vector lt int gt  c     7 8 9           Just creates an iterator     for  auto amp  iter   boost  join a  boost  join b  c              std  cout  lt  lt  iter  lt  lt                 std  cout  lt  lt    n          Can also be used to create a copy     std  vector lt int gt  d      boost  copy boost  join a  boost  join b  c    std  back inserter d        for  auto amp  iter   d            std  cout  lt  lt  iter  lt  lt                 return EXIT SUCCESS      For large vectors this might be an advantage  as there is no copying  It can be also used for copying an generalizes easily to more than one container    For some reason there is nothing like boost  join a b c   which could be reasonable

User · Answer

std  vector lt int gt  first  std  vector lt int gt  second   first insert first end    second begin    second end

User · Answer

A general performance boost for concatenate is to check the size of the vectors  And merge insert the smaller one with the larger one      vector lt int gt  v1 v2  if v1 size   gt v2 size          v1 insert v1 end   v2 begin   v2 end       else       v2 insert v2 end   v1 begin   v1 end

User · Answer

I ve implemented this function which concatenates any number of containers  moving from rvalue-references and copying otherwise  namespace internal       Implementation detail of Concatenate  appends to a pre-reserved vector  copying or moving if    appropriate template lt typename Target  typename Head  typename    Tail gt  void AppendNoReserve Target  target  Head amp  amp  head  Tail amp  amp     tail           Currently  require each homogenous inputs  If there is demand  we could probably implement a        version that outputs a vector whose value type is the common type of all the containers        passed to it  and call it ConvertingConcatenate      static assert              std  is same v lt                      typename std  decay t lt Target gt   value type                      typename std  decay t lt Head gt   value type gt                Concatenate requires each container passed to it to have the same value type        if constexpr  std  is lvalue reference v lt Head gt             std  copy head begin    head end    std  back inserter  target          else           std  move head begin    head end    std  back inserter  target              if constexpr  sizeof    Tail   gt  0            AppendNoReserve target  std  forward lt Tail gt  tail                template lt typename Head  typename    Tail gt  size t TotalSize const Head amp  head  const Tail amp     tail        if constexpr  sizeof    Tail   gt  0            return head size     TotalSize tail            else           return head size                   namespace internal      Concatenate the provided containers into a single vector  Moves from rvalue references  copies     otherwise  template lt typename Head  typename    Tail gt  auto Concatenate Head amp  amp  head  Tail amp  amp     tail        size t totalSize   internal  TotalSize head  tail          std  vector lt typename std  decay t lt Head gt   value type gt  result      result reserve totalSize       internal  AppendNoReserve  amp result  std  forward lt Head gt  head   std  forward lt Tail gt  tail           return result

User · Answer

With C  11  I d prefer following to append vector b to a   std  move b begin    b end    std  back inserter a      when a and b are not overlapped  and b is not going to be used anymore     This is std  move from  lt algorithm gt   not the usual std  move from  lt utility gt

User · Answer

Or you could use   std  copy source begin    source end    std  back inserter destination      This pattern is useful if the two vectors don t contain exactly the same type of thing  because you can use something instead of std  back inserter to convert from one type to the other

User · Answer

If you are interested in strong exception guarantee  when copy constructor can throw an exception    template lt typename T gt  inline void append copy std  vector lt T gt  amp  v1  const std  vector lt T gt  amp  v2        const auto orig v1 size   v1 size        v1 reserve orig v1 size   v2 size         try               v1 insert v1 end    v2 begin    v2 end               catch                    v1 erase v1 begin     orig v1 size  v1 end             throw            Similar append move with strong guarantee can t be implemented in general if vector element s move constructor can throw  which is unlikely but still

User · Answer

Or you could use   std  copy source begin    source end    std  back inserter destination      This pattern is useful if the two vectors don t contain exactly the same type of thing  because you can use something instead of std  back inserter to convert from one type to the other

User · Answer

Add this one to your header file   template  lt typename T gt  vector lt T gt  concat vector lt T gt   amp a  vector lt T gt   amp b        vector lt T gt  ret   vector lt T gt         copy a begin    a end    back inserter ret        copy b begin    b end    back inserter ret        return ret      and use it this way   vector lt int gt  a   vector lt int gt     vector lt int gt  b   vector lt int gt      a push back 1   a push back 2   b push back 62    vector lt int gt  r   concat a  b     r will contain  1 2 62

User · Answer

vector1 insert  vector1 end    vector2 begin    vector2 end

User · Answer

A general performance boost for concatenate is to check the size of the vectors  And merge insert the smaller one with the larger one      vector lt int gt  v1 v2  if v1 size   gt v2 size          v1 insert v1 end   v2 begin   v2 end       else       v2 insert v2 end   v1 begin   v1 end

User · Answer

vector lt int gt  v1    1  2  3  4  5   vector lt int gt  v2    11  12  13  14  15   copy v2 begin    v2 end    back inserter v1

User · Answer

If you are using C  11   and wish to move the elements rather than merely copying them  you can use std  move iterator along with insert  or copy     include  lt vector gt   include  lt iostream gt   include  lt iterator gt   int main int argc  char   argv      std  vector lt int gt  dest 1 2 3 4 5     std  vector lt int gt  src 6 7 8 9 10         Move elements from src to dest       src is left in undefined but safe-to-destruct state    dest insert        dest end          std  make move iterator src begin           std  make move iterator src end                 Print out concatenated vector    std  copy        dest begin          dest end          std  ostream iterator lt int gt  std  cout    n             return 0      This will not be more efficient for the example with ints  since moving them is no more efficient than copying them  but for a data structure with optimized moves  it can avoid copying unnecessary state    include  lt vector gt   include  lt iostream gt   include  lt iterator gt   int main int argc  char   argv      std  vector lt std  vector lt int gt  gt  dest  1 2 3 4 5    3 4      std  vector lt std  vector lt int gt  gt  src  6 7 8 9 10          Move elements from src to dest       src is left in undefined but safe-to-destruct state    dest insert        dest end          std  make move iterator src begin           std  make move iterator src end              return 0      After the move  src s element is left in an undefined but safe-to-destruct state  and its former elements were transfered directly to dest s new element at the end

User · Answer

Here s a general purpose solution using C  11 move semantics   template  lt typename T gt  std  vector lt T gt  concat const std  vector lt T gt  amp  lhs  const std  vector lt T gt  amp  rhs        if  lhs empty    return rhs      if  rhs empty    return lhs      std  vector lt T gt  result         result reserve lhs size     rhs size         result insert result cend    lhs cbegin    lhs cend         result insert result cend    rhs cbegin    rhs cend         return result     template  lt typename T gt  std  vector lt T gt  concat std  vector lt T gt  amp  amp  lhs  const std  vector lt T gt  amp  rhs        lhs insert lhs cend    rhs cbegin    rhs cend         return std  move lhs      template  lt typename T gt  std  vector lt T gt  concat const std  vector lt T gt  amp  lhs  std  vector lt T gt  amp  amp  rhs        rhs insert rhs cbegin    lhs cbegin    lhs cend         return std  move rhs      template  lt typename T gt  std  vector lt T gt  concat std  vector lt T gt  amp  amp  lhs  std  vector lt T gt  amp  amp  rhs        if  lhs empty    return std  move rhs       lhs insert lhs cend    std  make move iterator rhs begin     std  make move iterator rhs end          return std  move lhs       Note how this differs from appending to a vector

User · Answer

To be honest  you could fast concatenate two vectors by copy elements from two vectors into the other one or just only append one of two vectors   It depends on your aim   Method 1  Assign new vector with its size is the sum of two original vectors  size   vector lt int gt  concat vector   vector lt int gt     concat vector setcapacity vector A size     vector B size        Loop for copy elements in two vectors into concat vector   Method 2  Append vector A by adding inserting elements of vector B       Loop for insert elements of vector B into vector A with insert    function  vector A insert vector A  end    vector B cbegin    vector B cend

User · Answer

With range v3  you may have a lazy concatenation   ranges  view  concat v1  v2    Demo

User · Answer

vector lt int gt  v1    1  2  3  4  5   vector lt int gt  v2    11  12  13  14  15   copy v2 begin    v2 end    back inserter v1

User · Answer

Try  create two vectors and add second vector to first vector  code  std  vector lt int gt  v1 1 2 3   std  vector lt int gt  v2 4 5    for int i   0  i lt v2 size   i           v1 push back v2 i       v1 1 2 3  Description  While i int not v2 size  push back element   index i in v1 vector

User · Answer

You should use vector  insert   v1 insert v1 end    v2 begin    v2 end

User · Answer

vector1 insert  vector1 end    vector2 begin    vector2 end

User · Answer

Here s a general purpose solution using C  11 move semantics   template  lt typename T gt  std  vector lt T gt  concat const std  vector lt T gt  amp  lhs  const std  vector lt T gt  amp  rhs        if  lhs empty    return rhs      if  rhs empty    return lhs      std  vector lt T gt  result         result reserve lhs size     rhs size         result insert result cend    lhs cbegin    lhs cend         result insert result cend    rhs cbegin    rhs cend         return result     template  lt typename T gt  std  vector lt T gt  concat std  vector lt T gt  amp  amp  lhs  const std  vector lt T gt  amp  rhs        lhs insert lhs cend    rhs cbegin    rhs cend         return std  move lhs      template  lt typename T gt  std  vector lt T gt  concat const std  vector lt T gt  amp  lhs  std  vector lt T gt  amp  amp  rhs        rhs insert rhs cbegin    lhs cbegin    lhs cend         return std  move rhs      template  lt typename T gt  std  vector lt T gt  concat std  vector lt T gt  amp  amp  lhs  std  vector lt T gt  amp  amp  rhs        if  lhs empty    return std  move rhs       lhs insert lhs cend    std  make move iterator rhs begin     std  make move iterator rhs end          return std  move lhs       Note how this differs from appending to a vector

User · Answer

You should use vector  insert   v1 insert v1 end    v2 begin    v2 end

User · Answer

This solution might be a bit complicated  but boost-range has also some other nice things to offer    include  lt iostream gt   include  lt vector gt   include  lt boost range algorithm copy hpp gt   int main int  char          std  vector lt int gt  a     1 2 3        std  vector lt int gt  b     4 5 6        boost  copy b  std  back inserter a        for  auto amp  iter   a            std  cout  lt  lt  iter  lt  lt                 return EXIT SUCCESS      Often ones intention is to combine vector a and b just iterate over it doing some operation  In this case  there is the ridiculous simple join function     include  lt iostream gt   include  lt vector gt   include  lt boost range join hpp gt   include  lt boost range algorithm copy hpp gt   int main int  char          std  vector lt int gt  a     1 2 3        std  vector lt int gt  b     4 5 6        std  vector lt int gt  c     7 8 9           Just creates an iterator     for  auto amp  iter   boost  join a  boost  join b  c              std  cout  lt  lt  iter  lt  lt                 std  cout  lt  lt    n          Can also be used to create a copy     std  vector lt int gt  d      boost  copy boost  join a  boost  join b  c    std  back inserter d        for  auto amp  iter   d            std  cout  lt  lt  iter  lt  lt                 return EXIT SUCCESS      For large vectors this might be an advantage  as there is no copying  It can be also used for copying an generalizes easily to more than one container    For some reason there is nothing like boost  join a b c   which could be reasonable

User · Answer

std  vector lt int gt  first  std  vector lt int gt  second   first insert first end    second begin    second end

User · Answer

I prefer one that is already mentioned    a insert a end    b begin    b end       But if you use C  11  there is one more generic way   a insert std  end a   std  begin b   std  end b        Also  not part of a question  but it is advisable to use reserve before appending for better performance  And if you are concatenating vector with itself  without reserving it fails  so you always should reserve     So basically what you need   template  lt typename T gt  void Append std  vector lt T gt  amp  a  const std  vector lt T gt  amp  b        a reserve a size     b size         a insert a end    b begin    b end

User · Answer

Concatenate two std  vector-s with for loop in one std  vector      std  vector  lt int gt  v1  1  2  3     declare vector1     std  vector  lt int gt  v2  4  5     declare vector2     std  vector  lt int gt  suma    declare vector suma      for int i   0  i  lt  v1 size    i      for loop 1                suma push back v1 i               for int i   0  i lt  v2 size    i      for loop 2                suma push back v2 i               for int i   0  i  lt  suma size    i      for loop 3-output                std  cout  lt  lt  suma i

[c++] Concatenating two std::vectors

Examples related to c++

Examples related to vector

Examples related to stl

Examples related to concatenation

Examples related to stdvector