Boost.PropertyTree 五分钟快速入门

本教程使用XML。注意，这个库不是专门绑定到XML的，而是可以使用任何其他支持的格式(如INI或JSON)。之所以选择XML，是因为作者认为很多人都熟悉XML。

假设我们正在为某个应用程序编写一个日志系统，并且需要在程序启动时从文件中读取日志配置。带有日志配置的文件如下所示:

1. <debug>
2. <filename>debug.log</filename>
3. <modules>
4. <module>Finance</module>
5. <module>Admin</module>
6. <module>HR</module>
7. </modules>
8. <level>2</level>
9. </debug>

它包含日志文件名、启用日志记录的模块列表和调试级别值。

我们需要包含的头文件：

1. #include<boost/property_tree/ptree.hpp>
2. #include<boost/property_tree/xml_parser.hpp>
3. #include<boost/foreach.hpp>
4. #include<string>
5. #include<set>
6. #include<exception>
7. #include<iostream>
8. namespace pt = boost::property_tree;

为了存储日志的配置信息，我们创建一个结构来存储它

1. struct debug_settings
2. {
3. std::string m_file;// log filename
4. int m_level;// debug level
5. std::set<std::string> m_modules;// modules where logging is enabled
6. void load(const std::string &filename);
7. void save(const std::string &filename);
8. };

现在需要做的就是编写load()和save()成员函数的实现。让我们先来处理load()。它只包含7行代码，尽管它做了所有必要的事情，包括错误报告:

1. void debug_settings::load(const std::string &filename)
2. {
3. // Create empty property tree object
4. pt::ptree tree;
6. // Parse the XML into the property tree.
7. pt::read_xml(filename, tree);
9. // Use the throwing version of get to find the debug filename.
10. // If the path cannot be resolved, an exception is thrown.
11. m_file = tree.get<std::string>("debug.filename");
13. // Use the default-value version of get to find the debug level.
14. // Note that the default value is used to deduce the target type.
15. m_level = tree.get("debug.level",0);
17. // Use get_child to find the node containing the modules, and iterate over
18. // its children. If the path cannot be resolved, get_child throws.
19. // A C++11 for-range loop would also work.
20. BOOST_FOREACH(pt::ptree::value_type &v, tree.get_child("debug.modules")){
21. // The data function is used to access the data stored in a node.
22. m_modules.insert(v.second.data());
23. }
25. }

存储函数

1. void debug_settings::save(const std::string &filename)
2. {
3. // Create an empty property tree object.
4. pt::ptree tree;
6. // Put the simple values into the tree. The integer is automatically
7. // converted to a string. Note that the "debug" node is automatically
8. // created if it doesn't exist.
9. tree.put("debug.filename", m_file);
10. tree.put("debug.level", m_level);
12. // Add all the modules. Unlike put, which overwrites existing nodes, add
13. // adds a new node at the lowest level, so the "modules" node will have
14. // multiple "module" children.
15. BOOST_FOREACH(const std::string &name, m_modules)
16. tree.add("debug.modules.module", name);
18. // Write property tree to XML file
19. pt::write_xml(filename, tree);
20. }

 

来个全代码的：

1. //
2. // Created by 瓜不甜 on 2018/1/20.
3. //
4. #include<boost/property_tree/ptree.hpp>
5. #include<boost/property_tree/xml_parser.hpp>
6. #include<boost/foreach.hpp>
7. #include<string>
8. #include<set>
9. #include<exception>
10. #include<iostream>
11. namespace pt = boost::property_tree;
13. struct debug_settings
14. {
15. std::string m_file;// log filename
16. int m_level;// debug level
17. std::set<std::string> m_modules;// modules where logging is enabled
20. void load(const std::string &filename);
21. void save(const std::string &filename);
22. };
23. void debug_settings::load(const std::string &filename)
24. {
25. // Create empty property tree object
26. pt::ptree tree;
28. // Parse the XML into the property tree.
29. pt::read_xml(filename, tree);
31. // Use the throwing version of get to find the debug filename.
32. // If the path cannot be resolved, an exception is thrown.
33. m_file = tree.get<std::string>("debug.filename");
35. // Use the default-value version of get to find the debug level.
36. // Note that the default value is used to deduce the target type.
37. m_level = tree.get("debug.level",0);
39. // Use get_child to find the node containing the modules, and iterate over
40. // its children. If the path cannot be resolved, get_child throws.
41. // A C++11 for-range loop would also work.
42. BOOST_FOREACH(pt::ptree::value_type &v, tree.get_child("debug.modules")){
43. // The data function is used to access the data stored in a node.
44. m_modules.insert(v.second.data());
45. }
47. }
49. void debug_settings::save(const std::string &filename)
50. {
51. // Create an empty property tree object.
52. pt::ptree tree;
54. // Put the simple values into the tree. The integer is automatically
55. // converted to a string. Note that the "debug" node is automatically
56. // created if it doesn't exist.
57. tree.put("debug.filename", m_file);
58. tree.put("debug.level", m_level);
60. // Add all the modules. Unlike put, which overwrites existing nodes, add
61. // adds a new node at the lowest level, so the "modules" node will have
62. // multiple "module" children.
63. BOOST_FOREACH(const std::string &name, m_modules)
64. tree.add("debug.modules.module", name);
66. // Write property tree to XML file
67. pt::write_xml(filename, tree);
68. }
70. void test1(){
71. debug_settings a;
72. a.load("setting.xml");
73. std::cout<<a.m_file<<std::endl;
74. std::cout<<a.m_level<<std::endl;
75. std::set<std::string>::iterator i;
76. for( i = a.m_modules.begin(); i != a.m_modules.end();++i){
77. std::cout<<*i<<std::endl;
78. }
81. }

很明显，这个是个非常好用的结构！

简单，高效！

这里有个foreach结构：

BOOST_FOREACH(const std::string &name, m_modules)

{

       tree.add("debug.modules.module", name);

}

这个是C++的一个类宏的高级应用了