boost::property_tree

最新推荐文章于 2023-12-01 16:16:57 发布
最新推荐文章于 2023-12-01 16:16:57 发布
阅读量1.3k 收藏
点赞数
分类专栏： boost boost-property_tree

boost::property_tree 的解析xml模块是基于rapidXml的, 以下是两个例子:

例子1:

[cpp] view plain copy print ?
  1. #include <boost/property_tree/ptree.hpp> 
  2. #include <boost/property_tree/xml_parser.hpp> 
  3. #include <boost/typeof/typeof.hpp> 
  4. #include <iostream> 
  5.  
  6. using namespace std; 
  7.  
  8. void ReadConfig() 
  9. { 
  10.   boost::property_tree::ptree pt; 
  11.         boost::property_tree::read_xml("del.conf", pt); 
  12.         filenum = pt.get<int>("root.delfile.filenum"); 
  13.  
  14.         cout << "filenum: " << filenum << endl; 
  15.          
  16.         BOOST_AUTO(child, pt.get_child("root.delfile.paths")); 
  17.         for (BOOST_AUTO(pos, child.begin()); pos != child.end(); ++pos) 
  18.         { 
  19.          BOOST_AUTO(child_paths, pos->second.get_child("")); //此处不需要填结点名,但引号不能省. 
  20.          for (BOOST_AUTO(pos_paths, child_paths.begin()); pos_paths != child_paths.end(); ++pos_paths) 
  21.           cout << pos_paths->second.data() << endl; 
  22.         } 
  23.          
  24. } 
  25. int main() 
  26. { 
  27. ReadConfig(); 
  28. return 0; 
  29. } 
  30.  
  31.  
  32. /*
  33. 附录:配置文件del.conf
  34. */  
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/typeof/typeof.hpp>
#include <iostream>

using namespace std;

void ReadConfig()
{
  boost::property_tree::ptree pt;
        boost::property_tree::read_xml("del.conf", pt);
        filenum = pt.get<int>("root.delfile.filenum");

        cout << "filenum: " << filenum << endl;
        
        BOOST_AUTO(child, pt.get_child("root.delfile.paths"));
        for (BOOST_AUTO(pos, child.begin()); pos != child.end(); ++pos)
        {
         BOOST_AUTO(child_paths, pos->second.get_child("")); //此处不需要填结点名,但引号不能省.
         for (BOOST_AUTO(pos_paths, child_paths.begin()); pos_paths != child_paths.end(); ++pos_paths)
          cout << pos_paths->second.data() << endl;
        }
        
}
int main()
{
 ReadConfig();
 return 0;
}


/*
附录:配置文件del.conf
*/

[html] view plain copy print ?
  1. <root> 
  2. <delfile> 
  3.  
  4.   <filenum> 35 </filenum> 
  5.  
  6.   <paths> 
  7.    <path>  
  8.     <pathname>/tmp/tmp0/</pathname> 
  9.     <before_hours> 0 </before_hours> 
  10.    </path> 
  11.    
  12.    <path>  
  13.     <pathname>/tmp/tmp1/</pathname> 
  14.     <before_hours> 1 </before_hours> 
  15.    </path> 
  16.    
  17.    <path>  
  18.     <pathname>/tmp/tmp2/</pathname> 
  19.     <before_hours> 2 </before_hours> 
  20.    </path> 
  21.    
  22.    <path>  
  23.     <pathname>/tmp/tmp3/</pathname> 
  24.     <before_hours> 3 </before_hours> 
  25.    </path> 
  26.    
  27.    <path>  
  28.     <pathname>/tmp/tmp4/</pathname> 
  29.     <before_hours> 4 </before_hours> 
  30.    </path> 
  31.   </paths> 
  32.  
  33. </delfile> 
  34.  
  35.  
  36. <backup> 
  37.   <backuptime> 23:59 </backuptime> 
  38. </backup> 
  39.  
  40. </root>  
<root>
 <delfile>

  <filenum> 35 </filenum>

  <paths>
   <path> 
    <pathname>/tmp/tmp0/</pathname>
    <before_hours> 0 </before_hours>
   </path>
  
   <path> 
    <pathname>/tmp/tmp1/</pathname>
    <before_hours> 1 </before_hours>
   </path>
  
   <path> 
    <pathname>/tmp/tmp2/</pathname>
    <before_hours> 2 </before_hours>
   </path>
  
   <path> 
    <pathname>/tmp/tmp3/</pathname>
    <before_hours> 3 </before_hours>
   </path>
  
   <path> 
    <pathname>/tmp/tmp4/</pathname>
    <before_hours> 4 </before_hours>
   </path>
  </paths>

 </delfile>


 <backup>
  <backuptime> 23:59 </backuptime>
 </backup>

