Boost.Intrusive offers another useful feature that's not present in STL containers: it's possible to obtain an iterator to a value from the value itself. This feature is implemented in Boost.Intrusive containers by a function called iterator_to:
Boost.Intrusive 提供了 STL 容器中沒有的一個很有用的特性：它可以從值獲得一個指向該值的迭代器。Boost.Intrusive 容器的這一特性是通過一個名為 iterator_to 的函數實現的：

iterator iterator_to(reference value);
const_iterator iterator_to(const_reference value);

For Boost.Intrusive containers that have local iterators, like unordered associative containers, we can also obtain local iterators:
對於具有局部迭代器的 Boost.Intrusive 容器，如無序關聯容器，我們也可以取得局部迭代器：

local_iterator local_iterator_to(reference value);
const_local_iterator local_iterator_to(const_reference value) const;

For most Boost.Intrusive containers (list, slist, set, multiset) we have an alternative static s_iterator_to function.
對於多數 Boost.Intrusive 容器(list, slist, set, multiset)，我們有另一個靜態的 s_iterator_to 函數。

For unordered associative containers (unordered_set, multiset), iterator_to has no static alternative function. On the other hand, local_iterator_to functions have their s_local_iterator_to static alternatives.
對於無序關聯容器(unordered_set, multiset), iterator_to 沒有靜態的函數。另一方面，local_iterator_to 函數則具有 s_local_iterator_to 靜態替代物。

Alternative static functions are available under certain circunstances explained in the Stateful value traits section; if the programmer uses hooks provided by Boost.Intrusive, those functions will be available.
替代的靜態函數在 帶狀態的值 traits 一節中所說明的特定環境下可用；如果程序員使用了由 Boost.Intrusive 提供的鉤子，這些函數就是可用的。

Let's see a small function that shows the use of iterator_to and local_iterator_to:
我們來看一個示範 iterator_to 和 local_iterator_to 用法的小例子：

#include <boost/intrusive/list.hpp>
#include <boost/intrusive/unordered_set.hpp>
#include <boost/functional/hash.hpp>
#include <vector>

using namespace boost::intrusive;

class intrusive_data
{
   int data_id_;
   public:

   void set(int id)  {  data_id_ = id;    }

   //This class can be inserted in an intrusive list 這個類可以插入到介入式鏈表中
   list_member_hook<>   list_hook_;

   //This class can be inserted in an intrusive unordered_set 這個類可以插入到介入式 unordered_set 中
   unordered_set_member_hook<>   unordered_set_hook_;

   //Comparison operators 比較操作符
   friend bool operator==(const intrusive_data &a, const intrusive_data &b)
   {  return a.data_id_ == b.data_id_; }

   friend bool operator!=(const intrusive_data &a, const intrusive_data &b)
   {  return a.data_id_ != b.data_id_; }

   //The hash function 散列函數
   friend std::size_t hash_value(const intrusive_data &i)
   {  return boost::hash<int>()(i.data_id_);  }
};

//Definition of the intrusive list that will hold intrusive_data 保存 intrusive_data 的介入式鏈表的定義
typedef member_hook<intrusive_data, list_member_hook<>
        , &intrusive_data::list_hook_> MemberListOption;
typedef list<intrusive_data, MemberListOption> list_t;

//Definition of the intrusive unordered_set that will hold intrusive_data 保存 intrusive_data 的介入式無序集合的定義
typedef member_hook
      < intrusive_data, unordered_set_member_hook<>
      , &intrusive_data::unordered_set_hook_> MemberUsetOption;
typedef boost::intrusive::unordered_set
   < intrusive_data, MemberUsetOption> unordered_set_t;

int main()
{
   //Create MaxElem objects 創建 MaxElem 對像
   const int MaxElem = 100;
   std::vector<intrusive_data> nodes(MaxElem);

   //Declare the intrusive containers 聲明介入式容器
   list_t     list;
   unordered_set_t::bucket_type buckets[MaxElem];
   unordered_set_t  unordered_set
      (unordered_set_t::bucket_traits(buckets, MaxElem));

   //Initialize all the nodes 初始化所有節點
   for(int i = 0; i < MaxElem; ++i) nodes[i].set(i);

   //Now insert them in both intrusive containers 現在將它們插入到兩個介入式容器中
   list.insert(list.end(), nodes.begin(), nodes.end());
   unordered_set.insert(nodes.begin(), nodes.end());

   //Now check the iterator_to function 現在檢查 iterator_to 函數
   list_t::iterator list_it(list.begin());
   for(int i = 0; i < MaxElem; ++i, ++list_it)
      if(list.iterator_to(nodes[i])       != list_it ||
         list_t::s_iterator_to(nodes[i])  != list_it)
         return 1;

   //Now check unordered_set::s_iterator_to (which is a member function)
   //and unordered_set::s_local_iterator_to (which is an static member function)
   //現在檢查 unordered_set::s_iterator_to (它是一個成員函數)和 unordered_set::s_local_iterator_to (它是一個靜態成員函數)
   unordered_set_t::iterator unordered_set_it(unordered_set.begin());
   for(int i = 0; i < MaxElem; ++i){
      unordered_set_it = unordered_set.find(nodes[i]);
      if(unordered_set.iterator_to(nodes[i]) != unordered_set_it)
         return 1;
      if(*unordered_set.local_iterator_to(nodes[i])      != *unordered_set_it ||
         *unordered_set_t::s_local_iterator_to(nodes[i]) != *unordered_set_it )
         return 1;
   }

   return 0;
}