2012-01-13 20 views
9

मैं std::vector<unsigned int> को प्रारंभ करने के लिए एक विशेष विधि का उपयोग करना चाहता हूं जिसे एक संदर्भ के रूप में उपयोग किए जाने वाले सी ++ पुस्तक में वर्णित किया गया है (जर्मन पुस्तक 'डेर सी ++ प्रोग्रामर 'Ulrich Breymann द्वारा, मामले में मामले में)। उस पुस्तक में एसटीएल के अनुक्रम प्रकारों पर एक अनुभाग है, विशेष रूप से list, vector और deque का जिक्र है। इस भाग में वे लिखते हैं इस तरह के अनुक्रम प्रकार के दो विशेष कंस्ट्रक्टर्स देखते हैं कि, अर्थात्, यदि X इस तरह के एक प्रकार को संदर्भित करता है,std :: vector <unsigned int> की शुरुआत निरंतर हस्ताक्षरित पूर्णांक की सूची के साथ

X(n, t) // creates a sequence with n copies of t 
X(i, j) // creates a sequence from the elements of the interval [i, j) 

मैं unsigned int के अंतराल के लिए एक दूसरे का उपयोग करना चाहते हैं, कि

है
std::vector<unsigned int> l(1U, 10U); 

{1,2,...,9} के साथ प्रारंभ की गई सूची प्राप्त करने के लिए। हालांकि, मुझे एक वेक्टर है जो एक unsigned int के साथ वैल्यू 10 है: - | क्या दूसरा संस्करण मौजूद है, और यदि हां, तो मैं इसे कैसे बल दूं?

उत्तर

10

पढ़ना का वर्णन मानकों में से प्रत्येक क्या कर रहे हैं वहाँ के पास पैराग्राफ:

यहाँ कार्रवाई में "दो इटरेटर" निर्माता का एक उदाहरण है। विशेष रूप से, यह उल्लेख करना चाहिए कि i और j मान नहीं हैं, लेकिन iterators। इस कन्स्ट्रक्टर का उपयोग आमतौर पर अन्य प्रकार के कंटेनर की प्रतियां बनाने के लिए किया जाता है। यदि आप मानों का अनुक्रम प्राप्त करना चाहते हैं, तो Boost librarycounting iterator प्रदान करता है, जो वही करता है जो आप चाहते हैं।

std::vector<unsigned int> numbers(
    boost::counting_iterator<unsigned int>(0U), 
    boost::counting_iterator<unsigned int>(10U)); 
+0

धन्यवाद, वांछित के रूप में काम करता है! पुस्तक उस विशेष निर्माता के संबंध में थोड़ा सा विशिष्ट है, लेकिन बाद में अक्षरों पर, जे वास्तव में इसे इटरेटर के लिए स्पष्ट रूप से उपयोग किया जाता है। गु। – Thomas

0

नहीं, वह संस्करण मौजूद नहीं है। दूसरा कन्स्ट्रक्टर दो पुनरावृत्तियों से एक वेक्टर शुरू करता है जो एक और अनुक्रम में इंगित करता है।

int fill_data[4] = { 1, 2, 3, 4 }; 
std::vector<int> v(fill_data, fill_data + 4); 
+0

संपादन अनुरोध के लिए धन्यवाद, मैंने गलत तरीके से इसे गलत बताया है। :) मैंने इसे ठीक कर दिया है। –

2

एक आत्म-वृद्धिशील इटरेटर के साथ ऐसा करने के लिए एक गैर-बढ़ावा तरीका।

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

static int NUM_ITEMS = 10; 

class gen_range { 
    public: 
     gen_range(int i) { idx = i; } 
     int operator()() { return (idx++); }; 

    int idx; 
}; 

int main() { 

    std::vector<int> x(NUM_ITEMS); 
    std::generate_n(x.begin(), NUM_ITEMS, gen_range(0)); 

    for (int i=0; i < x.size(); i++) { 
     std::cout << x[i] << std::endl; 
    } 
} 
1

सी ++ 11:

std::vector<int> idxs (n); 

std::generate_n (idxs.begin(), n, [] { static int i {1}; return i++; }); 
19

वहाँ कम से कम तीन तरीकों से आप ऐसा कर सकते हैं। एक ब्रायन

से पहले उल्लेख किया गया था
//method 1 
generate(v.begin(), v.end(), [] { static int i {1}; return i++; });  

अगर आप C++ 11

//method 2 
iota(v.begin(), v.end(), 1); 

उपयोग कर रहे हैं या बजाय आप 1s के साथ अपने कंटेनर को प्रारंभ कर सकते हैं तुम भी std :: जरा भी उपयोग कर सकते हैं और फिर एक आंशिक करना उस पर योग मुझे नहीं लगता कि कोई भी इस तीसरे विधि का उपयोग करेगा :)

//method 3 
vector<int> v(n, 1);              
partial_sum(v.begin(), v.end(), v.begin()); 
+0

विधि 3 आसान है यदि आप संचयी रकम वाले सरणी उत्पन्न करना चाहते हैं। एक और 'partial_sum (v.begin(), v.end(), v.begin())' और n = 5 के लिए, आपको {1, 3, 6, 10, 15} मिलता है। – lifebalance

+0

नोट, 'जेनरेट' यहां स्थिर का उपयोग करता है। इसे एक फ़ंक्शन के भीतर रखें, इसे कई बार कॉल करें और यह गिनती रखेगा। 'ValueType i = {1} का उपयोग करें; std :: उत्पन्न करें (पहला, आखिरी, [& i] {वापसी i ++;}); 'इसके बजाए। –

संबंधित मुद्दे