दो std :: वैक्टरों को जोड़ना

vector1.insert( vector1.end(), vector2.begin(), vector2.end() );

मैं फ़ंक्शन डालने का उपयोग करूंगा, जैसे कुछ:

vector a, b;
//fill with data
b.insert(b.end(), a.begin(), a.end());

यदि आप सी ++ 11 का उपयोग कर रहे हैं, और केवल उन्हें कॉपी करने के बजाय तत्वों को स्थानांतरित करना चाहते हैं, तो आप std :: move_iterator ( http://en.cppreference.com/w/cpp/iterator/move_iterator ) डालने के साथ (या प्रतिलिपि):

#include 
#include 
#include 

int main(int argc, char** argv) {
  std::vector dest{1,2,3,4,5};
  std::vector 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(std::cout, "\n")
    );

  return 0;
}

यह इन्स के साथ उदाहरण के लिए अधिक कुशल नहीं होगा, क्योंकि उन्हें स्थानांतरित करने से उन्हें अधिक कुशल नहीं है, लेकिन अनुकूलित चाल के साथ डेटा संरचना के लिए, यह अनावश्यक स्थिति की प्रतिलिपि बनाने से बच सकता है:

#include 
#include 
#include 

int main(int argc, char** argv) {
  std::vector> dest{{1,2,3,4,5}, {3,4}};
  std::vector> 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;
}

चाल के बाद, src का तत्व एक अपरिभाषित लेकिन सुरक्षित-से-नष्ट राज्य में छोड़ा गया है, और इसके पूर्व तत्वों को अंत में सीधे भाग के नए तत्व में स्थानांतरित कर दिया गया था।

या आप इसका उपयोग कर सकते हैं:

std::copy(source.begin(), source.end(), std::back_inserter(destination));

यह पैटर्न उपयोगी है यदि दो वैक्टरों में बिल्कुल वही प्रकार की चीज़ नहीं है, क्योंकि आप एक प्रकार से दूसरे में परिवर्तित करने के लिए std :: back_inserter के बजाय कुछ उपयोग कर सकते हैं।

std::vector first;
std::vector second;

first.insert(first.end(), second.begin(), second.end());

सी ++ 11 के साथ, मैं वेक्टर बी को जोड़ने के लिए निम्न पसंद करना चाहूंगा:

std::move(b.begin(), b.end(), std::back_inserter(a));

जब a और b ओवरलैप नहीं होते हैं, और b अब और उपयोग नहीं किया जा रहा है।

मैं पहले से ही उल्लेख किया है कि एक पसंद है:

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

लेकिन यदि आप सी ++ 11 का उपयोग करते हैं, तो एक और सामान्य तरीका है:

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

इसके अलावा, किसी प्रश्न का हिस्सा नहीं है, लेकिन यह सलाह दी जाती है कि reserve </कोड> बेहतर प्रदर्शन के लिए जोड़ने से पहले। और यदि आप अपने साथ वेक्टर को संयोजित कर रहे हैं, तो इसे सुरक्षित रखने में विफल रहता है, इसलिए आपको हमेशा reserve होना चाहिए।

तो मूल रूप से आपको क्या चाहिए:

template 
void Append(std::vector& a, const std::vector& b)
{
    a.reserve(a.size() + b.size());
    a.insert(a.end(), b.begin(), b.end());
}

आपको वेक्टर :: सम्मिलित का उपयोग करना चाहिए

v1.insert(v1.end(), v2.begin(), v2.end());

यदि आप मजबूत अपवाद गारंटी में रुचि रखते हैं (जब कॉपी कन्स्ट्रक्टर अपवाद फेंक सकता है):

template
inline void append_copy(std::vector& v1, const std::vector& 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;
    }
}

मजबूत गारंटी के साथ समान append_move सामान्य रूप से लागू नहीं किया जा सकता है यदि वेक्टर तत्व के चालक निर्माता फेंक सकते हैं (जो कि असंभव है लेकिन अभी भी)।

vector v1 = {1, 2, 3, 4, 5};
vector v2 = {11, 12, 13, 14, 15};
copy(v2.begin(), v2.end(), back_inserter(v1));

इसे अपनी हेडर फ़ाइल में जोड़ें:

template  vector concat(vector &a, vector &b) {
    vector ret = vector();
    copy(a.begin(), a.end(), back_inserter(ret));
    copy(b.begin(), b.end(), back_inserter(ret));
    return ret;
}

और इस तरह इसका इस्तेमाल करें:

vector a = vector();
vector b = vector();

a.push_back(1);
a.push_back(2);
b.push_back(62);

vector r = concat(a, b);

आर में [1,2,62]

श्रेणी v3 के साथ, आपके पास आलसी concatenation हो सकता है:

ranges::view::concat(v1, v2)

Demo.

यहां C ++ 11 चाल semantics का उपयोग कर एक सामान्य उद्देश्य समाधान है:

template 
std::vector concat(const std::vector& lhs, const std::vector& rhs)
{
    if (lhs.empty()) return rhs;
    if (rhs.empty()) return lhs;
    std::vector 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 
std::vector concat(std::vector&& lhs, const std::vector& rhs)
{
    lhs.insert(lhs.cend(), rhs.cbegin(), rhs.cend());
    return std::move(lhs);
}

template 
std::vector concat(const std::vector& lhs, std::vector&& rhs)
{
    rhs.insert(rhs.cbegin(), lhs.cbegin(), lhs.cend());
    return std::move(rhs);
}

template 
std::vector concat(std::vector&& lhs, std::vector&& 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);
}

ध्यान दें कि यह वेक्टर में संलग्न करें से अलग है।

यदि आप जो खोज रहे हैं वह सृजन के बाद किसी दूसरे को वेक्टर जोड़ने का एक तरीका है, vector :: insert आपकी सबसे अच्छी शर्त है, जैसा कि कई बार उत्तर दिया गया है, उदाहरण के लिए:

vector first = {13};
const vector second = {42};

first.insert(first.end(), second.cbegin(), second.cend());

Sadly there's no way to construct a const vector, 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 vectors, there may be something better available to you, if:

1. आपका वेक्टर प्राइमेटिव
शामिल है
2. आपके निहित प्राइमेटिव आकार 32-बिट या छोटे
हैं
3. आप एक const कंटेनर
चाहते हैं

यदि उपरोक्त सभी सत्य हैं, तो मैं basic_string char_type कौन सा वेक्टर में निहित आदिम के आकार से मेल खाता है। आपको अपने कोड में एक static_assert शामिल करना चाहिए इन आकारों को मान्य रखें लगातार बने रहें:

static_assert(sizeof(char32_t) == sizeof(int));

इस होल्डिंग के साथ आप बस कर सकते हैं:

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

ईमानदार होने के लिए, आप दो वैक्टरों से दूसरे वैक्टरों में तत्वों की प्रतिलिपि बनाकर दो वैक्टरों को तेजी से जोड़ सकते हैं या केवल दो वैक्टरों में से एक को जोड़ सकते हैं! यह आपके लक्ष्य पर निर्भर करता है।

Method 1: Assign new vector with its size is the sum of two original vectors' size.

vector concat_vector = vector();
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());

Concatenate के लिए एक सामान्य प्रदर्शन वृद्धि वैक्टर के आकार की जांच करना है। और बड़े के साथ छोटे को मर्ज/डालें।

//vector v1,v2;
if(v1.size()>v2.size()){
    v1.insert(v1.end(),v2.begin(),v2.end());
}else{
    v1.insert(v2.end(),v1.begin(),v1.end());
}