Question

我有一个模板化的类myFoo，它存储T类型的“东西”，它可以是原始类型，也可以是指向复杂类型的指针。当myFoo被删除时，我想释放与它碰巧存储的所有内容相关的所有内存。这意味着我需要在每个存储的指针上调用delete，但我也可能最终在基元上调用delete。这样安全吗？

我在下面附上了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的是指针类型。例如，在delete上调用int是错误的。如果您安排模板以便代码尝试执行某些错误，则编译器会通知您并拒绝编译代码。

所以不，你不必担心“意外”删除非指针。

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

未选中的代码。

我可以在原语上调用delete吗？

2 个答案: