क्या पोर्टेबल तरीके से सरणी के लिए नया प्लेसमेंट इस्तेमाल किया जा सकता है?

Question

क्या एरे के लिए इसका उपयोग करते समय वास्तव में पोर्टेबल कोड में प्लेसमेंट का उपयोग करना संभव है?

ऐसा प्रतीत होता है कि जो सूचक आप नए से वापस प्राप्त करते हैं [] हमेशा आपके द्वारा दर्ज किए गए पते के समान नहीं होता है (5.3.4, मानक में नोट 12 यह पुष्टि करता है कि यह सही है), लेकिन मैं ' टी यह देखने के लिए कि यदि आप इस मामले में जाने के लिए सरणी के लिए एक बफर आवंटित कर सकते हैं तो देखें।

निम्नलिखित उदाहरण समस्या दिखाता है। दृश्य स्टूडियो के साथ संकलित, इस उदाहरण स्मृति भ्रष्टाचार में परिणाम:

#include <new> 
#include <stdio.h> 

class A 
{ 
    public: 

    A() : data(0) {} 
    virtual ~A() {} 
    int data; 
}; 

int main() 
{ 
    const int NUMELEMENTS=20; 

    char *pBuffer = new char[NUMELEMENTS*sizeof(A)]; 
    A *pA = new(pBuffer) A[NUMELEMENTS]; 

    // With VC++, pA will be four bytes higher than pBuffer 
    printf("Buffer address: %x, Array address: %x\n", pBuffer, pA); 

    // Debug runtime will assert here due to heap corruption 
    delete[] pBuffer; 

    return 0; 
} 

स्मृति को देखते हुए, संकलक उस में वस्तुओं की संख्या की गिनती स्टोर करने के लिए बफर के पहले चार बाइट्स का उपयोग किया जा रहा है। इसका मतलब है कि क्योंकि बफर केवल sizeof(A)*NUMELEMENTS बड़ा है, सरणी में अंतिम तत्व आवंटित ढेर में लिखा गया है।

तो सवाल यह है कि आप यह पता लगा सकते हैं कि नियुक्ति नया [] सुरक्षित रूप से उपयोग करने के लिए आपका कार्यान्वयन कितना अतिरिक्त ओवरहेड चाहता है? आदर्श रूप में, मुझे एक ऐसी तकनीक की आवश्यकता है जो विभिन्न कंपाइलरों के बीच पोर्टेबल हो। ध्यान दें कि, कम से कम वीसी के मामले में, ओवरहेड अलग-अलग वर्गों के लिए अलग दिखता है। उदाहरण के लिए, यदि मैं उदाहरण में वर्चुअल विनाशक को हटा देता हूं, तो नया [] से लौटाया गया पता उसी पते जैसा है जो मैं पास करता हूं।

Answer 1

व्यक्तिगत रूप से मैं सरणी पर नया प्लेसमेंट का उपयोग न करने के विकल्प के साथ जाऊंगा और इसके बजाय सरणी में प्रत्येक आइटम पर अलग-अलग प्लेसमेंट का उपयोग करूँगा। उदाहरण के लिए:

int main(int argc, char* argv[]) 
{ 
    const int NUMELEMENTS=20; 

    char *pBuffer = new char[NUMELEMENTS*sizeof(A)]; 
    A *pA = (A*)pBuffer; 

    for(int i = 0; i < NUMELEMENTS; ++i) 
    { 
    pA[i] = new (pA + i) A(); 
    } 

    printf("Buffer address: %x, Array address: %x\n", pBuffer, pA); 

    // dont forget to destroy! 
    for(int i = 0; i < NUMELEMENTS; ++i) 
    { 
    pA[i].~A(); 
    }  

    delete[] pBuffer; 

    return 0; 
} 

विधि आप उपयोग के बावजूद, सुनिश्चित करें कि आप मैन्युअल रूप से, सरणी में उन वस्तुओं में से प्रत्येक को नष्ट इससे पहले कि आप pBuffer हटाना आप लीक लग सकती है के रूप में करते हैं;)

नोट : मैंने इसे संकलित नहीं किया है, लेकिन मुझे लगता है कि इसे काम करना चाहिए (मैं ऐसी मशीन पर हूं जिसमें सी ++ कंपाइलर स्थापित नहीं है)। यह अभी भी बिंदु इंगित करता है :) उम्मीद है कि यह किसी भी तरह से मदद करता है!

---

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

कारण यह तत्वों की संख्या का ट्रैक रखने की जरूरत है तो यह है कि यह उन के माध्यम से पुनरावृति सकता है जब आप सरणी पर हटाने के फोन और यह सुनिश्चित करें विनाशकर्ता में से प्रत्येक पर कहा जाता है बनाने के वस्तुओं अगर यह नहीं जानता कि कितने हैं तो यह ऐसा करने में सक्षम नहीं होगा।

Answer 2

मुझे लगता है कि जीसीसी एमएसवीसी के समान ही काम करता है, लेकिन निश्चित रूप से यह ' इसे "पोर्टेबल" बनाओ।

मुझे लगता है कि आप समस्या को हल करने कर सकते हैं जब NUMELEMENTS वास्तव में एक संकलन समय स्थिर है, इसलिए जैसे:

