C++ 中的析构函数（与 java 相比）

Question

到目前为止，我一直在用 Java 编写程序。所以当我开始使用 C++ 时，我首先想到的是如何销毁/删除/终结我不再需要的对象。

在使用 Java 时，我曾经将它们设置为 null，以便垃圾收集器负责处理它。 但是，我不知道 C++ 的价值如何。我发现这篇文章http://en.wikipedia.org/wiki/Comparison_of_Java_and_C%2B%2B 解决了我的大部分问题。但是还是有一些我不明白的地方。

1) 在 Java 中，有一种方法可以强制垃圾收集器立即清理（这并不总是有用，因为它会在运行前等待一些垃圾堆积起来）。有没有办法用 C++ 做到这一点？

2) (C++) 同样与上述相反，我怎样才能使我将对象置于“标记为删除”的状态，并且程序决定何时清理它（如 Java）？

3) (C++)我应该强制垃圾收集器就地清理吗（我很确定这不是正确的方法，但我只是想确定一下）？

如果你能给出一个小代码示例，我会很感激它，其中代码触发了什么。

Answer 1

1) 如果您的对象在自动存储中，您可以限制它们的范围：

{
   X x;
   //...
}  //x gets destructed here

如果在动态存储中，完成后将其删除：

X* x = new X;
//...
delete x; //x gets destructed

2) 你不能（至少以干净的方式）。您必须指示 C++ 何时删除您的对象，即使该指令包含一个结束括号。 （见第一个代码sn-p）

3) C++ 中没有垃圾收集器。请参阅两个 sn-ps。您要么必须显式删除对象（如果在动态存储中），要么如果在自动存储中，它们将被自动删除（但不是由垃圾收集器）。

值得研究的是智能指针（那里有很多实现），但这也不是垃圾收集器。它只是为您节省了管理内存的麻烦。但它与 Java 完全不同。

Answer 2

C++ 在这方面与 Java 有很大不同，所以这里有一个简要的概述：

分配：为对象预留内存。
构造：对象已准备好使用。
破坏：对象“完成”一切并自行分解。
释放：内存归还给系统。

int main() {
    int myint;  //automatic int object is allocated and constructed
    //stuff
}   // when main ends, automatic int object is destroyed and deallocated

int main() {
    int* mypointer;  //automatic pointer object is allocated and constructed
    mypointer = new int;  //dynamic int object is allocated and constructed
    //stuff
    delete mypointer; //dynamic int object is destroyed and deallocated 
}   // when main ends, automatic pointer object is destroyed and deallocated
    // note: Pointers to _not_ delete the object they point to.

class myclass {
    //members
public:
    myclass() {} //this is the default constructor
    myclass(const myclass& rhs) {} //this is the copy constructor
    myclass& operator=(const myclass& rhs) {return *this} //this is the assignment operator
    ~myclass() {} //this is the destructor
};

当一个函数结束时，函数本身中的所有变量（我们称之为自动）都会调用它们的析构函数，然后它们会被自动释放。这意味着对于函数本地的对象，它们会在函数结束时自动清理自己即时。这也神奇地适用于类的成员。当它被销毁时，它的每个成员都会自动被销毁。这意味着大多数析构函数都是空的。

如果您手动分配东西（使用new 关键字），则必须使用delete 关键字手动销毁和释放它。当您调用delete 时，它会立即销毁（并取消分配），并且在完成之前不会继续。如果你忘记了，它永远不会被释放（尽管，一些操作系统会在你的程序结束时释放它）。

由于人们会犯错误，所以当您需要动态对象时，“正确”的做法是：

int main() {
    std::unique_ptr<myclass> myptr = new myclass(); //allocate and construct
} //both the unique_ptr and the dynamic object are destroyed and deallocated

unique_ptr 足够聪明，可以自动清理它所指向的东西，让您免于处理更大的问题。

C++ 这样做的原因是因为如果你有一个对象F 代表那个文件，它可能对那个文件有一个排他锁。在 C++ 中，一旦 F 被销毁，您可以立即创建使用同一文件的对象 G。在 Java 中，不能保证finalizer 将永远运行，这意味着该文件可能会保持锁定状态，直到您的程序结束。 （不太可能，但可能）

Answer 3

C++ 中没有垃圾收集器。您应该自己编写和运行析构函数。在 C++ 中，忘记运行析构函数是一个常见错误。

如果你的对象是用new 分配的，那么你应该用delete 删除它。所以，new 调用构造函数，而delete 调用析构函数。

myclass *p = new myclass();
// do something
delete p;

这称为动态对象分配。

如果你的对象是“正常”定义的，它会在超出范围时自动销毁。

myclass a;
// do something
// will destructed when }

这称为自动对象分配。

附：你也不要在 Java 中分配空值，因为垃圾收集器是为了不打扰对象删除而发明的。

Answer 4

C++ 使用 RAII (Resource Acquisition Is Initialization) 编程习惯，没有像 java 中的垃圾收集器或 Objective-C 2 中的 AutoZone 这样的自动内存管理。因此，正确的实例清理很容易变得复杂。回答您的问题：

ad 1：C++ 中没有 GC，因此您必须手动删除对象或使用引用计数技术或更好的智能指针，它们现在是 C++11 标准的一部分，但据我所知是尚未在任何 C++ 编译器中可用。现在您可以使用 Boost 库中的智能指针模板：http://www.boost.org/doc/libs/1_48_0/libs/smart_ptr/smart_ptr.htm。新的 C++ 标准直接采用了 Boost 实现，所以在不久的将来切换到新标准不会有问题（MSVC 2012 将实现 C++11 支持）。

广告 2：无法标记，只需在正确的位置“手动”删除它或将此任务留在智能指针上。

广告 3：不适用。

最后，总是有最简单的选择——不要在堆上分配对象，这意味着动态。在 Java 中没有这种可能性，但在 C++ 中却有。 我什至读过 Stroustrup（C++ 的创造者）的一些关于 C++ 编程的好书，在创建 C++ 时不推荐这种动态分配。他说：要让 RAII 正常工作，一定不能动态分配 - 今天听起来很奇怪，但这是 Stroustrup 写的，这不是我的想法，我个人几乎像每个人一样动态分配所有东西......

静态分配的主要原因是对象一旦超出范围就会被删除，因此完全不必担心异常安全和清理。如果您动态分配实例，如果实例离开当前范围，则不会自动删除它 - 您有内存泄漏 - 如果您不手动删除实例。考虑简单的 try-catch 块：

try 
{
Class *instance = new Class;
//some error
}
catch(...)
{
//error caught - current execution is terminated immediately, instance is no deleted - memory leak.
}

Java 有一个 finally 语句，它总是被调用，以便您可以在抛出异常时执行必要的清理。但是在 C++ 中你遇到了麻烦......除非你使用提到的智能指针或一些非常相似的技术。使用智能指针时，你不必再担心清理（在实践中并不完全正确，但你的生活肯定会更轻松，你的代码也更少错误）。

Answer 5

C++ 中的垃圾收集始终是即时的。没有单独的垃圾收集器；当您删除一个对象时，它会立即在当前线程上被删除。它看起来像这样：

MyObject* foo = new MyObject();
...
delete foo;

有可用于 C++ 的垃圾收集框架，您还可以查看智能指针，它也是垃圾收集的一种形式。

请注意下面 James 的 cmets —— 对象的析构函数和操作符 delete 总是被立即调用，但它取决于内存是否立即可用。