Order of destruction

Discussion in 'C++' started by Lilith, Apr 3, 2008.

  1. Lilith

    Lilith Guest

    Does the standard define the order in which objects declared in the
    same scope are destructed when those objects go out of scope? This
    has a bearing on some cleanup work I want to incorporate in one of my
    classes.

    TIA,
    Lilith
     
    Lilith, Apr 3, 2008
    #1
    1. Advertising

  2. Lilith

    Martin York Guest

    On Apr 3, 7:43 am, Lilith <> wrote:
    > Does the standard define the order in which objects declared in the
    > same scope are destructed when those objects go out of scope?


    Yes.
    Reverse order of creation.
     
    Martin York, Apr 3, 2008
    #2
    1. Advertising

  3. Lilith

    Lilith Guest

    On Thu, 3 Apr 2008 08:35:52 -0700 (PDT), Martin York
    <> wrote:

    >On Apr 3, 7:43 am, Lilith <> wrote:
    >> Does the standard define the order in which objects declared in the
    >> same scope are destructed when those objects go out of scope?


    >Yes.
    >Reverse order of creation.


    Thank you. That makes it much easier to maintain.

    --
    Lilith
     
    Lilith, Apr 3, 2008
    #3
  4. Lilith

    James Kanze Guest

    On Apr 4, 1:22 am, Ron Natalie <> wrote:
    > Lilith wrote:
    > > Does the standard define the order in which objects declared
    > > in the same scope are destructed when those objects go out
    > > of scope? This has a bearing on some cleanup work I want to
    > > incorporate in one of my classes.


    > Scope has no meaning for object lifetime. It doesn't exist at
    > runtime.


    Yes and no. The concepts are definitely orthogonal, but for
    historical reasons, in C++, object lifetime, or at least the
    default object lifetime, is partially determined by the scope of
    the object's definition.

    > But, with the exception of the dynamic allocation where you
    > specifically have control over when you destroy it, objects
    > are always destructed in reverse order of construction.


    Only within very restricted categories, and with numerous
    exceptions. Reverse order is true for members of a class,
    temporaries whose lifetime hasn't been extended, non-static
    local variables, objects with static lifetime, and I think (but
    I'm not sure) thrown objects. It's trivial, however, to create
    examples where order of destruction is not the reverse of
    construction: anytime a temporary is bound to a const reference,
    for example, or is used to initialize an other object; or between
    static and non-static local variables. E.g.:

    void
    f()
    {
    MyClass a ;
    static MyClass b ;
    }

    Order of construction: a, then b. Order of destruction, a, and
    sometime well after leaving f, b. (Throw in a call to exit() at
    the end of f, and the issue becomes even less clear---a will
    never be destructed.)

    --
    James Kanze (GABI Software) email:
    Conseils en informatique orientée objet/
    Beratung in objektorientierter Datenverarbeitung
    9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34
     
    James Kanze, Apr 4, 2008
    #4
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.
Similar Threads
  1. Stephan Keil

    Destruction order (e.g. singletons)

    Stephan Keil, Nov 16, 2004, in forum: C++
    Replies:
    0
    Views:
    453
    Stephan Keil
    Nov 16, 2004
  2. Davlet Panech
    Replies:
    4
    Views:
    347
    Davlet Panech
    Nov 10, 2006
  3. Dennis Jones
    Replies:
    2
    Views:
    323
    Dennis Jones
    Jan 5, 2007
  4. BeautifulMind
    Replies:
    7
    Views:
    649
    Ron Natalie
    Feb 8, 2007
  5. Victor Bazarov
    Replies:
    11
    Views:
    752
    James Kanze
    Dec 9, 2009
Loading...

Share This Page