Q: Order of construction for objects

[Jakob Bieling]

Hi,

I am aware of the fact, that the order of construction of global
objects is unspecified. But I am in a situation, where I need to
guarantee, that one object is created before others (not all others,
just all objects of a specified type). I came up with the following
solution, but I am not sure, if it does solve my problem:

class first
{
};

class A
{
static first first_obj;
};

int main ()
{
A mya;
}

class A (further implementation omitted) will rely on some
initialization done by class first. Is it guaranteed that this
initialization will be all done, before I use A?

thanks!
--
jb

(reply address in rot13, unscramble first)

[Rolf Magnus]

Jakob Bieling wrote:

Hi,

I am aware of the fact, that the order of construction of global
objects is unspecified.
Not entirely. Within one translation unit, it is well-defined.
But I am in a situation, where I need to guarantee, that one object is
created before others (not all others, just all objects of a specified
type).

The typical way to do this is by using the singleton pattern. Something like
this:

class first
{
static first& instance()
{
static first inst;
return inst;
}

private:
first() {}

// prevent copying
first(first&);
void operator=(first &);
};

Then you only use the object through the instance() member function. This
guarantees that the object gets created in the moment it is needed the
first time.

[Jakob Bieling]

"Rolf Magnus" <ra******@t-online.de> wrote in message
news:d7******** *****@news.t-online.com...

Jakob Bieling wrote:

Hi,

I am aware of the fact, that the order of construction of global
objects is unspecified.

Not entirely. Within one translation unit, it is well-defined.

But I am in a situation, where I need to guarantee, that one object
is
created before others (not all others, just all objects of a
specified
type).

The typical way to do this is by using the singleton pattern.
Something like
this:

class first
{
static first& instance()
{
static first inst;
return inst;
}

private:
first() {}

// prevent copying
first(first&);
void operator=(first &);
};

Then you only use the object through the instance() member function.
This
guarantees that the object gets created in the moment it is needed the
first time.

To be more exact, I will not need the object itself .. it only
contains a ctor and a dtor, which take care of initialization and
cleanup. And that initialization is needed for class A.

I could do the initialization at startup before anything else, but I
would like to automate this.

Thanks for the help!
--
jb

(reply address in rot13, unscramble first)

[John Carson]

"Jakob Bieling" <ar************ ****@rot13.com> wrote in message
news:d7******** *****@news.t-online.com

Hi,

I am aware of the fact, that the order of construction of global
objects is unspecified.
It is unspecified if they are in different translation units. If they are in
the same translation unit, then construction is in the same order as
definition. Section 3.6.2/1 of the standard:

"Objects with static storage duration (3.7.1) shall be zero-initialized
(8.5) before any other initialization takes place. Zero-initialization and
initialization with a constant expression are collectively called static
initialization; all other initialization is dynamic initialization. Objects
of POD types (3.9) with static storage duration initialized with constant
expressions (5.19) shall be initialized before any dynamic initialization
takes place. Objects with static storage duration defined in namespace scope
in the same translation unit and dynamically initialized shall be
initialized in the order in which their definition appears in the
translation unit."
But I am in a situation, where I need to
guarantee, that one object is created before others (not all others,
just all objects of a specified type). I came up with the following
solution, but I am not sure, if it does solve my problem:

class first
{
};

class A
{
static first first_obj;
};

This only declares first_obj, where do you define it?
int main ()
{
A mya;
}

class A (further implementation omitted) will rely on some
initialization done by class first. Is it guaranteed that this
initialization will be all done, before I use A?

Section 3.6.2/3 of the standard:

