दिलचस्प पोस्ट
कैसे जावा में एक प्रक्रिया बनाने के लिए लॉगरिदमिक स्केल के साथ सेट टिक्स क्रॉन का विंडोज संस्करण क्या है? JSON डेटा से JSON स्कीमा उत्पन्न करने के लिए उपकरण सीएसएस संक्रमण के दौरान वेबकिट टेक्स्ट रेंडरिंग बदलाव को रोकने के लिए पायथन कचरा कलेक्टर दस्तावेज़ कैसे malloc () आंतरिक रूप से लागू किया जाता है? क्या आप जावास्क्रिप्ट के साथ जीआईएफ एनिमेशन नियंत्रित कर सकते हैं? गतिशील रूप से चमकदार पृष्ठ का उपयोग करके वेब पेज पर प्लॉट जोड़ें स्विफ्ट में "इंडेक्स रेंज से बाहर" कैसे पकड़ सकता हूं? ग्रुप द्वारा गठबंधन / एक कॉलम को संरेखित करें जावा: यदि ए का विस्तार बी और बी ऑब्जेक्ट फैलता है, तो यह एकाधिक विरासत है ऐसे फाइल को लोड नहीं कर सकता – rvm pkg install zlib का उपयोग करने के बाद भी zlib Nvarchar (अधिकतम) के लिए मैं केवल TSQL में 4000 अक्षर मिल रहा है? एंड्रॉइड एप्लिकेशन का पैकेज नाम कैसे बदलना है

हार्डकोड तत्वों के साथ std :: vector को प्रारंभ करने का सबसे आसान तरीका क्या है?

मैं एक सरणी बना सकता हूं और इसे इस तरह प्रारंभ कर सकता हूं:

int a[] = {10, 20, 30}; 

मैं कैसे एक std::vector बना सकता हूँ और इसे समान रूप से सुरुचिपूर्ण रूप से प्रारंभ कर सकता हूं?

सबसे अच्छा तरीका मुझे पता है:

 std::vector<int> ints; ints.push_back(10); ints.push_back(20); ints.push_back(30); 

क्या कोई बेहतर तरीका है?

वेब के समाधान से एकत्रित समाधान "हार्डकोड तत्वों के साथ std :: vector को प्रारंभ करने का सबसे आसान तरीका क्या है?"

एक विधि वेक्टर को इनिशियलाइज़ करने के लिए सरणी का उपयोग करना होगा

 static const int arr[] = {16,2,77,29}; vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) ); 

यदि आपका कंपाइलर सी ++ 11 का समर्थन करता है, तो आप बस ऐसा कर सकते हैं:

 std::vector<int> v = {1, 2, 3, 4}; 

यह संस्करण 4.4 के अनुसार जीसीसी में उपलब्ध है। दुर्भाग्य से, इस संबंध में वीसी ++ 2010 पीछे पीछे हो रहा है।

वैकल्पिक रूप से, बूस्ट.एस्साइन लाइब्रेरी मैक्रो मैजिक का उपयोग करने के लिए निम्नलिखित की अनुमति देता है:

 #include <boost/assign/list_of.hpp> ... std::vector<int> v = boost::assign::list_of(1)(2)(3)(4); 

या:

 #include <boost/assign/std/vector.hpp> using namespace boost::assign; ... std::vector<int> v; v += 1, 2, 3, 4; 

लेकिन ध्यान रखें कि इसके कुछ ओवरहेड हैं (मूल रूप से, list_of ने list_of std::deque को हुड के तहत बनाया है) इसलिए प्रदर्शन-महत्वपूर्ण कोड के लिए आप बेहतर करना चाहते हैं क्योंकि यॅकी कहती हैं

सी ++ 0x में आप इसे उसी तरीके से करने में समर्थ होंगे जो आपने एक सरणी के साथ किया था, लेकिन वर्तमान मानक में नहीं।

