Implementación correcta de la configuración global

Question

Mi objetivo es tener constantes globales en un juego de C++ en el que estoy trabajando (para representar algunos gráficos de información y similares). Mi implementación actual es lanzarlos todos en .h e incluirlos en todos lados. Esto funciona, excepto que cada vez que cambio una configuración, toda la base de código debe recompilarse.

Por lo tanto, mi siguiente idea fue arrojarlos en algún archivo de configuración de configuración y analizarlos, de esa manera no se cambia el código cuando cambia la configuración. El analizador era bastante simple, y podía poner los valores en las constantes, pero como el analizador era un bloque de código, las constantes ya no eran globales.

¿Hay una buena manera de solucionar esto? ¿Quizás sea una forma de hacerlos globales a pesar de estar en un bloque o de alguna forma evitar volver a compilar todo al cambiar la configuración?

Answer 1

Otra forma de hacerlo sería crear una clase singleton.

#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; 
}; 

Aquí, la configuración se guarda en un mapa, es decir, el tiempo que parseFile puede leer el archivo y getValue puede analizar el tipo que no hay necesidad de volver a compilar la clase de configuración si se agrega nuevas llaves.

Uso:

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

Answer 2

ponga solo las declaraciones en el archivo principal y ponga las definiciones en un archivo cpp. a continuación, cambie las definiciones en el archivo cpp no ​​causará todo el código recompilado

Answer 3

¿Qué ocurre con la creación de funciones que devuelven las constantes que puede especificar en un archivo .cxx? Por ejemplo:

// foo.h 
const int BAR(); 

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

Answer 4

La forma en que solía resolver esto es poner las variables en un espacio de nombres global separada, que está en un archivo de cabecera llamado algo así como config.h, a continuación, incluir ese archivo en todas partes.

// 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 

El en un archivo fuente, que definir la variable y también se configura a un valor predeterminado. Este archivo fuente también tiene el código para cargar las variables desde su archivo de configuración.

// 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 
} 

Ahora en cada archivo fuente que necesitan las variables de configuración, incluyen config.h y accede a ellos como config::some_config_int.

Sin embargo, no hay una forma "adecuada" de resolver esto, todas las formas en que el trabajo es correcto a mis ojos.