1 void CreateXml()
 2 {
 3     rapidxml::xml_document<> doc;
 4
 5     auto nodeDecl = doc.allocate_node(rapidxml::node_declaration);
 6     nodeDecl->append_attribute(doc.allocate_attribute("version", "1.0"));
 7     nodeDecl->append_attribute(doc.allocate_attribute("encoding", "UTF-8"));
 8     doc.append_node(nodeDecl);//添加xml声明
 9
10     auto nodeRoot = doc.allocate_node(rapidxml::node_element, "Root");//创建一个Root节点
11     nodeRoot->append_node(doc.allocate_node(rapidxml::node_comment, NULL, "编程语言"));//添加一个注释内容到Root，注释没有name 所以第二个参数为NULL
12     auto nodeLangrage = doc.allocate_node(rapidxml::node_element, "language", "This is C language");//创建一个language节点
13     nodeLangrage->append_attribute(doc.allocate_attribute("name", "C"));//添加一个name属性到language
14     nodeRoot->append_node(nodeLangrage); //添加一个language到Root节点
15     nodeLangrage = doc.allocate_node(rapidxml::node_element, "language", "This is C++ language");//创建一个language节点
16     nodeLangrage->append_attribute(doc.allocate_attribute("name", "C++"));//添加一个name属性到language
17     nodeRoot->append_node(nodeLangrage); //添加一个language到Root节点
18
19     doc.append_node(nodeRoot);//添加Root节点到Document
20     std::string buffer;
21     rapidxml::print(std::back_inserter(buffer), doc, 0);
22     std::ofstream outFile("language.xml");
23     outFile << buffer;
24     outFile.close();
25 }

1 <?xml version="1.0" encoding="UTF-8"?>
2 <Root>
3     <!--编程语言-->
4     <language name="C">This is C language</language>
5     <language name="C++">This is C++ language</language>
6 </Root>

 1 void MotifyXml()
 2 {
 3     rapidxml::file<> requestFile("language.xml");//从文件加载xml
 4     rapidxml::xml_document<> doc;
 5     doc.parse<0>(requestFile.data());//解析xml
 6
 7     auto nodeRoot = doc.first_node();//获取第一个节点，也就是Root节点
 8     auto nodeLanguage = nodeRoot->first_node("language");//获取Root下第一个language节点
 9     nodeLanguage->first_attribute("name")->value("Motify C");//修改language节点的name属性为 Motify C
10     std::string buffer;
11     rapidxml::print(std::back_inserter(buffer), doc, 0);
12     std::ofstream outFile("MotifyLanguage.xml");
13     outFile << buffer;
14     outFile.close();
15 }

1 <Root>
2     <language name="Motify C">This is C language</language>
3     <language name="C++">This is C++ language</language>
4 </Root>

1     template<class OutIt, class Ch>
2     inline OutIt print(OutIt out, const xml_node<Ch> &node, int flags = 0)
3     {
4         return internal::print_node(out, &node, flags, 0);
5     }

 1  // Print node
 2         template<class OutIt, class Ch>
 3         inline OutIt print_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
 4         {
 5             // Print proper node type
 6             switch (node->type())
 7             {
 8
 9             // Document
10             case node_document:
11                 out = print_children(out, node, flags, indent);
12                 break;
13
14             // Element
15             case node_element:
16                 out = print_element_node(out, node, flags, indent);
17                 break;
18
19             // Data
20             case node_data:
21                 out = print_data_node(out, node, flags, indent);
22                 break;
23
24             // CDATA
25             case node_cdata:
26                 out = print_cdata_node(out, node, flags, indent);
27                 break;
28
29             // Declaration
30             case node_declaration:
31                 out = print_declaration_node(out, node, flags, indent);
32                 break;
33
34             // Comment
35             case node_comment:
36                 out = print_comment_node(out, node, flags, indent);
37                 break;
38
39             // Doctype
40             case node_doctype:
41                 out = print_doctype_node(out, node, flags, indent);
42                 break;
43
44             // Pi
45             case node_pi:
46                 out = print_pi_node(out, node, flags, indent);
47                 break;
48
49                 // Unknown
50             default:
51                 assert(0);
52                 break;
53             }
54
55             // If indenting not disabled, add line break after node
56             if (!(flags & print_no_indenting))
57                 *out = Ch('\n'), ++out;
58
59             // Return modified iterator
60             return out;
61         }

 1 // Print element node
 2 template<class OutIt, class Ch>
 3 inline OutIt print_element_node(OutIt out, const xml_node<Ch> *node, int flags, int indent)
 4 {
 5     assert(node->type() == node_element);
 6
 7     // Print element name and attributes, if any
 8     if (!(flags & print_no_indenting))
 9     ...//省略部分代码
10
11     return out;
12 } 

