For list, you can publicly derive from list_base_hook.
對於 list，你可以公有派生自 list_base_hook.

template <class ...Options>
class list_base_hook;

The class can take several options. Boost.Intrusive classes receive arguments in the form option_name<option_value>. You can specify the following options:
該類可以接受幾個選項。Boost.Intrusive 以 option_name<option_value> 的形式來接受實參。你可以指定以下選項：

For the following examples, let's forget the options and use the default values:
以下例子中，讓我們忘記這些選項，只使用缺省值：

#include <boost/intrusive/list.hpp>

using namespace boost::intrusive;

class Foo
   //Base hook with default tag, raw pointers and safe_link mode
   //帶缺省標記、裸指針和 safe_link 模式的基類鉤子
   :  public list_base_hook<>
{ /**/ };

After that, we can define the intrusive list:
然後，我們就可以定義介入式鏈表：

template <class T, class ...Options>
class list;

list receives the type to be inserted in the container (T) as the first parameter and optionally, the user can specify options. We have 3 option types:
list 將被插入到容器中的類型(T) 作為第一個參數，並接受其它由用戶指定的可選項。我們有3個選項類型：

Example of a constant-time size intrusive list that will store Foo objects, using the base hook with the default tag:
以下例子是一個保存 Foo 對象，使用基類鉤子，帶缺省標記，含常量時間大小函數的介入式鏈表：

typedef list<Foo> FooList;

Example of a intrusive list with non constant-time size that will store Foo objects:
以下例子是一個保存 Foo 對象，不含常量時間大小函數的介入式鏈表：

typedef list<Foo, constant_time_size<false> > FooList;

Remember that the user must specify the base hook if the base hook has no default tag (e.g: if more than one base hook is used):
請記住，如果基類鉤子沒有缺省標記，用戶必須指定該基類鉤子(如：如果有一個以上的基類鉤子)：

#include <boost/intrusive/list.hpp>

using namespace boost::intrusive;

struct my_tag;

typedef list_base_hook< tag<my_tag> > BaseHook;
class Foo   :  public BaseHook
{ /**/ };

typedef list< Foo, base_hook<BaseHook> > FooList;

Once the list is defined, we can use it:
定義了該鏈表後，我們就可以使用它了：

//An object to be inserted in the list 插入到鏈表中的對象
Foo foo_object;
FooList list;

list.push_back(object);

assert(&list.front() == &foo_object);

Sometimes an 'is-a' relationship between list hooks and the list value types is not desirable. In this case, using a member hook as a data member instead of 'disturbing' the hierarchy might be the right way: you can add a public data member list_member_hook<...> to your class. This class can be configured with the same options as list_base_hook except the option tag:
有時候，鏈表鉤子和鏈表值類型之間的 'is-a' 關係是不合理的。這時，使用一個成員鉤子作為數據成員，而不是'打亂'類的繼承層次，可能是正確的方法：你可增加一個公有數據成員 list_member_hook<...> 到你的類中。該類可以用和 list_base_hook 一樣的選項來配置，除了 tag 選項：

template <class ...Options>
class list_member_hook;

Example:
例如：

#include <boost/intrusive/list.hpp>

class Foo 
{
   public:
   list_member_hook<> hook_;  
   //...
};

When member hooks are used, the member_hook option is used to configure the list:
使用成員鉤子時，member_hook 選項被用於配置鏈表：

//This option will configure "list" to use the member hook 這個選項將 "list" 配置為使用成員鉤子
typedef member_hook<Foo, list_member_hook<>, &Foo::hook_> MemberHookOption;

//This list will use the member hook 這個 list 將使用成員鉤子
typedef list<Foo, MemberHookOption> FooList;

Now we can use the container:
現在我們就可以使用這個容器了：

//An object to be inserted in the list 被插入到鏈表中的對象
Foo foo_object;
FooList list;

list.push_back(object);

assert(&list.front() == &foo_object);

You can insert the same object in several intrusive containers at the same time, using one hook per container. This is a full example using base and member hooks:
你可以將同一個對像同時插入到多個介入式容器中，每個容器使用一個鉤子。以下是一個使用基類鉤子和成員鉤子的完整例子：

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

using namespace boost::intrusive;

class MyClass : public list_base_hook<>
{
   int int_;

   public:
   list_member_hook<> member_hook_;

   MyClass(int i) :  int_(i)  {}
};

//Define a list that will store MyClass using the base hook 定義一個鏈表，使用基類鉤子保存 MyClass
typedef list<MyClass> BaseList;

//Define a list that will store MyClass using the member hook 定義一個鏈表，使用成員鉤子保存 MyClass
typedef member_hook
   < MyClass, list_member_hook<>, &MyClass::member_hook_> MemberOption;
typedef list<MyClass, MemberOption> MemberList;

int main()
{
   typedef std::vector<MyClass>::iterator VectIt;
   typedef std::vector<MyClass>::reverse_iterator VectRit;

   //Create several MyClass objects, each one with a different value 創建幾個 MyClass 對象，各有不同的值
   std::vector<MyClass> values;
   for(int i = 0; i < 100; ++i)  values.push_back(MyClass(i));

   BaseList baselist;
   MemberList memberlist;

   //Now insert them in the reverse order in the base hook list 現在將它們以反序插入到基類鉤子鏈表中
   for(VectIt it(values.begin()), itend(values.end())
      ; it != itend  ; ++it){
      baselist.push_front(*it);
   }

   //Now insert them in the same order as in vector in the member hook list 現在將它們以相同順序插入到成員鉤子鏈表中
   for(VectIt it(values.begin()), itend(values.end()); it != itend; ++it)
      memberlist.push_back(*it);

   //Now test lists 現在測試這些鏈表
   {
      BaseList::reverse_iterator rbit(baselist.rbegin()), rbitend(baselist.rend());
      MemberList::iterator mit(memberlist.begin()), mitend(memberlist.end());
      VectIt  it(values.begin()), itend(values.end());

      //Test the objects inserted in the base hook list 測試插入到基類鉤子鏈表中的對象
      for(; it != itend; ++it, ++rbit)
         if(&*rbit != &*it)   return 1;

      //Test the objects inserted in the member hook list 測試插入到成員鉤子鏈表中的對象
      for(it = values.begin(); it != itend; ++it, ++mit)
         if(&*mit != &*it)    return 1;
   }

   return 0;
}

Even if the interface of list is similar to std::list, its usage is a bit different: You always have to keep in mind that you directly store objects in intrusive containers, not copies. The lifetime of a stored object is not bound to or managed by the container:
雖然 list 的接口與 std::list 類似，但是它的用法有些不一樣：你必須緊記你是直接將對像保存到介入式容器中，而不是其拷貝。被保存對象的生存期未被綁定到容器，也不是由容器負責管理：