The first test will measure the benefits we can obtain with intrusive containers avoiding memory allocations and deallocations. All the objects to be inserted in intrusive containers are allocated in a single allocation call, whereas std::list will need to allocate memory for each object and deallocate it for every erasure (or container destruction).
第一個測試將測量由於介入式容器避免了內存分配和釋放而獲得的優勢。所有被插入到介入式容器中的對象都是在一次內存分配調用中分配的，而 std::list 則需要為每一個對像分配一次內存，並為每一次刪除(或是容器的析構)釋放一次內存。

Let's compare the code to be executed for each container type for different insertion tests:
我們來比較一下對於各種容器類型、對於各種不同的插入測試所要執行的代碼：

std::vector<typename ilist::value_type> objects(NumElements);
ilist l;
for(int i = 0; i < NumElements; ++i)
l.push_back(objects[i]);
//Elements are unlinked in ilist's destructor 在 ilist 的析構函數中，元素被斷鏈
//Elements are destroyed in vector's destructor 在 vector 的析構函數中，元素被銷毀

For intrusive containers, all the values are created in a vector and after that inserted in the intrusive list.
對於介入式容器，所有值在一個 vector 中創建，稍後被插入到介入式鏈表中。

stdlist l;
for(int i = 0; i < NumElements; ++i)
l.push_back(typename stdlist::value_type(i));
//Elements unlinked and destroyed in stdlist's destructor 在 stdlist 的析構函數中，元素被斷鏈並銷毀 

For a standard list, elements are pushed back using push_back().
對於標準 list，使用 push_back() 將元素插入到後端。

std::vector<typename stdlist::value_type> objects(NumElements);
stdptrlist l;
for(int i = 0; i < NumElements; ++i)
l.push_back(&objects[i]);
//Pointers to elements unlinked and destroyed in stdptrlist's destructor
//在 stdptrlist 的析構函數中，元素指針被斷鏈並銷毀
//Elements destroyed in vector's destructor 在 vector 的析構函數中，元素被銷毀

For a standard compact pointer list, elements are created in a vector and pushed back in the pointer list using push_back().
對於標準的緊湊指針鏈表，元素在一個 vector 中創建，並用 push_back() 插入到指針鏈表的後端。

stdlist objects; stdptrlist l;
for(int i = 0; i < NumElements; ++i){
objects.push_back(typename stdlist::value_type(i));
l.push_back(&objects.back());
}
//Pointers to elements unlinked and destroyed in stdptrlist's destructor
//在 stdptrlist 的析構函數中，元素指針被斷鏈並銷毀
//Elements unlinked and destroyed in stdlist's destructor 在 stdlist 的析構函數中，元素被斷鏈並銷毀

For a disperse pointer list, elements are created in a list and pushed back in the pointer list using push_back().
對於 鬆散指針鏈表， 元素在一個 list 中創建，並用 push_back() 插入到指針鏈表的後端。

These are the times in microseconds for each case, and the normalized time:
以下是在各種情況下測試得到的毫秒時間，以及規格化時間：

The results are logical: intrusive lists just need one allocation. The destruction time of the normal_link intrusive container is trivial (complexity: O(1)), whereas safe_link and auto_unlink intrusive containers need to put the hooks of erased values in the default state (complexity: O(NumElements)). That's why normal_link intrusive list shines in this test.
結果是符合邏輯的：介入式鏈表只需要一次內存分配。normal_link 介入式容器的析構時間是平凡的(複雜度：O(1))，而 safe_link 和 auto_unlink 介入式容器則需要將被移除值的鉤子設置為缺省狀態(複雜度：O(NumElements))。這正是 normal_link 介入式鏈表在這個測試中勝出的原因。

Non-intrusive containers need to make many more allocations and that's why they lag behind. The disperse pointer list needs to make NumElements*2 allocations, so the result is not surprising.
非介入式容器需要進行多次的內存分配，這正是它們落在後面的原因。disperse pointer list 需要進行 NumElements*2 次分配，所以結果並不意外。

The Linux test shows that standard containers perform very well against intrusive containers with big objects. Nearly the same GCC version in MinGW performs worse, so maybe a good memory allocator is the reason for these excellent results.
Linux 上的測試顯示，對於大的對象，標準容器和介入式容器一樣好。而在 MinGW 平台上的相近版本的 GCC 則較差，因此也許一個好的內存分配器是這一卓越結果的原因。

The next test measures the time needed to complete calls to the member function reverse(). Values (test_class and itest_class) and lists are created as explained in the previous section.
下一個測試測量完成對成員函數 reverse() 的調用所需的時間。值(test_class 和 itest_class)和鏈表同樣是按上一節所說的那樣創建。

Note that for pointer lists, reverse does not need to access test_class values stored in another list or vector, since this function just needs to adjust internal pointers, so in theory all tested lists need to perform the same operations.
注意，對於指針鏈表，reverse 並不需要訪問保存在另一個 list 或 vector 中的 test_class 值，因為該函數只需調整內部的指針，所以理論上所有被測試的鏈表都只需完成相同的操作。

These are the results:
結果如下：

For small objects the results show that the compact storage of values in intrusive containers improve locality and reversing is faster than with standard containers, whose values might be dispersed in memory because each value is independently allocated. Note that the dispersed pointer list (a list of pointers to values allocated in another list) suffers more because nodes of the pointer list might be more dispersed, since allocations from both lists are interleaved in the code:
對 於小對象，介入式容器中的值的緊湊存儲提高了局部性，其反序操作比標準容器快一些，標準容器的值可能會鬆散分佈在內存中，因為它的每一個值都是獨立分配 的。注意，鬆散指針鏈表(其值在另一個 list 中分配的指針鏈表)更差一些，因為該指針鏈表的節點可能更加分散，在代碼中的兩個鏈表的分配是交錯的：