1     // Printing flags
2
3     const int print_no_indenting = 0x1;   //!< Printer flag instructing the printer to suppress indenting of XML. See print() function.

  1  // Parsing flags
  2
  3     //! Parse flag instructing the parser to not create data nodes.
  4     //! Text of first data node will still be placed in value of parent element, unless rapidxml::parse_no_element_values flag is also specified.
  5     //! Can be combined with other flags by use of | operator.
  6     //! <br><br>
  7     //! See xml_document::parse() function.
  8     const int parse_no_data_nodes = 0x1;
  9
 10     //! Parse flag instructing the parser to not use text of first data node as a value of parent element.
 11     //! Can be combined with other flags by use of | operator.
 12     //! Note that child data nodes of element node take precendence over its value when printing.
 13     //! That is, if element has one or more child data nodes <em>and</em> a value, the value will be ignored.
 14     //! Use rapidxml::parse_no_data_nodes flag to prevent creation of data nodes if you want to manipulate data using values of elements.
 15     //! <br><br>
 16     //! See xml_document::parse() function.
 17     const int parse_no_element_values = 0x2;
 18
 19     //! Parse flag instructing the parser to not place zero terminators after strings in the source text.
 20     //! By default zero terminators are placed, modifying source text.
 21     //! Can be combined with other flags by use of | operator.
 22     //! <br><br>
 23     //! See xml_document::parse() function.
 24     const int parse_no_string_terminators = 0x4;
 25
 26     //! Parse flag instructing the parser to not translate entities in the source text.
 27     //! By default entities are translated, modifying source text.
 28     //! Can be combined with other flags by use of | operator.
 29     //! <br><br>
 30     //! See xml_document::parse() function.
 31     const int parse_no_entity_translation = 0x8;
 32
 33     //! Parse flag instructing the parser to disable UTF-8 handling and assume plain 8 bit characters.
 34     //! By default, UTF-8 handling is enabled.
 35     //! Can be combined with other flags by use of | operator.
 36     //! <br><br>
 37     //! See xml_document::parse() function.
 38     const int parse_no_utf8 = 0x10;
 39
 40     //! Parse flag instructing the parser to create XML declaration node.
 41     //! By default, declaration node is not created.
 42     //! Can be combined with other flags by use of | operator.
 43     //! <br><br>
 44     //! See xml_document::parse() function.
 45     const int parse_declaration_node = 0x20;
 46
 47     //! Parse flag instructing the parser to create comments nodes.
 48     //! By default, comment nodes are not created.
 49     //! Can be combined with other flags by use of | operator.
 50     //! <br><br>
 51     //! See xml_document::parse() function.
 52     const int parse_comment_nodes = 0x40;
 53
 54     //! Parse flag instructing the parser to create DOCTYPE node.
 55     //! By default, doctype node is not created.
 56     //! Although W3C specification allows at most one DOCTYPE node, RapidXml will silently accept documents with more than one.
 57     //! Can be combined with other flags by use of | operator.
 58     //! <br><br>
 59     //! See xml_document::parse() function.
 60     const int parse_doctype_node = 0x80;
 61
 62     //! Parse flag instructing the parser to create PI nodes.
 63     //! By default, PI nodes are not created.
 64     //! Can be combined with other flags by use of | operator.
 65     //! <br><br>
 66     //! See xml_document::parse() function.
 67     const int parse_pi_nodes = 0x100;
 68
 69     //! Parse flag instructing the parser to validate closing tag names.
 70     //! If not set, name inside closing tag is irrelevant to the parser.
 71     //! By default, closing tags are not validated.
 72     //! Can be combined with other flags by use of | operator.
 73     //! <br><br>
 74     //! See xml_document::parse() function.
 75     const int parse_validate_closing_tags = 0x200;
 76
 77     //! Parse flag instructing the parser to trim all leading and trailing whitespace of data nodes.
 78     //! By default, whitespace is not trimmed.
 79     //! This flag does not cause the parser to modify source text.
 80     //! Can be combined with other flags by use of | operator.
 81     //! <br><br>
 82     //! See xml_document::parse() function.
 83     const int parse_trim_whitespace = 0x400;
 84
 85     //! Parse flag instructing the parser to condense all whitespace runs of data nodes to a single space character.
 86     //! Trimming of leading and trailing whitespace of data is controlled by rapidxml::parse_trim_whitespace flag.
 87     //! By default, whitespace is not normalized.
 88     //! If this flag is specified, source text will be modified.
 89     //! Can be combined with other flags by use of | operator.
 90     //! <br><br>
 91     //! See xml_document::parse() function.
 92     const int parse_normalize_whitespace = 0x800;
 93
 94     // Compound flags
 95
 96     //! Parse flags which represent default behaviour of the parser.
 97     //! This is always equal to 0, so that all other flags can be simply ored together.
 98     //! Normally there is no need to inconveniently disable flags by anding with their negated (~) values.
 99     //! This also means that meaning of each flag is a <i>negation</i> of the default setting.
100     //! For example, if flag name is rapidxml::parse_no_utf8, it means that utf-8 is <i>enabled</i> by default,
101     //! and using the flag will disable it.
102     //! <br><br>
103     //! See xml_document::parse() function.
104     const int parse_default = 0;
105
106     //! A combination of parse flags that forbids any modifications of the source text.
107     //! This also results in faster parsing. However, note that the following will occur:
108     //! <ul>
109     //! <li>names and values of nodes will not be zero terminated, you have to use xml_base::name_size() and xml_base::value_size() functions to determine where name and value ends</li>
110     //! <li>entities will not be translated</li>
111     //! <li>whitespace will not be normalized</li>
112     //! </ul>
113     //! See xml_document::parse() function.
114     const int parse_non_destructive = parse_no_string_terminators | parse_no_entity_translation;
115
116     //! A combination of parse flags resulting in fastest possible parsing, without sacrificing important data.
117     //! <br><br>
118     //! See xml_document::parse() function.
119     const int parse_fastest = parse_non_destructive | parse_no_data_nodes;
120
121     //! A combination of parse flags resulting in largest amount of data being extracted.
122     //! This usually results in slowest parsing.
123     //! <br><br>
124     //! See xml_document::parse() function.
125     const int parse_full = parse_declaration_node | parse_comment_nodes | parse_doctype_node | parse_pi_nodes | parse_validate_closing_tags;

1 doc.parse<0>(requestFile.data());//解析xml
2 auto nodeRoot = doc.first_node("");//获取第一个节点，也就是Root节点

1 doc.parse<rapidxml::parse_declaration_node | rapidxml::parse_comment_nodes | rapidxml::parse_non_destructive>(requestFile.data());//解析xml
2 auto nodeRoot = doc.first_node("Root");//获取第一个节点，也就是Root节点