</root>


例子2:

[cpp] view plain copy print ?
  1. #include <iostream> 
  2. #include <string> 
  3. #include <boost/property_tree/ptree.hpp> 
  4. #include <boost/property_tree/xml_parser.hpp> 
  5. #include <boost/foreach.hpp> 
  6.  
  7. using namespace std; 
  8. using namespace boost::property_tree; 
  9.  
  10. int main(void){ 
  11.     ptree pt; 
  12.     read_xml("debug_settings.xml", pt); 
  13.  
  14.         //loop for every node under debug 
  15.     BOOST_FOREACH(ptree::value_type &v1, pt.get_child("debug")){ 
  16.  
  17.         if(v1.first == "<xmlattr>"){ //it's an attribute 
  18.             //read debug name="debugname" 
  19.             cout<< "debug name=" << v1.second.get<string>("name") << endl; 
  20.         }else if(v1.first == "file"){ 
  21.             //read file name="debug.log" 
  22.             cout << "  file name=" << v1.second.get<string>("<xmlattr>.name") << endl; 
  23.         } 
  24.         else{ // v1.first == "modules" 
  25.             //get module type 
  26.             cout<< "  module type:" << v1.second.get<string>("<xmlattr>.type") << endl; 
  27.  
  28.             //loop for every node under modules 
  29.             BOOST_FOREACH(ptree::value_type &v2, v1.second){ 
  30.                 if(v2.first == "<xmlattr>"){  //it's an attribute 
  31.                     //this can also get module type 
  32.                     cout<< "  module type again:" << v2.second.get<string>("type") << endl; 
  33.                 } 
  34.                 else{ 
  35.                     //all the modules have the same structure, so just use data() function. 
  36.                     cout<< "    module name:" << v2.second.data() << endl; 
  37.                 } 
  38.             }//end BOOST_FOREACH 
  39.         } 
  40.     }//end BOOST_FOREACH 
  41. }  
#include <iostream>
#include <string>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/foreach.hpp>

using namespace std;
using namespace boost::property_tree;

int main(void){
	ptree pt;
	read_xml("debug_settings.xml", pt);

        //loop for every node under debug
	BOOST_FOREACH(ptree::value_type &v1, pt.get_child("debug")){

		if(v1.first == "<xmlattr>"){ //it's an attribute
			//read debug name="debugname"
			cout<< "debug name=" << v1.second.get<string>("name") << endl;
		}else if(v1.first == "file"){
			//read file name="debug.log"
			cout << "  file name=" << v1.second.get<string>("<xmlattr>.name") << endl;
		}
		else{ // v1.first == "modules"
			//get module type
			cout<< "  module type:" << v1.second.get<string>("<xmlattr>.type") << endl;

			//loop for every node under modules
			BOOST_FOREACH(ptree::value_type &v2, v1.second){
				if(v2.first == "<xmlattr>"){  //it's an attribute
					//this can also get module type
					cout<< "  module type again:" << v2.second.get<string>("type") << endl;
				}
				else{
					//all the modules have the same structure, so just use data() function.
					cout<< "    module name:" << v2.second.data() << endl;
				}
			}//end BOOST_FOREACH
		}
	}//end BOOST_FOREACH
}



[html] view plain copy print ?
  1. <debug name="debugname">   
  2.     <file name="debug.log"/>   
  3.     <modules type="internal">   
  4.         <module1>Finance_Internal</module1>   
  5.         <module2>Admin_Internal</module2>   
  6.         <module3>HR_Internal</module3>   
  7.     </modules>   
  8.        
  9.     <modules type="external">   
  10.         <module>Finance_External</module>   
  11.         <module>Admin_External</module>   
  12.         <module>HR_External</module>     
  13.     </modules>   
  14. </debug>    
<debug name="debugname">  
    <file name="debug.log"/>  
    <modules type="internal">  
        <module1>Finance_Internal</module1>  
        <module2>Admin_Internal</module2>  
        <module3>HR_Internal</module3>  
    </modules>  
      
    <modules type="external">  
        <module>Finance_External</module>  
        <module>Admin_External</module>  
        <module>HR_External</module>    
    </modules>  
</debug>



