boost::property_tree读取解析ini文件--推荐

 

boost::property_tree读取解析ini文件

#include "stdafx.h"  

#include <iostream>  

#include <boost/property_tree/ptree.hpp>  

#include <boost/property_tree/ini_parser.hpp>  

int main()  

{  

    boost::property_tree::ptree pt;  

    boost::property_tree::ini_parser::read_ini("D:\\Overlay.ini", pt);  

    std::cout << pt.get<std::string>("OVERLAY.OverlayFontName") << std::endl;  

    pt.put<std::string>("OVERLAY.OverlayFontName","宋体");  

    std::cout << pt.get<std::string>("OVERLAY.OverlayFontName") << std::endl;  

    boost::property_tree::ini_parser::write_ini("D:\\Overlay.ini",pt);  

  return 0;  

}  

 

 


在C++11下,宽字节和单字节转换就简单了。使用std::wstring_convert和std::codecvt_utf8 来处理UTF8与WChar之间的互转.

 #include <iostream>  

#include <string>  

#include <locale>  

#include <codecvt>  

#include <fstream>  

int main(int argc, char *argv[])  

{  

   std::wstring str = L"123,宋体!";  

   std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;  

   std::string narrowStr = conv.to_bytes(str);  

   {  

      std::ofstream ofs ("c:\\test.txt");  

      ofs << narrowStr;  

   }  

   std::wstring wideStr = conv.from_bytes(narrowStr);  

   {  

      std::locale::global(std::locale("Chinese-simplified"));  

      std::wofstream ofs (L"c:\\testW.txt");  

      ofs << wideStr;  

   }  

}  

 

 

另外可以保存函数,使用ptree:

struct debug_simple
{
     int itsNumber;
     std::string itsName; //这里使用string就可以
     void load(const std::string& filename); //载入函数
     void save(const std::string& filename); //保存函数
 };

 

保存函数,使用ptree:

 
 void debug_simple::save( const std::string& filename )
 {
     using boost::property_tree::ptree;
     ptree pt;
 
     pt.put("debug.number",itsNumber);
     pt.put("debug.name",itsName);
 
     write_xml(filename,pt);
 }
 
 

 

载入函数使用的wptree,读取的值为wstring,需转换成string

 
  void debug_simple::load( const std::string& filename )
  {
      using boost::property_tree::wptree;
      wptree wpt;
      read_xml(filename, wpt);
  
      itsNumber = wpt.get<int>(L"debug.number");
      std::wstring wStr = wpt.get<std::wstring>(L"debug.name");
      itsName = std::string(wStr.begin(),wStr.end()); //wstring转string
 }
main函数:
 
  int _tmain(int argc, _TCHAR* argv[])
  {
      
      try
      {
          debug_simple ds,read;
          ds.itsName = "汉字english";
          ds.itsNumber = 20;
  
         ds.save("simple.xml");
         read.load("simple.xml");
 
         std::cout<<read.itsNumber<<read.itsName;
 
     }
     catch (std::exception &e)
     {
         std::cout << "Error: " << e.what() << "\n";
     }
     return 0;
 }
 
 
 

由于.ini文件是utf-8格式的,所以操作时要utf-8到unicode转换,或unicode到utf-8转换;

// PropertyTree.cpp : 定义控制台应用程序的入口点。  

//  

#include "stdafx.h"  

#include <iostream>  

using namespace std;  

#include <boost/property_tree/ptree.hpp>  

#include <boost/property_tree/ini_parser.hpp>  

//unicode 转UTF8  

//参数1是UTF8字符串当前位置指针,这里必须要是指针,因为必须要通过第1个字符进行判断才知道一个完整的字符的编码要向后取多少个字符    

//参数2是返回的UCS-2编码的Unicode字符    

inline int UTF82UnicodeOne(const char* utf8, wchar_t& wch)    

{    

if (utf8==NULL)  

    {  

return -1;  

    }  

//首字符的Ascii码大于0xC0才需要向后判断,否则,就肯定是单个ANSI字符了    

    unsigned char firstCh = utf8[0];    

if (firstCh >= 0xC0)    

    {    

//根据首字符的高位判断这是几个字母的UTF8编码    

int afters, code;    

if ((firstCh & 0xE0) == 0xC0)    

        {    

            afters = 2;    

            code = firstCh & 0x1F;    

        }    

else if ((firstCh & 0xF0) == 0xE0)    

        {    

            afters = 3;    

            code = firstCh & 0xF;    

        }    

else if ((firstCh & 0xF8) == 0xF0)    

        {    

            afters = 4;    

            code = firstCh & 0x7;    

        }    

else if ((firstCh & 0xFC) == 0xF8)    

        {    

            afters = 5;    

            code = firstCh & 0x3;    

        }    

else if ((firstCh & 0xFE) == 0xFC)    

        {    

            afters = 6;    

            code = firstCh & 0x1;    

        }    

else    

        {    

            wch = firstCh;    

return 1;    

        }    

//知道了字节数量之后,还需要向后检查一下,如果检查失败,就简单的认为此UTF8编码有问题,或者不是UTF8编码,于是当成一个ANSI来返回处理    

for(int k = 1; k < afters; ++ k)    

        {    

if ((utf8[k] & 0xC0) != 0x80)    

            {    

//判断失败,不符合UTF8编码的规则,直接当成一个ANSI字符返回    

                wch = firstCh;    

return 1;    

            }    

            code <<= 6;    

            code |= (unsigned char)utf8[k] & 0x3F;    

        }    

        wch = code;    

return afters;    

    }    

else    

    {    

        wch = firstCh;    

    }    

return 1;    

}    

