C++ 如果是双重注册的，如何从boost树中删除子级？_C++_Boost_Tree_Double

C++ 如果是双重注册的，如何从boost树中删除子级？

c++ boost tree

C++ 如果是双重注册的，如何从boost树中删除子级？,c++,boost,tree,double,C++,Boost,Tree,Double,你能帮我做一下吗我填充这个finalTree=treeA+treeB 然而，问题是treeB的某些元素与treeA的某些元素具有相同的名称。因此，我可能会有一些孩子的双重注册即我想要实现的是删除香蕉的第一个条目，保留最后一个条目。到目前为止，我做到了： boost::property_tree::ptree & node = informationTree.add("information.fruitTypes", ""); node.add("<xmlattr>

你能帮我做一下吗

我填充这个finalTree=treeA+treeB

然而，问题是treeB的某些元素与treeA的某些元素具有相同的名称。因此，我可能会有一些孩子的双重注册

即

我想要实现的是删除香蕉的第一个条目，保留最后一个条目。到目前为止，我做到了：

boost::property_tree::ptree  & node = informationTree.add("information.fruitTypes", "");
node.add("<xmlattr>.type", fruit);
node.add_child("characteristic", char);

boost:：property_tree:：ptree&node=informationTree.add（“information.fruitTypes”，”）；
添加（“.type”，水果）；
添加子节点（“特征”，字符）；

问题是，我不知道如何删除它，因为我不知道下次复式输入是香蕉还是其他东西。我应该复制这棵树吗？您有什么建议吗？

如果您只是在构建树，您可以使用

put.*

而不是

add.*

，如果元素已经以该名称存在，它将覆盖该元素

如果您有一棵树，并且希望删除某个子树上的重复项，则必须手动执行，例如：

#include <boost/property_tree/xml_parser.hpp>
#include <iostream>
#include <map>
using boost::property_tree::ptree;

template <typename KeyF>
ptree nodup(ptree const& pt, KeyF key_accessor) {
    ptree filtered;
    std::map<std::string, std::reference_wrapper<ptree> > seen;

    for (auto& entry : pt) {
        auto key      = key_accessor(entry);
        auto previous = seen.find(key);

        if (seen.end() == previous)
            seen.emplace(key, filtered.add_child(entry.first, entry.second));
        else
            previous->second.get() = entry.second; // overwrite
    }

    return filtered;
}

int main() {
    ptree pt;
    {
        std::istringstream iss( "<category><fruit type=\"banana\"><characteristic><point v=\"0\"/></characteristic></fruit><fruit type=\"orange\"><characteristic><point v=\"1\"/></characteristic></fruit><fruit type=\"banana\"><characteristic><point v=\"2\"/></characteristic></fruit><fruit type=\"fig\"><characteristic><point v=\"3\"/></characteristic></fruit></category>");
        read_xml(iss, pt);
    }
    write_xml(std::cout, pt, boost::property_tree::xml_writer_make_settings<std::string>(' ', 4, "utf-8"));

    auto& subtree = pt.get_child("category");
    subtree = nodup(subtree, [](ptree::value_type const& item) { return item.second.get("<xmlattr>.type", ""); });

    write_xml(std::cout, pt, boost::property_tree::xml_writer_make_settings<std::string>(' ', 4, "utf-8"));
}

template <typename KeyF>
ptree nodup(ptree const& pt, KeyF key_accessor) {
    ptree filtered;
    std::map<std::string, std::reference_wrapper<ptree> > seen;

    for (auto entry = pt.rbegin(), last = pt.rend(); entry != last; ++entry) {
        auto key      = key_accessor(*entry);
        auto previous = seen.find(key);

        if (seen.end() == previous)
            seen.emplace(key, filtered.add_child(entry->first, entry->second));
    }

    return filtered;
}

#包括
#包括
#包括
使用boost:：property_tree:：ptree；
模板
ptree nodup（ptree const&pt、KeyF key_访问器）{
p树过滤；
std：：所见地图；
用于（自动和输入：pt）{
自动钥匙=钥匙存取器（输入）；
自动上一步=查看。查找（键）；
如果（参见.end（）==上一个）
seen.emplace（key，filtered.add_child（entry.first，entry.second））；
其他的
previous->second.get（）=entry.second；//覆盖
}
返回过滤；
}
int main（）{
ptree-pt；
{
std:：istringstream iss（“”）；
读取xml（iss、pt）；
}
编写xml（std:：cout，pt，boost:：property\u tree:：xml\u writer\u make\u设置（“”，4，“utf-8”）；
auto&subtree=pt.get_child（“类别”）；
subtree=nodup（子树，[]（ptree:：value_type const&item）{return item.second.get（“.type”，”）；}）；
编写xml（std:：cout，pt，boost:：property\u tree:：xml\u writer\u make\u设置（“”，4，“utf-8”）；
}

如果您更关心性能，可以向后迭代并避免一些覆盖操作：

#include <boost/property_tree/xml_parser.hpp>
#include <iostream>
#include <map>
using boost::property_tree::ptree;

template <typename KeyF>
ptree nodup(ptree const& pt, KeyF key_accessor) {
    ptree filtered;
    std::map<std::string, std::reference_wrapper<ptree> > seen;

    for (auto& entry : pt) {
        auto key      = key_accessor(entry);
        auto previous = seen.find(key);

        if (seen.end() == previous)
            seen.emplace(key, filtered.add_child(entry.first, entry.second));
        else
            previous->second.get() = entry.second; // overwrite
    }

    return filtered;
}

int main() {
    ptree pt;
    {
        std::istringstream iss( "<category><fruit type=\"banana\"><characteristic><point v=\"0\"/></characteristic></fruit><fruit type=\"orange\"><characteristic><point v=\"1\"/></characteristic></fruit><fruit type=\"banana\"><characteristic><point v=\"2\"/></characteristic></fruit><fruit type=\"fig\"><characteristic><point v=\"3\"/></characteristic></fruit></category>");
        read_xml(iss, pt);
    }
    write_xml(std::cout, pt, boost::property_tree::xml_writer_make_settings<std::string>(' ', 4, "utf-8"));

    auto& subtree = pt.get_child("category");
    subtree = nodup(subtree, [](ptree::value_type const& item) { return item.second.get("<xmlattr>.type", ""); });

    write_xml(std::cout, pt, boost::property_tree::xml_writer_make_settings<std::string>(' ', 4, "utf-8"));
}

template <typename KeyF>
ptree nodup(ptree const& pt, KeyF key_accessor) {
    ptree filtered;
    std::map<std::string, std::reference_wrapper<ptree> > seen;

    for (auto entry = pt.rbegin(), last = pt.rend(); entry != last; ++entry) {
        auto key      = key_accessor(*entry);
        auto previous = seen.find(key);

        if (seen.end() == previous)
            seen.emplace(key, filtered.add_child(entry->first, entry->second));
    }

    return filtered;
}

模板
ptree nodup（ptree const&pt、KeyF key_访问器）{
p树过滤；
std：：所见地图；
对于（自动输入=pt.rbegin（），最后一个=pt.rend（）；输入！=最后一个；++entry）{
自动钥匙=钥匙存取器（*输入）；
自动上一步=查看。查找（键）；
如果（参见.end（）==上一个）
seen.emplace（key，filtered.add_child（entry->first，entry->second））；
}
返回过滤；
}

但是，请记住，这可能会改变结果在子树中的显示顺序。

如果您只是在构建树，您可以使用

put.*

而不是

add.*

，如果元素已经以该名称存在，它将覆盖该元素

如果您有一棵树，并且希望删除某个子树上的重复项，则必须手动执行，例如：

#include <boost/property_tree/xml_parser.hpp>
#include <iostream>
#include <map>
using boost::property_tree::ptree;

template <typename KeyF>
ptree nodup(ptree const& pt, KeyF key_accessor) {
    ptree filtered;
    std::map<std::string, std::reference_wrapper<ptree> > seen;

    for (auto& entry : pt) {
        auto key      = key_accessor(entry);
        auto previous = seen.find(key);

        if (seen.end() == previous)
            seen.emplace(key, filtered.add_child(entry.first, entry.second));
        else
            previous->second.get() = entry.second; // overwrite
    }

    return filtered;
}

int main() {
    ptree pt;
    {
        std::istringstream iss( "<category><fruit type=\"banana\"><characteristic><point v=\"0\"/></characteristic></fruit><fruit type=\"orange\"><characteristic><point v=\"1\"/></characteristic></fruit><fruit type=\"banana\"><characteristic><point v=\"2\"/></characteristic></fruit><fruit type=\"fig\"><characteristic><point v=\"3\"/></characteristic></fruit></category>");
        read_xml(iss, pt);
    }
    write_xml(std::cout, pt, boost::property_tree::xml_writer_make_settings<std::string>(' ', 4, "utf-8"));

    auto& subtree = pt.get_child("category");
    subtree = nodup(subtree, [](ptree::value_type const& item) { return item.second.get("<xmlattr>.type", ""); });

    write_xml(std::cout, pt, boost::property_tree::xml_writer_make_settings<std::string>(' ', 4, "utf-8"));
}

template <typename KeyF>
ptree nodup(ptree const& pt, KeyF key_accessor) {
    ptree filtered;
    std::map<std::string, std::reference_wrapper<ptree> > seen;

    for (auto entry = pt.rbegin(), last = pt.rend(); entry != last; ++entry) {
        auto key      = key_accessor(*entry);
        auto previous = seen.find(key);

        if (seen.end() == previous)
            seen.emplace(key, filtered.add_child(entry->first, entry->second));
    }

    return filtered;
}

#包括
#包括
#包括
使用boost:：property_tree:：ptree；
模板
ptree nodup（ptree const&pt、KeyF key_访问器）{
p树过滤；
std：：所见地图；
用于（自动和输入：pt）{
自动钥匙=钥匙存取器（输入）；
自动上一步=查看。查找（键）；
如果（参见.end（）==上一个）
seen.emplace（key，filtered.add_child（entry.first，entry.second））；
其他的
previous->second.get（）=entry.second；//覆盖
}
返回过滤；
}
int main（）{
ptree-pt；
{
std:：istringstream iss（“”）；
读取xml（iss、pt）；
}
编写xml（std:：cout，pt，boost:：property\u tree:：xml\u writer\u make\u设置（“”，4，“utf-8”）；
auto&subtree=pt.get_child（“类别”）；
subtree=nodup（子树，[]（ptree:：value_type const&item）{return item.second.get（“.type”，”）；}）；
编写xml（std:：cout，pt，boost:：property\u tree:：xml\u writer\u make\u设置（“”，4，“utf-8”）；
}

如果您更关心性能，可以向后迭代并避免一些覆盖操作：

#include <boost/property_tree/xml_parser.hpp>
#include <iostream>
#include <map>
using boost::property_tree::ptree;

template <typename KeyF>
ptree nodup(ptree const& pt, KeyF key_accessor) {
    ptree filtered;
    std::map<std::string, std::reference_wrapper<ptree> > seen;

    for (auto& entry : pt) {
        auto key      = key_accessor(entry);
        auto previous = seen.find(key);

        if (seen.end() == previous)
            seen.emplace(key, filtered.add_child(entry.first, entry.second));
        else
            previous->second.get() = entry.second; // overwrite
    }

    return filtered;
}

int main() {
    ptree pt;
    {
        std::istringstream iss( "<category><fruit type=\"banana\"><characteristic><point v=\"0\"/></characteristic></fruit><fruit type=\"orange\"><characteristic><point v=\"1\"/></characteristic></fruit><fruit type=\"banana\"><characteristic><point v=\"2\"/></characteristic></fruit><fruit type=\"fig\"><characteristic><point v=\"3\"/></characteristic></fruit></category>");
        read_xml(iss, pt);
    }
    write_xml(std::cout, pt, boost::property_tree::xml_writer_make_settings<std::string>(' ', 4, "utf-8"));

    auto& subtree = pt.get_child("category");
    subtree = nodup(subtree, [](ptree::value_type const& item) { return item.second.get("<xmlattr>.type", ""); });

    write_xml(std::cout, pt, boost::property_tree::xml_writer_make_settings<std::string>(' ', 4, "utf-8"));
}

template <typename KeyF>
ptree nodup(ptree const& pt, KeyF key_accessor) {
    ptree filtered;
    std::map<std::string, std::reference_wrapper<ptree> > seen;

    for (auto entry = pt.rbegin(), last = pt.rend(); entry != last; ++entry) {
        auto key      = key_accessor(*entry);
        auto previous = seen.find(key);

        if (seen.end() == previous)
            seen.emplace(key, filtered.add_child(entry->first, entry->second));
    }

    return filtered;
}

模板
ptree nodup（ptree const&pt、KeyF key_访问器）{
p树过滤；
std：：所见地图；
对于（自动输入=pt.rbegin（），最后一个=pt.rend（）；输入！=最后一个；++entry）{
自动钥匙=钥匙存取器（*输入）；
自动上一步=查看。查找（键）；
如果（参见.end（）==上一个）
seen.emplace（key，filtered.add_child（entry->first，entry->second））；
}
返回过滤；
}

但是，请记住，这可能会改变果实在子树中出现的顺序