如何在boost :: intrusive :: list中使用boost :: intrusive_ptr？

如何解决如何在boost :: intrusive :: list中使用boost :: intrusive_ptr？

我想一次分配一个对象，然后将其推入少量列表。如何使用boost::intrusive_ptr和boost::intrusive::list执行此操作？还是应该使用其他容器和参考计数器？

解决方法

侵入列表和intrusive_ptr不相关。

一个来自"Boost Intrusive" library
另一个是来自"Boost SmartPtr" library的智能指针

您可以使用。侵入式容器具有更多管理功能，但每个容器需要dedicated hook。

intrusive_ptr更为灵活，因为它可以通过使用引用计数来支持无边界的容器。

此外，请记住，如果您只希望对同一基础数据使用多个索引，则通常可以使用Boost MultiIndex并获得两全其美。

侵入列表

最简单的演示： Live On Compiler Explorer

#include <string>
#include <boost/intrusive/list.hpp>
#include <boost/intrusive/list_hook.hpp>

// for debug output
#include <fmt/ranges.h>

namespace bi = boost::intrusive;

using BaseHook = bi::list_base_hook<>;
using MemberHook = bi::list_member_hook<>;

struct Item : BaseHook {
    std::string data;
    Item(std::string data) : data(std::move(data)) {}

    MemberHook _secondary,_secondary2;

    bool operator<(Item const& rhs) const { return data < rhs.data; }
};

template <> struct fmt::formatter<Item> : fmt::formatter<std::string> {
    template <typename Ctx>
    auto format(Item const&val,Ctx &ctx) { return fmt::format_to(ctx.out(),"'{}'",val.data); }
};

// primary container uses the base hook
using Items     = bi::list<Item>;
using Secondary = bi::list<Item,bi::member_hook<Item,MemberHook,&Item::_secondary >>;
using Third     = bi::list<Item,&Item::_secondary2 >>;

int main() {
    Item elements[] { {"one"},{"two"},{"three"} };

    Items primary(std::begin(elements),std::end(elements));

    Secondary idx1(primary.begin(),primary.end());
    Third     idx2(primary.begin(),primary.end());

    idx1.sort();
    idx2.reverse();

    fmt::print("primary: {}\n",primary);
    fmt::print("idx1: {}\n",idx1);
    fmt::print("idx2: {}\n",idx2);
}

打印

primary: {'one','two','three'}
idx1: {'one','three','two'}
idx2: {'three','one'}

使用`intrusive_ptr`

请注意这是如何动态的，但结果要花费更多。还要注意，由于容器元素不再是“直接值”，因此所有操作都会由于间接而变得更加复杂：

插入需要动态分配（new）
sort需要一个谓词，以免您要对指针进行排序
打印需要间接

我在这里使用其他各种Boost助手来节省时间，但是请注意，这种复杂性可能会进一步降低您的开发速度，具体取决于您是否知道这些助手位

Live On Compiler Explorer

#include <string>
#include <boost/intrusive_ptr.hpp>
#include <boost/smart_ptr/intrusive_ref_counter.hpp>
#include <list>

// helpers to make handling containers of intrusive pointers easier
#include <boost/range/adaptor/indirected.hpp>
#include <boost/ptr_container/indirect_fun.hpp>
#include <memory>

// for debug output
#include <fmt/ranges.h>

struct Item : boost::intrusive_ref_counter<Item> {
    std::string data;
    Item(std::string data) : data(std::move(data)) {}

    bool operator<(Item const& rhs) const { return data < rhs.data; }
};

template <> struct fmt::formatter<Item> : fmt::formatter<std::string> {
    template <typename Ctx>
    auto format(Item const&val,val.data); }
};

int main() {
    using List = std::list<boost::intrusive_ptr<Item> >;

    List primary;
    for (auto name : {"one","two","three"}) {
        primary.emplace_back(new Item(name));
    }

    List idx1(primary.begin(),primary.end());
    List idx2(primary.begin(),primary.end());

    idx1.sort(boost::make_indirect_fun(std::less<Item>{}));
    idx2.reverse();

    fmt::print("primary: {}\n",primary | boost::adaptors::indirected);
    fmt::print("idx1: {}\n",idx1 | boost::adaptors::indirected);
    fmt::print("idx2: {}\n",idx2 | boost::adaptors::indirected);
}

打印

primary: {'one','one'}

奖金：多索引容器

您并没有要求这样做，但是对于示例来说，这似乎是一个合理的解决方案（当然，我意识到该示例可能并不代表您的问题）：

Live On Compiler Explorer

#include <string>
#include <boost/multi_index_container.hpp>
#include <boost/multi_index/sequenced_index.hpp>

// for debug output
#include <fmt/ranges.h>

struct Item {
    std::string data;
    bool operator<(Item const& rhs) const { return data < rhs.data; }
};

template <> struct fmt::formatter<Item> : fmt::formatter<std::string> {
    template <typename Ctx>
    auto format(Item const&val,val.data); }
};

namespace bmi = boost::multi_index;
using Table = bmi::multi_index_container<Item,bmi::indexed_by<
        bmi::sequenced<>,// primary
        bmi::sequenced<bmi::tag<struct Index1> >,bmi::sequenced<bmi::tag<struct Index2> >
      > >;

int main() {
    Table primary{ {"one"},{"three"} };
    
    auto& idx1 = primary.get<Index1>();
    auto& idx2 = primary.get<Index2>();

    idx1.sort();
    idx2.reverse();

    fmt::print("primary: {}\n",'one'}

到目前为止，后者具有最大的灵活性和最高级别的语义（例如，删除元素适用于所有索引）。您可以具有关联索引，有序键，复合键等。在这种情况下，它们将自动维护在replace或modify上。

当然，如果您的用例不像固定集合的索引，那么您可能需要第一个选项。