----------------------------------------------------------------------------------------------------------------------------------------------

----------------------------------------------------------------------------------------------------------------------------------------------

关于boost::property_tree, 转自:  http://notes.xj-labs.net/?p=52


Boost.PropertyTree 应该是 Boost 1.41.0 开始正式加入 Boost 版本的。目前 ( 2010/02/28 ) 能下到的最新版本是 1.42.0。

  • 主要作用/应用场合

Boost.PropertyTree 提供了一种结构化的数据存储容器。并且提供了一系列的解释器可以将内存中的结构与具体格式相互转换 (比如: INI, XML, JSON )。

至少可以用在:

  1. 进程间通讯或者跨语言的进程间的通讯
  2. 一些配置文件的存取
  3. 网络通讯协议的格式
  • 基本用法

基本用法有 2 种场景。第一种是从 Property Tree存储到具体格式。第二种是从具体格式解析到具体的 Property Tree。其他还有一些 Property Tree 操作的方法，比如：遍历、搜索等方法。

以下这个 Sample 就是基本用法的测试：

先把 数据存储到 datum 中,随后输出 相应的 XML 和 JSON 到 std::cout 上。最后再从 JSON Stream 中解析输入到 ptParse 中获得相应 的数据。

[cpp] view plain copy print ?
  1. #include <stdio.h> 
  2.  
  3. #include <iostream> 
  4. #include <sstream> 
  5. #include <string> 
  6. #include <locale> 
  7.  
  8. #include "boost/property_tree/ptree.hpp" 
  9. #include "boost/property_tree/json_parser.hpp" 
  10. #include "boost/property_tree/xml_parser.hpp" 
  11.  
  12. int main(int argc, char **argv) 
  13. { 
  14.     /* The data format
  15.      * <root>
  16.      *  <num>1</num>
  17.      *  <str>Test</str>
  18.      * </root>
  19.      */ 
  20.     try 
  21.     { 
  22.         /* create the property tree */ 
  23.         boost::property_tree::ptree datum; 
  24.         datum.put("root.num", 100); 
  25.         datum.put("root.str", "string"); 
  26.  
  27.         /* output XML string */ 
  28.         std::ostringstream xmlOutputStream; 
  29.         boost::property_tree::xml_parser::write_xml(xmlOutputStream, 
  30.             datum); 
  31.         std::cout << "XML format:" << std::endl; 
  32.         std::cout << xmlOutputStream.str() << std::endl; 
  33.  
  34.         /* output JSON string */ 
  35.         std::ostringstream jsonOutputStream; 
  36.         boost::property_tree::json_parser::write_json(jsonOutputStream, 
  37.             datum); 
  38.         std::cout << "JSON format:" << std::endl; 
  39.         std::cout << jsonOutputStream.str() << std::endl; 
  40.  
  41.         /* read datum from JSON stream */ 
  42.         boost::property_tree::ptree ptParse; 
  43.         std::istringstream jsonIStream; 
  44.         jsonIStream.str(jsonOutputStream.str()); 
  45.         boost::property_tree::json_parser::read_json(jsonIStream, 
  46.             ptParse); 
  47.         int num = ptParse.get<int>("root.num"); 
  48.         std::string strVal = ptParse.get<std::string>("root.str"); 
  49.         std::cout << "Num=" << std::dec << num 
  50.             << " Str=" << strVal << std::endl << std::endl; 
  51.     } 
  52.     catch (...) 
  53.     { 
  54.         printf("create boost::property_tree::ptree failed\n"); 
  55.     } 
  56.  
  57.     return 0; 
  58. }  
#include <stdio.h>

#include <iostream>
#include <sstream>
#include <string>
#include <locale>

#include "boost/property_tree/ptree.hpp"
#include "boost/property_tree/json_parser.hpp"
#include "boost/property_tree/xml_parser.hpp"

