[C++][STL] C++ STL 之 List

List
    双向链表
    每一个结点都包括一个信息快Info、一个前驱指针Pre、一个后驱指针Post。可以不分配必须的内存大小方便的进行添加和删除操作。使用的是非连续的内存空间进行存储。
   优点：(1) 不使用连续内存完成动态操作。
           (2) 在内部方便的进行插入和删除操作
           (3) 可在两端进行push、pop
   缺点：(1) 不能进行内部的随机访问，即不支持[ ]操作符和vector.at()
            (2) 相对于verctor占用内存多

测试目的：
   （1） 熟悉了解STL List基本使用方法；
   （2） 熟悉函数特性，合理高效使用标准函数；
   （3） 使用标准：尽可能使用标准函数，高效使用interator，泛型编程思想；

#include <iostream>
#include <list>
#include <ctime>
#include <cstdio>
#include <windows.h>

using namespace std;

//
//STL List Test
typedef list<int> IntList;

class IntListTest
{
public:
 IntListTest():MAX_LIST_SIZE(10) { InitIntList(); }
 ~IntListTest(){};

 //assign() test
 /*************************************************************************************
 *  void assign( input_iterator start, input_iterator end );
 *  void assign( size_type num, const TYPE &val );
 *  assign()函数以迭代器start和end指示的范围为list赋值或者为list赋值num个以val为值的元素。
 *************************************************************************************/
 void assign_Test1();
 void assign_Test2();
 void assign_performance_test();

 //back() test
 /*************************************************************************************
 *  reference back();
 *  back()函数返回一个引用，指向list的最后一个元素。
 *************************************************************************************/
 void back_test();

 //clear() and empty() test
 /*************************************************************************************
 *  void clear();
 *  clear()函数删除list的所有元素
 ---
 *  bool empty();
 *  empty()函数返回真(true)如果链表为空，否则返回假
 *************************************************************************************/
 void clear_empty_test();

 //erase() test;
 /*************************************************************************************
 *  iterator erase( iterator pos );
 *  iterator erase( iterator start, iterator end );
 *  erase()函数删除以pos指示位置的元素, 或者删除start和end之间的元素。 返回值是一个迭代器，
 *  指向最后一个被删除元素的下一个元素。
 *************************************************************************************/
 void erase_test();

 //front() test
 /*************************************************************************************
 *  reference front();
 *  front()函数返回一个引用，指向链表的第一个元素。
 *************************************************************************************/
 void front_test();

 //get_allocator() test
 /*
 *  allocator_type get_allocator();
 *  get_allocator()函数返回链表的配置器。
 */
 void get_allocator_test();//?????????

 //insert() test1
 /*************************************************************************************
 *  iterator insert( iterator pos, const TYPE &val );
 *  void insert( iterator pos, size_type num, const TYPE &val );
 *  void insert( iterator pos, input_iterator start, input_iterator end );
 *  insert()插入元素val到位置pos，或者插入num个元素val到pos之前，或者插入start到end之间的元素到pos的
 *  位置。返回值是一个迭代器，指向被插入的元素。
 *************************************************************************************/
 void insert_test1();
 void insert_test2();
 void insert_test3();
 void insert_performance_test();

 //
 /*************************************************************************************
 *  size_type max_size();
 *  max_size()函数返回链表能够储存的元素数目。
 *************************************************************************************/
 void max_size_test();
 //
 /*
 *  void merge( list &lst );
 *  void merge( list &lst, Comp compfunction );
 *  merge()函数把自己和lst链表连接在一起，产生一个整齐排列的组合链表。如果指定compfunction，则将指定函数作为比较的依据。
 */
 void merge_test();//???
 IntList& merge_compfunction(IntList& l1);
 typedef void(*cmpfun)(IntList& l1);

 //
 /*
 *  void remove( const TYPE &val );
 *  remove()函数删除链表中所有值为val的元素
 */
 void remove_test();
 /*
 *  void remove_if( UnPred pr );
 *  remove_if()以一元谓词pr为判断元素的依据，遍历整个链表。如果pr返回true则删除该元素。
 */
 void remove_if_test();

 //
 /*
 *  void resize( size_type num, TYPE val );
 *  resize()函数把list的大小改变到num。被加入的多余的元素都被赋值为val
 */
 void resize_test();

 //
 /*
 *  void reverse();
 *  reverse()函数把list所有元素倒转。
 */
 void reverse_test();