केवल भाषा समर्थन के साथ आप इसका उपयोग कर सकते हैं:

 int tmp[] = { 10, 20, 30 }; std::vector<int> v( tmp, tmp+3 ); // use some utility to avoid hardcoding the size here 

यदि आप अन्य पुस्तकालयों को जोड़ सकते हैं तो आप बढ़ावा दे सकते हैं: असाइनमेंट:

 vector<int> v = list_of(10)(20)(30); 

सरणी का आकार हार्डकोडिंग से बचने के लिए:

 // option 1, typesafe, not a compile time constant template <typename T, std::size_t N> inline std::size_t size_of_array( T (&)[N] ) { return N; } // option 2, not typesafe, compile time constant #define ARRAY_SIZE(x) (sizeof(x) / sizeof(x[0])) // option 3, typesafe, compile time constant template <typename T, std::size_t N> char (&sizeof_array( T(&)[N] ))[N]; // declared, undefined #define ARRAY_SIZE(x) sizeof(sizeof_array(x)) 

बस सोचा कि मैं अपने $ 0.02 में टॉस होगा मैं यह घोषणा करता हूं:

 template< typename T, size_t N > std::vector<T> makeVector( const T (&data)[N] ) { return std::vector<T>(data, data+N); } 

किसी यूटिलिटी हैडर में कहीं और फिर सभी की आवश्यकता है:

 const double values[] = { 2.0, 1.0, 42.0, -7 }; std::vector<double> array = makeVector(values); 

लेकिन मैं सी ++ 0x के लिए इंतजार नहीं कर सकता मैं फँस गया हूँ क्योंकि मेरा कोड भी विजुअल स्टूडियो में संकलित होना चाहिए। बू।

सी ++ 11 में:

 #include <vector> using std::vector; ... vector<int> vec1 { 10, 20, 30 }; // or vector<int> vec2 = { 10, 20, 30 }; 

बूस्ट सूची का उपयोग करना:

 #include <vector> #include <boost/assign/list_of.hpp> using std::vector; ... vector<int> vec = boost::assign::list_of(10)(20)(30); 

बढ़ावा आवंटन का उपयोग करना:

 #include <vector> #include <boost/assign/std/vector.hpp> using std::vector; ... vector<int> vec; vec += 10, 20, 30; 

पारंपरिक एसटीएल:

 #include <vector> using std::vector; ... static const int arr[] = {10,20,30}; vector<int> vec (arr, arr + sizeof(arr) / sizeof(arr[0]) ); 

सामान्य मैक्रोज़ के साथ परम्परागत एसटीएल:

 #include <vector> #define ARRAY_SIZE(ar) (sizeof(ar) / sizeof(ar[0]) #define ARRAY_END(ar) (ar + ARRAY_SIZE(ar)) using std::vector; ... static const int arr[] = {10,20,30}; vector<int> vec (arr, ARRAY_END(arr)); 

एक वेक्टर प्रारंभिक मैक्रो के साथ पारंपरिक एसटीएल:

 #include <vector> #define INIT_FROM_ARRAY(ar) (ar, ar + sizeof(ar) / sizeof(ar[0]) using std::vector; ... static const int arr[] = {10,20,30}; vector<int> vec INIT_FROM_ARRAY(arr); 

सी ++ 11 से पहले:

विधि 1 =>

 vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0])); vector<int>v; 

विधि 2 =>

  v.push_back(SomeValue); 

नीचे सी +11 आगे भी संभव है

 vector<int>v = {1, 3, 5, 7}; 

के साथ शुरू:

 int a[] = {10, 20, 30}; //i'm assuming a is just a placeholder 

यदि आपके पास सी ++ 11 कंपाइलर नहीं है और आप बढ़ावा देने का उपयोग नहीं करना चाहते हैं:

 const int a[] = {10, 20, 30}; const std::vector<int> ints(a,a+sizeof(a)/sizeof(int)); //make it const if you can 

यदि आपके पास कोई C ++ 11 संकलक नहीं है और बढ़ावा दे सकता है:

 #include <boost/assign.hpp> const std::vector<int> ints = boost::assign::list_of(10)(20)(30); 

