foo will be printed first, as the objects are initialized in the order of their declarations. Run and see: Ideone online demo By the way, __attribute__((constructor)) is not Standard C++. It is GCC’s extension. So the behavior of your program depends on how GCC has defined it. In short, it is implementation-defined, according to it … Read more
Yes, static initializer blocks are guaranteed to execute in textual order. From the JLS, section 12.4.1: The intent is that a class or interface type has a set of initializers that put it in a consistent state, and that this state is the first state that is observed by other classes. The static initializers and … Read more
Why the static variables are deterministically initialized and local variables aren’t? See how the static variables are implemented. The memory for them is allocated at link time, and the initial value for them is also provided at link time. There is no runtime overhead. On the other hand, the memory for local variables is allocated … Read more
A static initialization blocks allows more complex initialization, for example using conditionals: static double a; static { if (SomeCondition) { a = 0; } else { a = 1; } } Or when more than just construction is required: when using a builder to create your instance, exception handling or work other than creating static … Read more
Interfaces should not have side-effects and that even applies to static intializers. They would have highly JVM-implementation dependent behavior. Look at the following code public class InterfaceSideEffects { public static void main(String[] args) { System.out.println(“InterfaceSideEffects.main()”); Impl i=new Impl(); System.out.println(“Impl initialized”); i.bla(); System.out.println(“Impl instance method invoked”); Foo f=new Impl(); System.out.println(“Impl initialized and assigned to Foo”); f.bla(); … Read more
The short version: The underlying reason for the problem when class A is instantiated outside of main is that a particular hook routine which is required to initialise the CUDA runtime library with your kernels is not being run before the constructor of class A is being called. This happens because there are no guarantees … Read more
The JLS holds the answer (note the bold statement): Similarly, every blank final variable must be assigned at most once; it must be definitely unassigned when an assignment to it occurs. Such an assignment is defined to occur if and only if either the simple name of the variable (or, for a field, its simple … Read more
Consider: template<typename T, T> struct value { }; template<typename T> struct HasStatics { static int a; // we force this to be initialized typedef value<int&, a> value_user; }; template<typename T> int HasStatics<T>::a = /* whatever side-effect you want */ 0; It’s also possible without introducing any member: template<typename T, T> struct var { enum { … Read more
The modern, more pattern-oriented way is not to use globals in the first place. There’s no other way around it. It wouldn’t be much of a “fiasco”, otherwise!