¿Puedo llamar eliminar en primitivas?

Question

Tengo una clase de plantilla, myFoo, que almacena "cosas" de tipo T que pueden ser primitivas o punteros a tipos complejos. Cuando myFoo se elimina, deseo liberar toda la memoria asociada con todo lo que sucede al almacenar. Esto significa que necesito llamar a eliminar en cada puntero que se almacena, pero también podría terminar llamando a eliminar en una primitiva. ¿Esto es seguro?

He incluido un boceto de myFoo a continuación para destacar mejor lo que está sucediendo. No estoy seguro si el comportamiento del destructor está bien definido.

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

El único que se puede llamar en delete es un tipo de puntero. Es un error llamar al delete en un int, por ejemplo. Si organiza sus plantillas para que su código intente hacer algo que sea un error, el compilador le informará y se negará a compilar su código.

Así que no, no tiene que preocuparse por la eliminación "accidental" de un puntero.

Answer 2

especialización de plantilla

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

Repita para todos los tipos primitivos. Luego

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

Código desmarcado.