Constructor Console (global area)

Question

I have a problem with ordering the constructor, I'm trying to find creative ways to solve it.

Basically, I have a simple Color class that stores information about RGB color and allows you to manipulate the specified color and convert it to other color spaces (24 bits, 16 bits, 4 bits, HSV, XYZ, LAB, etc.). The class itself works great.

I also have a library of predefined colors, for example:

 namespace Colors { const Color Snow (255,250,250); const Color GhostWhite (248,248,255); const Color WhiteSmoke (245,245,245); const Color Gainsboro (220,220,220); const Color FloralWhite (255,250,240); const Color OldLace (253,245,230); const Color Linen (250,240,230); const Color AntiqueWhite (250,235,215); const Color PapayaWhip (255,239,213); const Color BlanchedAlmond (255,235,205); }; 

And they all work fine during normal use in the program.

My problem arises when I try to use these library colors in the constructor for another object. There is nothing to say that the constructor for the color of the library that I am using has been executed and color data has been assigned (it does a little preprocessing to calculate some color space values) before the constructor for another class that receives Color and assigns it a storage variable inside itself.

For example, the Color class has a constructor:

 Color(const Color &c) { setColor(c.getRed(), c.getGreen(), c.getBlue()); } 

And the operator = :

 Color &Color::operator=(const Color &rhs) { setColor(rhs.getRed(), rhs.getGreen(), rhs.getBlue()); return *this; } 

setColor() is just a small helper function that stores values ​​and pre-computes alternative color space values.

When I include it in the constructor of another object, let's say:

 Color _storeColor; TestClass(const Color &c) { _storeColor = c; } 

or

 Color _storeColor; TestClass(const Color &c) : _storeColor(c) {} 

with:

 TestClass myTest(Colors::WhiteSmoke); 

the assigned color data (almost always) is all 0 , as if the constructor for the Color class is not already running, which is what I get completely.

So, I'm looking for ideas on how I can create my library of predefined colors so that they are available to other designers in the global area.

By the way, things like:

 TestClass myTest(Color(245,245,245)); 

works fine, although I would prefer not to have hundreds (and hundreds) or #define macros for the color library, as this will cause a lot of unnecessary duplication of objects, and I would prefer to keep it as always referring to the same global instances when the color is reused .

Answer 1

The C ++ standard does not define the order in which constructors in different translation units are obtained, as you know.

But most C ++ implementations usually provide a means of specifying the initialization order of the constructor, which you may be able to take advantage of.

For example, gcc has an init_priority attribute that can be attached to the constructor and control the initialization order of the constructor relative to other constructors. This will probably be the answer in the case of gcc.

Check your compiler documentation for more information on what functions related to the compiler are offered in this area.

For a more portable approach, it may be possible to do something so that the PODs are initialized before non-trivial class instances in the namespace area. Perhaps you can use this to come up with some kind of approach here, but first I suggest you first examine your compiler capabilities. There is nothing wrong with using the extra features that your compiler offers.

Answer 2

What you encounter is sometimes called the "static initialization fiasco order".

One way to deal with it is to use Construct on First Use Idiom, implemented, for example, by changing the color definitions in the getter function:

 const Color & Snow(void) { static Color snow(255,250,250); return snow; } 

You can read more in this article .

---

Edit: to avoid excessive code, you can simply define a helper macro:

 #define DEF_COLOR(name, r, g, b) \ const Color & name(void) { \ static Color name(r,g,b); \ return name; \ } DEF_COLOR(Snow, 255,250,250) DEF_COLOR(GhostWhite, 248,248,255) // ... 

Answer 3

If you can use C++11 , you can also try to organize your preprocessing so that it can be calculated at compile time and made constexpr color constexpr :

 class Color { public: int m_r, m_g, m_b; constexpr Color(int r, int g, int b) : m_r(r), m_g(g), m_b(b) {} constexpr Color(Color const& o) : m_r(o.m_r), m_g(o.m_g), m_b(o.m_b) {} }; constexpr const Color RED = Color(255,0,0); constexpr const Color BLUE = Color(0,255,0); constexpr const Color GREEN = Color(0,0,255); 

This should ensure that colors are initialized before calling other constructors (constant initialization occurs before dynamic initialization). This has the added benefit that the compiler can do your preprocessing at compile time, so it can be even a little more efficient (however, it also means that it will not work if your preprocessing depends on values ​​available only at runtime )