यदि आपके पास सी ++ 11 कंपाइलर है:

 const std::vector<int> ints = {10,20,30}; 

ऐसा करने का सबसे आसान तरीका यह है:

 vector<int> ints = {10, 20, 30}; 

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

 #define INIT_VECTOR(type, name, ...) \ static const type name##_a[] = __VA_ARGS__; \ vector<type> name(name##_a, name##_a + sizeof(name##_a) / sizeof(*name##_a)) 

इस मैक्रो के साथ, आप इस तरह से कोड के साथ एक प्रारंभिक वेक्टर को परिभाषित कर सकते हैं:

 INIT_VECTOR(int, my_vector, {1, 2, 3, 4}); 

यह 1, 2, 3, 4 के तत्वों के साथ my_vector नामक इनट के एक नए सदिश का निर्माण करेगा।

यदि आप बढ़ावा देने के लिए उपयोग नहीं करना चाहते हैं, लेकिन जैसे वाक्यविन्यास का आनंद लेना चाहते हैं

 std::vector<int> v; v+=1,2,3,4,5; 

बस कोड का यह हिस्सा शामिल करें

 template <class T> class vector_inserter{ public: std::vector<T>& v; vector_inserter(std::vector<T>& v):v(v){} vector_inserter& operator,(const T& val){v.push_back(val);return *this;} }; template <class T> vector_inserter<T> operator+=(std::vector<T>& v,const T& x){ return vector_inserter<T>(v),x; } 

आप बढ़ावा कर सकते हैं:

 vector<int> values; values += 1,2,3,4,5,6,7,8,9; 

यहाँ विस्तार

सी ++ 11 में:

 static const int a[] = {10, 20, 30}; vector<int> vec (begin(a), end(a)); 

मैं अपना स्वयं का समाधान va_arg का उपयोग कर रहा va_arg यह समाधान C98 अनुरूप है

 #include <cstdarg> #include <iostream> #include <vector> template <typename T> std::vector<T> initVector (int len, ...) { std::vector<T> v; va_list vl; va_start(vl, len); for (int i = 0; i < len; ++i) v.push_back(va_arg(vl, T)); va_end(vl); return v; } int main () { std::vector<int> v = initVector<int> (7,702,422,631,834,892,104,772); for (std::vector<int>::const_iterator it = v.begin() ; it != v.end(); ++it) std::cout << *it << std::endl; return 0; } 

डेमो

एक और हालिया डुप्लिकेट प्रश्न का उत्तर विक्टर एसहर से है मेरे लिए, यह कॉम्पैक्ट, नेत्रहीन अपील (जैसा लगता है कि आप मूल्यों को 'हिलाना' हैं), को c ++ 11 या तीसरे पक्ष के मॉड्यूल की आवश्यकता नहीं है, और अतिरिक्त (लिखित) चर का उपयोग करने से बचा जाता है नीचे मैं इसे कुछ बदलावों के साथ प्रयोग कर रहा हूं। मैं भविष्य के इंटिड में वेक्टर और / या वीएआरएग के फ़ंक्शन का विस्तार करने के लिए स्विच कर सकता हूं।


 // Based on answer by "Viktor Sehr" on Stack Overflow // https://stackoverflow.com/a/8907356 // template <typename T> class mkvec { public: typedef mkvec<T> my_type; my_type& operator<< (const T& val) { data_.push_back(val); return *this; } my_type& operator<< (const std::vector<T>& inVector) { this->data_.reserve(this->data_.size() + inVector.size()); this->data_.insert(this->data_.end(), inVector.begin(), inVector.end()); return *this; } operator std::vector<T>() const { return data_; } private: std::vector<T> data_; }; std::vector<int32_t> vec1; std::vector<int32_t> vec2; vec1 = mkvec<int32_t>() << 5 << 8 << 19 << 79; // vec1 = (5,8,19,79) vec2 = mkvec<int32_t>() << 1 << 2 << 3 << vec1 << 10 << 11 << 12; // vec2 = (1,2,3,5,8,19,79,10,11,12) 

