C++ boost:：instrusive:：list with the auto unlink hook：我可以使用列表中的值来确定列表中是否只有一个元素吗？

我有一个

boost:：intrusive:：list

，其中

Foo

继承自

list\u base\u hook

hook。使用列表元素

foo

，我可以通过调用

list:：s_iterator_to（foo）

来获取它的迭代器。我的问题是如何使用这个迭代器遍历列表。特别是，是否有办法判断此元素是否是列表中唯一的元素

源代码建议

list

在其值特征中使用

cicular\u list\u算法

，或许我可以使用以下测试

auto itr1 = list_t::s_iterator_to(foo);
auto itr2 = list_t::s_iterator_to(foo);
&(*++itr1) == &(*--itr2);

它看起来很粗糙，但似乎很管用。我不确定它是否正确和地道。谁能给点建议吗

完整列表：

#include <iostream>
#include <boost/intrusive/list.hpp>

using namespace boost::intrusive;

typedef list_base_hook<link_mode<auto_unlink> > auto_unlink_hook;

class Foo : public auto_unlink_hook
{
    int int_;
    public:
    Foo(int i = 0)   :  int_(i)  {}
    int  get_int()    { return int_; }
    void unlink()     {  auto_unlink_hook::unlink(); }
    bool is_linked()  {  return auto_unlink_hook::is_linked();  }
};

int main()
{
    typedef list<Foo, constant_time_size<false>> ListType;
    ListType l;
    Foo foo1{42};
    l.push_back(foo1);

    auto itr1 = ListType::s_iterator_to(foo1);
    auto itr2 = ListType::s_iterator_to(foo1);
    std::cout << (&(*++itr1) == &(*--itr2)) << std::endl;

    Foo foo2{43};
    l.push_back(foo2);
    itr1 = ListType::s_iterator_to(foo1);
    itr2 = ListType::s_iterator_to(foo1);
    std::cout << (&(*++itr1) == &(*--itr2)) << std::endl;

    foo1.unlink();

    return 0;
}

#包括
#包括
使用名称空间boost:：intrusive；
typedef list_base_hook auto_unlink_hook；
Foo类：公共自动解锁挂钩
{
int_；
公众：
Foo（int i=0）：int_（i）{
int get_int（）{return int；}
void unlink（）{auto_unlink_hook:：unlink（）；}
bool是链接的（）{return auto_unlink_hook:：is_linked（）}
};
int main（）
{
类型定义列表列表类型；
列表类型l；
富富1{42}；
l、 推回（foo1）；
auto itr1=ListType:：s_迭代器_to（foo1）；
auto itr2=ListType:：s_迭代器_to（foo1）；
std：：cout我尝试了这些方法，效果很好。但是，它与实现细节紧密结合。其想法是从值中获取底层节点指针并比较指针

typedef list<Foo, constant_time_size<false>> ListType;                                    
ListType l;                                                                               
Foo foo1{42};                                                                             
l.push_back(foo1);                                                                        

ListType::const_node_ptr cur = ListType::value_traits::to_node_ptr(foo1);                 
std::cout << (ListType::node_traits::get_previous(cur) == ListType::node_traits::get_next(cur)) << std::endl;

Foo foo2{43};                                                                             
l.push_back(foo2);                                                                        
std::cout << (ListType::node_traits::get_previous(cur) == ListType::node_traits::get_next(cur)) << std::endl;

typedef列表列表类型；
列表类型l；
富富1{42}；
l、 推回（foo1）；
ListType:：const_node_ptr cur=ListType:：value_traits:：to_node_ptr（foo1）；
std:：cout为什么不与
--列表结束（）进行比较？当你说“列表中的最后一个”时，你的意思是“它在列表的末尾”还是“列表只有一个元素”？我应该更清楚。
foo
是从另一个容器获得的，当我得到它时，我不再有对列表的引用。当然，我可以将引用与每个
foo
对象一起存储，但这可能是一种过分的做法。我的意思是“列表只有一个元素”.我明白了，我已经对你的问题进行了一些编辑，以使其更加清晰。请你发布一个完整的工作示例程序，我们可以使用它吗？你不能。为此，你需要一个容器的引用（该引用未存储在
自动取消链接
hook中）。并且在未事先检查迭代器有效性的情况下，不能取消引用
++itr1
或
--itr1
。这些不是“实现细节”它们是实现机制，而您只使用可供记录的文档特征。只需考虑在友好的助手函数中隐藏复杂性并尽可能地将其写入泛型，谢谢您的答复。我的观点是，双链接列表不一定是循环的。另一种实现方式也可以定义t。他的头部和尾部是空的。啊。是的。这是一个很好的观点。我假设这是记录在案的行为。如果不是，那么就不要使用这个，因为你只是遇到了未指定或未定义的行为。只要看一下文档，如果你确定你正在使用，你应该没事