Question

我有;

class object {
                    // any private datas token in heap area 
             public : 
                   ~object () ; 

};

在功能中;

 vector < object*> tmp ;

我的问题是;

如何删除/取消分配 tmp [i] ？换句话说，我应该在object :: destructor中写什么？

Answer 1

你似乎有点困惑。这里有两个概念：

tmp的所有者如何解除tmp内指针引用的对象？
object类（~object）的析构函数应该做什么？

这些并不是那么相关。完成tmp向量后，必须手动遍历并在其每个元素上调用delete，以释放元素指向的object对象占用的内存。。这假设元素当然是用new分配的。

object析构函数~object的目的是释放object对象拥有的所有内容，不以释放object对象本身。如果object对象不拥有任何动态分配的数据，则不需要执行任何操作。

换句话说，当你写delete tmp[i]时，会发生两件事：

*(tmp[i])::~object()被称为
tmp[i]指向的内存已取消分配

注意，即使（1）绝对没有，也会发生（2）。步骤（1）的要点是允许即将被解除分配的对象解除分配需要被解除分配的任何成员对象。析构函数的工作重点是而不是来释放调用它的对象。

通过明确的例子：

class object {
  private:
    int foo;
  public:
    object() : foo(42) {}
    ~object() { /* nothing to do here; foo is not dynamically allocated */ }
};

int main() {
  vector<object*> tmp;
  tmp.push_back(new object());

  // Do some stuff with tmp

  for (int i = 0; i < tmp.size(); ++i) {
    delete tmp[i]; // Calls ~object and deallocates *tmp[i]
  }
  tmp.clear();

  return 0;
}

或者，相比之下

class object {
  private:
    int* foo;
  public:
    object() : foo(new int()) { *foo = 42; }
    ~object() { 
      // Now since foo is dynamically allocated, the destructor
      // needs to deallocate it
      delete foo;
    }
};

int main() {
  vector<object*> tmp;
  tmp.push_back(new object());

  // Do some stuff with tmp

  for (int i = 0; i < tmp.size(); ++i) {
    delete tmp[i]; // Calls ~object (which deallocates tmp[i]->foo) 
                   // and deallocates *tmp[i]
  }
  tmp.clear();

  return 0;
}

Answer 2

我写了这个通用函数模板，它可以帮助你：

template<typename FwdIterator>
void deleter(FwdIterator from, FwdIterator to)
{
   while ( from != to ) 
   {
       delete *from;
       from++;
   }
}

示例：

struct object { ~object() { cout << "object deleted" << endl; } };

int main() {

        vector<object*> objects;
        objects.push_back(new object());
        objects.push_back(new object());
        objects.push_back(new object());
        objects.push_back(new object());
        objects.push_back(new object());

        deleter(objects.begin(), objects.end()); //delete objects
        objects.clear(); //clear the vector
        return 0;
}

输出：

object deleted
object deleted
object deleted
object deleted
object deleted

在ideone演示：http://www.ideone.com/t5PI0

Answer 3

您只需致电delete tmp[i];即可。但我建议改为使用std::vector< std::shared_ptr< object > >。

Answer 4

析构函数应该包含释放内存对象占用的所有必要内容。

由于此对象指针存储在向量中，因此应在销毁之后删除对它的引用。也就是说，从矢量中删除该对象*。

Answer 5

要删除该指针末尾的对象，请调用delete myVector [i]

然后从向量中移除该指针，调用myVector.erase（myVector.begin（）+ i）

Answer 6

你将析构函数放入你的课程所需的任何内容中以释放其成员。

对于向量，它包含指针，而不是对象实例。因此，调用erase()只会从向量中删除指针，但不会释放指针指向的对象。您必须单独释放对象，例如：

std::vector<object*> tmp;
tmp.push_back(new object);
...
std::vector<object*>::iterator iter = ...;
delete *iter;
tmp.erase(iter);

Answer 7

您可以使用vector::erase ..

你的object析构函数应该delete你在堆中分配的所有成员。

如何在向量中释放对象指针？

7 个答案: