C++ 如何在c+中使用TinyXml2解析xml文件+；节目？

我第一次使用TinyXml2获取xml文件，如下所示：

<ORDER>
<ITEM>
<SN>132487A-J</SN>
<NAME>crank casing</NAME>
<Person age="12" passed="Yes">Alive</Person>
<QTY>1</QTY>
</ITEM>
</ORDER>

132487A-J
曲轴机匣
活着的
1.

---

那么，如何在VisualStudio中从TinyXml2生成这种类型的xml呢。我在网上搜索过，但他们给出的例子确实冗长而复杂，难以理解。因此，请用C++语言来简单地介绍我的代码，它可以满足我的目的。 注意我添加了一个非巨魔的答案，因为我有时间使用TinyXML

Boost属性树

#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>

struct Person {
    int age;
    bool passed;
    enum Condition { Alive, Dead } condition;

    friend std::ostream& operator<<(std::ostream& os, Condition c) {
        switch (c) {
            case Alive : return os << "Alive";
            case Dead  : return os << "Dead";
        }
        throw "failure"; //TODO
    }
};

struct Order {
    struct Item {
        std::string serialnumber, name;
        Person person;
        int quantity;
    };

    std::vector<Item> items;
};

using Tree = boost::property_tree::ptree;

Tree make_tree(Person const& p) {
    Tree pt;
    pt.put("<xmlattr>.age", p.age);
    pt.put("<xmlattr>.passed", p.passed?"Yes":"No");
    pt.put_value(p.condition);

    return pt;
}

Tree make_tree(Order::Item const& p) {
    Tree pt;
    pt.put("SN",     p.serialnumber);
    pt.put("NAME",   p.name);
    pt.put_child("Person", make_tree(p.person));
    pt.put("QTY",    p.quantity);

    return pt;
}

Tree make_tree(Order const& p) {
    Tree pt;
    Tree& order = pt.put_child("ORDER", {});
    for (auto& item : p.items)
        order.add_child("ITEM", make_tree(item));

    return pt;
}

#include <iostream>
/*
 *  <ORDER>
 *    <ITEM>
 *      <SN>132487A-J</SN>
 *      <NAME>crank casing</NAME>
 *      <Person age="12" passed="Yes">Alive</Person>
 *      <QTY>1</QTY>
 *    </ITEM>
 *  </ORDER>
 *
 */

int main() {
    Order const order {
        {
            Order::Item {
                "132487A-J", "crank casing", 
                Person { 12, true, Person::Alive },
                1
            },
        }
    };

    using namespace boost::property_tree;
    auto settings = xml_parser::xml_writer_make_settings<std::string>(' ', 4, "utf-8");
    write_xml(std::cout, make_tree(order), settings);
}

#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：troll答案类别中的ostream&operator：

注意我添加了一个非巨魔的答案，因为我有时间使用TinyXML

Boost属性树


#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>

struct Person {
    int age;
    bool passed;
    enum Condition { Alive, Dead } condition;

    friend std::ostream& operator<<(std::ostream& os, Condition c) {
        switch (c) {
            case Alive : return os << "Alive";
            case Dead  : return os << "Dead";
        }
        throw "failure"; //TODO
    }
};

struct Order {
    struct Item {
        std::string serialnumber, name;
        Person person;
        int quantity;
    };

    std::vector<Item> items;
};

using Tree = boost::property_tree::ptree;

Tree make_tree(Person const& p) {
    Tree pt;
    pt.put("<xmlattr>.age", p.age);
    pt.put("<xmlattr>.passed", p.passed?"Yes":"No");
    pt.put_value(p.condition);

    return pt;
}

Tree make_tree(Order::Item const& p) {
    Tree pt;
    pt.put("SN",     p.serialnumber);
    pt.put("NAME",   p.name);
    pt.put_child("Person", make_tree(p.person));
    pt.put("QTY",    p.quantity);

    return pt;
}

Tree make_tree(Order const& p) {
    Tree pt;
    Tree& order = pt.put_child("ORDER", {});
    for (auto& item : p.items)
        order.add_child("ITEM", make_tree(item));

    return pt;
}

#include <iostream>
/*
 *  <ORDER>
 *    <ITEM>
 *      <SN>132487A-J</SN>
 *      <NAME>crank casing</NAME>
 *      <Person age="12" passed="Yes">Alive</Person>
 *      <QTY>1</QTY>
 *    </ITEM>
 *  </ORDER>
 *
 */

int main() {
    Order const order {
        {
            Order::Item {
                "132487A-J", "crank casing", 
                Person { 12, true, Person::Alive },
                1
            },
        }
    };

    using namespace boost::property_tree;
    auto settings = xml_parser::xml_writer_make_settings<std::string>(' ', 4, "utf-8");
    write_xml(std::cout, make_tree(order), settings);
}

#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：troll答案类别中的ostream&operator：

注意我添加了一个非巨魔的答案，因为我有时间使用TinyXML

Boost属性树


#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>

struct Person {
    int age;
    bool passed;
    enum Condition { Alive, Dead } condition;

    friend std::ostream& operator<<(std::ostream& os, Condition c) {
        switch (c) {
            case Alive : return os << "Alive";
            case Dead  : return os << "Dead";
        }
        throw "failure"; //TODO
    }
};

struct Order {
    struct Item {
        std::string serialnumber, name;
        Person person;
        int quantity;
    };

    std::vector<Item> items;
};

using Tree = boost::property_tree::ptree;

Tree make_tree(Person const& p) {
    Tree pt;
    pt.put("<xmlattr>.age", p.age);
    pt.put("<xmlattr>.passed", p.passed?"Yes":"No");
    pt.put_value(p.condition);

    return pt;
}

Tree make_tree(Order::Item const& p) {
    Tree pt;
    pt.put("SN",     p.serialnumber);
    pt.put("NAME",   p.name);
    pt.put_child("Person", make_tree(p.person));
    pt.put("QTY",    p.quantity);

    return pt;
}

Tree make_tree(Order const& p) {
    Tree pt;
    Tree& order = pt.put_child("ORDER", {});
    for (auto& item : p.items)
        order.add_child("ITEM", make_tree(item));

    return pt;
}

#include <iostream>
/*
 *  <ORDER>
 *    <ITEM>
 *      <SN>132487A-J</SN>
 *      <NAME>crank casing</NAME>
 *      <Person age="12" passed="Yes">Alive</Person>
 *      <QTY>1</QTY>
 *    </ITEM>
 *  </ORDER>
 *
 */

int main() {
    Order const order {
        {
            Order::Item {
                "132487A-J", "crank casing", 
                Person { 12, true, Person::Alive },
                1
            },
        }
    };

    using namespace boost::property_tree;
    auto settings = xml_parser::xml_writer_make_settings<std::string>(' ', 4, "utf-8");
    write_xml(std::cout, make_tree(order), settings);
}

#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：troll答案类别中的ostream&operator：

注意我添加了一个非巨魔的答案，因为我有时间使用TinyXML

Boost属性树


#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>

struct Person {
    int age;
    bool passed;
    enum Condition { Alive, Dead } condition;

    friend std::ostream& operator<<(std::ostream& os, Condition c) {
        switch (c) {
            case Alive : return os << "Alive";
            case Dead  : return os << "Dead";
        }
        throw "failure"; //TODO
    }
};

struct Order {
    struct Item {
        std::string serialnumber, name;
        Person person;
        int quantity;
    };

    std::vector<Item> items;
};

using Tree = boost::property_tree::ptree;

Tree make_tree(Person const& p) {
    Tree pt;
    pt.put("<xmlattr>.age", p.age);
    pt.put("<xmlattr>.passed", p.passed?"Yes":"No");
    pt.put_value(p.condition);

    return pt;
}

Tree make_tree(Order::Item const& p) {
    Tree pt;
    pt.put("SN",     p.serialnumber);
    pt.put("NAME",   p.name);
    pt.put_child("Person", make_tree(p.person));
    pt.put("QTY",    p.quantity);

    return pt;
}

Tree make_tree(Order const& p) {
    Tree pt;
    Tree& order = pt.put_child("ORDER", {});
    for (auto& item : p.items)
        order.add_child("ITEM", make_tree(item));

    return pt;
}

#include <iostream>
/*
 *  <ORDER>
 *    <ITEM>
 *      <SN>132487A-J</SN>
 *      <NAME>crank casing</NAME>
 *      <Person age="12" passed="Yes">Alive</Person>
 *      <QTY>1</QTY>
 *    </ITEM>
 *  </ORDER>
 *
 */

int main() {
    Order const order {
        {
            Order::Item {
                "132487A-J", "crank casing", 
                Person { 12, true, Person::Alive },
                1
            },
        }
    };

    using namespace boost::property_tree;
    auto settings = xml_parser::xml_writer_make_settings<std::string>(' ', 4, "utf-8");
    write_xml(std::cout, make_tree(order), settings);
}

#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：ostream&operator这是使用Pugi XML的例子。我真的希望这会更方便用户

注意我添加了一个非巨魔的答案，因为我有时间使用TinyXML

#包括
#包括
#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：ostream&operator这是使用Pugi XML的例子。我真的希望这会更方便用户

注意我添加了一个非巨魔的答案，因为我有时间使用TinyXML

#包括
#包括
#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：ostream&operator这是使用Pugi XML的例子。我真的希望这会更方便用户

注意我添加了一个非巨魔的答案，因为我有时间使用TinyXML

#包括
#包括
#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：ostream&operator这是使用Pugi XML的例子。我真的希望这会更方便用户

注意我添加了一个非巨魔的答案，因为我有时间使用TinyXML

#包括
#包括
#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：ostream&operator好的，因为您非常有耐心，而且因为我想第一次试用TinyXml2，下面是：

#include <tinyxml2.h>
#include <vector>
#include <iostream>
#include <sstream>

struct Person {
    int age;
    bool passed;
    enum Condition { Alive, Dead } condition;

    friend std::ostream& operator<<(std::ostream& os, Condition c) {
        switch (c) {
            case Alive : return os << "Alive";
            case Dead  : return os << "Dead";
        }
        throw "failure"; //TODO
    }
};

struct Order {
    struct Item {
        std::string serialnumber, name;
        Person person;
        int quantity;
    };

    std::vector<Item> items;
};

using Tree = tinyxml2::XMLNode;
using Document = tinyxml2::XMLDocument;

Tree* make_tree(Person const& p, Document& doc) {
    auto pt = doc.NewElement("Person");

    pt->SetAttribute("age", p.age);
    pt->SetAttribute("passed", p.passed?"Yes":"No");
    std::ostringstream oss;
    oss << p.condition;
    pt->SetValue(oss.str().c_str());

    return pt;
}

Tree* make_tree(Order::Item const& p, Document& doc) {
    auto pt = doc.NewElement("ITEM");
    (pt->InsertEndChild(doc.NewElement("SN")))->InsertFirstChild(doc.NewText(p.serialnumber.c_str()));
    (pt->InsertEndChild(doc.NewElement("NAME")))->InsertFirstChild(doc.NewText(p.name.c_str()));
    pt->InsertEndChild(make_tree(p.person, doc));
    (pt->InsertEndChild(doc.NewElement("QTY")))->InsertFirstChild(doc.NewText(std::to_string(p.quantity).c_str()));

    return pt;
}

Tree* make_tree(Order const& p, Document& doc) {
    auto pt = doc.NewElement("ORDER");
    for (auto& item : p.items)
        pt->InsertEndChild(make_tree(item, doc));

    return pt;
}

#include <iostream>
/*
 *  <ORDER>
 *    <ITEM>
 *      <SN>132487A-J</SN>
 *      <NAME>crank casing</NAME>
 *      <Person age="12" passed="Yes">Alive</Person>
 *      <QTY>1</QTY>
 *    </ITEM>
 *  </ORDER>
 *
 */

int main() {
    Order const order {
        {
            Order::Item {
                "132487A-J", "crank casing", 
                Person { 12, true, Person::Alive },
                1
            },
        }
    };

    Document doc;
    doc.InsertFirstChild(make_tree(order, doc));

    tinyxml2::XMLPrinter printer;
    doc.Print(&printer);

    std::cout << printer.CStr() << "\n";
}

