¿Cómo uso boost :: lexical_cast y std :: boolalpha? es decir impulso :: lexical_cast < bool > ("verdadero")

Question

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

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

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

This es una buena solución al problema de cadena a bool, pero carece de validación de entrada que boost :: lexical_cast proporciona.

Answer 1

les dejo la respuesta a mi propia pregunta aquí por 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

Además del formulario de respuesta Poindexter, se puede envolver el método de here 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 utilizarla:

#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 ha gustado este enfoque porque oculta ningún código especial (por ejemplo, usando LocaleBool o to_bool(...) desde el enlace) para convertir a/desde bools.

Answer 3

Reúna su propia plantilla sobre el impulso de conversión léxica para el análisis. 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); 
} 

A continuación, puede especializarse para cualquier cosa, incluyendo Bools:

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

Es obvio que hay un número de maneras de hacer esto, y se puede añadir más condiciones para una verdadera vs falsa (que había asegúrese de que todas las variantes de "VERDADERO" y "FALSO" como "Verdadero", más "T" y "F" funcionan bien). Incluso podría extenderlo a un análisis numérico.