Initialization of a static member inside a template

Question

Here's a minimal example:

#include <iostream>

struct B {
  B() { x = 42; }
  static int x;
};  

int B::x;

template <int N>
struct A {
  int foo() { return b.x; }
  static B b;
};

template<int N>
B A<N>::b;

//template struct A<2>; // explicit instantiation with N = 2 (!)

int main(int argc, char **argv) {
  std::cout << A<1>().foo() << std::endl;
  return 0;
}

This program writes 42 using g++ 4.9.2, but writes 0 using Visual Studio 2015 RC. Also, if I uncomment the explicit instantiation, VS2015RC also gives 42, which is quite interesting, as the template parameter here is different from the one used in the main function.

Is this a bug? I assume that g++ is correct, as there is a reference to b inside foo, so B's constructor should be called.

EDIT: There is a simple workaround - if there is a non-static variable in B, that is referenced in A, VS2015RC will compile correctly:

// ...

struct B {
  B() { x = 42; }
  static int x;
  int y;                         // <- non-static variable
};

// ...

template <int N>
struct A {
  int foo() { b.y; return b.x; } // <- reference to b.y
  static B b;
};

This seems to work, even though b.y, as a statement, is obviously NOP.

possibly related: http://stackoverflow.com/questions/3035422/static-initialization-order-fiasco — NathanOliver, Jul 13 '15 at 12:57

Barry · Accepted Answer · 2015-07-13T13:12:32.940

From [basic.start.init]:

Variables with static storage duration (3.7.1) or thread storage duration (3.7.2) shall be zero-initialized (8.5) before any other initialization takes place. A constant initializer for an object o is an expression that is a constant expression, except that it may also invoke constexpr constructors for o and its subobjects even if those objects are of non-literal class types. [ ... ]

Together, zero-initialization and constant initialization are called static initialization; all other initialization is dynamic initialization. Static initialization shall be performed before any dynamic initialization takes place.

In our case, b is statically initialized but b.x is dynamically initialized (the constructor isn't constexpr). But we also have:

It is implementation-defined whether the dynamic initialization of a non-local variable with static storage duration is done before the first statement of main. If the initialization is deferred to some point in time after the first statement of main, it shall occur before the first odr-use (3.2) of any function or variable defined in the same translation unit as the variable to be initialized.

Odr-used means, from [basic.def.odr]:

A variable x whose name appears as a potentially-evaluated expression ex is odr-used by ex unless applying the lvalue-to-rvalue conversion (4.1) to x yields a constant expression (5.20) that does not invoke any nontrivial functions and, if [ ... ]

But evaluating b.x does not yield a constant expression, so we can stop there - b.x is odr-used by A<N>::foo(), which is also the first odr-use. So while the initialization does not have to occur before main(), it does have to occur before foo(). So if you get 0, that's a compiler error.

score -2 · Answer 2 · edited Jul 13 '15 at 13:07

-2

I would be inclined to write the code like this:

struct B {
   B() {} 
   static int x;
};

int B::x = 42;

After all, the static (x) is defined (and therefore should be initialized) on the last line. Putting the initialization inside the constructor of B means that the static x (there is only one of them!) would be re-initialized each and every single time you construct a B. There is one static, you should initialize only once.

edited Jul 13 '15 at 13:07

Barry

286,269
29
621
977

answered Jul 13 '15 at 13:06

Laurent Michel

395
1
5

How does this address the question? – Barry Jul 13 '15 at 13:07
The bug is in the poster's code. Completely unwise to initialize a static repeatedly in the constructor. – Laurent Michel Jul 13 '15 at 13:10
This is a minimal example. The real code I'm looking at has a complex initialization involving two static arrays and template metaprogramming. Also, the static is not initialized repeatedly, as there is only one instance of B. – vukung Jul 13 '15 at 13:33

Initialization of a static member inside a template

2 Answers2