Tôi có thể gọi xóa trên tài liệu gốc không?

Question

Tôi có một lớp templated, myFoo, lưu trữ "thứ" của loại T, có thể là nguyên thủy hoặc con trỏ đến các kiểu phức tạp. Khi myFoo bị xóa, tôi muốn giải phóng tất cả bộ nhớ liên quan đến mọi thứ nó xảy ra để lưu trữ. Điều này có nghĩa là tôi cần phải gọi xóa trên mỗi con trỏ được lưu trữ nhưng tôi cũng có thể kết thúc gọi xóa trên một nguyên thủy. Cái này có an toàn không ??

Tôi đã bao gồm một bản phác thảo của myFoo bên dưới để làm nổi bật những gì đang diễn ra tốt hơn. Tôi không chắc chắn nếu hành vi của destructor được xác định rõ.

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

Điều duy nhất bạn có thể gọi delete là loại con trỏ. Đó là lỗi khi gọi số delete trên số điện thoại int. Nếu bạn sắp xếp các mẫu của bạn để mã của bạn cố gắng làm điều gì đó sai sót, trình biên dịch sẽ cho bạn biết và từ chối biên dịch mã của bạn.

Vì vậy, không, bạn không phải lo lắng về việc "vô tình" xóa một con trỏ không.

Answer 2

Template chuyên môn

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

Lặp lại cho tất cả các loại nguyên thủy. Sau đó,

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

Mã không được kiểm tra.