//参数1是UTF8编码的字符串    

//参数2是输出的UCS-2的Unicode字符串    

//参数3是参数1字符串的长度    

//使用的时候需要注意参数2所指向的内存块足够用。其实安全的办法是判断一下pUniBuf是否为NULL,如果为NULL则只统计输出长度不写pUniBuf,这样    

//通过两次函数调用就可以计算出实际所需要的Unicode缓存输出长度。当然,更简单的思路是:无论如何转换,UTF8的字符数量不可能比Unicode少,所    

//以可以简单的按照sizeof(wchar_t) * utf8Leng来分配pUniBuf的内存……    

int UTF82Unicode(const char* utf8Buf, wchar_t *pUniBuf, int utf8Leng)    

{       

if ((utf8Buf==NULL)||(pUniBuf==NULL))  

    {  

return -1;  

    }  

int i = 0, count = 0;    

while(i < utf8Leng)    

    {    

        i += UTF82UnicodeOne(utf8Buf + i, pUniBuf[count]);    

        count ++;    

    }    

return count;    

}    

inline int Unicode2UTF8One(unsigned wchar, char *utf8)    

{    

if (utf8==NULL)  

    {  

return -1;  

    }  

int len = 0;    

if (wchar < 0xC0)    

    {     

        utf8[len ++] = (char)wchar;    

    }    

else if (wchar < 0x800)    

    {    

        utf8[len ++] = 0xc0 | (wchar >> 6);    

        utf8[len ++] = 0x80 | (wchar & 0x3f);    

    }    

else if (wchar < 0x10000)    

    {    

        utf8[len ++] = 0xe0 | (wchar >> 12);    

        utf8[len ++] = 0x80 | ((wchar >> 6) & 0x3f);    

        utf8[len ++] = 0x80 | (wchar & 0x3f);    

    }    

else if (wchar < 0x200000)     

    {    

        utf8[len ++] = 0xf0 | ((int)wchar >> 18);    

        utf8[len ++] = 0x80 | ((wchar >> 12) & 0x3f);    

        utf8[len ++] = 0x80 | ((wchar >> 6) & 0x3f);    

        utf8[len ++] = 0x80 | (wchar & 0x3f);    

    }    

else if (wchar < 0x4000000)    

    {    

        utf8[len ++] = 0xf8 | ((int)wchar >> 24);    

        utf8[len ++] = 0x80 | ((wchar >> 18) & 0x3f);    

        utf8[len ++] = 0x80 | ((wchar >> 12) & 0x3f);    

        utf8[len ++] = 0x80 | ((wchar >> 6) & 0x3f);    

        utf8[len ++] = 0x80 | (wchar & 0x3f);    

    }    

else if (wchar < 0x80000000)    

    {    

        utf8[len ++] = 0xfc | ((int)wchar >> 30);    

        utf8[len ++] = 0x80 | ((wchar >> 24) & 0x3f);    

        utf8[len ++] = 0x80 | ((wchar >> 18) & 0x3f);    

        utf8[len ++] = 0x80 | ((wchar >> 12) & 0x3f);    

        utf8[len ++] = 0x80 | ((wchar >> 6) & 0x3f);    

        utf8[len ++] = 0x80 | (wchar & 0x3f);    

    }    

return len;    

}    

//  

int Unicode2UTF8( const wchar_t *pUniBuf,char* utf8Buf, int UniLeng)    

{     

if ((utf8Buf==NULL)||(pUniBuf==NULL))  

    {  

return -1;  

    }  

int count = 0, i = 0;    

while(i < UniLeng)    

    {    

        count += Unicode2UTF8One(pUniBuf[i], utf8Buf+count);    

        i ++;    

    }    

return count;    

}    

int main()  

{  

    boost::property_tree::ptree pt;  

using boost::property_tree::wptree;   

    wptree wpt;  

    boost::property_tree::ini_parser::read_ini("D:\\Overlay.ini", pt);  

    std::string fontName=pt.get<std::string>("OVERLAY.OverlayFontName") ;  

wchar_t wfontName[128]={0};  

    UTF82Unicode(fontName.c_str(),wfontName,fontName.length());  

    std::wstring  wstrfontName=wfontName;  

//std::wcout << wstrfontName.c_str()<< std::endl;  

/*std::wstring */  

    wstrfontName=_T("我是谁");  

char cfontName[128]={0};  

    Unicode2UTF8(wstrfontName.c_str(),cfontName,wstrfontName.length());  

    pt.put<std::string>("OVERLAY.OverlayFontName",cfontName);  

//std::cout << pt.get<std::string>("OVERLAY.OverlayFontName") << std::endl;  

    boost::property_tree::ini_parser::write_ini("D:\\Overlay.ini",pt);  

return 0;  

}  

 

 

posted @ 2015-03-31 14:40  廖先生  阅读(1145)  评论(0编辑  收藏  举报