"It is implementation-defined whether or not the dynamic initialization
(8.5, 9.4, 12.1, 12.6.1) of an object of namespace scope is done before the
first statement of main. If the initialization is deferred to some point in
time after the first statement of main, it shall occur before the first use
of any function or object defined in the same translation unit as the object
to be initialized.31) [Example:
// – File 1 –
#include "a.h"
#include "b.h"
B b;
A::A(){
b.Use();
}

// – File 2 –
#include "a.h"
A a;

// – File 3 –
#include "a.h"
#include "b.h"
extern A a;
extern B b;
int main() {
a.Use();
b.Use();
}
It is implementation-defined whether either a or b is initialized before
main is entered or whether the initializations are delayed until a is first
used in main. In particular, if a is initialized before main is entered, it
is not guaranteed that b will be initialized before it is used by the
initialization of a, that is, before A::A is called. If, however, a is
initialized at some point after the first statement of main, b will be
initialized prior to its use in A::A. ]"

Section 9.4.2/7:

"Static data members are initialized and destroyed exactly like non-local
objects (3.6.2, 3.6.3)."

From all this, we may conclude: the initialization of

static first first_obj;

"shall occur before the first use [in main()] of any function or object
defined in the same translation unit as the object to be initialized [i.e.,
first_obj]." So if first_obj and A are defined in the same translation unit,
first_obj must be initialised before the first use of A in main(). At least
that is how it appears to me.

--
John Carson

[Ioannis Vranos]

Jakob Bieling wrote:

Hi,

I am aware of the fact, that the order of construction of global
objects is unspecified. But I am in a situation, where I need to
guarantee, that one object is created before others (not all others,
just all objects of a specified type). I came up with the following
solution, but I am not sure, if it does solve my problem:

class first
{
};

class A
{
static first first_obj;
};

int main ()
{
A mya;
}

class A (further implementation omitted) will rely on some
initialization done by class first. Is it guaranteed that this
initialization will be all done, before I use A?

Yes. However all global objects would be initialised before the invocation of main().

In any case, first_obj will be initialised before any use of class A.

--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Ioannis Vranos]

Ioannis Vranos wrote:

Yes. However all global objects would be initialised before the
invocation of main().

In any case, first_obj will be initialised before any use of class A.

.... even if class A is defined in some local scope (like a function, method or even a
block). That is, in any scope.
--
Ioannis Vranos

http://www23.brinkster.com/noicys

[Rolf Magnus]

Jakob Bieling wrote:

"Rolf Magnus" <ra******@t-online.de> wrote in message
news:d7******** *****@news.t-online.com...

Jakob Bieling wrote:

Hi,

I am aware of the fact, that the order of construction of global
objects is unspecified.

Not entirely. Within one translation unit, it is well-defined.

But I am in a situation, where I need to guarantee, that one object
is
created before others (not all others, just all objects of a
specified
type).

The typical way to do this is by using the singleton pattern.
Something like
this:

class first
{
static first& instance()
{
static first inst;
return inst;
}

private:
first() {}

// prevent copying
first(first&);
void operator=(first &);
};

Then you only use the object through the instance() member function.
This
guarantees that the object gets created in the moment it is needed the
first time.

To be more exact, I will not need the object itself .. it only
contains a ctor and a dtor, which take care of initialization and
cleanup. And that initialization is needed for class A.

I could do the initialization at startup before anything else, but I
would like to automate this.

Well, you can also do that with the singleton. You can put your
initialization into the constructor and the cleanup in the destructor.

[Jakob Bieling]

"John Carson" <jc************ ****@netspace.n et.au> wrote in message
news:d7******** **@otis.netspac e.net.au...

"Jakob Bieling" <ar************ ****@rot13.com> wrote in message
news:d7******** *****@news.t-online.com
--- A.h ---

class first
{
};

class A
{
static first first_obj;
}; This only declares first_obj, where do you define it?
Oops. It should have been in a different translation unit:

--- A.cpp ---

first A::first_obj;

--- main.cpp ---
int main ()
{
A mya;
}

Section 3.6.2/3 of the standard:

"It is implementation-defined whether or not the dynamic
initialization (8.5, 9.4, 12.1, 12.6.1) of an object of namespace
scope is done before the first statement of main. If the
initialization is deferred to some point in time after the first
statement of main, it shall occur before the first use of any function
or object defined in the same translation unit as the object to be
initialized.31) [Example:
Since first_obj is in its own translation unit, it may possibly not
be initialized at all?
From all this, we may conclude: the initialization of

static first first_obj;

"shall occur before the first use [in main()] of any function or
object defined in the same translation unit as the object to be
initialized [i.e., first_obj]." So if first_obj and A are defined in
the same translation unit, first_obj must be initialised before the
first use of A in main(). At least that is how it appears to me.

It would be a different translation unit. first_obj is in a
translation unit by itself, with no code of A in it. I should add, that
A actually is a template, and thus the definition of its member
functions are inlined. Just let me create a new example, which more
reflects the actual problem:

--- class.h ---

class API_init
{
API_init() { init_some_API (); }
~API_init() { cleanup_some_AP I (); }
};

template <typename T>
class A
{
static API_init init_obj;

A ()
{
API_function_th at_relies_on_in it ();
}

void func ()
{
other_API_funct ion_that_relies _on_init ();
}
};
--- class.cpp ---

#include "class.h"

API_init A::init_obj;
--- main.cpp ---

#include "class.h"

A a1;

int main ()
{
A a2;
a1.func ();
a2.func ();
}
Will the ctor of API_init be called *before* the ctor of A is
called? If not, or if that is not guaranteed, then it may be possible
that the API I will use is not initialized properly, making subsequent
calls to other API functions fail. And that is basically the problem I
am trying to solve.

Thanks
--
jb

(reply address in rot13, unscramble first)

[Jakob Bieling]

"Ioannis Vranos" <iv*@remove.thi s.grad.com> wrote in message
news:1117288986 .240165@athnrd0 2...

Ioannis Vranos wrote:

Yes. However all global objects would be initialised before the
invocation of main().

In any case, first_obj will be initialised before any use of class A.

... even if class A is defined in some local scope (like a function,
method or even a block). That is, in any scope.

Even if class A does not call any member function of first_obj? I
posted a more exact example in reply to John's answer .. so if your 'in
any case' applies to that case as well, my problem would be solved :)

Thanks!
--
jb

(reply address in rot13, unscramble first)

[Jakob Bieling]

"Rolf Magnus" <ra******@t-online.de> wrote in message
news:d7******** *****@news.t-online.com...

Jakob Bieling wrote:

"Rolf Magnus" <ra******@t-online.de> wrote in message
news:d7******** *****@news.t-online.com...

Jakob Bieling wrote:

Hi,

I am aware of the fact, that the order of construction of
global
objects is unspecified.

Not entirely. Within one translation unit, it is well-defined.

But I am in a situation, where I need to guarantee, that one object
is
created before others (not all others, just all objects of a
specified
type).

The typical way to do this is by using the singleton pattern.
Something like
this:

class first
{
static first& instance()
{
static first inst;
return inst;
}

private:
first() {}

// prevent copying
first(first&);
void operator=(first &);
};

Then you only use the object through the instance() member function.
This
guarantees that the object gets created in the moment it is needed
the
first time.

To be more exact, I will not need the object itself .. it only
contains a ctor and a dtor, which take care of initialization and
cleanup. And that initialization is needed for class A.

I could do the initialization at startup before anything else,
but I
would like to automate this.

Well, you can also do that with the singleton. You can put your
initialization into the constructor and the cleanup in the destructor.

Uh yes, but 'instance' will never be called, because an instance is
not needed. The class 'first' does not contain any functionality, other
than initializing an API (and cleaning up). I wanted to avoid having a
dummy call in all class A ctors (either to a global function containing
the static object, or the member function as in your example), so I came
up with the static-member-of-class idea.
Since John's post I realized that the cut-down example I gave you,
did not really reflect the problem, so I wrote a new one in reply to
John's answer.
Basically, I want the initialization code to be automatically
executed (ie. no explicit function calls) before I use the API. Same for
the cleanup code: cleanup after I am done with everything. But I assumed
once the first problem is solved, the second will automatically be
solved, because destructions takes place in the reverse order of
construction. Or am I assuming too much?

Thanks!
--
jb

(reply address in rot13, unscramble first)