#包括
#包括
#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：ostream&operatorInsertFirstChild（doc.NewText（p.serialnumber.c_str（））；
（pt->InsertEndChild（doc.NewElement（“NAME”））->InsertFirstChild（doc.NewText（p.NAME.c_str（））；
pt->InsertEndChild（生成树（p.person，doc））；
（pt->InsertEndChild（doc.NewElement（“数量”））->InsertFirstChild（doc.NewText（std:：to_string（p.quantity）.c_str（））；
返回pt；
}
树*make_树（订单常量和p、文档和文档）{
自动pt=单据新元素（“订单”）；
用于（自动和项目：p.items）
pt->InsertEndChild（生成树（项目、文档））；
返回pt；
}
#包括
/*
*  
*    
*132487A-J
*曲轴箱
*活的
*      1
*    
*  
*
*/
int main（）{
命令常量命令{
{
订单：：项目{
“132487A-J”，“曲轴箱”，
人{12，对，人：：活着}，
1.
},
}
};
文件文件；
doc.InsertFirstChild（生成树（订单，doc））；
tinyxml2:：XMLPrinter打印机；
文档打印（和打印机）；
std：：cout好的，因为你非常有耐心，而且因为我想第一次试用TinyXml2，下面是：

#include <tinyxml2.h>
#include <vector>
#include <iostream>
#include <sstream>

struct Person {
    int age;
    bool passed;
    enum Condition { Alive, Dead } condition;

    friend std::ostream& operator<<(std::ostream& os, Condition c) {
        switch (c) {
            case Alive : return os << "Alive";
            case Dead  : return os << "Dead";
        }
        throw "failure"; //TODO
    }
};

struct Order {
    struct Item {
        std::string serialnumber, name;
        Person person;
        int quantity;
    };

    std::vector<Item> items;
};

using Tree = tinyxml2::XMLNode;
using Document = tinyxml2::XMLDocument;

Tree* make_tree(Person const& p, Document& doc) {
    auto pt = doc.NewElement("Person");

    pt->SetAttribute("age", p.age);
    pt->SetAttribute("passed", p.passed?"Yes":"No");
    std::ostringstream oss;
    oss << p.condition;
    pt->SetValue(oss.str().c_str());

    return pt;
}

Tree* make_tree(Order::Item const& p, Document& doc) {
    auto pt = doc.NewElement("ITEM");
    (pt->InsertEndChild(doc.NewElement("SN")))->InsertFirstChild(doc.NewText(p.serialnumber.c_str()));
    (pt->InsertEndChild(doc.NewElement("NAME")))->InsertFirstChild(doc.NewText(p.name.c_str()));
    pt->InsertEndChild(make_tree(p.person, doc));
    (pt->InsertEndChild(doc.NewElement("QTY")))->InsertFirstChild(doc.NewText(std::to_string(p.quantity).c_str()));

    return pt;
}

Tree* make_tree(Order const& p, Document& doc) {
    auto pt = doc.NewElement("ORDER");
    for (auto& item : p.items)
        pt->InsertEndChild(make_tree(item, doc));

    return pt;
}

#include <iostream>
/*
 *  <ORDER>
 *    <ITEM>
 *      <SN>132487A-J</SN>
 *      <NAME>crank casing</NAME>
 *      <Person age="12" passed="Yes">Alive</Person>
 *      <QTY>1</QTY>
 *    </ITEM>
 *  </ORDER>
 *
 */

int main() {
    Order const order {
        {
            Order::Item {
                "132487A-J", "crank casing", 
                Person { 12, true, Person::Alive },
                1
            },
        }
    };

    Document doc;
    doc.InsertFirstChild(make_tree(order, doc));

    tinyxml2::XMLPrinter printer;
    doc.Print(&printer);

    std::cout << printer.CStr() << "\n";
}

#包括
#包括
#包括
#包括
结构人{
智力年龄；
布尔通过；
枚举条件{Alive，Dead}条件；
friend std:：ostream&operatorInsertFirstChild（doc.NewText（p.serialnumber.c_str（））；
（pt->InsertEndChild（doc.NewElement（“NAME”））->InsertFirstChild（doc.NewText（p.NAME.c_str（））；
pt->InsertEndChild（生成树（p.person，doc））；
（pt->InsertEndChild（doc.NewElement（“数量”））->InsertFirstChild（doc.NewText（std:：to_string（p.quantity）.c_str（））；
返回pt；
}
树*make_树（订单常量和p、文档和文档）{
自动pt=单据新元素（“订单”）；
用于（自动和项目：p.items）
pt->InsertEndChild（生成树（项目、文档））；
返回pt；
}
#包括
/*
*  
*    
*132487A-J
*曲轴箱
*活的
*      1
*    
*  
*
*/
int main（）{
命令常量命令{
{
订单：：项目{
“132487A-J”，“曲轴箱”，
人{12，对，人：：活着}，
1.
},
}
};
文件文件；
doc.InsertFirstChild（生成树（订单，doc））；
tinyxml2:：XMLPrinter打印机；
文档打印（和打印机）；
std：：cout好的，因为你非常有耐心，因为我想试用TinyXml2治疗f