मैं एसटीएल सूची में सरणी कैसे स्टोर करूं?

Question

सी ++ और एसटीएल का उपयोग करते हुए, क्या कोई जानता है कि एक एसटीएल सूची या वेक्टर में नोड्स के रूप में पूर्णांक सरणी को कैसे स्टोर किया जाए? मेरे पास संख्याओं के जोड़े की अज्ञात संख्या है जिन्हें मुझे स्टोर करने की आवश्यकता है, और अन्य भाषाओं से आना मेरा पहला विचार किसी प्रकार की सूची का उपयोग करना था- या वेक्टर जैसी डेटा संरचना ... लेकिन मैं कुछ परेशानी में भाग रहा हूं। मुझे 100% यकीन है कि मैं एक स्पष्ट शुरुआत करने वाला सी ++ गलती कर रहा हूं, और कोई भी जो वास्तव में भाषा जानता है, वह एक नजर डालेगा जो मैं करने की कोशिश कर रहा हूं और मुझे सीधे सेट करने में सक्षम हूं।

तो, मैंने जो कोशिश की है वह यहां है। एक सूची की घोषणा तो काम करता है जैसे:

stl::list<int[2]> my_list; 

और फिर मैं आसानी से ऐसा तरह एक दो तत्व सरणी बना सकते हैं,:

int foo[2] = {1,2}; 

यह संकलित करता है तथा ठीक चलाता है। हालांकि, जैसे ही मैं अपने सूची में foo जोड़ने के लिए है, तो तरह की कोशिश के रूप में:

my_list.push_back(foo); 

मैं संकलक त्रुटियों, जिनमें से कोई भी मैं सच में समझ में (मेरी सी ++ की एक पूरी ऐंठा हुआ सेट प्राप्त - फू लगभग न के बराबर है):

/usr/include/c++/4.0.0/ext/new_allocator.h: In member function ‘void __gnu_cxx::new_allocator<_Tp>::construct(_Tp*, const _Tp&) [with _Tp = int [2]]’: 
/usr/include/c++/4.0.0/bits/stl_list.h:440: instantiated from ‘std::_List_node<_Tp>* std::list<_Tp, _Alloc>::_M_create_node(const _Tp&) [with _Tp = int [2], _Alloc = std::allocator<int [2]>]’ 
/usr/include/c++/4.0.0/bits/stl_list.h:1151: instantiated from ‘void std::list<_Tp, _Alloc>::_M_insert(std::_List_iterator<_Tp>, const _Tp&) [with _Tp = int [2], _Alloc = std::allocator<int [2]>]’ 
/usr/include/c++/4.0.0/bits/stl_list.h:773: instantiated from ‘void std::list<_Tp, _Alloc>::push_back(const _Tp&) [with _Tp = int [2], _Alloc = std::allocator<int [2]>]’ 
test.cpp:5: instantiated from here 
/usr/include/c++/4.0.0/ext/new_allocator.h:104: error: ISO C++ forbids initialization in array new 

तो, किसी के पास विचार है कि मैं यहां क्या गलत कर रहा हूं? कोई पॉइंटर्स (कोई इरादा नहीं है) सबसे उपयोगी होगा। क्या std :: सूची में सरणी स्टोर करना संभव नहीं है? क्या मुझे एक संरचना का उपयोग करना चाहिए? क्या मुझे बस * या & कहीं याद आ रहा है?

Answer 1

आप एसटीएल कंटेनरों में सरणियों की दुकान नहीं कर सकते हैं। आप सामान्य मामले के लिए वेक्टर के एक वेक्टर या somesuch का उपयोग करेंगे। आपके विशिष्ट मामले के लिए, मैं std :: जोड़ी के वेक्टर का उपयोग करता हूं, जैसे: std::vector<std::pair<int, int> >। std::pair एक वर्ग है जिसमें दो सदस्य हैं, first और second, जो भी प्रकार आप इसे टेम्पलेट करते हैं।

संपादित करें: मूल रूप से यह std::vector<std::pair<int> > के रूप में था, लेकिन मुझे यकीन नहीं था कि अगर यह दोनों प्रकार समान हैं तो केवल 1 पैरामीटर स्वीकार करने के लिए अधिभारित किया गया था ... थोड़ा खोदने से इसका कोई सबूत नहीं निकला, इसलिए मैंने इसे स्पष्ट रूप से यह बताने के लिए संशोधित किया कि first और secondint एस हैं।

Answer 2

मानक लाइब्रेरी कंटेनर में संग्रहीत चीज असाइन करने योग्य और कॉपी करने योग्य होनी चाहिए - सरणी न तो हैं। आपकी सबसे अच्छी शर्त std :: वेक्टर की एक सूची बनाना है। वैकल्पिक रूप से, आप एक struct में सरणी लपेट कर सकते हैं:

struct A { 
    int array[2]; 
}; 

std::list <A> alist; 

Answer 3

यह "क्लासिक" सी-स्टाइल सरणी के बजाय boost::array का उपयोग करने के लिए एक अच्छी स्थिति है। यह काम करना चाहिए:

std::list<boost::array<int,2> > my_list; 
boost::array<int,2> foo={{1,2}}; 
my_list.push_back(foo); 

Answer 4

मैं तुम्हें इस मामले में मान संग्रहीत करने के लिए std :: जोड़ी का उपयोग सुझाव देना चाहेंगे। यह
<utility> में स्थित है।

आप सूची में सरणी को पॉइंटर्स स्टोर कर सकते हैं लेकिन फिर आपको सभी मेमोरी प्रबंधन से निपटना होगा। जोड़ी का उपयोग करना बहुत आसान है यदि मूल्यों के जोड़े आपको चाहिए।

Answer 5

सी ++ 11 के रूप में, हम मानक std::array के साथ ऐसा कर सकते हैं:

#include <array> 
#include <list> 
#include <iostream> 

int main() { 
    std::list<std::array<int, 2>> l {{3,4},{5,6}}; 
    l.push_back({1,2}); 

    for (const auto &arr : l) 
     for (const auto &v : arr) 
      std::cout << v << ' '; 
} 

या

l.push_back({{1,2}}); 

आदि कुछ बजना चेतावनी मौन करने।

आउटपुट:

3 4 5 6 1 2 

Answer 6

के साथ सी ++ 11 है एक ::std::array wrapper उपलब्ध है जो इस तरह मानक कंटेनर के साथ इस्तेमाल किया जा सकता:

#include <array> 
#include <iostream> 
#include <list> 
#include <cstdint> 

int 
main() 
{ 
    using t_Buffer = ::std::array<::std::int32_t, 2>; 
    using t_Buffers = ::std::list<t_Buffer>; 
    t_Buffers buffers; 
    buffers.emplace_back(t_Buffer{1, 2}); 
    ::std::cout << buffers.front()[0] << " " << buffers.front()[1] << ::std::endl; 
    return(0); 
} 

Run this code online