Crear un fichero de configuración y un analizador sintáctico sencillos en C++

Como otros han señalado, probablemente será menos trabajo hacer uso de una biblioteca de analizador de archivos de configuración existente en lugar de reinventar la rueda.

Por ejemplo, si decide usar la biblioteca Config4Cpp (que mantengo), entonces la sintaxis del archivo de configuración será ligeramente diferente (ponga comillas dobles alrededor de los valores y termine las instrucciones de asignación con un punto y coma) como se muestra en el siguiente ejemplo:

# File: someFile.cfg
url = "http://mysite.com";
file = "main.exe";
true_false = "true";

El siguiente programa analiza lo anterior archivo de configuración, copia los valores deseados en variables y las imprime:

#include <config4cpp/Configuration.h>
#include <iostream>
using namespace config4cpp;
using namespace std;

int main(int argc, char ** argv)
{
    Configuration *  cfg = Configuration::create();
    const char *     scope = "";
    const char *     configFile = "someFile.cfg";
    const char *     url;
    const char *     file;
    bool             true_false;

    try {
        cfg->parse(configFile);
        url        = cfg->lookupString(scope, "url");
        file       = cfg->lookupString(scope, "file");
        true_false = cfg->lookupBoolean(scope, "true_false");
    } catch(const ConfigurationException & ex) {
        cerr << ex.c_str() << endl;
        cfg->destroy();
        return 1;
    }
    cout << "url=" << url << "; file=" << file
         << "; true_false=" << true_false
         << endl;
    cfg->destroy();
    return 0;
}

El sitio web de Config4Cpp proporciona documentación completa, pero leer solo los capítulos 2 y 3 de la "Guía de Introducción" debería ser más que suficiente para sus necesidades.

Un enfoque ingenuo podría verse así:

#include <map>
#include <sstream>
#include <stdexcept>
#include <string>

std::map<std::string, std::string> options; // global?

void parse(std::istream & cfgfile)
{
    for (std::string line; std::getline(cfgfile, line); )
    {
        std::istringstream iss(line);
        std::string id, eq, val;

        bool error = false;

        if (!(iss >> id))
        {
            error = true;
        }
        else if (id[0] == '#')
        {
            continue;
        }
        else if (!(iss >> eq >> val >> std::ws) || eq != "=" || iss.get() != EOF)
        {
            error = true;
        }

        if (error)
        {
            // do something appropriate: throw, skip, warn, etc.
        }
        else
        {
            options[id] = val;
        }
    }
}

Ahora puede acceder a cada valor de opción desde el mapa global options en cualquier lugar de su programa. Si desea castability, puede hacer que el tipo asignado sea a boost::variant.

Libconfig es muy fácil, y lo que es mejor, utiliza una notación pseudo json para una mejor legibilidad.

Fácil de instalar en Ubuntu: sudo apt-get install libconfig++8-dev

Y enlace: -lconfig++

¿Por qué no probar algo simple y legible, como JSON (o XML) ?

Hay muchas implementaciones de código abierto pre-hechas de JSON (o XML) para C++-yo usaría una de ellas.

Y si quieres algo más "binario" - prueba BJSON o BSON:)

¿Qué tal formatear su configuración como JSON, y usar una biblioteca como jsoncpp?

Por ejemplo

{"url": "http://mysite dot com",
"file": "main.exe",
"true": 0}

Luego puede leerlo en variables con nombre, o incluso almacenarlo todo en un mapa std::, etc. Esto último significa que puede agregar opciones sin tener que cambiar y recompilar su analizador de configuración.

He buscado bibliotecas de análisis de configuración para mi proyecto recientemente y encontré estas bibliotecas:

• http://www.hyperrealm.com/libconfig / - biblioteca pequeña pero potente y fácil de usar, ejemplos de uso están en el paquete fuente y aquí
• http://pocoproject.org/docs/Poco.Util.PropertyFileConfiguration.html - una parte de pocoproject. Puede usar abstracción en su código y detrás de eso usar varias implementaciones compatibles (ini archivos, configuraciones Xml, incluso variables de entorno)

Aquí hay un simple trabajo alrededor del espacio en blanco entre el signo '=' y los datos, en el archivo de configuración. Asignar a lastreamingstream desde la ubicación después del signo ' = ' y al leer desde él, cualquier espacio en blanco inicial se ignora.

Nota: mientras usa unstreamingstream en un bucle, asegúrese de llamar a clear() antes de asignarle una nueva cadena.

//config.txt
//Input name = image1.png
//Num. of rows = 100
//Num. of cols = 150

std::string ipName;
int nR, nC;

std::ifstream fin("config.txt");
std::string line;
std::istringstream sin;

while (std::getline(fin, line)) {
 sin.str(line.substr(line.find("=")+1));
 if (line.find("Input name") != std::string::npos) {
  std::cout<<"Input name "<<sin.str()<<std::endl;
  sin >> ipName;
 }
 else if (line.find("Num. of rows") != std::string::npos) {
  sin >> nR;
 }
 else if (line.find("Num. of cols") != std::string::npos) {
  sin >> nC;
 }
 sin.clear();
}