वेक्टर के लिए बहुआयामी सरणी कॉपी और इसके विपरीत

Question

int dArray[1600][32]; 
vector < vector <int> > dVector; 

n= 1600; k = 32 
dVector.resize(n); 
for(int i = 0 ; i < n ; ++i){ 
dVector[i].resize(k); 
} 

std::copy (dArray, dArray + tmp_c, std::back_inserter (dVector)); 

कैसे मैं std :: प्रतिलिपि (या किसी अन्य समारोह) एक वेक्टर के लिए एक बहु आयामी सरणी कॉपी और इसके विपरीत करने के लिए प्रयोग करते हैं?

Answer 1

आप इसे सीधे नहीं कर सकते हैं, लेकिन मध्यवर्ती चरण के साथ। आपकी आवश्यकताओं के आधार पर, vector_wrapper जैसे कुछ आपके लिए काम कर सकते हैं

#include <vector> 

template<typename T, int N> struct vector_wrapper { 
    vector_wrapper(T (&a)[N]) { 
     std::copy(a, a + N, std::back_inserter(v)); 
    } 

    std::vector<T> v; 
}; 

int dArray[1600][32]; 
std::vector<vector_wrapper<int, 32> > dVector; 

int main(int argc, char **argv) 
{ 
    std::copy(dArray, dArray + 1600, std::back_inserter(dVector)); 
    return 0; 
} 

Answer 2

आपको अपना खुद का इटरेटर लिखना होगा कि, अव्यवस्था पर, एक सहायक वस्तु उत्पन्न करती है, जो असाइनमेंट पर std::copy (और विपरीत दिशा में प्रतिलिपि बनाने के लिए) के साथ एक वेक्टर में एक-आयामी सरणी प्रतिलिपि बनाता है, एक अन्य पुनरावर्तक जो करता है विलोम)। असल में, back_insert_iterator को कार्यान्वित किया गया है, और इसे बहुत अधिक करें, केवल push_back कॉल std::copy पर क्लिक करें।

व्यक्तिगत रूप से मुझे लगता है कि यह इसके लायक नहीं है। मैं बाहरी प्रतिलिपि के लिए बस for लूप का उपयोग करूंगा। आपके पास पहले से ही एक है, resize के ठीक बाद, अपने शरीर में std::copy जोड़ें।

ध्यान दें कि यदि आप resize अपने वैक्टर पहले से ही हैं, तो आपको std::back_inserter की आवश्यकता नहीं है क्योंकि यह अभी तक और अधिक संग्रहण आवंटित करेगा। इसके बजाय begin का उपयोग करें।

Answer 3

आपको मूल रूप से output iterator लिखने की आवश्यकता होगी। यह एक सा बदसूरत है, लेकिन कुछ इस तरह चाल करना चाहिए:

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

template <typename ContainerOfContainer, typename Container, std::size_t n> 
struct nested_back_inserter : public std::iterator<std::output_iterator_tag, void, 
                void, void, void> 
{ 
    std::size_t k; 
    std::size_t current_; 
    ContainerOfContainer* container_; 

    explicit nested_back_inserter(ContainerOfContainer& cont) 
    : k(0), current_(0), container_(&cont) 
    { } 

    nested_back_inserter& operator=(typename Container::value_type value) 
    { 
     if(k == n) { 
      ++current_; 
      k = 0; 
     } 
     (*container_)[current_].push_back(value); 
     ++k; 
     return *this; 
    } 

    nested_back_inserter& operator*() 
    { 
     return *this; 
    } 

    nested_back_inserter& operator++() 
    { 
     return *this; 
    } 

    nested_back_inserter& operator++(int) 
    { 
     return *this; 
    } 
}; 

int main() 
{ 
    int arr[3][3] = {{1,2,3}, {4,5,6}, {7,8,9}}; 
    std::vector<std::vector<int>> v; 

    for(unsigned i = 0; i < 3; ++i) { 
     std::vector<int> vi; 
     v.push_back(vi); 
    } 

    typedef std::vector<std::vector<int>> nested; 
    typedef std::vector<int> cont; 
    std::copy(arr[0], arr[2] + 3, nested_back_inserter<nested, cont, 3>(v)); 

    for(auto it = v.begin(); it != v.end(); ++it) { 
     std::cout << "{"; 
     for(auto it2 = it->begin(); it2 != it->end(); ++it2) { 
       std::cout << *it2 << ", "; 
     } 
     std::cout << "}\n"; 
    } 

    return 0; 
} 

नोट std::copy(arr[0], arr[2] + 3, ...); में विशेष रूप से uglyness।

थकावट के कारण, मैं किसी भी एक-एक-एक त्रुटि या अन्य विषमता के लिए कोई जिम्मेदारी नहीं लेता जो इसके साथ हो सकता है। यह आपको इस तरह के कुछ को कार्यान्वित करने का विचार देना चाहिए।