 //
 /*
 *  void sort();
 *  void sort( Comp compfunction );
 *  sort()函数为链表排序，默认是升序。如果指定compfunction的话，就采用指定函数来判定两个元素的大小。
 */
 void sort_test1();
 void sort_test2();

 //
 /*
 *  void splice( iterator pos, list &lst );
 *  void splice( iterator pos, list &lst, iterator del );
 *  void splice( iterator pos, list &lst, iterator start, iterator end );
    *  splice()函数把lst连接到pos的位置。如果指定其他参数，则插入lst中del所指元素到现链表的pos上，或者用start和end指定范围。
 */
 void splice_test1();
 void splice_test2();
 void splice_test3();

 //
 /*
 *  void swap( list &lst );
    *  swap()函数交换lst和现链表中的元素。
 */
 void swap_test();

 //
 /*
 *  void unique();
 *  void unique( BinPred pr );
    *  unique()函数删除链表中所有重复的元素。如果指定pr，则使用pr来判定是否删除
 */
 void unique_test();
private:
 void InitIntList();
 bool CheckList(const IntList& list1, const IntList& list2);
 
 void ShowDiffTime();
 void ShowDiffTime2();
 void StartTime();
 void EndTime();

private:
 const size_t MAX_LIST_SIZE;
 IntList intList1;
 IntList intList2;
 time_t startTime;
 time_t finishTime;
 SYSTEMTIME sysStartTime;
 SYSTEMTIME sysEndTime;
};

 

//implement
void IntListTest::InitIntList()
{
 intList1.clear();
 intList2.clear();

 for (size_t i = 0; i != MAX_LIST_SIZE; ++i)
 {
  intList1.push_back(i);
  intList2.push_back(i);
 }

 return;
}

bool IntListTest::CheckList(const IntList& list1, const IntList& list2)
{
 if (  list1.size()!=list2.size()
    || list1.size()==0
    || list2.size()==0 )
 {
  return false;
 }

 IntList::const_iterator itr1 = list1.begin(),itr2 =list2.begin();
 IntList::const_iterator end1 = list1.end(),end2 =list2.end();

 for (size_t i = 0; (i!=MAX_LIST_SIZE) && (itr1!=end1) && (itr2!=end2); ++i,++itr1,++itr2)
 {
  if (*itr1 != *itr2)
  {
   return false;
  }
 }

 return true;
}

void IntListTest::ShowDiffTime()
{
 time_t elapsed_time = finishTime - startTime;
 
 printf("Program takes %6.6d seconds./n", elapsed_time);

 ShowDiffTime2();
 return;
}

void IntListTest::ShowDiffTime2()
{
 SYSTEMTIME Time ;
 Time.wMinute = sysEndTime.wMinute - sysStartTime.wMinute;
 Time.wSecond = sysEndTime.wSecond - sysStartTime.wSecond;
 Time.wMilliseconds = sysEndTime.wMilliseconds - sysStartTime.wMilliseconds;

 printf("Program takes --%2d Minutes %2d Seconds %6d Milliseconds./n",
  Time.wMinute,     
  Time.wSecond,
  Time.wMilliseconds); 

 return;
}

void IntListTest::StartTime()
{
 time(&startTime);
 GetSystemTime(&sysStartTime);
}

void IntListTest::EndTime()
{
 time(&finishTime);
 GetSystemTime(&sysEndTime);
}

void IntListTest::assign_Test1()
{
 intList2.clear();

 if (intList2.size() > 0 )
 {
  cout<<"[assign_Test1]:intList2 is not empty! /n";
  return;
 }
 else
 {
  intList2.assign(intList1.begin(), intList1.end());

  if (!CheckList(intList1, intList2))
  {
   cout<<"[assign_Test1]:intList1 not equals intList2! /n";
   return;
  }
 }
}

void IntListTest::assign_Test2()
{
 intList1.clear();
 intList2.clear();

 const int INT_ITEM = 100;

 for (size_t i = 0; i!= MAX_LIST_SIZE; ++i)
 {
  intList1.push_back(INT_ITEM);
 }

 if (intList1.size() != MAX_LIST_SIZE)
 {
  cout<<"[assign_Test2]:intList1's size not equals "<<MAX_LIST_SIZE<<"! /n";
  return;
 }
 else if (intList2.size() > 0 )
 {
  cout<<"[assign_Test2]:intList2 is not empty! /n";
  return;
 }
 else
 {
  intList2.assign(MAX_LIST_SIZE, INT_ITEM);

  if (!CheckList(intList1, intList2))
  {
   cout<<"[assign_Test2]:intList1 not equals intList2! /n";
   return;
  }
 }
}

