C ++永远不会引用静态类的静态成员。 是否可以确定将其初始化，还是可以从二进制文件中将其省略？

Question

Let's say I have class A with only static members. One of its members is of class B

class A { 
  //...
  static B b;
}

In the A.cpp file I initialize all static members, using their constructors.

A.cpp:

B A::b(/*constructor arguments*/);

Now, nowhere in my whole project do I ever use the variable A::b.

Does that mean that the construction of that variable may totally be omitted from the final binary file by the compiler or the linker?

Even if I never use that variable, its construction has impact to the system configuration. (It may affect peripheral registers for example).

I am not using makefiles. I am using Atmel studio for AVR uControllers.

How can I be sure that the constructor of that variable will be executed during the globals and statics initialization phase of my program?

And, in general, how can I control that? (There may be a case that I need the opposite: to make sure it doesn't get initialized unless needed somewhere)

I have the impression that the initialization code may be omitted by the linker if there is no reference of that name anywhere.

Is that true?

Does it make a difference if other static variables from the file A.cpp are used? Maybe it has to do with the automated Makefile creation by the IDE, maybe it omits the whole cpp file if nothing is referenced from within

*The A.cpp belongs to a static library which I include into the project as a .a file

Thanks!

Answer 1

It's a bit complicated, because it depends also on the linker.

If you are building static libraries lib*.a then it's possible that the object will not be pulled into an executable during linking. In this case it will not be run. see GCC C++ Linker errors: Undefined reference to 'vtable for XXX', Undefined reference to 'ClassName::ClassName()'

If you use shared libraries or just build an executable then the code will be in the binary. Now comes the question of will it be executed.

Whether a static storage duration object is initialized depends a tiny bit on the implementation (there is some leeway to allow for optimization). BUT I think most implementations usually do it before main() . But a static storage duration object must be initialized before any variable or function defined in the same translation unit are used. See 6.8.3.3 of the standard for exact legal definition. see https://stackoverflow.com/a/1273257/14065

Now there is also another thing you have to consider. All static storage duration objects in a translation unit are constructed in the same order that they are declared within the translation unit (that happen during the dynamic initialization phase). Note: the order across translation units is undefined. see https://stackoverflow.com/a/211307/14065

Note: There is also a "static initialization" phase that happens prior to "dynamic initialization" phase where all static storage duration objects are zero initialized or are initialized using constant expressions.

But because of "Initialization Order Fiasco" (hate that name, it's not a fiasco its well defined you just need to know the rules, but that's the name you should google). You should avoid static storage duration objects at file scope (especially if they reference other static storage variables at file scope).

But there is workaround: Create a static storage duration in a function and return a reference. Use the function to get access to the object and that will solve your initialization order issues.

Using functions rather than globals: Is access to a static function variable slower than access to a global variable?
Solving the order of initialization: https://stackoverflow.com/a/335746/14065