Boost::Lexical_キャストの使用

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;

}