एसटीडी को शुरू करने का सबसे आसान तरीका क्या है :: हार्डकोड तत्वों के साथ वेक्टर?

Question

मैं एक सरणी बना सकता हूं और इसे इस तरह से शुरू कर सकता हूं:

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

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

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

std::vector<int> ints;

ints.push_back(10);
ints.push_back(20);
ints.push_back(30);

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

Comments

यदि आप आरंभीकरण के बाद ints के आकार को बदलने नहीं जा रहे हैं, तो tr1 सरणी का उपयोग करने पर विचार करें।

— zr

@zr, आपने मुझे उत्सुक किया है ... अगर मुझे निश्चित आकार की आवश्यकता है, तो क्या मैं स्वयं सादे पुराने सरणियों का उपयोग नहीं कर सकता हूं? अभी tr1 एरे को देखते हुए ...

— एगेल कुरियन

tr1::arrayयह उपयोगी है क्योंकि साधारण सरणियाँ STL कंटेनरों का इंटरफ़ेस प्रदान नहीं करती हैं

— मैनुअल

इसे स्पष्ट रूप से C ++ 03 प्रश्न बनाने के लिए शीर्षक को बदला गया। नए मानक C ++ के साथ समझ बनाने के लिए सभी उत्तरों को ठीक करने और तय करने की तुलना में यह आसान था।

— TED

इसे सूची आरंभीकरण कहा जाता है ।

— एलन डॉकिंस

Answer 1

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

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

Comments

@ एग्नेल यह बिना staticया उसके ठीक काम करेगा const, लेकिन वे दोनों इसे अधिक स्पष्ट करते हैं कि इसका उपयोग कैसे किया जाए और कंपाइलर को अतिरिक्त अनुकूलन करने की अनुमति दी जाए।

— याकूब

मैंने इसे कम नहीं किया, लेकिन मुझे लुभाया गया। मुख्य रूप से क्योंकि यह आपको पहले स्थान पर आरंभीकृत सरणी का उपयोग करके लगभग कुछ भी नहीं बचाता है। हालाँकि, यह वास्तव में C ++ की गलती है, आपकी नहीं।

— TED

क्या आप बता सकते हैं कि आप vec वेक्टर को परिभाषित करते समय उन मापदंडों का उपयोग क्यों कर रहे हैं।

— डोमएक्स

sizeof (सरणी) कुछ अपवादों में से एक है जो सरणी के तत्वों के कुल आकार को प्राप्त करने की अनुमति देता है और न ही गिरफ्तारी सूचक आयाम। तो मूल रूप से वह वेक्टर (pointer_to_first_element, pointer_to_first_element + size_in_bytes_of_the_whole_array / size_of_one_element) का उपयोग कर रहा है, वह है: वेक्टर (pointer_to_first_element, pointer_after_final_element)। प्रकार पहले से ही <int> के साथ दिया गया है, इसलिए वेक्टर जानता है कि एक तत्व कितना है। याद रखें कि पुनरावृत्तियों को पॉइंटर्स के रूप में माना जा सकता है, इसलिए आप मूल रूप से वेक्टर का उपयोग कर रहे हैं (पुनरावृत्ति शुरू, पुनरावृत्त अंत) कंस्ट्रक्टर

— जॉनी पॉलिंग

@ टेड: कभी-कभी आपको परिणामी वेक्टर को संशोधित करने की आवश्यकता होती है। उदाहरण के लिए, आपको हमेशा कुछ डिफ़ॉल्ट पैरामीटर रखने की आवश्यकता हो सकती है और कभी-कभी उनमें कुछ अनुकूलित भी जोड़ सकते हैं।

— DarkWanderer

Answer 2

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

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

यह संस्करण 4.4 के रूप में जीसीसी में उपलब्ध है । दुर्भाग्य से, VC ++ 2010 इस संबंध में पिछड़ता नजर आ रहा है।

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

#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निर्माण std::dequeकरता है) इसलिए प्रदर्शन-महत्वपूर्ण कोड के लिए आप बेहतर कर रहे हैं जैसा कि यकोबी कहते हैं।

Comments

चूंकि वैक्टर स्व-आकार वाले होते हैं, क्या इसे भी खाली करना ठीक होगा? कंस्ट्रक्टर में पसंद है this->vect = {};:?

— अज़र्सपॉट

@ अज़र्सपॉट आप इसे केवल इनिशियलाइज़ कर सकते हैं, और यह खाली हो जाएगा:std::vector<T> vector;

— ल्यूक

बस किसी के बारे में उत्सुक हो सकता है std::vector<int> v = {1, 2, 3, 4};, वेक्टर initializer list constructorको इस तरह के इनिशियलाइज़ेशन के लिए बुलाया जाएगा, इसका डॉक C++ 11अनुभाग में पाया जा सकता है ।

