एक आंतरिक बफर करने के लिए एक सूचक के साथ अर्थ विज्ञान ले जाएँ

Question

मान लीजिए मैं एक वर्ग जो एक आंतरिक बफर करने के लिए एक सूचक का प्रबंधन करता है: एक प्रतिलिपि सहित अब

class Foo 
{ 
    public: 

    Foo(); 

    ... 

    private: 

    std::vector<unsigned char> m_buffer; 
    unsigned char* m_pointer; 
}; 

Foo::Foo() 
{ 
    m_buffer.resize(100); 
    m_pointer = &m_buffer[0]; 
} 

, मान लीजिए मैं भी सही ढंग से लागू कर दिया है शासन-ऑफ-द 3 सामान निर्माता जो प्रतियां आंतरिक बफर, और फिर आंतरिक बफर के नई प्रतिलिपि करने के लिए सूचक reassigns:

Foo::Foo(const Foo& f) 
{ 
    m_buffer = f.m_buffer; 
    m_pointer = &m_buffer[0]; 
} 

मैं भी चाल अर्थ विज्ञान लागू करते हैं तो यह सिर्फ सूचक कॉपी और बफर स्थानांतरित करने के लिए सुरक्षित है?

Foo::Foo(Foo&& f) : m_buffer(std::move(f.m_buffer)), m_pointer(f.m_pointer) 
{ } 

व्यवहार में, मैं जानता हूँ कि यह काम करना चाहिए, क्योंकि std::vector चाल निर्माता सिर्फ आंतरिक सूचक बढ़ रहा है - यह वास्तव में कुछ भी नहीं कर रहा है पुनः दिए तो m_pointer अभी भी एक वैध पते के लिए अंक। हालांकि, मुझे यकीन नहीं है कि मानक इस व्यवहार की गारंटी देता है या नहीं। std::vector स्थानांतरित करें अर्थशास्त्र की गारंटी है कि कोई पुनर्वितरण नहीं होगा, और इस प्रकार वेक्टर के सभी पॉइंटर्स/इटरेटर वैध हैं?

Answer 1

मैं &m_buffer[0] फिर से करूंगा, बस इतना है कि आपको इन प्रश्नों से पूछना नहीं है। यह स्पष्ट रूप से सहज नहीं है, इसलिए ऐसा मत करो। और, ऐसा करने में, आपके पास कुछ भी खोने के लिए कुछ भी नहीं है। फायदे का सौदा।

Foo::Foo(Foo&& f) 
    : m_buffer(std::move(f.m_buffer)) 
    , m_pointer(&m_buffer[0]) 
{} 

मैं यह ज्यादातर के साथ आराम कर रहा हूँ क्योंकि m_pointer एक सदस्य m_buffer में दृश्य है, बल्कि सख्ती से अपने आप में एक सदस्य की तुलना में।

कौन सा सवाल पूछता है ... यह क्यों है? क्या आप &m_buffer[0] देने के लिए सदस्य फ़ंक्शन का पर्दाफाश नहीं कर सकते?

Answer 2

इस हो सकता है ऐसा करने के लिए एक बेहतर तरीका:

class Foo 
{ 

    std::vector<unsigned char> m_buffer; 
    size_t m_index; 

    unsigned char* get_pointer() { return &m_buffer[m_index]; 
}; 

यानी बजाय, एक वेक्टर तत्व के लिए सूचक की दुकान यह सूचकांक की दुकान। इस तरह यह वैक्टर बैकिंग स्टोर की प्रतिलिपि बनाने/आकार बदलने के प्रति प्रतिरक्षा होगी।

Answer 3

मैं ओपी के कोड पर टिप्पणी नहीं करूंगा। सभी मैं कर रहा हूँ इस सवाल aswering है:

std :: वेक्टर चाल अर्थ विज्ञान की गारंटी है कि कोई पुनः आबंटन हो जाएगा, और इस प्रकार सभी संकेत/iterators वेक्टर के लिए मान्य हैं करता है?

हाँ चालक के लिए हाँ। इसमें निरंतर जटिलता है (जैसा कि 23.2.1/4, तालिका 96 और नोट बी द्वारा निर्दिष्ट किया गया है) और इसी कारण से कार्यान्वयन के पास मूल vector (इसलिए कोई स्मृति पुनर्वितरण नहीं होता है) से स्मृति चोरी करने के अलावा कोई विकल्प नहीं है और मूल vector खाली कर रहा है ।

चाल असाइनमेंट ऑपरेटर के लिए नहीं। मानक के लिए केवल रैखिक जटिलता की आवश्यकता होती है (जैसा ऊपर वर्णित उसी अनुच्छेद और तालिका में निर्दिष्ट है) क्योंकि कभी-कभी एक पुनर्वितरण की आवश्यकता होती है। हालांकि, कुछ परिसंचरणों में, इसमें निरंतर जटिलता हो सकती है (और कोई पुनर्वितरण नहीं किया जाता है) लेकिन यह आवंटक पर निर्भर करता है। इतना के नव निर्मित दृष्टि से, (आप Howard Hinnanthere द्वारा ले जाया गया vector रों पर उत्कृष्ट प्रदर्शनी पढ़ सकते हैं।)

Answer 4

चाल निर्माण के मामले कदम दूसरे से एक कंटेनर से बफर करने के लिए गारंटी है वस्तु, ऑपरेशन ठीक है।

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

सामान्य रूप से वहां से स्थानांतरित होने के बाद आपके ऑब्जेक्ट का कोई उपयोग नहीं होगा (अनुमान है कि एक रावल्यू-रेफरेंस द्वारा बाध्य होना चाहिए यह एक रावल्यू होना चाहिए), तथ्य यह है कि आप बाहर निकल सकते हैं कास्टिंग द्वारा या std::move (जो मूल रूप से एक कास्ट है) का उपयोग करके एक लाभा, जिसमें केस कोड वास्तव में आपके ऑब्जेक्ट का उपयोग करने का प्रयास कर सकता है।