C / C++ / MFC

George_George wrote:

The design pattern is, embed a sub-object into another object (e.g. embed Goo object g into Foo object),

include <iostream>
class Goo
{
public:
  int id;
  Goo() {
    printf("Goo()\n");
  }
  virtual ~Goo() {
    printf("~Goo(%d)\n", id);
  }
};
class Foo
{
public:
  Goo g;
  Foo(const Goo& v) : g(v) {
    printf("Foo()\n");
    g.id = 2;
  }
  virtual ~Foo() {
    printf("~Foo()\n");
  }
};
void func()
{
  printf("--> func()\n");
  Goo g;
  g.id = 1;
  printf("sep\n");
  Foo f(g);
  printf("<-- func()\n");
}
void main()
{
  printf("before func()\n");
  func();
  printf("after func()\n");
}

before func()
--> func()
Goo()
sep
Foo()
<-- func()
~Foo()
~Goo(2)
~Goo(1)
after func()

George_George wrote:

What do you want to prove in this sample?

George_George wrote:

2. the order of destructors (of current instance and members) being called.
Your sample answered (1), but how about (2)?

George_George wrote:

I have looked at the result -- I think it is what you mean. What I mean is (sorry I have not made myself understood), is it Spec regulated that destructor of current object instance is invoked before destructors of member variables? Or implementation specific things?

George_George wrote:

It just mentioned in the reverse order of construction. Not mentioning the order of construction in the link you referred.

George_George wrote:

I have found the initialization order below. I think it means construction of member variables before the completion of constructor of current object. I think it also means the construction of member variables are before construction of current object.

So, the reverse order should be, destruct current object, then destruct member variables. Right?