Constant singleton object initialization

[Helge Bahmann <hcb at chaoticmind dot net>]

Hello,

Assume the following very similiar class declarations:

class A {
public:
	int x;
};

class B {
public:
	inline B(int _x) : x(_x) {}
	int x;
};

class C {
public:
	inline C(int _x) : x(_x) {}
	virtual ~C(void) {}
	int x;
};

Now assume the following definitions:

const A a={42};
const B b(42);
const C c(42);

If I compile this, a will end up in the ".rodata" section with the correct 
initialization value written to the segment, while b and c end up in BSS and 
are initialized at runtime. While I think that at least b could reasonably be 
put into rodata, I am more interested in c -- is there a fundamental reason 
why this is not possible? (i.e. is this an artifact of the presence of a 
constructor, or does the virtual methods table pointer affect initialization 
as well?)

I have a program which declares a large amount of singleton objects in this 
way, I would like them to have virtual methods, and all constructors are 
empty. The problem is that the initialization of the objects is really eating 
into the start-up overhead. I could replace the classes with virtual methods 
with struct containing function-pointer tables, but this appears very 
un-C++-ish...

Thanks and best regards
-- 
Mathematicians stand on each other's shoulders while computer scientists stand 
on each other's toes.
-- Richard Hamming