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

boost::property_tree读取解析ini文件

1. #include "stdafx.h"
2. #include <iostream>
3. #include <boost/property_tree/ptree.hpp>
4. #include <boost/property_tree/ini_parser.hpp>
5. int main()
6. {
7. boost::property_tree::ptree pt;
8. boost::property_tree::ini_parser::read_ini("D:\\Overlay.ini", pt);
9. std::cout << pt.get<std::string>("OVERLAY.OverlayFontName") << std::endl;
10. pt.put<std::string>("OVERLAY.OverlayFontName","宋体");
11. std::cout << pt.get<std::string>("OVERLAY.OverlayFontName") << std::endl;
12. boost::property_tree::ini_parser::write_ini("D:\\Overlay.ini",pt);
13. return 0;
14. }

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

1. #include <iostream>
2. #include <string>
3. #include <locale>
4. #include <codecvt>
5. #include <fstream>
6. int main(int argc, char *argv[])
7. {
8. std::wstring str = L"123,宋体！";
9. std::wstring_convert<std::codecvt_utf8<wchar_t>> conv;
10. std::string narrowStr = conv.to_bytes(str);
11. {
12. std::ofstream ofs ("c:\\test.txt");
13. ofs << narrowStr;
14. }
15. std::wstring wideStr = conv.from_bytes(narrowStr);
16. {
17. std::locale::global(std::locale("Chinese-simplified"));
18. std::wofstream ofs (L"c:\\testW.txt");
19. ofs << wideStr;
20. }
21. ｝

另外可以保存函数，使用ptree：

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

保存函数，使用ptree：

 1 void debug_simple::save( const std::string& filename )
 2 {
 3     using boost::property_tree::ptree;
 4     ptree pt;
 5
 6     pt.put("debug.number",itsNumber);
 7     pt.put("debug.name",itsName);
 8
 9     write_xml(filename,pt);
10 }

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

 1 void debug_simple::load( const std::string& filename )
 2 {
 3     using boost::property_tree::wptree;
 4     wptree wpt;
 5     read_xml(filename, wpt);
 6
 7     itsNumber = wpt.get<int>(L"debug.number");
 8     std::wstring wStr = wpt.get<std::wstring>(L"debug.name");
 9     itsName = std::string(wStr.begin(),wStr.end()); //wstring转string
10 }

main函数：

 1 int _tmain(int argc, _TCHAR* argv[])
 2 {
 3
 4     try
 5     {
 6         debug_simple ds,read;
 7         ds.itsName = "汉字english";
 8         ds.itsNumber = 20;
 9
10         ds.save("simple.xml");
11         read.load("simple.xml");
12
13         std::cout<<read.itsNumber<<read.itsName;
14
15     }
16     catch (std::exception &e)
17     {
18         std::cout << "Error: " << e.what() << "\n";
19     }
20     return 0;
21 }

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

1. // PropertyTree.cpp : 定义控制台应用程序的入口点。
2. //
3. #include "stdafx.h"
4. #include <iostream>
5. using namespace std;
6. #include <boost/property_tree/ptree.hpp>
7. #include <boost/property_tree/ini_parser.hpp>
8. //unicode 转UTF8
9. //参数1是UTF8字符串当前位置指针，这里必须要是指针，因为必须要通过第1个字符进行判断才知道一个完整的字符的编码要向后取多少个字符
10. //参数2是返回的UCS-2编码的Unicode字符
11. inline int UTF82UnicodeOne(const char* utf8, wchar_t& wch)
12. {
13. if (utf8==NULL)
14. {
15. return -1;
16. }
17. //首字符的Ascii码大于0xC0才需要向后判断，否则，就肯定是单个ANSI字符了
18. unsigned char firstCh = utf8[0];
19. if (firstCh >= 0xC0)
20. {
21. //根据首字符的高位判断这是几个字母的UTF8编码
22. int afters, code;
23. if ((firstCh & 0xE0) == 0xC0)
24. {
25. afters = 2;
26. code = firstCh & 0x1F;
27. }
28. else if ((firstCh & 0xF0) == 0xE0)
29. {
30. afters = 3;
31. code = firstCh & 0xF;
32. }
33. else if ((firstCh & 0xF8) == 0xF0)
34. {
35. afters = 4;
36. code = firstCh & 0x7;
37. }
38. else if ((firstCh & 0xFC) == 0xF8)
39. {
40. afters = 5;
41. code = firstCh & 0x3;
42. }
43. else if ((firstCh & 0xFE) == 0xFC)
44. {
45. afters = 6;
46. code = firstCh & 0x1;
47. }
48. else
49. {
50. wch = firstCh;
51. return 1;
52. }
53. //知道了字节数量之后，还需要向后检查一下，如果检查失败，就简单的认为此UTF8编码有问题，或者不是UTF8编码，于是当成一个ANSI来返回处理
54. for(int k = 1; k < afters; ++ k)
55. {
56. if ((utf8[k] & 0xC0) != 0x80)
57. {
58. //判断失败，不符合UTF8编码的规则，直接当成一个ANSI字符返回
59. wch = firstCh;
60. return 1;
61. }
62. code <<= 6;
63. code |= (unsigned char)utf8[k] & 0x3F;
64. }
65. wch = code;
66. return afters;
67. }
68. else
69. {
70. wch = firstCh;
71. }
72. return 1;
73. }
74. //参数1是UTF8编码的字符串
75. //参数2是输出的UCS-2的Unicode字符串
76. //参数3是参数1字符串的长度
77. //使用的时候需要注意参数2所指向的内存块足够用。其实安全的办法是判断一下pUniBuf是否为NULL，如果为NULL则只统计输出长度不写pUniBuf，这样
78. //通过两次函数调用就可以计算出实际所需要的Unicode缓存输出长度。当然，更简单的思路是：无论如何转换，UTF8的字符数量不可能比Unicode少，所
79. //以可以简单的按照sizeof(wchar_t) * utf8Leng来分配pUniBuf的内存……
80. int UTF82Unicode(const char* utf8Buf, wchar_t *pUniBuf, int utf8Leng)
81. {
82. if ((utf8Buf==NULL)||(pUniBuf==NULL))
83. {
84. return -1;
85. }
86. int i = 0, count = 0;
87. while(i < utf8Leng)
88. {
89. i += UTF82UnicodeOne(utf8Buf + i, pUniBuf[count]);
90. count ++;
91. }
92. return count;
93. }
94. inline int Unicode2UTF8One(unsigned wchar, char *utf8)
95. {
96. if (utf8==NULL)
97. {
98. return -1;
99. }
100. int len = 0;
101. if (wchar < 0xC0)
102. {
103. utf8[len ++] = (char)wchar;
104. }
105. else if (wchar < 0x800)
106. {
107. utf8[len ++] = 0xc0 | (wchar >> 6);
108. utf8[len ++] = 0x80 | (wchar & 0x3f);
109. }
110. else if (wchar < 0x10000)
111. {
112. utf8[len ++] = 0xe0 | (wchar >> 12);
113. utf8[len ++] = 0x80 | ((wchar >> 6) & 0x3f);
114. utf8[len ++] = 0x80 | (wchar & 0x3f);
115. }
116. else if (wchar < 0x200000)
117. {
118. utf8[len ++] = 0xf0 | ((int)wchar >> 18);
119. utf8[len ++] = 0x80 | ((wchar >> 12) & 0x3f);
120. utf8[len ++] = 0x80 | ((wchar >> 6) & 0x3f);
121. utf8[len ++] = 0x80 | (wchar & 0x3f);
122. }
123. else if (wchar < 0x4000000)
124. {
125. utf8[len ++] = 0xf8 | ((int)wchar >> 24);
126. utf8[len ++] = 0x80 | ((wchar >> 18) & 0x3f);
127. utf8[len ++] = 0x80 | ((wchar >> 12) & 0x3f);
128. utf8[len ++] = 0x80 | ((wchar >> 6) & 0x3f);
129. utf8[len ++] = 0x80 | (wchar & 0x3f);
130. }
131. else if (wchar < 0x80000000)
132. {
133. utf8[len ++] = 0xfc | ((int)wchar >> 30);
134. utf8[len ++] = 0x80 | ((wchar >> 24) & 0x3f);
135. utf8[len ++] = 0x80 | ((wchar >> 18) & 0x3f);
136. utf8[len ++] = 0x80 | ((wchar >> 12) & 0x3f);
137. utf8[len ++] = 0x80 | ((wchar >> 6) & 0x3f);
138. utf8[len ++] = 0x80 | (wchar & 0x3f);
139. }
140. return len;
141. }
142. //
143. int Unicode2UTF8( const wchar_t *pUniBuf,char* utf8Buf, int UniLeng)
144. {
145. if ((utf8Buf==NULL)||(pUniBuf==NULL))
146. {
147. return -1;
148. }
149. int count = 0, i = 0;
150. while(i < UniLeng)
151. {
152. count += Unicode2UTF8One(pUniBuf[i], utf8Buf+count);
153. i ++;
154. }
155. return count;
156. }
157. int main()
158. {
159. boost::property_tree::ptree pt;
160. using boost::property_tree::wptree;
161. wptree wpt;
162. boost::property_tree::ini_parser::read_ini("D:\\Overlay.ini", pt);
163. std::string fontName=pt.get<std::string>("OVERLAY.OverlayFontName") ;
164. wchar_t wfontName[128]={0};
165. UTF82Unicode(fontName.c_str(),wfontName,fontName.length());
166. std::wstring  wstrfontName=wfontName;
167. //std::wcout << wstrfontName.c_str()<< std::endl;
168. /*std::wstring */
169. wstrfontName=_T("我是谁");
170. char cfontName[128]={0};
171. Unicode2UTF8(wstrfontName.c_str(),cfontName,wstrfontName.length());
172. pt.put<std::string>("OVERLAY.OverlayFontName",cfontName);
173. //std::cout << pt.get<std::string>("OVERLAY.OverlayFontName") << std::endl;
174. boost::property_tree::ini_parser::write_ini("D:\\Overlay.ini",pt);
175. return 0;
176. }