int main(int argc, char **argv)
{
    /* The data format
     * <root>
     *  <num>1</num>
     *  <str>Test</str>
     * </root>
     */
    try
    {
        /* create the property tree */
        boost::property_tree::ptree datum;
        datum.put("root.num", 100);
        datum.put("root.str", "string");

        /* output XML string */
        std::ostringstream xmlOutputStream;
        boost::property_tree::xml_parser::write_xml(xmlOutputStream,
            datum);
        std::cout << "XML format:" << std::endl;
        std::cout << xmlOutputStream.str() << std::endl;

        /* output JSON string */
        std::ostringstream jsonOutputStream;
        boost::property_tree::json_parser::write_json(jsonOutputStream,
            datum);
        std::cout << "JSON format:" << std::endl;
        std::cout << jsonOutputStream.str() << std::endl;

        /* read datum from JSON stream */
        boost::property_tree::ptree ptParse;
        std::istringstream jsonIStream;
        jsonIStream.str(jsonOutputStream.str());
        boost::property_tree::json_parser::read_json(jsonIStream,
            ptParse);
        int num = ptParse.get<int>("root.num");
        std::string strVal = ptParse.get<std::string>("root.str");
        std::cout << "Num=" << std::dec << num
            << " Str=" << strVal << std::endl << std::endl;
    }
    catch (...)
    {
        printf("create boost::property_tree::ptree failed\n");
    }

    return 0;
}


  • 关于字符集

Boost 目前是支持 UTF8 的，但是不能用 直接用 Unicode。所以，如果要存储宽字符就有点麻烦需要用到 Boost 提供的 utf8_codecvt_facet 做转换。

下面就是一个存储 wchar_t 的 Sample:

和之前的其实差不多,有 2 点主要不同。一是用了 wptree 替换了 ptree。二是增加了 utf8_codecvt_facet 在相应的 Stream 里做转换。

[cpp] view plain copy print ?
  1. #include <stdio.h> 
  2.  
  3. #include <iostream> 
  4. #include <sstream> 
  5. #include <string> 
  6. #include <locale> 
  7.  
  8. #include "boost/property_tree/ptree.hpp" 
  9. #include "boost/property_tree/json_parser.hpp" 
  10. #include "boost/property_tree/xml_parser.hpp" 
  11.  
  12. #include "boost/program_options/detail/convert.hpp" 
  13. #include "boost/program_options/detail/utf8_codecvt_facet.hpp" 
  14.  
  15. int main(int argc, char **argv) 
  16. { 
  17.     /* The data format
  18.      * <root>
  19.      *  <num>1</num>
  20.      *  <str>Test</str>
  21.      * </root>
  22.      */ 
  23.     /* test UTF-8 format */ 
  24.     try 
  25.     { 
  26.         /* create boost utf8 codecvt */ 
  27.         std::locale oldLocale; 
  28.         std::locale utf8Locale(oldLocale, 
  29.             new boost::program_options::detail::utf8_codecvt_facet()); 
  30.         std::wcout.imbue(utf8Locale); 
  31.  
  32.         /* create the wptree for save the UTF-8 data */ 
  33.         boost::property_tree::wptree datum; 
  34.         datum.put(L"root.num", 100); 
  35.         datum.put(L"root.str", L"wstring"); 
  36.  
  37.         /* output XML string */ 
  38.         std::wostringstream xmlOutputStream; 
  39.         xmlOutputStream.imbue(utf8Locale); 
  40.         boost::property_tree::xml_parser::write_xml(xmlOutputStream, 
  41.             datum); 
  42.         std::wcout << L"XML format:" << std::endl; 
  43.         std::wcout << xmlOutputStream.str() << std::endl; 
  44.  
  45.         /* output JSON string */ 
  46.         std::wostringstream jsonOutputStream; 
  47.         jsonOutputStream.imbue(utf8Locale); 
  48.         boost::property_tree::json_parser::write_json(jsonOutputStream, 
  49.             datum); 
  50.         std::wcout << L"JSON format:" << std::endl; 
  51.         std::wcout << jsonOutputStream.str() << std::endl; 
  52.  
  53.         /* read datum from JSON stream */ 
  54.         boost::property_tree::wptree wptParse; 
  55.         std::wistringstream jsonIStream; 
  56.         jsonIStream.imbue(utf8Locale); 
  57.         jsonIStream.str(jsonOutputStream.str()); 
  58.         boost::property_tree::json_parser::read_json(jsonIStream, 
  59.             wptParse); 
  60.         int num = wptParse.get<int>(L"root.num"); 
  61.         std::wstring wstrVal = wptParse.get<std::wstring>(L"root.str"); 
  62.         std::wcout << L"Num=" << std::dec << num 
  63.             << L" Str=" << wstrVal << std::endl << std::endl; 
  64.     } 
  65.     catch (...) 
  66.     { 
  67.         printf("create boost::property_tree::wptree failed\n"); 
  68.     } 
  69.  
  70.     return 0; 
  71. }  
#include <stdio.h>

#include <iostream>
#include <sstream>
#include <string>
#include <locale>

