Постоянная инициализация зависимых нелокальных постоянных переменных с плавающей запятой со статической продолжительностью хранения в различных единицах трансляции

Хм ... Я бы не стал доверять этому коду, потому что боялся бы статического фиаско с порядком инициализации. AFAIK, порядок статической инициализации между разными единицами компиляции не определен. Значит, даже тесты не дадут мне уверенности в том, что всегда все будет хорошо.

Не вдаваясь в подробности, я не смог найти в стандарте ничего, что гарантировало бы, что Foo::kValue в foo.cpp будет инициализирован до Bar::kValue в bar.cpp. И если порядок неправильный, значение в Foo::kValue будет просто неопределенным.

const float не соответствует требованиям для того, чтобы быть постоянным выражением

(Этот ответ основан на Комментарий @ Oktalist, так как он воздержался от создания собственного ответа)

В следующих:

// foo.h
struct Foo {
  static const float kValue;
};

// foo.cpp
const float Foo::kValue = 1.5F;

Foo::kValue действительно инициализируется константным выражением посредством постоянной инициализации, но Foo::kValue сам по себе не является константным выражением, потому что он не является ни целым, ни перечислением, ни constexpr, ни временным. [expr.const] / 2 указывает [ акцент мой]:

< / a> является основным константным выражением, если только оно не включает одно из следующего в качестве потенциально оцениваемого подвыражения ([basic.def.odr]), но подвыражения логического И ([expr.log.and]), логическое ИЛИ ([expr.log.or]) и условным ([expr.cond]) операции, которые не оцениваются, не рассматриваются [Примечание: перегруженный оператор вызывает функцию. - конечное примечание]:

...

(2.9): преобразование lvalue-to-rvalue ([conv.lval]) если он не применяется к

• значение glvalue целочисленного или перечисляемого типа, которое относится к энергонезависимому константному объекту с предыдущей инициализацией, инициализированному константным выражением, или
• значение glvalue литерального типа, которое относится к энергонезависимому объекту, определенному с помощью constexpr, или которое относится к подобъекту такого объекта, или
• значение glvalue литерального типа, которое относится к энергонезависимому временному объекту, время жизни которого еще не закончилось, инициализированному константным выражением;

Поскольку ни один из подпунктов для (2.9) здесь не применяется, Foo::kValue не является постоянным выражением. Это следует из [basic.start.init] / 2 (как указано в более ранней стандартной версии вопроса), что Bar::kValue инициализируется не с помощью постоянной инициализации, а как часть динамической инициализации.

Переменные со статической продолжительностью хранения ([basic.stc.static]) или продолжительность хранения потока ([basic.stc.thread]) должен быть инициализирован нулем ([dcl.init] ) перед любой другой инициализацией [выделено мной]:

Постоянная инициализация выполняется:

• ...
• если объект со статической продолжительностью хранения или продолжительностью хранения потока не инициализирован вызовом конструктора и если каждое полное выражение, которое появляется в его инициализаторе, является постоянным выражением.

Примечание о "фиаско с порядком статической инициализации"

Обратите внимание, что этот конкретный пример не приводит к риску фиаско с порядком статической инициализации, поскольку Foo::kValue инициализируется как средство постоянной инициализации, а Bar::kValue инициализируется как часть динамической инициализации, а первый гарантированно завершится до начала динамической инициализации. .

Если бы первый также был инициализирован как часть динамической инициализации, инициализация двух была бы неопределенно последовательной по отношению друг к другу (и все остальные динамические инициализации).

Однако никогда не полагайтесь на тот факт, что этот конкретный пример имеет четко определенный порядок инициализации, поскольку небольшие изменения сделают этот факт недействительным:

// foo.h
struct Foo {
  static const float kDummyValue;
  static const float kValue;
};

// foo.cpp
const float Foo::kDummyValue = 1.5F;    // Constant initialization
const float Foo::kValue = kDummyValue;  // (!) Dynamic initialization

// bar.h
struct Bar {
  static const float kValue;
};

// bar.cpp
#include "foo.h"
const float Bar::kValue = Foo::kValue;  // (!) Dynamic initialization

// main.cpp
#include "bar.h"
#include <iostream>

int main() { std::cout << Bar::kValue; }

Как и в этом примере модификатора, инициализация Foo::kValue и Bar::kValue неопределенно упорядочена по отношению друг к другу, что означает, что Bar::kValue может быть инициализирован (со «значением» Foo::kValue) до того, как будет выполнено Foo::kValue.