दो 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());
}

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);
}

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