Kann ich löschen auf Primitiven aufrufen?

Question

Ich habe eine Template-Klasse, myFoo, die "stuff" vom Typ T speichert, die entweder primitiv oder Zeiger auf komplexe Typen sein kann. Wenn myFoo gelöscht wird, möchte ich den gesamten Speicher freigeben, der mit allem verknüpft ist, was gerade gespeichert wird. Das bedeutet, dass ich für jeden gespeicherten Zeiger löschen muss, aber ich könnte auch löschen auf einem Primitiv aufrufen. Ist das sicher?

Ich habe unten eine Skizze von myFoo eingefügt, um besser hervorzuheben, was vor sich geht. Ich bin mir nicht sicher, ob das Verhalten des Destruktors gut definiert ist.

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

Das einzige, was Sie delete auf ein Zeigertyp aufrufen können. Es ist ein Fehler, zum Beispiel delete auf einem int aufzurufen. Wenn Sie Ihre Vorlagen so anordnen, dass Ihr Code versucht, etwas zu tun, das ein Fehler ist, wird der Compiler Sie wissen lassen und die Kompilierung Ihres Codes ablehnen.

Also nein, Sie müssen sich keine Sorgen machen, dass Sie versehentlich einen Nicht-Zeiger löschen.

Answer 2

Template Spezialisierung

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) {} 
}; 

Wiederholen Sie für alle primitiven Typen. Dann

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

Ungeprüfter Code.