स्मृति

Question

रिहा

चलें कहते हैं कि मैं एक एसटीडी वेक्टर में डेटा प्राप्त करने के लिए एक समारोह है बिना std :: वेक्टर नष्ट:

void getData(std::vector<int> &toBeFilled) { 
    // Push data into "toBeFilled" 
} 

अब मैं एक और समारोह के लिए इस डेटा भेजना चाहते हैं, कि डेटा समाप्त होने पर मुक्त कर देना चाहिए :

void useData(int* data) 
{ 
    // Do something with the data... 
    delete[] data; 
} 

दोनों कार्य (getData और useData) तय किए गए हैं और इन्हें बदला नहीं जा सकता है।

{ 
    std::vector<int> data; 
    getData(data); 
    int *heapData = new int[data.size()]; 
    memcpy(heapData, data.data(), data.size()*sizeof(int)); 
    useData(heapData); 
    data.clear(); 
} 

हालांकि, इस memcpy ऑपरेशन के बाद से डेटा ढेर पर पहले से ही है, महंगा है और वास्तव में आवश्यक नहीं है: जब डेटा एक बार को कॉपी यह ठीक काम करता है। क्या सीडी वेक्टर द्वारा आवंटित डेटा को सीधे निकालना और उपयोग करना संभव है? (स्यूडोकोड) की तरह कुछ:

{ 
    std::vector<int> data; 
    getData(data); 
    useData(data.data()); 
    data.clearNoDelete(); 
} 

संपादित करें:

उदाहरण शायद बहुत ज्यादा मतलब नहीं है, क्योंकि यह संभव है बस useData को समारोह कॉल के बाद वेक्टर मुक्त करने के लिए। हालांकि, वास्तविक कोड में, useData नहीं एक समारोह लेकिन एक वर्ग है कि डेटा प्राप्त करता है, और इस वर्ग के वेक्टर से अधिक समय रहता है ...

Answer 1

सं

एपीआई का उपयोग कर रहे है एक अनुबंध जो कहता है कि यह आपके द्वारा प्रदान किए जाने वाले डेटा का स्वामित्व लेता है, और यह डेटा एक सूचक के माध्यम से प्रदान किया जाता है। यह मूल रूप से मानक वैक्टर का उपयोग कर नियम बनाता है।

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

आप यदि आप उनमें से स्वामित्व ... या कदम प्रत्येक तत्व बाहर अपने खुद के कंटेनर में लेना चाहते हैं डेटा की एक प्रतिलिपि बनाने के लिए है। या पहले स्थान पर अपने new[] से शुरू करें (यूघ) हालांकि आप इसे कम से कम कुछ कक्षा में लपेट सकते हैं जो std::vector की नकल करता है और गैर-स्वामित्व बन जाता है।

Answer 2

यहाँ एक भयानक हैक जो आप क्या जरूरत है ऐसा करने की अनुमति चाहिए है, लेकिन यह सबसे सरल बात यह कर सकते हैं कर अपरिभाषित व्यवहार पर निर्भर करता है।

template <class T> 
struct CheatingAllocator : std::allocator<T> 
{ 
    using typename std::allocator<T>::pointer; 
    using typename std::allocator<T>::size_type; 

    void deallocate(pointer p, size_type n) { /* no-op */ } 

    // Do not add ANY data members!! 
}; 


{ 
    std::vector<int, CheatingAllocator<int>> data; 
    getData(reinterpret_cast<std::vector<int>&>(data)); // type pun, `getData()` will use std::allocator internally 
    useData(data.data()); 
    // data actually uses your own allocator, so it will not deallocate anything 
} 

ध्यान दें कि यह के रूप में hacky और असुरक्षित हैक्स जाना के रूप में बताया गया है: कि आप अपना खुद संभाजक जो लेआउट संगत std::allocator और टाइप-यमक वेक्टर के साथ है बनाने के लिए है। यह मेमोरी लेआउट पर निर्भर नहीं है और यह new[] का उपयोग allocate फ़ंक्शन के अंदर करता है। मैं इसे उत्पादन कोड में खुद का उपयोग नहीं करता, लेकिन मेरा मानना ​​है कि यह एक (हताश) समाधान है।

---

सही ढंग से टिप्पणी में कहा @TonyD कि std::allocator काफी करने के लिए आंतरिक रूप से नहीं उपयोग new[] संभावना है। इसलिए, उपर्युक्त के अंदर delete[] पर अधिकतर असफल हो जाएगा। वही @ टोनीडी ने reserve() (उम्मीदपूर्वक) getData() के अंदर पुनर्वितरण को रोकने के लिए एक अच्छा बिंदु भी बनाया।तो अद्यतन कोड इस तरह दिखेगा:

template <class T> 
struct CheatingAllocator : std::allocator<T> 
{ 
    using typename std::allocator<T>::pointer; 
    using typename std::allocator<T>::size_type; 

    pointer allocate(size_type n) { return new T[n]; } 

    void deallocate(pointer p, size_type n) { /* no-op */ } 

    // Do not add ANY data members!! 
}; 


{ 
    std::vector<int, CheatingAllocator<int>> data; 
    data.reserve(value_such_that_getData_will_not_need_to_reallocate); 
    getData(reinterpret_cast<std::vector<int>&>(data)); // type pun, `getData()` will use std::allocator internally 
    useData(data.data()); 
    // data actually uses your own allocator, so it will not deallocate anything 
}