C++ 如何使用boost:：lexical_cast和std:：boolalpha？i、 e.boost：：词法演员阵容<；布尔>；（“真的”）

我已经看到了其他

boost:：lexical_cast

问题的一些答案，这些问题断言以下是可能的：

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

bool b=boost:：lexical_cast（“true”）；

这在我使用g++4.4.3 boost 1.43时不起作用。（也许它确实在默认设置了

std:：boolalpha

的平台上工作）

---

是字符串到布尔问题的一个很好的解决方案，但它缺少boost:：lexical_cast提供的输入验证。

我在这里为其他可能正在寻找类似内容的人发布我自己问题的答案：

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

struct LocaleBool{
布尔数据；
LocaleBool（）{}
LocaleBool（bool数据）：数据（data）{}
运算符bool（）常量{返回数据；}
friend std:：ostream&operator>std:：boolalpha>>b.data；
返回；
}
};

用法：

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

#包括
#包括
#包括“LocaleBool.hpp”
int main（）{
bool b=boost：：词法转换（“真”）；
std：：cout我将自己问题的答案张贴在这里，供其他可能正在寻找类似问题的人参考：

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

struct LocaleBool{
布尔数据；
LocaleBool（）{}
LocaleBool（bool数据）：数据（data）{}
运算符bool（）常量{返回数据；}
friend std:：ostream&operator>std:：boolalpha>>b.data；
返回；
}
};

用法：

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

#包括
#包括
#包括“LocaleBool.hpp”
int main（）{
bool b=boost：：词法转换（“真”）；
std:：cout除了答案表单poindexter之外，您还可以将来自的方法包装到专门版本的
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();
    }
}

namespace boost{
模板
bool词法转换（const std:：string和arg）{
std:：istringstream ss（arg）；
布尔b；
ss>>std:：boolalpha>>b；
返回b；
}
模板
std:：字符串词法转换（const bool&b）{
std：：ostringstream ss；
ss除了答案形式poindexter之外，您还可以将来自的方法包装到专门版本的
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();
    }
}

namespace boost{
模板
bool词法转换（const std:：string和arg）{
std:：istringstream ss（arg）；
布尔b；
ss>>std:：boolalpha>>b；
返回b；
}
模板
std:：字符串词法转换（const bool&b）{
std：：ostringstream ss；
ss将您自己的模板放在boost词法转换之上进行解析。请注意示例中的“default”参数，以确保重载正常工作（如果您愿意，可以使用其他方法）

模板
T Parse（const std:：string&valStr，const T&default=T（））{
T结果=boost：：词法转换（valStr）；
}

然后，你可以专攻任何东西，包括布尔：

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

模板
bool解析（const std:：string&valStr，const bool&default=true）{
if（strcmp（valStr.c_str（），“true”）==0）{
返回true；
}
返回false；
}

显然，有很多方法可以做到这一点，您可以为true和false添加更多的条件（我会确保“true”和“false”的所有变体，如“true”，再加上“T”和“F”都能正常工作）。您甚至可以将其扩展到数字解析。
在boost词法转换的顶部添加您自己的模板以进行解析。请注意“默认值”参数，以确保重载正确工作（如果需要，可以随意使用其他方法）

模板
T Parse（const std:：string&valStr，const T&default=T（））{
T结果=boost：：词法转换（valStr）；
}

然后，你可以专攻任何东西，包括布尔：

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

模板
bool解析（const std:：string&valStr，const bool&default=true）{
if（strcmp（valStr.c_str（），“true”）==0）{
返回true；
}
返回false；
}

显然，有很多方法可以做到这一点，您可以为true和false添加更多条件（我会确保所有“true”和“false”的变体，如“true”，加上“T”和“F”都能正常工作）。您甚至可以将其扩展到数字解析。
关于将答案发布到您自己的问题上的意见是混合的，但至少将您的答案作为答案发布。请将您的答案作为答案发布。编辑！（由于某些原因，我没有收到您的评论的电子邮件。）关于将答案发布到您自己的问题上的意见不一，但至少将您的答案作为答案发布。请将您的答案作为答案发布。已编辑！（由于某些原因，我没有收到包含您的评论的电子邮件。）顺便说一句-在
operator>
或
operatorOops中接收的流上使用
std:：boolalpha
是一种好的风格吗？为了保持理智，你可以在iostreams上使用boost:：ios\u flags\u saver。实际上，我想得越多。如果你打算提取/插入LocaleBool，你只想尊重流的状态在boost:：lexical_cast之外使用RATOR。因此，在大多数情况下，它应该是合理的，注意不要将它与用于实际i/o的iostream混合使用。真是天才！！顺便问一下-在
operator>
或
OperatorOps>中接收的流上使用
std:：boolalpha
是一种好的风格吗ld在iostreams上使用boost:：ios_flags_saver。事实上，我想得越多。如果您打算在boost:：lexical_cast之外使用LocaleBool的提取/插入操作符，那么您只想尊重流的状态。因此在大多数情况下，它应该是合理的，但要注意的是，您不应该将它与iostream bein混合使用g用于实际i/o。真是天才！！非常简单，但是这个解决方案不应该有
if（！ss）throw boost:：bad\u lexical\u cast；
，以符合其他专门化吗？非常简单，但是这个解决方案不应该有
if（！ss）抛出boost:：bad_lexical_cast；
以符合其他专门化？