3

考虑以下代码

#include<iostream>
#include<string>

class A
{
    private:
        char name[10];

    public:
        A() { }
        A(const char *str)
        {
            strcpy(name, str);
            std::cout<<name<<" constructed"<<endl; 
        }
        ~A()
        {
           std::cout<<name<<" destructed"<<endl;
        }
};

int main()
{
   A a("a");
   A b("b");
   return 0;
}

以下程序的 O/P 为：

a constructed
b constructed
b destructed
a destructed

我对上面代码的唯一解释是，既然b是在之后创建a的，它应该存储a在堆栈的上方。现在，当 main 完成时，b首先弹出然后a，因此它的析构函数首先被调用，然后是 of a。

我的问题是：我的想法是否正确，或者以上是未定义的行为，并且可能因编译器而异？

4

2 回答 2

11

它不会改变，自动内存（堆栈）中的对象以它们创建的相反顺序被破坏。它完全由标准指定。

C++03 15.2。构造函数和析构函数

  1. [...] 自动对象按照其构建完成的相反顺序被销毁。
于 2012-06-17T16:04:22.533 回答
3

这就是为什么破坏顺序很重要（并且应该颠倒创建顺序）

class Foo
{
public:
  void foo() { /* ... */ }
};

class Bar
{
public:
   Bar(Foo const & foo) foo(foo) {}
   virtual ~Bar() { this->foo.foo(); }

   Foo const & foo;
};

int main()
{
  Foo foo;
  Bar bar(foo);
  // if foo gets destroyed before bar, then bar will call method foo() on invalid reference in its destructor
  // it is much more convenient to have bar destroyed before foo in such cases
}
于 2012-06-17T17:20:06.663 回答