दिलचस्प पोस्ट
MySQL में, क्या मैं एक ही तालिका में सम्मिलित करने के लिए एक पंक्ति को कॉपी कर सकता हूँ? क्लिक पर QWidget पर आयताकार ओवरले ड्रॉ करें वेब-आईएनएफ / लिब स्वचालित रूप से एक्लिप्स / टॉमकैट पर 3 जी पार्टी जार जोड़ना बढ़ाना तर्क उस .CSS फ़ाइल के भीतर उपयोग के लिए .CSS फ़ाइल में एक वैरिएबल बनाएँ आईओएस में UIAlertview में UITextView कैसे डालें IntelliJ पर एक .jar फ़ाइल या निर्यात जार कैसे बनाएं (जैसे ग्रहण जावा संग्रह निर्यात) क्या टेम्पलेट तर्क (हस्ताक्षर) std :: function भाग का प्रकार नहीं है? क्या कोई स्पष्ट, सरल शब्दों में मुझे संग्रह का चयन कर सकता है? IFRAMEs और iPad पर सफारी, कैसे उपयोगकर्ता सामग्री स्क्रॉल कर सकते हैं? एक अनुक्रम में पहला तत्व ढूंढें जो एक निस्संदेह से मेल खाता है Concat JSON ऑब्जेक्ट्स IE8 / 9 में jQuery और XDomainRequest के साथ कॉर्स असफल मान्यकरण या अमान्य डुप्लिकेट के लिए खाली HTTP स्थिति कोड सीएसएस 'अतिप्रवाह: छिपा हुआ' काम कैसे चल तत्वों के चारों ओर लपेटने के लिए एक तत्व (चल तत्वों को युक्त) करने के लिए काम करता है?

कैसे शुरू करने के लिए 'const std :: vector <T>' एसी सरणी की तरह

क्या एक निश्चित (और छोटी) मानों की संख्या के लिए const T a[] = { ... } तरह एक const std::vector<const T> बनाने और शुरू करने का एक शानदार तरीका है?
मुझे एक फ़ंक्शन अक्सर कॉल करने की ज़रूरत है जो एक vector<T> अपेक्षा करता है, लेकिन ये मान मेरे मामले में कभी नहीं बदलेगा

सिद्धांत रूप में मैंने ऐसा कुछ सोचा था

 namespace { const std::vector<const T> v(??); } 

चूंकि वी इस संकलन इकाई के बाहर प्रयोग नहीं किया जाएगा।

वेब के समाधान से एकत्रित समाधान "कैसे शुरू करने के लिए 'const std :: vector <T>' एसी सरणी की तरह"

आपको या तो C ++ 0x के लिए इंतजार करना होगा या बूस्ट जैसा कुछ करना होगा। ऐसा करने के लिए एसेन करें

उदाहरण के लिए:

 #include <boost/assign/std/vector.hpp> using namespace boost::assign; // bring 'operator+=()' into scope vector<int> v; v += 1,2,3,4,5; 

सी ++ के लिए 11:

 vector<int> luggage_combo = { 1, 2, 3, 4, 5 }; 

यदि आप पूछ रहे हैं कि कैसे एक const सदिश शुरू करने के लिए है कि यह दिलचस्प सामग्री है, तो जवाब शायद प्रतिलिपि निर्माता का उपयोग करने के लिए है पहले आप सख्ती से सदिश को भरते हैं, फिर आप इसे अपने नए कंसेक्टर वेक्टर बनाते हैं। या आप किसी अन्य प्रकार के कंटेनर या एक सरणी से शुरू करने के लिए वेक्टर <InputIterator> (InputIterator, InputIterator) कन्स्ट्रक्टर टेम्पलेट का उपयोग कर सकते हैं। यदि कोई सरणी, तो वह प्रारंभिक सूची के साथ परिभाषित किया जा सकता था।

ऐसा कुछ उम्मीद है कि आप क्या चाहते हैं:

 const T ra[3] = {t1, t2, t3}; const vector<const T> v(ra, ra+3); 

यदि आप पूछ रहे हैं कि एक सदिश को एक समारोह में कैसे पारित करना है जो एक सदिश लेता है तो इसका उत्तर या तो होता है:

  • आप ऐसा नहीं कर सकते हैं, क्योंकि फ़ंक्शन वेक्टर को बदल सकता है और आपका ऑब्जेक्ट / रेफरेंस कॉन्स्ट्र है मूल के एक गैर-कॉस्ट की प्रतिलिपि बनाएँ, और उस में पास करें

