Giriş
Şu satırı dahil ederiz.
Şöyle yaparız.
Altta sprintf() çağrısını kullanır. Şöyledir.
Şöyle yaparız.
detail isim alanını kullanarak şöyle yaparız.
Sınıfımız için tanımladığımız << operatörü çağrılır.
Örnek
Şöyle yaparız.
Ya da yardımcı sınıf kullanırız. Şöyle yaparız.
Elimizde şöyle bir kod olsun. Kendi sınıfımız için tanımlı operator exception fırlattığı için boost::lexical_cast başarısız olur.
Bilimsel formatlı stringler çevrilebilir. Şöyle yaparız.
Şöyle yaparız.
Şöyle yaparız. Sınıfımız için yazdığımız >> operatörünün N isim alanı içinde olması gerekir.
Eğer elimizde boost yoksa çok basit bir şekilde şöyle yaparız.
Eğer istersek kendisini de yakalayabiliriz.
Exception: bad lexical cast: source type value could not be interpreted as target
Şu satırı dahil ederiz.
#include <boost/lexical_cast.hpp>
String'e Çevirme - boost::chrono::nanosecondsŞöyle yaparız.
#include <iostream>
#include <string>
#include "boost/lexical_cast.hpp"
#include "boost/chrono.hpp"
int main()
{
boost::chrono::nanoseconds test1{1000}; // could use long long here directly
auto text = boost::lexical_cast<std::string>(test1);
std::cout << text << '\n';
auto val = boost::lexical_cast<boost::chrono::nanoseconds>(text);
std::cout << val << '\n';
}
Çıktı olarak şunu alırız.1000 nanoseconds
1000 nanoseconds
String'e Çevirme - doubleAltta sprintf() çağrısını kullanır. Şöyledir.
sprintf(begin,
"%.*g", static_cast<int>(boost::detail::lcast_get_precision<double>()), val);
lexical_cast string çıktısını formatlama konusunda iyi değil. O yüzden tavsiye etmem. Açıklaması şöyleÖrnekFor more involved conversions, such as where precision or formatting need tighter control than is offered by the default behavior of lexical_cast, the conventional std::stringstream approach is recommended.
Şöyle yaparız.
std::wcout << boost::lexical_cast<std::wstring>(5.453) << std::endl;
Çıktı olarak şunu alırız.5.4530000000000003
Örnekdetail isim alanını kullanarak şöyle yaparız.
#include <boost/lexical_cast.hpp>
#ifdef BOOST_LCAST_NO_COMPILE_TIME_PRECISION
# error unsupported
#endif
template <>
struct boost::detail::lcast_precision<double> : std::integral_constant<unsigned, 5> { };
std::cout << boost::lexical_cast<std::string>(0.0009) << std::endl;
Çıktı olarak şunu alırız.0.0009
String'e Çevirme - Kendi SınıfımızSınıfımız için tanımladığımız << operatörü çağrılır.
Örnek
Şöyle yaparız.
namespace Nodes {
struct Building { std::string id; };
static inline std::ostream& operator<<(std::ostream& os, Building const& b)
{ return os << "Building " << b.id; }
...
}
Şöyle yaparız.boost::lexical_cast<std::string>(building);
ÖrnekYa da yardımcı sınıf kullanırız. Şöyle yaparız.
template <typename Container>
struct pipe_manip {
Container const& _data;
friend std::ostream& operator<<(std::ostream& os, pipe_manip const& manip) {
bool first = true;
for(auto& i : manip._data) {
if (!first) os << "|";
first = false;
os << i;
}
return os;
}
};
template <typename Container>
pipe_manip<Container> as_pipe(Container const& c) { return {c}; }
Şöyle yaparız.std::vector<uint> s { {1,2,3,4,5} };
std::cout << "Source is " << as_pipe(s) << "\n";
std::string text = boost::lexical_cast<std::string>(as_pipe(
std::set<std::string>{"foo", "bar", "qux"}));
std::cout << "Other containers work too: " << text << "\n";
Çıktı olarak şunu alırız.Source is 1|2|3|4|5
Other containers work too: bar|foo|qux
ÖrnekElimizde şöyle bir kod olsun. Kendi sınıfımız için tanımlı operator exception fırlattığı için boost::lexical_cast başarısız olur.
enum class MyType {};
std::ostream& operator<<( std::ostream&, MyType const& )
{
throw "error";
}
int main()
{
try
{
boost::lexical_cast< std::string >( MyType{} );
}
catch(...)
{
std::cout << "lexical_cast exception";
}
}
String'den Okuma - double Bilimsel formatlı stringler çevrilebilir. Şöyle yaparız.
std::string val = "2.12e-6";
double y = boost::lexical_cast<double>(val);
wstring'den çevirmek için şöyle yaparız.std::wstring t = L"91.25";
float r = boost::lexical_cast<float>(t);
String'den Okuma - shortŞöyle yaparız.
short myInt = boost::lexical_cast<short>(*argv);
std::string backToString = boost::lexical_cast<std::string>(myInt);
String'den Okuma - Kendi SınıfımızŞöyle yaparız. Sınıfımız için yazdığımız >> operatörünün N isim alanı içinde olması gerekir.
namespace N {
enum class alarm_code_t {
BLAH
};
std::istream& operator>>(std::istream& is, N::alarm_code_t& code) {
std::string tmp;
is >> tmp;
if (tmp == "BLAH")
code = N::alarm_code_t::BLAH;
else
is.setstate(std::ios::failbit);
return is;
}
}
int main() {
auto code = boost::lexical_cast<N::alarm_code_t>("BLAH");
}
String'den Okuma - Boost YoksaEğer elimizde boost yoksa çok basit bir şekilde şöyle yaparız.
#include <sstream>
#include <iostream>
#include <string>
#include <stdexcept>
template<typename T>
T ConvertStringToNumber(const std::string& str)
{
std::istringstream ss(str);
T number = 0;
ss >> number;
if (ss.fail( ))
{
throw std::invalid_argument("ConvertStringToNumber:" + str);
}
return number;
}
int main(int argc, char argv[]){
std::string num_str = "10.5";
float f = ConvertStringToNumber<float>(num_str);
std::cout << f << std::endl;
return 0;
}
bad_lexical_cast exception Sınıfı
Şöyle tanımlı. Dolayısıyla sadece std::exception olarak yakalamak mümkün.class bad_lexical_cast : public std::bad_cast
Eğer istersek kendisini de yakalayabiliriz.
catch (const boost::bad_lexical_cast& e)
{
std::cout << "Exception: " << e.what() << "\n";
}
Çıktı olarak şunu verir.Exception: bad lexical cast: source type value could not be interpreted as target