#include "boost/property_tree/ptree.hpp"
#include "boost/property_tree/json_parser.hpp"
#include "boost/property_tree/xml_parser.hpp"

#include "boost/program_options/detail/convert.hpp"
#include "boost/program_options/detail/utf8_codecvt_facet.hpp"

int main(int argc, char **argv)
{
    /* The data format
     * <root>
     *  <num>1</num>
     *  <str>Test</str>
     * </root>
     */
    /* test UTF-8 format */
    try
    {
        /* create boost utf8 codecvt */
        std::locale oldLocale;
        std::locale utf8Locale(oldLocale,
            new boost::program_options::detail::utf8_codecvt_facet());
        std::wcout.imbue(utf8Locale);

        /* create the wptree for save the UTF-8 data */
        boost::property_tree::wptree datum;
        datum.put(L"root.num", 100);
        datum.put(L"root.str", L"wstring");

        /* output XML string */
        std::wostringstream xmlOutputStream;
        xmlOutputStream.imbue(utf8Locale);
        boost::property_tree::xml_parser::write_xml(xmlOutputStream,
            datum);
        std::wcout << L"XML format:" << std::endl;
        std::wcout << xmlOutputStream.str() << std::endl;

        /* output JSON string */
        std::wostringstream jsonOutputStream;
        jsonOutputStream.imbue(utf8Locale);
        boost::property_tree::json_parser::write_json(jsonOutputStream,
            datum);
        std::wcout << L"JSON format:" << std::endl;
        std::wcout << jsonOutputStream.str() << std::endl;

        /* read datum from JSON stream */
        boost::property_tree::wptree wptParse;
        std::wistringstream jsonIStream;
        jsonIStream.imbue(utf8Locale);
        jsonIStream.str(jsonOutputStream.str());
        boost::property_tree::json_parser::read_json(jsonIStream,
            wptParse);
        int num = wptParse.get<int>(L"root.num");
        std::wstring wstrVal = wptParse.get<std::wstring>(L"root.str");
        std::wcout << L"Num=" << std::dec << num
            << L" Str=" << wstrVal << std::endl << std::endl;
    }
    catch (...)
    {
        printf("create boost::property_tree::wptree failed\n");
    }

    return 0;
}