या

  • कंसैस्ट को हटाने के लिए const_cast का प्रयोग करें ताकि इसे एक समारोह में पारित किया जा सके जो एक गैर-कंटेंट वेक्टर लेता है, लेकिन जो आप जानते हैं, वे सदिश को संशोधित नहीं करेंगे।

उत्तरार्द्ध उन चीजों में से एक है, जो सही ढंग से, किसी को भी, जो इसे चश्मे के बारे में टिप्पणी करने के लिए देखता है, और यह तथ्य कि वे कुछ भी नहीं करते हैं। यह ठीक है कि const_cast के लिए क्या है, लेकिन एक काफी मजबूत तर्क है जो कहता है कि आपको const_cast की आवश्यकता है, तो आप पहले ही खो चुके हैं।

उन दोनों चीजों (एक कंट्रोल कन्स्ट्रक्टर के साथ एक कॉन्स्ट-वेक्टर बनाकर, कन्स्ट्रक्शन को निर्वर्तित करना) को निश्चित रूप से ग़लत करना है – आपको सिर्फ एक गैर-कॉन्स्ट वेक्टर का प्रयोग करना चाहिए था। तो इनमें से अधिकतर एक को चुनें …

[संपादित करें: बस देखा गया कि आप वेक्टर <टी> और कॉन्स्ट वेक्टर <const T> के बीच अंतर के बारे में बात कर रहे हैं। दुर्भाग्य से एसटीएल में, वेक्टर <कॉन्स्ट टी> और वेक्टर <टी> पूरी तरह असंबंधित प्रकार हैं, और इन दोनों के बीच कन्वर्ट करने का एकमात्र तरीका कॉपी कर रहा है। यह वैक्टर और एरे के बीच का अंतर है – एक टी ** चुपचाप हो सकता है और सुरक्षित रूप से कॉन्स्ट टी * कॉन्स्ट * में परिवर्तित हो सकता है

लघु और गंदे तरीके (बूस्ट की सूची (जैसे) के समान)

 #include <iostream> #include <vector> #include <iterator> #include <algorithm> using namespace std; template <typename T> struct vlist_of : public vector<T> { vlist_of(const T& t) { (*this)(t); } vlist_of& operator()(const T& t) { this->push_back(t); return *this; } }; int main() { const vector<int> v = vlist_of<int>(1)(2)(3)(4)(5); copy(v.begin(), v.end(), ostream_iterator<int>(cout, "\n")); } 

अब, C ++ 11 की प्रारंभिक सूची है, इसलिए आपको ऐसा करने की आवश्यकता नहीं है या फिर बूस्ट का उपयोग करें। लेकिन, एक उदाहरण के रूप में, आप ऊपर सी + + 11 में और अधिक कुशलतापूर्वक ऐसा कर सकते हैं:

 #include <iostream> #include <vector> #include <utility> #include <ostream> using namespace std; template <typename T> struct vlist_of : public vector<T> { vlist_of(T&& t) { (*this)(move(t)); } vlist_of& operator()(T&& t) { this->push_back(move(t)); return *this; } }; int main() { const vector<int> v = vlist_of<int>(1)(2)(3)(4)(5); for (const auto& i: v) { cout << i << endl; } } 

लेकिन, यह अभी भी सफ़ेद के लिए परिभाषित नहीं है क्योंकि कोई ऑपरेटर = (vlist_of &&) नहीं है क्योंकि यह अभी भी एक C + + 11 प्रारंभिक सूची के उपयोग के रूप में कुशल नहीं है।

tjohns20 का तरीका निम्न की तरह संशोधित किया जा सकता है एक बेहतर सी ++ 11 vlist_of:

 #include <iostream> #include <vector> #include <utility> using namespace std; template <typename T> class vlist_of { public: vlist_of(T&& r) { (*this)(move(r)); } vlist_of& operator()(T&& r) { v.push_back(move(r)); return *this; } vector<T>&& operator()() { return move(v); } private: vector<T> v; }; int main() { const auto v = vlist_of<int>(1)(2)(3)(4)(5)(); for (const auto& i : v) { cout << i << endl; } } 

जैसा कि अन्य लोगों ने कहा है, आप एक सदिश को उसी तरीके से नहीं जोड़ सकते हैं, जिस तरह से आप सी-स्टाइल सरणी का प्रयोग कर सकते हैं, जब तक कि आप उसे एक स्रोत सरणी के लिए पॉइंटर्स नहीं देते। लेकिन उस स्थिति में, यदि आपका सदिश एक वैश्विक कॉन्स्ट है, तो इसके बजाय सिर्फ एक पुराने सी-स्टाइल का उपयोग क्यों न करें?

 const int MyInts[] = { 1, 2, 3, 4, 5}; const size_t NumMyInts = sizeof(MyInts)/sizeof(MyInts[0]); 

आप इस सरणी के विरुद्ध एसटीएल एल्गोरिदम का उपयोग भी कर सकते हैं, उसी तरह से आप एक सब्स वेक्टर के विरुद्ध एल्गोरिदम का प्रयोग करेंगे …

 const int* myInt = std::find( &MyInts[0], &MyInts[NumMyInts], 3); 

आप इसे दो चरणों में कर सकते हैं:

 namespace { const T s_actual_array[] = { ... }; const std::vector<const T> s_blah(s_actual_array, s_actual_array + (sizeof(s_actual_array) / sizeof(s_actual_array[0]))); } 

शायद आप के रूप में सुंदर नहीं हो सकता है, लेकिन कार्यात्मक

कैसा रहेगा:

 int ar[]={1,2,3,4,5,6}; const int TotalItems = sizeof(ar)/sizeof(ar[0]); std::vector<int> v(ar, ar+TotalItems); 

पुराने प्रश्न, लेकिन आज मैं उसी मुद्दे पर गया, यहां मेरे दृष्टिकोण के लिए सबसे अधिक स्वीकार्य दृष्टिकोण है:

 vector<int> initVector(void) { vector<int> initializer; initializer.push_back(10); initializer.push_back(13); initializer.push_back(3); return intializer; } int main() { const vector<int> a = initVector(); return 0; } 

अत्यधिक नकल से बचने के लिए उदाहरण:

 vector<int> & initVector(void) { static vector<int> initializer; if(initializer.empty()) { initializer.push_back(10); initializer.push_back(13); initializer.push_back(3); } return intializer; } int main() { const vector<int> & a = initVector(); return 0; } 

निश्चित नहीं कि मैं आपको सही समझता हूं। मैं आपके प्रश्न को इस तरह समझता हूं: आप तत्वों की एक बड़ी संख्या में वेक्टर को प्रारंभ करना चाहते हैं। सदिश पर push_back () का उपयोग करने में क्या गलत है? 🙂

यदि आप तत्वों की संख्या को संग्रहीत करने के लिए जानते हैं (या यह सुनिश्चित कर रहे हैं कि यह 2 की अगली शक्ति से कम स्टोर करेगा) आप ऐसा कर सकते हैं, यदि आपके पास प्रकार एक्स के पॉइंटर्स (पॉइंटर्स के साथ काम करता है) का एक सदिश है:

 std::vector< X* > v; v.reserve(num_elems); X* p = v.begin(); for (int count = 0; count < num_elems; count++) p[count] = some_source[count]; 

Push_back () का उपयोग करते हुए भी, 2 तत्वों की अगली शक्ति से अधिक जोड़ने का सावधान रहें अंक v.begin () के लिए तब अमान्य होगा।

यदि वे सभी एक ही हैं, तो आप ऐसा कर सकते हैं

 vector<T> vec(num_items, item); 

लेकिन मुझे लगता है कि वे नहीं हैं – जो मामले में सबसे अच्छा तरीका शायद है:

 vector<T> vec(num_items); vec[0] = 15; vec[1] = 5; ... 

सी ++ 0x आपको एक प्रारंभिक सूची का उपयोग बिल्कुल उसी तरह करेगी जिसकी आप सोच रहे हैं, लेकिन यह अभी बहुत अच्छा नहीं है, दुर्भाग्य से।

Shadow2531 की प्रतिक्रिया के आधार पर, मैं इस वर्ग का उपयोग वैक्टर को प्रारंभ करने के लिए कर रहा हूँ, बिना वास्तव में एसडीडी :: वेक्टर जैसे शैडो के समाधान से विरासत में मिली

 template <typename T> class vector_init { public: vector_init(const T& val) { vec.push_back(val); } inline vector_init& operator()(T val) { vec.push_back(val); return *this; } inline std::vector<T> end() { return vec; } private: std::vector<T> vec; }; 

उपयोग:

 std::vector<int> testVec = vector_init<int>(1)(2)(3)(4)(5).end(); 

स्टीव जेसप के समाधान के मुकाबले यह बहुत अधिक कोड बनाता है, लेकिन अगर सरणी निर्माण निष्पादन महत्वपूर्ण नहीं है, तो मुझे एक पंक्ति में एक सरणी शुरू करने का एक अच्छा तरीका मिल रहा है