typedef A Arr[NUMELEMENTS];

A* p = new (buffer) Arr;

यह अदिश नियुक्ति नए प्रयोग करना चाहिए।

Answer 3

एक प्लेसमेंट के लिए आकार की गणना करने के लिए आप एक तत्व का उपयोग कैसे करेंगे- नए, सरणी के लिए आवश्यक आकार की गणना करने के लिए उन तत्वों की एक सरणी का उपयोग करें।

यदि आपको अन्य गणनाओं के लिए आकार की आवश्यकता होती है जहां तत्वों की संख्या ज्ञात नहीं हो सकती है तो आप आकार (ए [1]) का उपयोग कर सकते हैं और अपनी आवश्यक तत्व गणना से गुणा कर सकते हैं।

ई।जी

char *pBuffer = new char[ sizeof(A[NUMELEMENTS]) ]; 
A *pA = (A*)pBuffer; 

for(int i = 0; i < NUMELEMENTS; ++i) 
{ 
    pA[i] = new (pA + i) A(); 
} 

Answer 4

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

मैं भी वास्तव में स्पष्ट नहीं हूं कि इसे अतिरिक्त डेटा की आवश्यकता क्यों है, क्योंकि आप किसी भी तरह से सरणी पर हटाएं [] को कॉल नहीं करेंगे, इसलिए मुझे पूरी तरह से नहीं पता कि इसे क्यों पता होना चाहिए कि इसमें कितनी वस्तुएं हैं ।

Answer 5

@James

मैं भी नहीं वास्तव में स्पष्ट कारण है कि यह अतिरिक्त डेटा की जरूरत है, के रूप में हटाना [] सरणी वैसे भी पर कॉल नहीं होता, तो मैं पूरी तरह से नहीं दिख रहा है कारण है कि यह जरूरत है यह जानने के लिए कि इसमें कितने आइटम हैं।

कुछ विचार देने के बाद, मैं आपसे सहमत हूं। प्लेसमेंट को तत्वों की संख्या को स्टोर करने की आवश्यकता होने का कोई कारण नहीं है, क्योंकि कोई प्लेसमेंट डिलीट नहीं है। चूंकि कोई प्लेसमेंट डिलीट नहीं है, इसलिए तत्वों की संख्या को स्टोर करने के लिए प्लेसमेंट नए के लिए कोई कारण नहीं है।

मैंने एक विनाशक के साथ एक वर्ग का उपयोग करके, मैक पर जीसीसी के साथ इसका परीक्षण किया। मेरे सिस्टम पर, प्लेसमेंट नया सूचक बदल रहा था। इससे मुझे आश्चर्य होता है कि यह एक वीसी ++ मुद्दा है, और क्या यह मानक का उल्लंघन कर सकता है (मानक विशेष रूप से इसे संबोधित नहीं करता है, जहां तक ​​मुझे मिल सकता है)।

Answer 6

@Derek

5.3.4, खंड 12 सरणी आवंटन भूमि के ऊपर और, जब तक कि मैं इसे ग़लत व्याख्या कर रहा हूँ, यह मेरे लिए जो बताते हैं कि यह मान्य है संकलक नियुक्ति नई पर इसे जोड़ने के लिए के लिए लगता है के बारे में वार्ता साथ ही:

यह ओवरहेड सभी सरणी नई-भाव में लागू किया जा सकता है, पुस्तकालय समारोह ऑपरेटर नई [] संदर्भित और अन्य प्लेसमेंट आवंटन कार्य (std :: size_t * शून्य,) भी शामिल हैं। ओवरहेड की मात्रा नए से दूसरे के एक आमंत्रण से भिन्न हो सकती है।

उसने कहा, मुझे लगता है कि वीसी एकमात्र कंपाइलर था जिसने मुझे इसके बारे में परेशानी दी, जीसीसी, कोडवायरियर और प्रोडीजी। हालांकि, मुझे यकीन करने के लिए फिर से जांचना होगा।

Answer 7

प्लेसमेंट नया स्वयं पोर्टेबल है, लेकिन आपके द्वारा किए गए अनुमानों के बारे में आप स्मृति के निर्दिष्ट ब्लॉक के साथ क्या कर रहे हैं पोर्टेबल नहीं हैं। जैसा कि पहले कहा गया था, अगर आप एक कंपाइलर थे और उन्हें स्मृति का एक हिस्सा दिया गया था, तो आप कैसे जानते होंगे कि कैसे एक सरणी आवंटित करें और प्रत्येक तत्व को ठीक से नष्ट कर दें यदि आपके पास कोई सूचक था? (ऑपरेटर के इंटरफेस को नष्ट [] देखें।)

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

और वास्तव में एक प्लेसमेंट वहाँ हटाएं होता है, केवल यह तभी होता है जब एक निर्माता है, जबकि [] नियुक्ति नए के साथ एक सरणी का आवंटन एक अपवाद फेंकता है कहा जाता है।

चाहे नए [] को वास्तव में तत्वों की संख्या का ट्रैक रखने की आवश्यकता है, किसी भी तरह मानक के लिए छोड़ दिया गया है, जो इसे कंपाइलर तक छोड़ देता है। दुर्भाग्य से, इस मामले में।