— सिमो

Answer 3

यदि आप आधुनिक C ++ [11,14,17, ...] का उपयोग कर सकते हैं:

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

एक चर-लंबाई सरणी पर लूपिंग का पुराना तरीका या sizeof()वास्तव में आंखों पर भयानक है और मानसिक उपरि के संदर्भ में पूरी तरह से अनावश्यक है। छी।

Comments

निष्पक्षता में, यह मूल रूप से C ++ 03 प्रश्न था, लेकिन मुझे आशा है कि लोग / कंपनियां नए मानकों को अपनाते हैं। C ++ को अभी भी मानक पुस्तकालय में वैरिएबल-लेंथ सरणी (VLA) के कार्यान्वयन की आवश्यकता है जो कि Eigen और Boost में उपलब्ध है।

— एडम एरिकसन

दुर्भाग्य से, यह दृष्टिकोण कुछ मामलों में समस्याग्रस्त है, जैसे open-std.org/jtc1/sc22/wg21/docs/cwg_defects.html#1467 । छी।

— लाइटनेस दौड़ ऑर्बिट में

यदि "एक ही प्रकार की वस्तु से किसी कुल की सूची-आरंभीकरण" आपकी बात है, तो शायद आपके कोडबेस में बड़ी समस्याएं हैं ... मैं बिना किसी एप्लिकेशन के विचार कर सकता हूं कि यह डिबगिंग समस्याओं को कहां तक ​​उचित ठहराएगा।

— एडम एरिकसन

Answer 4

C ++ 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))

Comments

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

— मैनुअल

@ मैनुअल, सरणी का आकार प्रकार का हिस्सा है, और जैसे कि यह एक संकलन समय स्थिर है। अब, विकल्प 1 एक फ़ंक्शन के लिए वापसी मान के रूप में समय संकलन 'एन' का उपयोग करता है। किसी फ़ंक्शन की वापसी एक संकलित समय नहीं है, लेकिन रनटाइम मूल्य, भले ही यह संभवतः कॉल के स्थान पर निरंतर मान के रूप में इनबिल्ड हो जाएगा। अंतर यह है कि आप ऐसा नहीं कर सकते: int another[size_of_array(array)]जबकि आप कर सकते हैं int another[ARRAY_SIZE(array)]।

— डेविड रोड्रिगेज -

विकल्प 3 में: मुझे वास्तव में वह नहीं मिला, जिसका अर्थ है "घोषित, अपरिभाषित"? तो चर अतिरिक्त मेमोरी नहीं ले जाएगा?

— 1

@ To1ne जो वास्तव में एक फ़ंक्शन डिक्लेरेशन है, न कि एक चर। इसे परिभाषित करने या परिभाषित करने का कारण यह है कि हम वास्तव में sizeofअभिव्यक्ति के अलावा किसी अन्य चीज के लिए फ़ंक्शन नहीं चाहते हैं, जिसे परिभाषा की आवश्यकता नहीं है। जब आप वास्तव में एक परिभाषा प्रदान कर सकते हैं, तो इसे सही करने के लिए एक सरणी के स्थैतिक आवंटन की आवश्यकता होगी और इसके लिए एक संदर्भ वापस करना होगा, और अगला प्रश्न यह होगा कि सरणी के लिए मानों का क्या मतलब होगा? (यह भी ध्यान दें कि इसका मतलब है कि फ़ंक्शन के इंस्टेंसेस के प्रकार / आकार संयोजन के लिए एक सरणी!) चूंकि इसके लिए कोई समझदार उपयोग नहीं है, इसलिए मैं इससे बचना चाहूंगा।

— डेविड रॉड्रिग्ज - dribeas

@ एम्एचडी: आप भाषा में एक खाली सरणी का निर्माण नहीं कर सकते। 'int arr [0] = {};' C ++ कोड मान्य नहीं है। लेकिन आप सही हैं कि यदि आप एक खाली वेक्टर और एक गैर-खाली वेक्टर को शुरू करना चाहते हैं, तो आपको विभिन्न निर्माणों का उपयोग करना होगा। C ++ 11 के बाद से यह एक गैर-मुद्दा है क्योंकि आप इनिशियलाइज़र सूची के निर्माता का उपयोग कर सकते हैं

— डेविड रॉड्रिग्ज़ - dribeas

Answer 5

C ++ 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));

एक वेक्टर इनिलाइज़र मैक्रो के साथ पारंपरिक STL:

#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);

Comments

C ++ 11 भी समर्थन करता है std::beginऔर std::endसरणी के लिए, इसलिए एक वेक्टर को भी आरंभीकृत किया जा सकता है static const int arr[] = {10,20,30}; vector<int> vec(begin(arr), end(arr));।

