c++ - ¿Cómo uso boost:: lexical_cast y std:: boolalpha? es decir, boost:: lexical_cast<bool>("true")

string lexical-cast

Question

He visto algunas respuestas a otras preguntas boost::lexical_cast que afirman que es posible lo siguiente:

bool b = boost::lexical_cast< bool >("true");

Esto no funciona para mí con g ++ 4.4.3 boost 1.43. (Tal vez es cierto que funciona en una plataforma donde std :: boolalpha está configurado por defecto)

Esta es una buena solución para el problema de cadena a bool pero carece de validación de entrada que boost :: lexical_cast proporciona.

Answer 1

Estoy publicando la respuesta a mi pregunta aquí para otros que pueden estar buscando algo como esto:

struct LocaleBool {
    bool data;
    LocaleBool() {}
    LocaleBool( bool data ) : data(data) {}
    operator bool() const { return data; }
    friend std::ostream & operator << ( std::ostream &out, LocaleBool b ) {
        out << std::boolalpha << b.data;
        return out;
    }
    friend std::istream & operator >> ( std::istream &in, LocaleBool &b ) {
        in >> std::boolalpha >> b.data;
        return in;
    }
};

uso:

#include <boost/lexical_cast.hpp>
#include <iostream>
#include "LocaleBool.hpp"

int main() {
    bool b = boost::lexical_cast< LocaleBool >("true");
    std::cout << std::boolalpha << b << std::endl;
    std::string txt = boost::lexical_cast< std::string >( LocaleBool( b ) );
    std::cout << txt << std::endl;
    return 0;
}

Answer 2

Reúna su propia plantilla sobre el impulso de conversión léxica para analizar. Tenga en cuenta el parámetro "predeterminado" en el ejemplo para asegurarse de que la sobrecarga funcione correctamente (puede usar otro medio si lo desea).

template<typename T>
T Parse(const std::string& valStr, const T& default=T()) {
   T result = boost::lexical_cast<T>(valStr);
}

Luego, puedes especializarte en CUALQUIER COSA, incluidos bools:

template<>
bool Parse(const std::string& valStr, const bool& default=true) {
   if(strcmp(valStr.c_str(), "true") == 0) {
       return true;
   }
   return false;
}

Obviamente, hay varias maneras de hacerlo, y puede agregar más condiciones para verdadero vs falso (Me aseguraría de que todas las variantes de "VERDADERO" y "FALSO" como "Verdadero", más "T" y "F" trabajo bien). Incluso podría extenderlo a un análisis numérico.

Answer 3

Además del formulario de respuesta poindexter, puede ajustar el método desde aquí en una versión especializada de boost::lexical_cast :

namespace boost {
    template<> 
    bool lexical_cast<bool, std::string>(const std::string& arg) {
        std::istringstream ss(arg);
        bool b;
        ss >> std::boolalpha >> b;
        return b;
    }

    template<>
    std::string lexical_cast<std::string, bool>(const bool& b) {
        std::ostringstream ss;
        ss << std::boolalpha << b;
        return ss.str();
    }
}

Y úsala:

#include <iostream>
#include <boost/lexical_cast.hpp>

//... specializations

int main() {
    bool b = boost::lexical_cast<bool>(std::string("true"));
    std::cout << std::boolalpha << b << std::endl;
    std::string txt = boost::lexical_cast< std::string >(b);
    std::cout << txt << std::endl;

    return 0;
}

Personalmente me gustó este enfoque porque oculta cualquier código especial (por ejemplo, usando LocaleBool o to_bool(...) desde el enlace) para convertir a / desde bools.