एक डिफ़ॉल्ट कन्स्ट्रक्टर

Question

के बिना std :: वेक्टर के आकार को कम करना मेरे पास टेम्पलेट तर्क के std::vector का उपयोग करके एक टेम्पलेट श्रेणी है। तर्क डिफ़ॉल्ट रचनात्मक नहीं हो सकता है। मैं वेक्टर के आकार को कम करना चाहता हूं (इसे किसी दिए गए आकार में काट दें)। जाहिर है

vec.resize(reduced_size); 

... काम नहीं करता क्योंकि इसे एक डिफ़ॉल्ट कन्स्ट्रक्टर की आवश्यकता होती है।

मैं कर सकता निश्चित रूप से:

1. किसी भी इस्तेमाल किया प्रकार के लिए डिफ़ॉल्ट निर्माता बनाने के लिए (जो मुझे इसे जोड़ने के लिए की आवश्यकता है जब यह एक अच्छा डिजाइन विकल्प नहीं हो सकता है)
2. कार्य करने के लिए एक डिफ़ॉल्ट मान पारित (अंतरफलक के बेकार अव्यवस्था)
3. जबकि प्रश्न लिखने एक निर्माण विधि टेम्पलेट के लिए (भी बेकार अव्यवस्था)

गुजरती हैं, मैंने देखा है कि मैं यह कर सकते हैं,210 अंत करने के लिए वेक्टर ऊपर से तत्वों:

vec.erase (vec.begin() + position, vec.end()); 

... हालांकि, मैं नहीं यकीन है कि अगर इस resize के रूप में के रूप में कुशल हो जाएगा हूँ।

क्या डिफॉल्ट कन्स्ट्रक्टर के बिना वेक्टर के आकार को कम करने का कोई प्रभावी तरीका है?

सी ++ 11 समाधान स्वीकार्य हैं।

---

संपादित करें: लगता है कि दोनों MSVC और जीसीसी एक मिटा कॉल के रूप में आकार बदलने के सिकुड़ने को लागू है, इसलिए है कि मेरे प्रदर्शन सवाल का जवाब।

Answer 1

मेरी कार्यान्वयन में, ऐसा लगता है कि हमारे पास (कुछ सरलीकरण के साथ):

void std::vector<T,A>::resize(size_type __new_size) 
{ 
    if (__new_size > size()) 
     _M_default_append(__new_size - size()); 
    else if (__new_size < size()) 
     _M_erase_at_end(begin() + __new_size); 
} 

auto std::vector<T,A>::erase(iterator __first, iterator __last) -> iterator 
{ 
    if (__first != __last) 
    { 
     if (__last != end()) 
      _GLIBCXX_MOVE3(__last, end(), __first); 
     _M_erase_at_end(__first + (end() - __last)); 
    } 
    return __first; 
} 

जहां _M_... निजी सदस्य कार्य हैं। आप वास्तव में _M_erase_at_end के प्रभाव चाहते हैं। मुझे लगता है कि _M_default_appendv.resize(sz) से कॉल करने के लिए संकलक के लिए मुश्किल या असंभव होगा, लेकिन v.erase(iter, v.end()) में __last == end() में नोटिस करना और _GLIBCXX_MOVE3 और + (end() - __last) को ऑप्टिमाइज़ करना आसान है। तो erase()resize() से कहीं अधिक कुशल हो सकता है।

मैं अपेक्षा करता हूं कि अधिकांश कार्यान्वयन समान कहानी हों: कुछ सरल if परीक्षण, और फिर अंत में तत्वों के लिए विनाशकों को कॉल करने के लिए कुछ समान विधि को बुलाएं।

Answer 2

ज़रूर - जब आप resize कहते हैं, आप सही प्रकार है कि (सैद्धांतिक) रिक्त स्थान को भरने के लिए अगर आप resize का उपयोग वेक्टर के आकार को बढ़ाने के लिए इस्तेमाल किया जाएगा के एक मूल्य गुजर एक दूसरा पैरामीटर आपूर्ति कर सकते हैं। सी ++ 03 में, उस तर्क का T() का डिफ़ॉल्ट मान होता है, जहां डिफ़ॉल्ट सीटीआर चीजों में आता है (सी ++ 11 में, वे इसके बजाय ओवरलोडिंग का उपयोग करते हैं, ताकि आप बिना किसी कठिनाई के आकार को कम करने के लिए resize() पर कॉल कर सकें)।

अपने आप के मूल्य को पार करके, आप डिफ़ॉल्ट ctor की आवश्यकता से बचते हैं। जैसा ऊपर बताया गया है, सी ++ 11 में, डिफ़ॉल्ट सीटीआर की आवश्यकता नहीं होगी/भले ही आप दूसरे तर्क को पास न करें।

मुझे संदेह है कि यह erase का उपयोग करने की तुलना में कोई वास्तविक सुधार देगा। विशेष रूप से, मानक में विनिर्देश (§23.3.6.3/9) है: erase(begin() + sz, end()); को

तो sz <= size(), बराबर।

जैसे, इस मामले में resize और erase के बीच कोई अंतर के लिए कोई वास्तविक कारण हो रहा है।

Answer 3

erase का उपयोग करने का आपका विचार सही मार्ग है।

template<typename Container> 
Container&& reduce_size(Container&& c, std::size_t amount) { 
    using std::begin; using std::end; // enable ADL 
    amount = std::min(amount, std::size_t(end(c)-begin(c))); // paranoid! 
    c.erase(end(c)-amount, end(c)); 
    return std::forward<Container>(c); // I like my container-algorithms to pass through 
} 

जो के रूप में तेजी से अपने erase कार्यान्वयन के रूप में हो सकता है (अच्छी तरह से, एक और शाखा और जाँच) होगा: भ्रम की मात्रा को कम करने के लिए, मैं एक कंटेनर आधारित एल्गोरिथ्म लिखेंगे।

उपयोग:

std::vector<Foo> blah; 
blah.emplace_back(7); 
reduce_size(blah, 10);