— जेजे

Answer 6

बस मैंने सोचा था कि मैं अपने $ 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);

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

Comments

इस तकनीक का उपयोग टाइप किए गए आकार के साथ एक सरणी को स्वीकार करने के लिए एक फ़ंक्शन को अधिभार करने के लिए भी किया जा सकता है।

— एंड्रेस रिओप्रियो

क्या आप const T (&data)[N]हिस्सा समझा सकते हैं ? आपकी कॉल में सरणी का आकार कैसे घटाया गया है makeVector(values)?

— पैट्रीक

Answer 7

C ++ 11 से पहले:

विधि 1 =>

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

विधि 2 =>

 v.push_back(SomeValue);

नीचे की ओर C ++ 11 भी संभव है

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

Answer 8

के साथ शुरू:

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

यदि आपके पास C ++ 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);

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

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

Answer 9

वेक्टर प्रारंभिक के लिए -

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

यदि आप c ++ 11 संकलक हैं तो किया जा सकता है।

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

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

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

Answer 10

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

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

Comments

कौन सा संकलक? क्या आप यहां C ++ 11 का उपयोग कर रहे हैं?

— एगेल कुरियन

g ++ 4.6.3 with -std = c ++ 0x।

— पॉल बाल्टेसु

Answer 11

मैं अपने समाधान का उपयोग कर निर्माण करता हूं va_arg। यह समाधान C ++ 98 अनुरूप है।

#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;
}

डेमो

Answer 12

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

#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 नाम की एक नई वेक्टर बनाता है।

Answer 13

यदि आप बूस्ट का उपयोग नहीं करना चाहते हैं, लेकिन सिंटैक्स का आनंद लेना चाहते हैं

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;
}

Comments

मैं यह पता नहीं लगा पाया कि इस कोड का उपयोग कैसे किया जाए, लेकिन यह दिलचस्प लगता है।

— डैनियल बकमास्टर 10

यह ऊपर की टिप्पणी में से एक की तरह है। बस ओवरलोडिंग + = और अल्पविराम ऑपरेटर। स्पष्टता के लिए कोष्ठक लगाना: ((((v+=1),2),3),4),5) यह है कि यह कैसे काम करता है: सबसे पहले, vector<T> += Tएक वेक्टर_inserter देता है viजो इसे कॉल करता है जो मूल वेक्टर को अतिक्रमण करता है और फिर मूल वेक्टर में vi,Tटी जोड़ता है जो एनकैप्सुलेट viकरता है और इसे स्व वापस करता है ताकि हम vi,Tफिर से कर सकें ।

— पिटी ओंगमोंग्कोलकुल

इस कोड ने gcc पर सही ढंग से काम नहीं किया। 4.2.1 मुझे लगता है कि + = ऑपरेटर के अंदर एक स्थानीय चर के संदर्भ में लौटने के कारण विचार अतिश्योक्तिपूर्ण है। मैंने कोड संपादित किया है और एक और कॉपी कंस्ट्रक्टर दिखाई देता है। प्रवाह अब है -> + = -> ctor -> अल्पविराम -> प्रतिलिपि -> dtor -> अल्पविराम ...... -> अल्पविराम -> dtor

— येवैन

मैंने शायद ओवरलोड किया होगा << + के बजाय =। कम से कम << पहले से ही थोड़ा सा बदलाव और

— कटआउट के

Answer 14

C ++ 11 में:

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

Comments

यदि आप पहले से ही C ++ 11 का उपयोग कर रहे हैं, तो आप प्रत्यक्ष दृष्टिकोण के लिए भी जा सकते हैं - vector<int> arr = {10, 20, 30};।

— बर्नहार्ड बार्कर

वास्तव में मेरे पास एक आवक int [] (कुछ C lib) था और एक वेक्टर (C ++ lib) में धकेलना चाहता था। इस उत्तर ने मदद की, बाकी लोगों ने ;-)

— नेबुला

Answer 15

आप इसे बढ़ावा देने का उपयोग कर सकते हैं :: असाइन करें।

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

यहां विस्तार से

Comments

मैंने लंबे समय में ऑपरेटर द्वारा दुर्व्यवहार के दुरुपयोग का एक बदतर मामला नहीं देखा है। क्या +=यह करता है .. 1,2,3,4 पर वहाँ कील मूल्यों का अंत करने के लिए, या जोड़ने 1 MATLAB- में यह चाहिए की तरह 3 तत्व को 2 तत्व, 3 करने के लिए 1 तत्व, 2 के लिए (वाक्य रचना के रूप में भाषाओं की तरह)

— bobobobo

Answer 16

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

