Как использовать boost::lexical cast и std:: boolalpha? т. е. boost:: лексический бросок ("true")

Я видел некоторые ответы на другие boost::lexical_cast возможны вопросы, которые утверждают следующее:

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

это не работает для меня с G++ 4.4.3 повысить 1.43. (Возможно, это правда, что он работает на платформе, где std:: boolalpha установлен по умолчанию)

этой является хорошим решением проблемы string to bool, но ему не хватает проверки ввода, которая обеспечивает boost:: lexical_cast.

17
boost c++ lexical-cast string

3 ответов

Я размещаю ответ на свой собственный вопрос здесь для других, кто может искать что-то вроде этого:

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

использование:

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

в дополнение к форме ответа 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();
    }
}

и использовать его:

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

мне лично понравился этот подход, потому что он скрывает любой специальный код (например, используя LocaleBool или to_bool(...) из ссылки) для преобразования в / из bools.

13

соберите свой собственный шаблон поверх boost lexical cast для синтаксического анализа. Обратите внимание на параметр" default " в примере, чтобы убедиться, что перегрузка работает правильно (не стесняйтесь использовать другие средства, если хотите).

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

тогда вы можете специализироваться на чем угодно, включая bools:

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

очевидно, есть несколько способов сделать это, и вы можете добавить больше условий для true vs false (я бы убедился, что все варианты "TRUE" и "FALSE", такие как "True", плюс " T " и "F" работает правильно). Вы даже можете расширить его до числового анализа.

0