वेक्टर आरंभीकरण के लिए –

 vector<int> v = {10,20,30} 

अगर आपके पास सी ++ 11 कंपाइलर है तो क्या किया जा सकता है

वरना, आप डेटा की एक सरणी बना सकते हैं और फिर लूप का उपयोग कर सकते हैं।

 int array[] = {10,20,30} for(int i=0; i<sizeof(array); i++) v.push_back(array[i]); 

इन के अलावा, कुछ कोड का उपयोग करने के ऊपर वर्णित कई अन्य तरीके हैं। मेरी राय में, इन तरीकों को याद रखना आसान है और लिखने के लिए त्वरित

नीचे दिए गए तरीकों का उपयोग सदिश को सी ++ में आरंभ करने के लिए किया जा सकता है

  1. int arr[] = {1, 3, 5, 6}; vector<int> v(arr, arr + sizeof(arr)/sizeof(arr[0]));

  2. vector<int>v; v.push_back(1); v.push_back(2); v.push_back(3); और इसी तरह

  3. vector<int>v = {1, 3, 5, 7};

तीसरे को केवल C ++ 11 के बाद ही अनुमति दी जाती है।

यदि आप बूस्ट :: पर निर्भरता के बिना बूस्ट :: असाइन किए गए एक ही सामान्य आदेश पर कुछ चाहते हैं, तो निम्न में कम से कम अस्पष्ट समान है:

 template<class T> class make_vector { std::vector<T> data; public: make_vector(T const &val) { data.push_back(val); } make_vector<T> &operator,(T const &t) { data.push_back(t); return *this; } operator std::vector<T>() { return data; } }; template<class T> make_vector<T> makeVect(T const &t) { return make_vector<T>(t); } 

हालांकि मैं चाहता हूं कि यह उपयोग करने के लिए वाक्यविन्यास साफ था, यह अभी भी विशेष रूप से भयानक नहीं है:

 std::vector<int> x = (makeVect(1), 2, 3, 4); 
 typedef std::vector<int> arr; arr a {10, 20, 30}; // This would be how you initialize while defining 

उपयोग संकलित करने के लिए:

 clang++ -std=c++11 -stdlib=libc++ <filename.cpp> 

यहां बहुत सारे अच्छे उत्तर दिए गए हैं, लेकिन जब से मैं इसे पढ़ने से पहले अपने आप में स्वतंत्र रूप से पहुंचा, मुझे लगा कि मैं यहाँ भी मेरे ऊपर टॉस करूँगा …

यहाँ एक ऐसी विधि है जिसका उपयोग मैं इसके लिए कर रहा हूं जो कि कम्पाइलर और प्लेटफार्मों पर सार्वभौमिक रूप से कार्य करेगा:

वस्तुओं के अपने संग्रह के लिए एक कंटेनर के रूप में एक स्ट्रेट या क्लास बनाएं << के लिए एक ऑपरेटर अधिभार समारोह को परिभाषित करें

 class MyObject; struct MyObjectList { std::list<MyObject> objects; MyObjectList& operator<<( const MyObject o ) { objects.push_back( o ); return *this; } }; 

आप फ़ंक्शंस बना सकते हैं जो आपके स्ट्रेट को पैरामीटर के रूप में लेते हैं, उदाहरण के लिए:

 someFunc( MyObjectList &objects ); 

फिर, आप उस फ़ंक्शन को इस तरह कॉल कर सकते हैं:

 someFunc( MyObjectList() << MyObject(1) << MyObject(2) << MyObject(3) ); 

