Re: How to write a library with a static object?
Adrian Hawryluk wrote:
John Harrison wrote:
Jeroen wrote:
OK, thanx. Very helpfull to read the link. Let me try a better
construction: if I go back to my code (yet to write...), then I have:
* class A that's available to the user
* class B that is used 'underwater', but only if the user does
something with class A
* a list for objects of class B (only accessed if the user does
something with class A...)
So maybe I am safe if I put the list as a static member of class A?
class B {
int blah;
};
class A {
private:
static list<B> my_list;
static void put_B_in_the_list(const B& b);
static B& find_B_in_the_list(int blah);
int more_blah;
};
Given the fact that the list is only accessed if the user of the
library uses class A, this should prevent the init fiasco described
in the link you gave?
Thanx again,
Jeroen
No, if your user attempts to use class A in the construction of a
global object there is no guarantee that my_list will have been
constructed. You only get that guarantee by putting my_list as a
static in a global function as shown in the FAQ.
john
Excuse me, but does anyone know why this fiasco even exist? Why is
there not some dependency mechanism in place? Or something like the
static local object being constructed when the control flows to them (as
opposed to over them)?
It's a good question. One issue would be that with such a scheme the
order of initialisation would be unpredictable, and that wouldn't mesh
well with the one guarantee that the standard does give, which is that
definitions within a single file are initialised in the order that they
occur in that file. I know at times I found that certainty to be useful.
There may be reasons why what you're suggesting isn't easy to achieve, I
don't know, but representatives of the major compiler wiriters work on
the C++ standards board so they wouldn't have decided on this fiasco
with out good reason.
One other thing. In that FAQ we have Fred defined as so:
// File x.cpp
#include "Fred.h"
Fred& x()
{
static Fred* ans = new Fred();
return *ans;
}
Why is it not defined like this:
// File x.cpp
#include "Fred.h"
Fred& x()
{
static Fred ans;
return &ans;
}
If you read FAQ 10.14 he explains why the pointer is used. Personally I
think the issue raised in that FAQ is more of a theoretical concern, I
never been bitten by it in practise (unlike the initalisation order fiasco).
It looks to me that the compilers are built pretty flimsily.
Adrian