5

我有一个模板类 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;
}
4

2 回答 2

5

您唯一可以调用delete的是指针类型。例如，调用 是一个错误delete。int如果您安排您的模板，以便您的代码尝试做一些错误的事情，编译器会通知您并拒绝编译您的代码。

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

于 2012-07-25T05:43:00.850 回答
1

模板专业化

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

未经检查的代码。

于 2012-07-25T06:16:47.687 回答