void IntListTest::assign_performance_test()
{
 const size_t TOTAL_TEST_TIMES = 500000;
 const int LIST_ITEM = 0;
  
 //
 //test1
 intList1.clear();
 StartTime();
 for (size_t i = 0 ; i != TOTAL_TEST_TIMES; ++i)
 {
  intList1.push_back(LIST_ITEM);
 }
 EndTime();
 ShowDiffTime();

 //
 //test 2
 intList2.clear();
 StartTime();
 for (IntList::const_iterator itr = intList1.begin(), e=intList1.end(); itr != e; ++itr)
 {
  intList2.push_back(*itr);
 }
 EndTime();
 ShowDiffTime();

 if (!CheckList(intList1, intList2))
 {
  cout<<"[assign_performance_test]:intList1 not equals intList2! /n";
  return;
 }

 //
 //test 3
    intList2.clear();
 StartTime();
 intList2.assign(TOTAL_TEST_TIMES, LIST_ITEM);
 EndTime();
 ShowDiffTime();

 if (!CheckList(intList1, intList2))
 {
  cout<<"[assign_performance_test]:intList1 not equals intList2! /n";
  return;
 }

 //
 //test 4
 intList2.clear();
 if (intList2.size() != 0)
 {
  cout<<"[assign_performance_test]:intList3 is not empty! /n";
  return;
 }

 StartTime();
 intList2.assign(intList1.begin(), intList1.end());
 EndTime();
 ShowDiffTime();

 if (!CheckList(intList1, intList2))
 {
  cout<<"[assign_performance_test]:intList1 not equals intList2! /n";
  return;
 }
}

void IntListTest::back_test()
{
 InitIntList();

 int member = static_cast<int> (MAX_LIST_SIZE-1);

 while ( intList1.size() != 0)
 {
  if ( intList1.back() == member)
  {
   intList1.pop_back();
//    IntList::iterator pos = intList1.end();
//    intList1.erase(pos);
   member--;
   continue;
  }
  else
  {
   cout<<"[back_test]:Member doesn't matched! /n";
   return;
  }
  
 }
 return;
}

void IntListTest::clear_empty_test()
{
 intList1.clear();
 intList2.clear();

 if (!intList1.empty())
 {
  cout<<"[clear_empty_test]:intList1 is not empty!/n";
  return;
 }
 else if (!intList2.empty())
 {
  cout<<"[clear_empty_test]:intList2 is not empty!/n";
  return;
 }

 InitIntList();

 if (intList1.empty())
 {
  cout<<"[clear_empty_test]:intList1 is empty!/n";
   return;
 }
 else if (intList2.empty())
 {
  cout<<"[clear_empty_test]:intList2 is empty!/n";
   return;
 }

 return;
}
void IntListTest::erase_test()
{
 InitIntList();

 size_t listSize = 0;
 while ( (listSize=intList1.size()) != 0 )
 {
  intList1.erase(intList1.begin());

  if ( listSize != (intList1.size()+1) )
  {
   cout<<"[erase_test]:erase data failed!/n";
   return;
  }
  //invalid usage
  //intList1.erase(intList1.end());
 }
 
 return;
}
void IntListTest::front_test()
{
 InitIntList();
 
 for (size_t i = 0; i != MAX_LIST_SIZE-1; i++)
 {
  if ( intList1.front() == static_cast<int>(i) )
  {
   intList1.erase(intList1.begin());
   continue;
  }
  else
  {
   cout<<"[front_test]:get front failed! /n";
   break;
  }
 }
}

void IntListTest::get_allocator_test()
{
 //Returns a copy of the allocator object used to construct a list.
//  Allocator get_allocator( ) const;
//
//  // list_get_allocator.cpp
//  // compile with: /EHsc
// #include <list>
// #include <iostream>
//
//  int main( )
//  {
//   using namespace std;
//   // The following lines declare objects
//   // that use the default allocator.
 intList1.clear();
 intList2.clear();

  list <int> c1;
 const int MAX_INT_SIZE = 100;
 for (int i =0; i<MAX_INT_SIZE; i++)
 {
  intList1.push_back(i);
 }

 IntList intList3(intList1.get_allocator());//????????????????????????????????

 if (intList3.size() == 0)
 {
  return;
 }

 for (IntList::const_iterator itr = intList3.begin(),e=intList3.end(); itr!=e; ++itr)
 {
  int item = *itr;
  continue;
 }

 list <int, allocator<int> > c2 = list <int, allocator<int> >( allocator<int>( ) );

  // c3 will use the same allocator class as c1
 list <int> c3( c1.get_allocator( ) );

 list<int>::allocator_type xlst = c1.get_allocator( );
  // You can now call functions on the allocator class used by c1
//  }
}