इस प्रकार, आप एक सिंगल क्लीन लाइन में किसी फ़ंक्शन में ऑब्जेक्ट्स का डायनामिक आकार के संग्रह का निर्माण और पास कर सकते हैं!

 // Before C++11 // I used following methods: // 1. int A[] = {10, 20, 30}; // original array A unsigned sizeOfA = sizeof(A)/sizeof(A[0]); // calculate the number of elements // declare vector vArrayA, std::vector<int> vArrayA(sizeOfA); // make room for all // array A integers // and initialize them to 0 for(unsigned i=0; i<sizeOfA; i++) vArrayA[i] = A[i]; // initialize vector vArrayA //2. int B[] = {40, 50, 60, 70}; // original array B std::vector<int> vArrayB; // declare vector vArrayB for (unsigned i=0; i<sizeof(B)/sizeof(B[0]); i++) vArrayB.push_back(B[i]); // initialize vArrayB //3. int C[] = {1, 2, 3, 4}; // original array C std::vector<int> vArrayC; // create an empty vector vArrayC vArrayC.resize(sizeof(C)/sizeof(C[0])); // enlarging the number of // contained elements for (unsigned i=0; i<sizeof(C)/sizeof(C[0]); i++) vArrayC.at(i) = C[i]; // initialize vArrayC // A Note: // Above methods will work well for complex arrays // with structures as its elements. 

मैंने देखा कि अगर सरणी है:

 int arr[] = {1, 2, 3}; int len = sizeof(arr) // sizeof(arr[0]); // finding length of array vector < int > v; std:: v.assign(arr, arr+len); // assigning elements from array to vector 

"मैं एक एसटीएल वेक्टर कैसे बनाऊं और इसके ऊपर की तरह इनिशियलाइज़ करूँ? न्यूनतम टाइपिंग प्रयास के साथ ऐसा करने का सबसे अच्छा तरीका क्या है?"

सदिश को प्रारंभ करने का सबसे आसान तरीका है क्योंकि आपने अपने अंतर्निहित सरणी को आरम्भ किया है, प्रारंभिक सूची का उपयोग कर रहा है जिसे सी ++ 11 में पेश किया गया था

 // Initializing a vector that holds 2 elements of type int. Initializing: std::vector<int> ivec = {10, 20}; // The push_back function is more of a form of assignment with the exception of course //that it doesn't obliterate the value of the object it's being called on. Assigning ivec.push_back(30); 

आइसीवीसी (लेबल वाला कथन) निष्पादित होने के बाद आकार में 3 तत्व हैं।

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

 #define VECTOR(first,...) \ ([](){ \ static const decltype(first) arr[] = { first,__VA_ARGS__ }; \ std::vector<decltype(first)> ret(arr, arr + sizeof(arr) / sizeof(*arr)); \ return ret;})() 

उदाहरण फ़ंक्शन

 template<typename T> void test(std::vector<T>& values) { for(T value : values) std::cout<<value<<std::endl; } 

उदाहरण का उपयोग करें

 test(VECTOR(1.2f,2,3,4,5,6)); 

यद्यपि decltype के बारे में सावधान रहें, सुनिश्चित करें कि पहला मान स्पष्ट रूप से आप क्या चाहते हैं

बी। Stroustrup 16.2.10 में चेन ऑपरेशन के लिए एक अच्छा तरीका का वर्णन करता है पृष्ठ 464 पर आत्मनिर्धारित कार्यक्रम के सी +11 संस्करण में। लैंग। जहां एक फ़ंक्शन एक संदर्भ देता है, यहां एक वेक्टर में संशोधित किया गया है। इस तरह आप v.pb(1).pb(2).pb(3); जैसी चेन कर सकते हैं v.pb(1).pb(2).pb(3); लेकिन ऐसे छोटे लाभों के लिए बहुत ज्यादा काम हो सकते हैं।

 #include <iostream> #include <vector> template<typename T> class chain { private: std::vector<T> _v; public: chain& pb(T a) { _v.push_back(a); return *this; }; std::vector<T> get() { return _v; }; }; using namespace std; int main(int argc, char const *argv[]) { chain<int> v{}; v.pb(1).pb(2).pb(3); for (auto& i : v.get()) { cout << i << endl; } return 0; } 

1
2
3