Mr_John_Liang
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【BOOST C++Data-struct专题04】【05】 Boost.PropertyTree
gongdiwudu的专栏
10-19 4495
借助类 boost::property_tree::ptree，Boost.PropertyTree 提供了一个树结构来存储键/值对。树形结构意味着一个树干存在许多分支，其中有许多树枝。文件系统是树结构的一个很好的例子。文件系统有一个带有子目录的根目录，这些子目录本身可以有子目录等等。
boost::property_tree::ptree 创建和解析json数组
小灰灰的博客
02-22 7822
boost::property_tree::ptree 对简单的json处理我觉得还可以，对于数组的处理网上有些代码可能不适合新版本的boost。比如push_back(); 第二个参数很多代码都是字符串，可是我目前使用的代码要求第二个参数必须是boost::property_tree::ptree，如果你用字符串报错,那么可以试试我的方法。 头文件 #include <boost/p...
boost::property_tree讲解
明天，你又将身在何方……
07-04 6756
转自：http://viml.nchc.org.tw/blog/paper_info.php?CLASS_ID=1&SUB_ID=1&PAPER_ID=315 Boost C++ Libraries 的 PropertyTree 這個函式庫（官方文件），基本上是一種通用型的樹狀資料結構的資料結構；在這棵資料樹裡面的每一個節點，都有它自己的資料、以及下方的成員清單。他每一個節點的內
boost::property_tree::ptree解析json数组
dxmcu的专栏
12-25 1473
json数组如下： {"var_name":"var1","positions":[0.1,0.1,0.1,0.1,0.1,0.1]},; 1 代码： #include <boost/property_tree/ptree.hpp> #include <boost/property_tree/json_parser.hpp> std::stringstream str...
【C++】开源：Boost配置文件解析库PropertyTree配置使用
最新发布
DevFrank的博客
12-01 983
Boost配置文件解析库PropertyTree配置使用
用boost::property_tree来解析XML，JSON的示例代码。
07-25
具体信息可以参考 http://blog.csdn.net/harbinzju/article/details/6631738；http://blog.csdn.net/harbinzju/article/details/6632349
使用boost读取XML文件详细介绍
12-31
boost中提供了对配置文件读取的支持，它就是：property_tree。  basic_ptree 是property_tree的核心基础。其接口像std::list。可以执行很多基本的元素操作，比如使用begin()、end()等。  此外还加入了操作属性树...
property_tree用于json
12-10
boost::property_tree::ptree pt; ``` 为了从JSON字符串解析数据，我们可以使用`read_json()`函数。假设我们有一个JSON字符串`json_str`，解析过程如下： ```cpp std::stringstream ss(json_str); boost::property...
Boost.orgproperty_tree模块.zip
03-31
Boost.property_tree在遇到解析错误或非法操作时，会抛出相应的异常，如`boost::property_tree::ptree_bad_path`和`boost::property_tree::ptree_bad_data`，帮助开发者快速定位问题。 10. **应用实例** Boost....
boost_1_68_0 binary
11-22
4. **容器** (Containers)：例如`multi_array`, `property_tree`等，扩展了标准模板库（STL）的容器。 5. **函数对象** (Function Objects)：包括函数包装器、函数适配器等，方便函数作为对象进行操作。 6. **正则...
BOOST之property_tree 及解析XML详解
05-23 1万+
摘要： property_tree是一个保存了多个属性值的属性数据结构，可以用类似路径的简单方式访问任意节点的属性，而且每个节点都可以用类似STL的风格遍历子节点。property_tree特别适合于应用程序的配置数据处理，可以解析xml、ini、json和info四个格式的文本数据。 在处理四种格式的文件时，除包含头文件、读文件、写文件时有部分区别外，其他对文件内部数据操作时基本一致（因为文
boost的property_tree组件
热门推荐
oowgsoo的专栏
12-29 1万+
stl中对线性表有充分的实现，无论是vector还是list都是典型的线性表，即便是set和map，尽管实现上采用了诸如红黑树之类的树形结构，但那仅仅是为了快速检索的需要，从语义上来说它们依旧是线性表，无法表达目录树这种树形结构。boost中的property_tree可以看做是对树形结构实现的补充，我们大可把它扩展应用到各种需要树形结构的地方。
（原创）boost.property_tree解析xml的帮助类以及中文解析问题的解决
weixin_33724659的博客
02-19 191
　　boost.property_tree可以用来解析xml和json文件，我主要用它来解析xml文件，它内部封装了号称最快的xml解析器rapid_xml，其解析效率还是很好的。但是在使用过程中却发现各种不好用，归纳一下不好用的地方有这些： 获取不存在的节点时就抛出异常 获取属性值时，要排除属性和注释节点，如果没注意这一点就会抛出异常，让人摸不着头脑。 内存模型有点怪。 默认不支持中...
BOOST 之 property_tree
Vin1282023650的博客
08-05 1057
property_tree：用于应用程序的配置的数据处理，可以解析xml，json，ini，info等格式的数据 1. 解析XML文件 #include <boost/property_tree/ptree.hpp> // 加载property_tree组件 #include <boost/property_tree/xml_parser.hp...
boost property_tree遍历
冰焰·
07-24 4011
#include #include #include #include #include using namespace std; using namespace boost; using namespace boost::property_tree; void printTree(ptree root) { BOOST_FOREACH(ptree::value_
boost::property_tree读取解析.xml文件
smilestone322的专栏
04-24 1592
boost::property_tree读取解析.xml文件
c++ ptree判断是否存在节点_c++11 boost - 容器(5) property_tree
weixin_42181686的博客
12-28 1160
c++11 boost - 容器(5) property_tree首页 计算机相关 c++11-boost库 c++11 boost - 容器(5) property_treeproperty_tree 可以解析xml、json、ini、info。解析 xmlusing namespace boost::property_tree;ptree pt;pt.get("debug.sex","0");...
使用 boost::property_tree::ptree 读取配置文件
Roc Cliff
05-05 2834
近期有一需求：需要一个地址配置项，同时提供一个地址列表，读取的地址如果在地址列表内，则自动替换，大概的 json 配置文件如下：{ "host_list" : { "BDC" : "chn.xxx.com", "MDC" : "alpha01.xxx.com", "vm" : "10.209.9.83", "local" : "127.0.0.1" }, "host" : {
boost::property_tree::ptree::begin()
05-23
`boost::property_tree::ptree::begin()` 是一个成员函数，用于返回指向第一个子节点的迭代器。`ptree` 是 Boost 库中用于处理属性树的类，类似于 XML 或 JSON 格式的数据结构。使用 `begin()` 函数可以遍历属性树中...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值