//insert()插入元素val到位置pos
void IntListTest::insert_test1()
{
 InitIntList();

 intList1.insert(intList1.end(), static_cast<int>(MAX_LIST_SIZE));
 intList1.insert(intList1.end(), static_cast<int>(MAX_LIST_SIZE+1));
 intList1.insert(intList1.end(), static_cast<int>(MAX_LIST_SIZE+2));

 int pos = 0;
 for (IntList::const_iterator itr=intList1.begin(), e=intList1.end(); itr!=e; ++itr,pos++)
 {
  if (*itr != pos)
  {
   cout<<"[insert_test1]:insert element failed! /n";
   return ;
  }
 }

 return;
}

//插入num个元素val到pos之前
void IntListTest::insert_test2()
{
 InitIntList();
 int number = 3;
 const int item = 10;

 intList1.insert(intList1.begin(), number, item);

 for (int i = 0; i<number; i++)
 {
  if ( intList1.front() == item
     && intList1.size() == (MAX_LIST_SIZE+number-i) )
  {
   intList1.pop_front();
  }
  else
  {
   cout<<"[insert_test2]:insert_test2 test failed!/n";
   return;
  }
 }
 return;
}

//插入start到end之间的元素到pos的位置
void IntListTest::insert_test3()
{
 InitIntList();

 intList1.insert(intList1.end(), intList2.begin(), intList2.end());

 if (intList1.size() != MAX_LIST_SIZE*2)
 {
  cout<<"[insert_test2]:Insert member failed! /n";
  return;
 }

 int item = 0;
 for (IntList::const_iterator itr = intList1.begin(),e=intList1.end(); itr!=e; ++itr)
 {
  if (*itr != item++)
  {
   cout<<"[insert_test2]:Insert member failed! /n";
   return;
  }

  if (item == MAX_LIST_SIZE)
  {
   item = 0;
  }
 }

 return;
}
void IntListTest::insert_performance_test()
{
 intList1.clear();
 intList2.clear();

 const int TEST_SIZE = 5000000;

 StartTime();
 for (int i = 0 ; i < TEST_SIZE; i++)
 {
  intList1.insert(intList1.end(), i);
 }
 EndTime();
 ShowDiffTime();

 StartTime();
 for (int i = 0 ; i < TEST_SIZE; i++)
 {
  intList2.push_back(i);
 }
 EndTime();
 ShowDiffTime();

 StartTime();
 for (IntList::const_iterator itr = intList1.begin(); itr!=intList1.end(); ++itr)
 {;}
 EndTime();
 ShowDiffTime();

 StartTime();
 for (IntList::const_iterator itr = intList1.begin(), e=intList1.end(); itr!=e; ++itr)
 {;}
 EndTime();
 ShowDiffTime();

 return;
}
void IntListTest::max_size_test()
{
 InitIntList();

 size_t maxSzie = intList1.max_size();

 maxSzie = intList2.max_size();

 return;
}
IntList& merge_compfunction(IntList& l1)
{
 return l1;
}
void IntListTest::merge_test()
{
 InitIntList();

 intList1.merge(intList2);
 size_t member = 0;

 if (intList1.size() != MAX_LIST_SIZE*2)
 {
  cout<<"Merge failed!/n";
  return;
 }

 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr)
 {
  member = *itr;

  cout<< member<<"/n";
 }

 member = intList2.size();
 for (IntList::const_iterator itr=intList2.begin(),e=intList2.end(); itr!=e; ++itr)
 {
  member = *itr;
 }

 //intList1.merge(intList2, &cmpfun);
 return;
}

