क्या मैं प्राइमेटिव्स पर डिलीट कॉल कर सकता हूं?

Question

मेरे पास एक टेम्पलेटेड क्लास है, मायफू, जो टाइप टी के "सामान" को स्टोर करता है जो जटिल प्रकारों के लिए आदिम या पॉइंटर्स हो सकता है। जब myFoo हटा दिया जाता है, तो मैं संग्रहीत होने वाली हर चीज़ से जुड़ी सभी मेमोरी को रिलीज़ करना चाहता हूं। इसका मतलब है कि मुझे संग्रहित होने वाले प्रत्येक पॉइंटर पर डिलीट कॉल करने की आवश्यकता है, लेकिन मैं आदिम पर कॉलिंग को भी समाप्त कर सकता हूं। क्या यह सुरक्षित है ??

मैंने आगे बढ़ने के लिए बेहतर तरीके से हाइलाइट करने के लिए नीचे myFoo का एक स्केच शामिल किया है। मुझे यकीन नहीं है कि विनाशक का व्यवहार अच्छी तरह परिभाषित है या नहीं।

template<class T> 
class myFoo 
{ 
    public: 
     myFoo(int size) 
     { 
      size_ = size; 
      T* foo = new T[size_]; 
     } 

     void addFoo(T tmp, int index) 
     { 
      foo[index] = tmp; 
     } 

     virtual ~myFoo() 
     { 
      for(int i=0; i < size_; i++) 
      { 
       delete foo[i]; 
      } 
      delete [] foo; 
     } 

    private: 
     int size_; 
     T* foo; 
} 

Answer 1

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

तो नहीं, आपको "गलती से" गैर-सूचक को हटाने की चिंता करने की आवश्यकता नहीं है।

Answer 2

खाका विशेषज्ञता

template <class T> struct delete_it; 

template <class T> struct delete_it<T*> 
{ 
    static void func(T* ptr) { delete ptr; } 
}; 

template <> struct delete_it<int> 
{ 
    static void func(int) {} 
}; 

template <> struct delete_it<double> 
{ 
    static void func(double) {} 
}; 

सभी आदिम प्रकार के लिए दोहराएँ। फिर

virtual ~myFoo() 
    { 
     for(int i=0; i < size_; i++) 
     { 
      delete_it<T>::func(foo[i]); 
     } 
     delete [] foo; 
    } 

अनचेक कोड।