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




vector stl (10)

आपको vector::insert उपयोग करना चाहिए

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

मैं दो std::vector एस को कैसे जोड़ूं?


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

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

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

vector<int> a = vector<int>();
vector<int> b = vector<int>();

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

vector<int> r = concat(a, b);

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



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

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

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

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

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

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

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

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

template<typename T>
inline void append_copy(std::vector<T>& v1, const std::vector<T>& 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 सामान्य रूप से लागू नहीं किया जा सकता है यदि वेक्टर तत्व के append_move कन्स्ट्रक्टर फेंक सकता है (जो कि असंभव है लेकिन अभी भी)।


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

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

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

  return 0;
}

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

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

int main(int argc, char** argv) {
  std::vector<std::vector<int>> dest{{1,2,3,4,5}, {3,4}};
  std::vector<std::vector<int>> 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 के बजाय कुछ उपयोग कर सकते हैं।


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

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

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


std::vector<int> first;
std::vector<int> second;

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

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






stdvector