Boost::Lexical_cast 的使用

1、C++代码
#include <boost/lexical_cast.hpp>   
#include <iostream>   
int main()   
{   
        using boost::lexical_cast;   
        int a = lexical_cast<int>("123");   
        double b = lexical_cast<double>("123.12");   
         std::cout<<a<<std::endl   
         std::cout<<b<<std::endl;   
        return 0;   
}  



2、数值->字符串

C++代码
#include <boost/lexical_cast.hpp>   
#include <string>   
#include <iostream>   
int main()   
{   
        using std::string;   
        const double d = 123.12;   
         string s = boost::lexical_cast<string>(d);   
         std::cout<<s<<std::endl;   
        return 0;   
}  


3、异常

C++代码
#include <boost/lexical_cast.hpp>   
#include <iostream>   
int main()   
{   
        using std::cout;   
        using std::endl;   
        int i;   
        try  
         {   
             i = boost::lexical_cast<int>("xyz");   
         }   
        catch(boost::bad_lexical_cast& e)   
         {   
             cout<<e.what()<<endl;   
            return 1;   
         }   
         cout<<i<<endl;   
        return 0;   
}  


显然“xyz”并不能转换为一个int类型的数值，于是抛出异常，捕捉后输出“bad lexical cast: source type value could not be interpreted as target”这样的信息。

4、注意事项

lexical_cast依赖于字符流std::stringstream，其原理相当简单：把源类型读入到字符流中，再写到目标类型中，就大功告成。

C++代码
int d = boost::lexical_cast<int>("123");  


相当于

C++代码
int d;   
std::stringstream s;   
s<<"123";   
s>>d;  

5、boost::lexical_cast 的原型： 
template<typename Target, typename Source> 
    Target lexical_cast(Source arg); 
lexical_cast 是依赖于字符串流 std::stringstream 的，其原理也是相当的简单：把源类型 (Source) 读入到字符流中，再写到目标类型 (Target) 中。但这里同时也带来了一些限制： 
  - 输入数据 (arg) 必须能够 “完整” 地转换，否则就会抛出 bad_lexical_cast 异常。例如： 
   int i = boost::lexical_cast<int>("123.456"); // this will throw 
    因为 “123.456” 只能 “部分” 地转换为 123，不能 “完整” 地转换为 123.456，还是让我们需要适当的注意一些这两个模板参数就好了。 
  - 由于 Visual C++ 6 的本地化（locale）部分实现有问题，如果使用了非默认的 locale，可能会莫名其妙地抛出异常。 
  - 源类型 (Source) 必须是一个可以输出到输出流的类型(OutputStreamable)，也意味着该类型需要 operator<< 被定义。 
  - 同样的，目标类型 (Target) 必须是一个可以输入到输入流的类型 (InputStreamable)，也意味着该类型需要 operator>> 被定义。 
  - 另外，Both Source and Target are CopyConstructible。 
  - Target is DefaultConstructible。 
其中，下面的四个限制是在使用自定义类型之间转换时必须做的一些工作的（当然流行的使用的 C 库函数等等都是不可以处理自定义类型之间的转换的）。

#include <boost/lexical_cast.hpp>
#include <iostream>
#include <string> 
#define ERROR_LEXICAL_CAST     1 
int main()
{
    using boost::lexical_cast;
    int         a = 0;
    double        b = 0.0;
    std::string s = ""; 
    int            e = 0;    
    try
    { 
        // ----- 字符串 --> 数值 
        a = lexical_cast<int>("123");
        b = lexical_cast<double>("123.12");
        // ----- 数值 --> 字符串
        s = lexical_cast<std::string>("123456.7"); 
        // ----- 异常处理演示
        e = lexical_cast<int>("abc");
    }
    catch(boost::bad_lexical_cast& e)
    {
        // bad lexical cast: source type value could not be interpreted as target
        std::cout << e.what() << std::endl;
        return ERROR_LEXICAL_CAST;
    } 
    
    std::cout << a << std::endl;    // 输出：123 
    std::cout << b << std::endl;    // 输出：123.12 
    std::cout << s << std::endl;     // 输出：123456.7 
    return 0;
}


6、小结

我们已经体验了boost::lexcial_cast。当然，lexical_cast不仅仅局限于字符串类型与数值类型之间的转换：可在任意可输出到stringstream的类型和任意可从stringstream输入的类型间转换。



一、lexical_cast的作用
lexical_cast使用统一的接口实现字符串与目标类型之间的转换。

二、lexical_cast与c/c++提供类似接口的比较
标准c家族中包含此类函数，例如atoi与itoa等，它们的缺点是：
（1）各个转换都是单向的，双向转换为不同函数，各种转换函数不同，接口众多；
（2）仅支持基础数据类型的子集，如int，long，double；
（3）不能提供统一的接口，易用性差；

c++中提供了stringstream，使用它进行格式转换可读性较差，使用起点较高，只是简单的转换，stringstream太重量级。

boost提供了lexical_cast，使用统一接口形式实现任意类型之间的转换，增强了易用性。但如果需要严密控制精度的转换，仍然推荐使用stringstream；数值之间的转换，推荐使用numeric_cast。



三、lexical_cast的样例
#include "iostream"
#include "boost/lexical_cast.hpp" // 需要包含的头文件
 
using boost::lexical_cast;
using boost::bad_lexical_cast;
using namespace std;
 
int main()
{
    char* p="32768";
    int i=0;
    try
    {
        i=lexical_cast<int>(p); // 将字符串转化为整数
    }
    catch(bad_lexical_cast&)    // 转换失败会抛出一个异常
    {
        i=0;
    }
    cout << i << endl;
    return i;
}