//remove()函数删除链表中所有值为val的元素
void IntListTest::remove_test()
{
 InitIntList();

 if ( intList1.size()!=MAX_LIST_SIZE
   || intList2.size()!=MAX_LIST_SIZE)
 {
  cout<<"[remove_test]:intList size  err!/n";
 }

 intList1.remove(0);
 intList2.remove(MAX_LIST_SIZE-1);

 int item =1;
 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,++item)
 {
  if (*itr != item)
  {
   cout<<"[remove_test]:intList1 member err!/n";
   return;
  }
 }

 item = 0;
 for (IntList::const_iterator itr=intList2.begin(),e=intList2.end(); itr!=e; ++itr,++item)
 {
  if (*itr != item)
  {
   cout<<"[remove_test]:intList2 member err!/n";
   return;
  }
 }

 return;
}

bool find_list_member1(int& value )
{
 if (value==0 )
 {
  return true;
 }

 return false;
}
bool find_list_member2(int& value /*value type of list*/)
{
 if (value==9/*MAX_LIST_SIZE-1*/)
 {
  return true;
 }

 return false;
}
//remove_if()以一元谓词pr为判断元素的依据，遍历整个链表。如果pr返回true则删除该元素。
void IntListTest::remove_if_test()
{
 InitIntList();

 if ( intList1.size()!=MAX_LIST_SIZE
  || intList2.size()!=MAX_LIST_SIZE)
 {
  cout<<"[remove_if_test]:intList size  err!/n";
 }

 intList1.remove_if(find_list_member1);
 intList2.remove_if(find_list_member2);

 int item =1;
 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,++item)
 {
  if (*itr != item)
  {
   cout<<"[remove_if_test]:intList1 member err!/n";
   return;
  }
 }

 item = 0;
 for (IntList::const_iterator itr=intList2.begin(),e=intList2.end(); itr!=e; ++itr,++item)
 {
  if (*itr != item)
  {
   cout<<"[remove_if_test]:intList2 member err!/n";
   return;
  }
 }

 return;
}

//resize()函数把list的大小改变到num。被加入的多余的元素都被赋值为val
void IntListTest::resize_test()
{
 InitIntList();

 //step 1
 int item = 0 ;
 const int TEST_SIZE = 5;
 if ( intList1.size() != MAX_LIST_SIZE )
 {
  cout<<"[resize_test]:intList1 size  err(step 1)!/n";
 }
 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,item++)
 {
  if (*itr != item)
  {
   cout<<"[resize_test]:intList1 member err(step 1)!/n";
   return;
  }
 }

 //step 2
 intList1.resize(TEST_SIZE, 100);
 item = 0 ;
 if ( intList1.size() != TEST_SIZE )
 {
  cout<<"[resize_test]:intList1 size  err(step 2)!/n";
 }
 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,item++)
 {
  if (*itr != item)
  {
   cout<<"[resize_test]:intList1 member err(step 2)!/n";
   return;
  }
 }

 //setp 3
 intList1.resize(TEST_SIZE*2, 100);
 item = 0 ;
 if ( intList1.size() != 10 )
 {
  cout<<"[resize_test]:intList1 size  err(step 3)!/n";
 }

 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,item++)
 {
  if (*itr != (item>TEST_SIZE-1 ? 100:item))
  {
   cout<<"[resize_test]:intList1 member err(step 3)!/n";
   return;
  }
 }
 return;
}

//reverse()函数把list所有元素倒转。
void IntListTest::reverse_test()
{
 InitIntList();

 intList1.reverse();

 int item = MAX_LIST_SIZE-1 ;
 if ( intList1.size() != MAX_LIST_SIZE )
 {
  cout<<"[resize_test]:intList1 size  err(step 1)!/n";
 }
 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,item--)
 {
  if (*itr != item)
  {
   cout<<"[reverse_test]:intList1 member err!/n";
   return;
  }
 }

 return;
}

void IntListTest::sort_test1()
{
 intList1.clear();
 
 intList1.push_back(2);
 intList1.push_back(0);
 intList1.push_back(1);
 intList1.push_back(4);
 intList1.push_back(3);

 intList1.sort();
 int item = 0 ;
 if ( intList1.size() != 5 )
 {
  cout<<"[sort_test1]:intList1 size  err(step 1)!/n";
 }
 for (IntList::const_iterator itr=intList1.begin(), e=intList1.end(); itr!=e; ++itr,item++)
 {
  if (*itr != item)
  {
   cout<<"[sort_test1]:intList1 member err!/n";
   return;
  }
 }
 return;
}

void IntListTest::sort_test2()
{
 //void sort( Comp compfunction );
 return;
}

