Повторная инициализация структуры в заголовке

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

super.hpp

#ifndef H_INIT
#define H_INIT

#include <iostream>
#include <string>

static bool isInit = false;

struct settings_struct{
std::string path = "foo";
void load(){ path = "bar"; }
};

struct initializer_struct{
settings_struct settings;

initializer_struct(){
if(!isInit){
std::cout << "Doing initialization\n";
settings.load();
isInit = true;
}
// settings.load();
}//====================

~initializer_struct(){
if(isInit){
std::cout << "Doing closing ops\n";
isInit = false;
}
}
};

static initializer_struct init; // static declaration: only create one!

#endif

Мое намерение с этим заголовком состоит в том, чтобы создать initializer_struct объект один раз; когда она построена, эта структура выполняет несколько действий, которые устанавливают флаги и настройки для всей библиотеки. Одним из этих действий является создание структуры настроек, которая загружает настройки из файла XML; это действие также должно происходить только один раз при создании структуры init, поэтому переменные (здесь path) сохраняются из файла настроек. super.hpp заголовок включен во все объекты в библиотеке, потому что разные объекты используются в разных мощностях, то есть нет способа предсказать, какие из них будут использоваться в приложении, поэтому я включаю super.hpp заголовок во всех них, чтобы гарантировать, что это называется независимо от того, какие объекты используются.

Моя проблема заключается в следующем: когда я включаю super.hpp в нескольких классах / объектах, которые все загружены основным приложением, структура init кажется, что инициализируется заново, и переменные устанавливаются, когда settings_struct построен перезаписаны значениями по умолчанию. Чтобы увидеть это в действии, рассмотрите следующие дополнительные файлы:

test.cpp

#include "classA.hpp"#include "classB.hpp"#include <iostream>

int main(int argc, char *argv[]){
(void) argc;
(void) argv;

classA a;
classB b;

std::cout << "Settings path = " << init.settings.path << std::endl;
std::cout << "Class A Number = " << a.getNumber() << std::endl;
std::cout << "Class B Number = " << b.getInteger() << std::endl;
}

classA.hpp

#ifndef H_CLASSA
#define H_CLASSA

class classA{
private:
double number;

public:
classA() : number(7) {}
double getNumber();
};

#endif

classA.cpp

#include "super.hpp"#include "classA.hpp"
double classA::getNumber(){ return number; }

classB.hpp

#ifndef H_CLASSB
#define H_CLASSB

class classB{
private:
int number;

public:
classB() : number(3) {}
int getInteger();
};

#endif

classB.cpp

#include "super.hpp"#include "classB.hpp"
int classB::getInteger(){ return number; }

Чтобы скомпилировать и запустить пример,

g++ -std=c++11 -W -Wall -Wextra -Weffc++ -pedantic -c classA.cpp -o classA.o
g++ -std=c++11 -W -Wall -Wextra -Weffc++ -pedantic -c classB.cpp -o classB.o
g++ -std=c++11 -W -Wall -Wextra -Weffc++ -pedantic classA.o classB.o test.cpp -o test.out
./test.out

Я ожидаю, что вывод test.out будет следующим:

Doing initialization
Settings path = bar
Number = 7
Doing closing ops

Однако, когда я запускаю это, я вместо этого получаю «Параметры пути = foo». Таким образом, мой вывод заключается в том, что initializer_struct, init, строится более одного раза. Первый раз, логическое isInit ложно, и структура настроек load наборы функций path в бар.» Для всех последующих инициализаций isInit верно, поэтому load функция не вызывается снова, и кажется, что значения переменных из неинициализированных settings (Т.е. path = "foo") перезаписать ранее загруженные значения, следовательно вывод init.settings.path в test.cpp,

Почему это? Почему init объект создается каждый раз, когда заголовок включен? Я бы подумал, что включенные охранники будут предотвращать повторный вызов кода заголовка. Если я сделаю init переменная в test.hpp нестатическая переменная, затем создается несколько копий, и выходные данные выводят несколько итераций «Выполнение инициализации» и «Выполнение операций закрытия». Кроме того, если я раскомментирую settings.load() вызов функции вне условного оператора в initializer_struct() конструктор, то вывод дает путь настройки «бар». Наконец, снятие включения super.hpp от classA.cpp приводит к значению пути «bar», что еще больше подтверждает мою гипотезу о том, что множественные включения test.hpp привести к нескольким вызовам конструктора.

Я хотел бы избежать settings.load()' called for every object that includessuper.hpp` — поэтому я поместил команду в условном выражении. Какие-нибудь мысли? Как убедиться, что файл настроек читается только один раз и что загруженные значения не перезаписываются? Это абсолютно тупой метод для установки некоторых флагов и настроек, которые использует моя библиотека? Если да, есть ли у вас какие-либо предложения, чтобы сделать процессы более простыми и / или более элегантными?

Спасибо!

редактировать: Обновлено, чтобы включить два класса объектов, чтобы ближе представить мою более сложную установку