---

// 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)

Answer 17

नीचे विधियों का उपयोग वेक्टर को c ++ में आरंभ करने के लिए किया जा सकता है।

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 के बाद की अनुमति है।

Answer 18

यहाँ बहुत सारे अच्छे उत्तर हैं, लेकिन जब से मैं स्वतंत्र रूप से इसे पढ़ने से पहले अपने दम पर आया, मुझे लगा कि मैं यहाँ अपना नाम लिखूंगा ...

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

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

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) );

इस तरह, आप एक सिंगल क्लीन लाइन में फ़ंक्शन के लिए गतिशील रूप से आकार के संग्रह का निर्माण और पास कर सकते हैं!

Answer 19

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

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);

Answer 20

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>

Comments

प्रश्न में C ++ 03 (11 नहीं)

— माइक पी

मुझे लगता है कि जब मैंने इसका उत्तर दिया तो यह 03 निर्दिष्ट नहीं था। हालांकि पूरी तरह से याद नहीं है। हालांकि, यह अभी भी किसी के लिए एक उपयोगी जवाब है जो त्वरित समाधान की तलाश कर रहा है।

— श्वेनांक

Answer 21

// 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.

Answer 22

यदि सरणी है:

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 

Answer 23

उदाहरण के लिए परीक्षण लिखते समय चर को परिभाषित किए बिना वेक्टर इनलाइन बनाना बहुत सुविधाजनक है:

assert(MyFunction() == std::vector<int>{1, 3, 4}); // <- this.

Answer 24

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

#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));

हालांकि घोषणा के बारे में सावधान रहें, सुनिश्चित करें कि पहला मूल्य स्पष्ट रूप से वही है जो आप चाहते हैं।

Answer 25

एक वेक्टर को हार्डकोड करने के विभिन्न तरीके हैं, मैं कुछ तरीके साझा करूंगा:

1. एक-एक करके मूल्यों को धक्का देकर आरंभ करना

// Create an empty vector 
    vector<int> vect;  

    vect.push_back(10); 
    vect.push_back(20); 
    vect.push_back(30); 

2. सरणियों की तरह प्रारंभिक

vector<int> vect{ 10, 20, 30 };

3. किसी सरणी से प्रारंभ करना

    int arr[] = { 10, 20, 30 }; 
    int n = sizeof(arr) / sizeof(arr[0]); 

    vector<int> vect(arr, arr + n); 

4. एक और वेक्टर से प्रारंभिक

    vector<int> vect1{ 10, 20, 30 }; 

    vector<int> vect2(vect1.begin(), vect1.end()); 

Answer 26

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

एक वेक्टर को इनिशियलाइज़ करने का सबसे आसान तरीका है जब आपने अपनी बिल्ट-इन सरणी को इनिशियलाइज़ किया है तो एक इनिशलाइज़र लिस्ट का उपयोग कर रहा है जिसे C ++ 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);

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

Comments

इसी तरह की पंक्तियों में, मैं मानचित्र को आरंभ करने की कोशिश कर रहा हूं, std :: map <int, bool> catinfo = {{1, false}}; लेकिन फिर यह त्रुटि त्रुटि प्राप्त करें: C ++ 98 में 'catinfo' को कंस्ट्रक्टर द्वारा आरंभीकृत किया जाना चाहिए, न कि '{...}' द्वारा

— pdk

Answer 27

बी। स्ट्रॉस्ट्रप 16.2.10 में चेन ऑपरेशंस के लिए एक अच्छा तरीका बताता है, जो प्रोग के C ++ 11 संस्करण में पेज 464 पर सेल्फी है । लैंग। जहां एक फ़ंक्शन एक संदर्भ देता है, यहां एक वेक्टर में संशोधित किया गया है। इस तरह से आप पसंद कर सकते हैं 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;
}

१
२
३

Comments

आर्मैडिलो लाइब्रेरी मैट्रिक्स इनिशियलाइज़ेशन के लिए ऐसा करती है लेकिन एक नामित फ़ंक्शन के बजाय << ऑपरेटर का उपयोग करती है: arma.sourceforge.net/docs.html#element_initialisation

— Agnel Kurian

Answer 28

सबसे सरल, अधिक एर्गोनोमिक तरीका (सी ++ 11 या बाद के साथ):

auto my_ints = {1,2,3};

Answer 29

यदि आप इसे अपनी कक्षा में रखना चाहते हैं:

#include <initializer_list>
Vector<Type>::Vector(std::initializer_list<Type> init_list) : _size(init_list.size()),
_capacity(_size),
_data(new Type[_size])
{
    int idx = 0;
    for (auto it = init_list.begin(); it != init_list.end(); ++it)
        _data[idx++] = *it;
}