//splice()函数把lst连接到pos的位置。如果指定其他参数，则插入lst中del所指元素到现链表的pos上，或者用start和end指定范围。
void IntListTest::splice_test1()
{
 InitIntList();

 intList1.clear();
 if ( intList1.size() != 0 )
 {
  cout<<"[splice_test1]:intList1 size  is not empty!/n";
 }

 int item = 0 ;
 intList1.splice(intList1.end(), intList2);//  void splice( iterator pos, list &lst );

 if ( intList1.size() != MAX_LIST_SIZE )
 {
  cout<<"[splice_test1]:intList1 size  err!/n";
 }

 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,item++)
 {
  if (*itr != item)
  {
   cout<<"[splice_test1]:intList1 member err!/n";
   return;
  }
 }
 return;
}

void IntListTest::splice_test2()
{
 InitIntList();

 intList1.clear();
 if ( intList1.size() != 0 )
 {
  cout<<"[splice_test2]:intList1 size  is not empty!/n";
 }

 int item = 5 ;
 IntList::iterator pos = intList2.begin();

 for (int i = 0; i < 5; i++)
 {
  ++pos;
 }

 intList1.splice(intList1.end(), intList2, pos); //void splice( iterator pos, list &lst, iterator del );

 if ( intList1.size() != 1 )
 {
  cout<<"[splice_test2]:intList1 size  err!/n";
  return;
 }

 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr)
 {
  if (*itr != item)
  {
   cout<<"[splice_test2]:intList1 member err!/n";
   return;
  }
 }
 return;
}

void IntListTest::splice_test3()
{
 InitIntList();

 intList1.clear();
 if ( intList1.size() != 0 )
 {
  cout<<"[splice_test3]:intList1 size  is not empty!/n";
 }

 int item = 5 ;
 IntList::iterator pos = intList2.begin();

 for (int i = 0; i < 5; i++)
 {
  ++pos;
 }

 intList1.splice(intList1.end(), intList2, pos, intList2.end());
 //void splice( iterator pos, list &lst, iterator start, iterator end );

 if ( intList1.size() != 5 )
 {
  cout<<"[splice_test3]:intList1 size  err!/n";
  return;
 }

 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,item++)
 {
  if (*itr != item)
  {
   cout<<"[splice_test3]:intList1 member err!/n";
   return;
  }
 }
 return;
}

void IntListTest::swap_test()
{
 InitIntList();

 intList1.clear();
 intList1.swap(intList2);

 if (intList2.size() != 0)
 {
  cout<<"[swap_test]:intList2 size  is not empty!/n";
  return;
 }
 else if (intList1.size()!=MAX_LIST_SIZE)
 {
  cout<<"[swap_test]:intList1 size  err!/n";
  return;
 }

 int item = 0;
 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,item++)
 {
  if (*itr != item)
  {
   cout<<"[swap_test]:intList1 member err!/n";
   return;
  }
 }
 return;
}

void IntListTest::unique_test()
{
 InitIntList();

 intList1.splice(intList1.end(), intList2);

 if (intList1.size() != 2*MAX_LIST_SIZE)
 {
  cout<<"[unique_test]:intList1 size  is  err!/n";
  return;
 }

 intList1.unique();
 intList1.sort();

 if (intList1.size() !=  MAX_LIST_SIZE)
 {
  cout<<"[unique_test]:intList1 size  is  err!/n";
  return;
 }

 int item = 0;
 for (IntList::const_iterator itr=intList1.begin(),e=intList1.end(); itr!=e; ++itr,item++)
 {
  if (*itr != item)
  {
   cout<<"[unique_test]:intList1 member err!/n";
   return;
  }
 }

 return;
}
//
void main()
{
 IntListTest test1;
 //  test1.assign_Test1();
 //  test1.assign_Test2();
 // test1.assign_performance_test();
 //  test1.back_test();
 // test1.clear_empty_test();
 // test1.erase_test();
 // test1.front_test();
 // test1.get_allocator_test();
 // test1.insert_test1();
 // test1.insert_test2();
 // test1.insert_test3();
 // test1.insert_performance_test();
 // test1.max_size_test();
 //  test1.merge_test();
 //  test1.remove_test();
 //  test1.remove_if_test();
 //  test1.resize_test();
 //  test1.resize_test();
 //  test1.reverse_test();
 //  test1.sort_test1();
 //  test1.splice_test1();
 //  test1.splice_test2();
 //  test1.splice_test3();
 test1.swap_test();
 test1.unique_test();
}