//Object list (holding `test_class`) 對像鏈表(保存 `test_class`)
stdlist objects;
//Pointer list (holding `test_class` pointers) 指針鏈表(保存 `test_class` 指針)
stdptrlist l;
for(int i = 0; i < NumElements; ++i){
//Allocation from the object list 從對像鏈表分配
 objects.push_back(stdlist::value_type(i));
//Allocation from the pointer list 從指針鏈表分配
 l.push_back(&objects.back());
}

For big objects the compact pointer list wins because the reversal test doesn't need access to values stored in another container. Since all the allocations for nodes of this pointer list are likely to be close (since there is no other allocation in the process until the pointer list is created) locality is better than with intrusive containers. The dispersed pointer list, as with small values, has poor locality.
對於大對象，緊湊指針鏈表勝出，因為反序測試無需訪問保存在另一個容器中的值。由於這個指針鏈表的節點的所有分配可能非常靠近(因為在該指針鏈表創建完成之前沒有其它的分配)，其局部性比介入式容器更好。和小對象的情況一樣，鬆散指針鏈表具有較差的局部性。

The next test measures the time needed to complete calls to the member function sort(Pred pred). Values (test_class and itest_class) and lists are created as explained in the first section. The values will be sorted in ascending and descenting order each iteration. For example, if l is a list:
下一個測試測量完成對成員函數 sort(Pred pred) 的調用所需的時間。值(test_class 和 itest_class)和鏈表同樣是按第一節所說的那樣創建。在每次循環中，這些值將以升序和降序排序。例如，如果 l 為一個鏈表：

for(int i = 0; i < NumIter; ++i){
if(!(i % 2))
l.sort(std::greater<stdlist::value_type>());
else
l.sort(std::less<stdlist::value_type>());
}

For a pointer list, the function object will be adapted using func_ptr_adaptor:
對於指針鏈表，將使用 func_ptr_adaptor 對函數對像進行適配：

for(int i = 0; i < NumIter; ++i){
if(!(i % 2))
l.sort(func_ptr_adaptor<std::greater<stdlist::value_type> >());
else
l.sort(func_ptr_adaptor<std::less<stdlist::value_type> >());
}

Note that for pointer lists, sort will take a function object that will access test_class values stored in another list or vector, so pointer lists will suffer an extra indirection: they will need to access the test_class values stored in another container to compare two elements.
注意，對於指針鏈表，sort 將接受一個要訪問保存在另一個 list 或 vector 中的 test_class 值的函數對象，所以指針鏈表需要多一個間接層：它們需要訪問保存在另一個容器中的 test_class 值來比較兩個元素。

These are the results:
結果如下：

The results show that intrusive containers are faster than standard containers. We can see that the pointer list holding pointers to values stored in a vector is quite fast, so the extra indirection that is needed to access the value is minimized because all the values are tightly stored, improving caching. The disperse list, on the other hand, is slower because the indirection to access values stored in the object list is more expensive than accessing values stored in a vector.
結 果顯示，介入式容器快於標準容器。我們可以看到，持有保存在 vector 的值的指針的指針鏈表速度很快，訪問值時所需的額外間接性是最小的，因為所有的值被緊密保存，這提升了緩存的作用。另一方面，鬆散鏈表較慢，因為訪問保存 在 list 中的值的間接性要比訪問保存在 vector 中值耗費更多。

The next test measures the time needed to iterate through all the elements of a list, and increment the value of the internal i_ member:
下一個測試測量遍歷一個鏈表中所有元素所需的時間，並將內部的 i_ 成員的值加一：

stdlist::iterator it(l.begin()), end(l.end());
for(; it != end; ++it)
++(it->i_);

Values (test_class and itest_class) and lists are created as explained in the first section. Note that for pointer lists, the iteration will suffer an extra indirection: they will need to access the test_class values stored in another container:
值(test_class 和 itest_class)和鏈表同樣是按第一節所說的那樣創建。注意，對於指針鏈表，遍歷操作需要多一個間接層：它們需要訪問保存在另一個容器中的 test_class 值：

stdptrlist::iterator it(l.begin()), end(l.end());
for(; it != end; ++it)
++((*it)->i_);

These are the results:
結果如下：

As with the read access test, the results show that intrusive containers outperform all other containers if the values are tightly packed in a vector. The disperse list is again the slowest.
和讀訪問測試一樣，結果顯示如果元素值是緊密壓縮在一個 vector 中的話，介入式容器要比所有其它容器都好。鬆散鏈表又一次成為最慢的。

Intrusive containers can offer performance benefits that can not be achieved with equivalent non-intrusive containers. Memory locality improvements are noticeable when the objects to be inserted are small. Minimizing memory allocation/deallocation calls is also an important factor and intrusive containers make this simple if the user allocates all the objects to be inserted in intrusive containers in containers like std::vector or std::deque.
介入式容器可以提供對等的非介入式容器不能實現的性能優勢。當插入的對象較小時，內存局部性的提升是顯著的。內存分配和釋放調用的次數最小化也是一個重要的因素，如果用戶將要插入到介入式容器中的所有對象分配到一個象 std::vector 或 std::deque 的容器中，那麼介入式容器就很簡單了。