Korrekte Implementierung der globalen Konfiguration

Question

Mein Ziel ist es, globale Konstanten in einem C++ - Spiel zu haben, an dem ich gerade arbeite (um einige Grafikinformationen und ähnliches darzustellen). Meine derzeitige Implementierung besteht darin, sie alle in eine .h zu werfen und sie überall einzubeziehen. Dies funktioniert, außer dass jedes Mal, wenn ich eine Einstellung ändere, die gesamte Codebasis neu kompiliert werden muss.

Also, meine nächste Idee war es, sie in einige Konfigurations-TXT-Datei werfen und analysieren sie, auf diese Weise wird kein Code tatsächlich geändert, wenn sich die Einstellungen ändern. Der Parser war einfach genug und ich konnte die Werte in die Konstanten schreiben, aber da der Parser ein Codeblock war, waren die Konstanten nicht länger global.

Gibt es einen guten Weg, dies zu lösen? Vielleicht eine Möglichkeit, sie global zu machen, auch wenn sie in einem Block sind oder irgendwie vermeiden, alles neu zu kompilieren, wenn man die Einstellungen ändert?

Answer 1

Eine andere Möglichkeit wäre das Erstellen einer Singleton-Klasse.

#include <fstream> 
#include <map> 
#include <string> 

class ConfigStore 
{ 
public: 
    static ConfigStore& get() 
    { 
     static ConfigStore instance; 
     return instance; 
    } 
    void parseFile(std::ifstream& inStream); 
    template<typename _T> 
    _T getValue(std::string key); 
private: 
    ConfigStore(){}; 
    ConfigStore(const ConfigStore&); 
    ConfigStore& operator=(const ConfigStore&); 
    std::map<std::string,std::string> storedConfig; 
}; 

Hier ist die Konfiguration in einer Karte gespeichert wird, was bedeutet, solange parseFile die Datei lesen und getValue den Typ gibt es keine Notwendigkeit, die Config-Klasse analysieren kann neu kompiliert werden, wenn Sie neue Schlüssel hinzuzufügen.

Verbrauch:

std::ifstream input("somefile.txt"); 
ConfigStore::get().parseFile(input); 
std::cout<<ConfigStore::get().getValue<std::string>(std::string("thing"))<<std::endl; 

Answer 2

Legen Sie nur die Deklarationen in Kopfdatei und setzen Sie die Definitionen in eine cpp-Datei. dann ändern Sie die Definitionen in CPP-Datei wird nicht dazu führen, dass alle Code neu kompiliert

Answer 3

Was ist mit dem Erstellen von Funktionen, die Ihre Konstanten zurückgeben, die Sie in einer .cxx-Datei angeben können? Zum Beispiel:

// foo.h 
const int BAR(); 

// foo.cxx 
const int BAR() { 
    return 10; 
}; 

Answer 4

Die Art und Weise habe ich lösen diese die Variablen in einem separaten globalen Namensraum zu setzen ist, die in einer Header-Datei so etwas wie config.h benannt ist, dann sind die überall Datei.

// In config.h 

#ifndef CONFIG_H 
#define CONFIG_H 

namespace config 
{ 
    extern int some_config_int; 
    extern std::string some_config_string; 

    bool load_config_file(); 
} 

#endif 

Die in einer Quelldatei, Sie die Variable definieren und diese auch auf einen Standardwert gesetzt. Diese Quelldatei enthält auch den Code zum Laden der Variablen aus Ihrer Konfigurationsdatei.

// In config.cpp 

namespace config 
{ 
    int some_config_int = 123; 
    std::string some_config_string = "foo"; 
} 

bool config::load_config_file() 
{ 
    // Code to load and set the configuration variables 
} 

nun in jeder Quelldatei müssen Sie die Konfigurationsvariablen umfassen config.h und greifen Sie wie config::some_config_int.

Allerdings gibt es keine "richtige" Art und Weise, dies zu lösen, alle Möglichkeiten, die Arbeit in meinen Augen richtig sind.