STL（五）list 双向链表
参考：
list
底层数据结构
list同样是一个模板类，它底层数据结构为双向循环链表。因此，它支持任意位置常数时间的插入/删除操作，不支持快速随机访问。
迭代器类型
list的迭代器具备前移、后移的能力，所以list提供的是Bidirectional iterator(双向迭代器)。由于采用的是双向迭代器，自然也很方便在指定元素之前插入新节点，所以list很正常地提供了insert()操作与push_back()/pop_back()操作。在C++11中，list新增了三个接口，以支持在指定位置构造对象后插入容器中:
| 接口（C++11新增) | 描述 |
|---|---|
| emplace | 在指定位置之前插入新构造的元素 |
| emplace_front | 在链表头插入新构造的元素 |
| emplace_back | 在链表尾插入新构造的元素 |
内存分配策略
list的空间配置策略，自然是像我们普通双向链表那样，有多少元素申请多少内存。它不像vector那样需要预留空间供新元素的分配，也不会因找不到连续的空间而引起整个容器的内存迁移。
迭代器失效问题
list 有一个重要性质：插入操作（insert)与接合操作（splice)都不会造成原有的list迭代器失效。这在vector是不成立的，因为vactor的插入可能引起空间的重新配置，导致原来的迭代器全部失效。list的迭代器失效，只会出现在删除的时候，指向删除元素的那个迭代器在删除后失效。
通常来说，forward_list在使用灵活度上比不上list，因为它只能单向迭代元素，且提供的接口没有list多。然而，在内存的使用上，它是比list占优势的。当对内存的要求占首要位置时，应该选择forward_list。
list使用优劣
优点：
(1) 不使用连续内存完成动态操作。
(2) 在内部方便的进行插入和删除操作
(3) 可在两端进行push、pop
缺点：
(1) 不能进行内部的随机访问，即不支持[ ]操作符和vector.at()
(2) 相对于verctor占用内存多
|
定义于头文件
|
||
| template< class T, |
(1) | |
| namespace pmr { template <class T> |
1、
成员函数
|
(构造函数)
|
构造 list (公开成员函数)
从各种数据源构造新容器，可选地使用用户提供的分配器
1) 默认构造函数。构造空容器。
2) 构造拥有
count 个有值
value 的元素的容器。
3) 构造拥有个
count 默认插入的
T 实例的容器。不进行复制。
4) 构造拥有范围
[first, last) 内容的容器。
5) 复制构造函数。构造拥有
other 内容的容器。若不提供
alloc ，则如同通过调用
std::allocator_traits<allocator_type>::select_on_container_copy_construction(other.get_allocator()) 获得分配器。
6) 移动构造函数。用移动语义构造拥有
other 内容的容器。分配器通过属于
other 的分配器移动构造获得。
7) 有分配器扩展的移动构造函数。将
alloc 用作新容器的分配器，从
other 移动内容；若
alloc != other.get_allocator() ，则它导致逐元素移动。
8) 构造拥有 initializer_list
init 内容的容器。
参数
复杂度
1) 常数
2-3) 与
count 成线性
4) 与
first 和
last 的距离成线性
5) 与
other 的大小成线性
6) 常数。
7) 若
alloc != other.get_allocator() 则为线性，否则为常数。
8) 与
init 的大小成线性。
异常 到 注意 在容器移动构造（重载 (6) ）后，指向 |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
(析构函数)
|
析构 list (公开成员函数) |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
operator=
|
赋值给容器 (公开成员函数)
替换容器内容。
1) 复制赋值运算符。以
other 的副本替换内容。
若 std::allocator_traits<allocator_type>::propagate_on_container_copy_assignment::value 为 true ，则以源分配器的副本替换目标分配器。若源分配器与目标分配器不比较相等，则用目标（ *this ）分配器销毁内存，然后在复制元素前用 other 的分配器分配。 (C++11 起).、
2) 移动赋值运算符。用移动语义以
other 的内容替换内容（即从
other 移动
other 中的数据到此容器）。之后
other 在合法但未指定的状态。若
std::allocator_traits<allocator_type>::propagate_on_container_move_assignment::value 为
true ，则用源分配器的副本替换目标分配器。若它为
false 且源与目标分配器不比较相等，则目标不能取走源内存的所有权，而必须单独移动赋值逐个元素，用自己的分配器按需分配额外的内存。任何情况下，原先在
*this 中的元素要么被销毁，要么以逐元素移动赋值替换。
3) 以 initializer_list
ilist 所标识者替换内容。
参数
返回值*this 复杂度
1) 与
*this 和
other 的大小成线性。
2) 与
*this 的大小成线性，除非分配器不比较相等且不传播，该情况下与
*this 和
other 的大小成线性。
3) 与
*this 和
ilist 的大小成线性。
注意 容器移动赋值（重载 (2) ）后，除非不兼容的分配器强制逐元素赋值，否则指向 |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
assign
|
将值赋给容器 (公开成员函数)
替换容器的内容。
1) 以
count 份
value 的副本替换内容。
2) 以范围
[first, last) 中元素的副本替换内容
3) 以来自 initializer_list
ilist 的元素替换内容。
所有指向容器元素的迭代器、指针及引用均被非法化。 参数
复杂度
1) 与
count 成线性
2) 与
first 和
last 间的距离成线性
3) 与
ilist.size() 成线性
|
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
get_allocator
|
返回相关的分配器 (公开成员函数)
返回与容器关联的分配器。 参数（无） 返回值关联的分配器。 复杂度常数。 |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
#include
#include
#include
using namespace std;
//队列重载<<
template
ostream& operator<<(ostream& s, const list& v)
{
s.put('[');
char comma[3] = { '\0', ' ', '\0' };
for (const auto& e : v) {
s << comma << e;
comma[0] = ',';
}
return s << ']';
}
int main()
{
listlst;
lst.push_back(1);
lst.push_back(2);
lst.push_back(3);
cout << "lst:" << lst << endl;
listlst1(lst.begin(), lst.end());
cout << "lst1:" << lst1 << endl;
//复制构造
listlst2(lst);
cout << "lst2:" << lst2 << endl;
listlst3(5, "AB");
cout << "lst3:" << lst3 << endl;
listnum1{ 1, 2, 3, 4, 5, 6 };
listnum2;
listnum3;
cout << "num1:" << num1 << endl;
// 复制赋值会从 nums1 复制数据到 nums2
num2 = num1;
cout << "num2:" << num2 << endl;
// 移动赋值会从 nums1 移动数据到 nums3
num3 = move(num2);
cout << "num3:" << num3 << endl;
listch;
ch.assign(6, '*');
cout << "ch:" << ch << endl;
//重新初始化对象
num1.assign(2, 6);
cout << "num1:" << num1 << endl;
//
listch1;
ch1.assign(ch.begin(), ch.end());
cout << "ch1:" << ch1 << endl;
list mylst;
int * p;
unsigned int i;
//分配数组5个元素的空间用于deque分配器
p = mylst.get_allocator().allocate(5);
// 空间中赋值
for (i = 0; i<5; i++)
mylst.get_allocator().construct(&p[i], i);
cout << "The allocated array contains:";
for (i = 0; i<5; i++)
cout << ' ' << p[i];
cout << '\n';
// 销毁空间
for (i = 0; i<5; i++)
mylst.get_allocator().destroy(&p[i]);
lst.get_allocator().deallocate(p, 5);
system("pause");
return 0;
}
2、
元素访问 |
||||||||||
|
front
|
访问第一个元素 (公开成员函数)
返回到容器首元素的引用。 在空容器上对 参数（无） 返回值到首元素的引用 复杂度常数 注意 对于容器 |
|||||||||
|
back
|
访问最后一个元素 (公开成员函数)
返回到容器中最后一个元素的引用。 在空容器上对 参数（无） 返回值到最后元素的引用。 复杂度常数。 注意 对于容器 示例 |
|||||||||
示例省略，注意元素访问无operater[ ]和at。
3、
迭代器 |
|||||||||||||||||||
|
begin
cbegin |
返回指向容器第一个元素的迭代器 (公开成员函数)
返回指向容器首元素的迭代器。 若容器为空，则返回的迭代将等于 end() 。 参数（无） 返回值指向首元素的迭代器 复杂度常数 |
||||||||||||||||||
|
end
cend |
返回指向容器尾端的迭代器 (公开成员函数)
返回指向后随容器最后元素的元素的迭代器。 此元素表现为占位符；试图访问它导致未定义行为。 参数（无） 返回值指向后随最后元素的迭代器。 复杂度常数。 |
||||||||||||||||||
|
rbegin
crbegin |
返回一个指向容器最后一个元素的反向迭代器 (公开成员函数)
返回值指向逆向容器的首元素。它对应非逆向容器的最末元素。 参数（无） 返回值指向首元素的逆向迭代器。 复杂度常数 |
||||||||||||||||||
|
rend
crend |
返回一个指向容器前端的反向迭代器 (公开成员函数）
返回逆向容器末元素的后一元素。它对应非逆向容器首元素的前一元素。此元素表现为占位符，试图访问它导致未定义行为。 参数（无） 返回值指向末元素后一元素的逆向迭代器。 复杂度常数。 |
||||||||||||||||||
#include
#include
#include
using namespace std;
int main()
{
liststr;
str.assign(2, "abac");
str.push_back("aaa");
str.push_back("bbb");
str.push_back("ccc");
//迭代器
list::iterator iter = str.begin();
for (; iter != str.end();)
{
cout << *iter++ << ' ';
}
cout << endl;
//常迭代器
list::const_iterator iter1 = str.begin();
for (; iter1 != str.end();)
{
cout << *iter1++ << ' ';
}
cout << endl;
//常反迭代器
list::const_reverse_iterator iter2 = str.rbegin();
for (; iter2 != str.rend();)
{
cout << *iter2++ << ' ';
}
cout << endl;
system("pause");
return 0;
}
4、
容量 |
|||||||||||||
|
empty
|
检查容器是否为空 (公开成员函数)
检查容器是否无元素，即是否 begin() == end() 。 参数（无） 返回值若容器为空则为 true ，否则为 false 复杂度常数。 |
||||||||||||
|
size
|
返回容纳的元素数 (公开成员函数)
返回容器中的元素数，即 std::distance(begin(), end()) 。 参数（无） 返回值容器中的元素数量。 复杂度常数。 |
||||||||||||
|
max_size
|
返回可容纳的最大元素数 (公开成员函数)
返回根据系统或库实现限制的容器可保有的元素最大数量，即对于最大容器的 std::distance(begin(), end()) 。 参数（无） 返回值元素数量的最大值。 复杂度常数。 注意 此值典型地反映容器大小上的理论极限。运行时，容器的大小可能被可用 RAM 总量限制到小于 |
||||||||||||
#include
#include
#include
#include
using namespace std;
int main()
{
srand(time(0));
list ch;
for (int i = 0; i < 10; i++)
ch.push_back((char)rand() % 10);
cout << "ch size:" << ch.size() << endl;
if (ch.empty() == 0)
cout << "ch is null" << endl;
ch.resize(20);
//容器可保有的元素最大数量
cout << "ch max_size:" << ch.max_size() << endl;
system("pause");
return 0;
}
5、
修改器 |
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
clear
|
清除内容 (公开成员函数)
从容器移除所有元素。 非法化任何指代所含元素的引用、指针或迭代器。任何尾后迭代器保持合法。 参数（无） 返回值（无） 复杂度与容器大小，即元素数成线性。 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
insert
|
插入元素 (公开成员函数)
插入元素到容器中的指定位置。
1-2) 在
pos 前插入
value 。
3) 在
pos 前插入
value 的
count 个副本。
4) 在
pos 前插入来自范围
[first, last) 的元素。
first 和
last 是指向
*this 中的迭代器，则行为未定义。
5) 在
pos 前插入来自 initializer_list
ilist 的元素。
没有引用和迭代器被非法化。 参数
返回值
1-2) 指向被插入
value 的迭代器。
3) 指向首个被插入元素的迭代器，或若
count==0 则为
pos 。
4) 指向首个被插入元素的迭代器，或若
first==last 则为
pos 。
5) 指向首个被插入元素的迭代器，或若
ilist 为空则为
pos 。
复杂度
1-2) 常数。
3) 与
count 成线性。
4) 与
std::distance(first, last) 成线性。
5) 与
ilist.size() 成线性。
异常若抛出异常，则无效果（强异常保证）。 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
emplace
(C++11)
|
原位构造元素 (公开成员函数)
直接于 没有引用和迭代器被非法化。 参数
返回值指向被安置的元素的迭代器。 复杂度常数。 异常若抛异常（例如由构造函数），则保留容器不修改，如同未曾调用过此函数（强异常保证）。 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
erase
|
擦除元素 (公开成员函数
从容器移除指定的元素。
1) 移除位于
pos 的元素。
2) 移除范围
[first; last) 中的元素。
指向被擦除元素的迭代器和引用被非法化。其他引用和迭代器不受影响。 迭代器 若 参数
返回值 后随最后被移除元素的迭代器。若迭代器 异常（无） 复杂度
1) 常数。
2) 与
first 和
last 间的距离成线性。
|
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
push_back
|
将元素添加到容器末尾 (公开成员函数)
后附给定元素
1) 初始化新元素为
value 的副本。
2) 移动
value 进新元素。
没有引用和迭代器被非法化。 参数
返回值（无） 复杂度常数。 异常 若抛出异常（可能因为 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
emplace_back
(C++11)
|
在容器末尾就地构造元素 (公开成员函数)
添加新元素到容器尾。元素通过 std::allocator_traits::construct 构造，它典型地用布置 new 于容器所提供的位置原位构造元素。参数 没有引用和迭代器被非法化。 参数
返回值
复杂度常数。 异常若抛出异常，则此函数无效果（强异常保证）。 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
pop_back
|
移除末元素 (公开成员函数)
移除容器的最末元素。 在空容器上调用 指向被擦除元素的迭代器和引用被非法化。 参数（无） 返回值（无） 复杂度常数。 异常（无） |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
push_front
|
插入元素到容器起始 (公开成员函数)
前附给定元素 没有引用和迭代器被非法化。 参数
返回值（无） 复杂度常数。 异常若抛出异常，则此函数无效果（强异常保证）。 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
emplace_front
(C++11)
|
在容器头部就地构造元素 (公开成员函数)
插入新元素到容器起始。通过 std::allocator_traits::construct 构造元素，它典型地用布置 new 在容器所提供的位置原位构造元素。将参数 没有引用和迭代器被非法化。 参数
返回值
复杂度常数。 异常若抛异常，则此函数无效果（强异常保证）。 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
pop_front
|
移除首元素 (公开成员函数)
移除容器首元素。若容器中无元素，则行为未定义。 指向被擦除元素的迭代器和引用被非法化。 参数（无） 返回值（无） 复杂度常数。 异常不抛出。 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
resize
|
改变容器中可存储元素的个数 (公开成员函数)
重设容器大小以容纳 若当前大小大于
参数
返回值（无） 复杂度 与当前大小和 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
|
swap
|
交换内容 (公开成员函数)
将内容与 所有迭代器和引用保持合法。在操作后，保有此容器中尾后值的迭代器指代此容器或另一容器是未指定的。
参数
返回值（无） 异常
复杂度常数。 |
||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
#include
#include
#include
#include
#include
using namespace std;
int main()
{
list str;
str.push_back("Hello");
str.push_back("World");
cout << "str: " << str.front() << " size:" << str.size() << endl;
str.clear();
if (!str.empty())
cout << "str: " << str.front() << endl;
else
cout<< "size:" << str.size() << endl;
list mylist;
//插入
// set some initial values:
for (int i = 1; i<6; i++)
mylist.push_back(i); // 1 2 3 4 5
list::iterator it = mylist.begin();
++it;
it = mylist.insert(it, 10); // 1 10 2 3 4 5
// "it" now points to the newly inserted 10
mylist.insert(it, 2, 20); // 1 20 20 10 2 3 4 5
// "it" no longer valid!
it = mylist.begin();
vector myvector(2, 30);
mylist.insert(it, myvector.begin(), myvector.end());
// 1 20 30 30 20 10 2 3 4 5
cout << "mylist contains:";
for (it = mylist.begin(); it != mylist.end(); ++it)
cout << ' ' << *it;
cout << '\n';
list mylist1 = { 10, 20, 30 };
auto it1 = mylist1.emplace(mylist1.begin(), 100);
mylist1.emplace(it1, 200);
mylist1.emplace(mylist1.end(), 300);
cout << "mylist1 contains:";
for (auto& x : mylist1)
cout << ' ' << x;
cout << '\n';
mylist1.emplace_back(100);
mylist1.emplace_back(200);
cout << "emplace_back:" << endl;
cout << "mylist1 contains:";
for (auto& x : mylist1)
cout << ' ' << x;
cout << '\n';
list str1;
str1.push_back("Hello");
str1.push_back("world");
cout << "str1: " << str1.front() << " size:" << str1.size() << endl;
str1.erase(str1.begin());
if (!str1.empty())
cout << "str1: " << str1.front() << " size:" << str1.size() << endl;
else
cout << "size:" << str1.size() << endl;
list arr{ 1, 2, 3, 4, 5, 6 };
for (list::iterator it = arr.begin(); it != arr.end(); it++)
cout << *it << ' ';
cout << endl;
//移除末元素
arr.pop_back();
cout << "pop_back:" << endl;
for (list::iterator it = arr.begin(); it != arr.end(); it++)
cout << *it << ' ';
cout << endl;
//移除首元素
arr.pop_front();
cout << "pop_front:" << endl;
for (list::iterator it = arr.begin(); it != arr.end(); it++)
cout << *it << ' ';
cout << endl;
//首元素插入
arr.push_front(6);
arr.push_front(6);
arr.push_front(6);
cout << "push_front:" << endl;
for (list::iterator it = arr.begin(); it != arr.end(); it++)
cout << *it << ' ';
cout << endl;
//交换
listarr1(5, 9);
cout << "arr1 size:" << arr1.size() << endl;
arr1.swap(arr);
cout << "arr1 size:" << arr1.size() << endl;
for (list::iterator it = arr.begin(); it != arr.end(); it++)
cout << *it << ' ';
cout << endl;
//首元素插入
arr.emplace_front(66);
arr.emplace_front(66);
arr.emplace_front(66);
cout << "emplace_front:" << endl;
for (list::iterator it = arr.begin(); it != arr.end(); it++)
cout << *it << ' ';
cout << endl;
system("pause");
return 0;
}
6、
操作 |
||||||||||||||||||||||||||||||||||
|
merge
|
合并二个已排序列表 (公开成员函数)
归并二个已排序链表为一个。链表应以升序排序。 不复制元素。操作后容器 此操作是稳定的：对于二个链表中的等价元素，来自 参数
返回值（无） 异常若抛出异常，则此函数无效果（强异常保证），除非异常来自比较函数。 复杂度至多 std::distance(begin(), end()) + std::distance(other.begin(), other.end()) - 1 次比较。 |
|||||||||||||||||||||||||||||||||
|
splice
|
从另一个list中移动元素 (公开成员函数)
从一个 list 转移元素给另一个。 不复制或移动元素，仅重指向链表结点的内部指针。若 get_allocator() != other.get_allocator() 则行为未定义。没有迭代器或引用被非法化，指向被移动元素的迭代器保持合法，但现在指代到 *this 中，而非到
1) 从
other 转移所有元素到
*this 中。元素被插入到
pos 所指向的元素之前。操作后容器
other 变为空。若
this == &other 则行为未定义。
2) 从
other 转移
it 所指向的元素到
*this 。元素被插入到
pos 所指向的元素之前。
3) 从
other 转移范围
[first, last) 中的元素到
*this 。元素被插入到
pos 所指向的元素之前。若
pos 是范围
[first,last) 中的迭代器则行为未定义。
参数
返回值（无） 复杂度1-2) 常数。 3) 若 this == &other 则为常数，否则与 std::distance(first, last) 成线性。 |
|||||||||||||||||||||||||||||||||
|
remove
remove_if |
移除满足特定标准的元素 (公开成员函数)
移除所有满足特定标准的元素。第一版本移除所有等于 参数
返回值（无） 复杂度与容器大小成线性 |
|||||||||||||||||||||||||||||||||
|
reverse
|
将该链表的所有元素的顺序反转 (公开成员函数)
逆转容器中的元素顺序。不非法化任何引用或迭代器。 参数（无） 返回值（无） 参数与容器大小成线性 |
|||||||||||||||||||||||||||||||||
|
unique
|
删除连续的重复元素 (公开成员函数)
从容器移除所有相继的重复元素。只留下相等元素组中的第一个元素。第一版本用 参数
返回值（无） 复杂度与容器大小成线性 |
|||||||||||||||||||||||||||||||||
|
sort
|
对元素进行排序 (公开成员函数)
以升序排序元素。保持相等元素的顺序。第一版本用 operator< 比较元素，第二版本用给定的比较函数 若抛出异常，则 *this 中元素顺序未指定。 参数
返回值（无） 复杂度大约 N log N 次比较，其中 N 是表中的元素数。 注意 std::sort 要求随机访问迭代器且不能用于 |
|||||||||||||||||||||||||||||||||
#include
#include
using namespace std;
template
ostream&operator<<(ostream&s, const list&list)
{
for (auto &i : list)
{
s << " " << i;
}
return s;
}
int main()
{
listlist1{ 1, 6, 3, 6, 2, 8 };
listlist2{ 7, 4, 2, 8, 6, 4, 9 };
//列表元素排序
list1.sort();
list2.sort();
cout << "list1:" << list1 << endl;
cout << "list2:" << list2 << endl;
list1.merge(list2);
cout << "list1 merge:" << list1 << endl;
advance(list1.begin(), 0);
cout << "list1 advace:" << list1 << endl;
//从一个 list 转移元素给另一个。
//不复制或移动元素，仅重指向链表结点的内部指针。
list1.splice(list1.begin(), list2);//将list2所有元素放置到list1中
cout << "list1:" << list1 << endl;
cout << "list2:" << list2 <<" size:"< 6; }); // 移除全部大于 6 的元素
cout << "list2:" << list2 << endl;
//列表反转
list2.reverse();
cout << "list2:" << list2 << endl;
//从容器移除所有相继的重复元素。
list2.unique();
cout << "list2:" << list2 << endl;
system("pause");
return 0;
}
7、
非成员函数
|
operator==
operator!= operator< operator<= operator> operator>= |
按照字典顺序比较 list 中的值 (函数模板)
比较二个容器的内容。
1-2) 检查
lhs 与
rhs 的内容是否相等，即是否
lhs.size() == rhs.size() 且每个
lhs 中的元素与
rhs 的同位置元素比较相等。
3-6) 按字典序比较
lhs 与
rhs 的内容。按照等价于
std::lexicographical_compare 的函数进行比较。
参数
返回值
1) 若容器内容相等则为
true ，否则为
false
2) 若容器内容不相等则为
true ，否则为
false
3) 若
lhs 的内容按字典序
小于
rhs 的内容则为
true ，否则为
false
4) 若
lhs 的内容按字典序
小于或
等于
rhs 的内容则为
true ，否则为
false
5) 若
lhs 的内容按字典序
大于
rhs 的内容则为
true ，否则为
false
6) 若
lhs 的内容按字典序
大于或
等于
rhs 的内容则为
true ，否则为
false
复杂度与容器大小成线性 |
||||||||||||||||||||||||||||||
|
std::swap
(std::list)
|
特化 std::swap 算法 (函数模板)
为 std::list 特化 std::swap 算法。交换 参数
返回值（无） 复杂度常数。 异常
|
#include
#include
using namespace std;
int main()
{
list a = { 10, 20, 30 };
list b = { 10, 20, 30 };
list c = { 30, 20, 10 };
if (a == b)
cout << "a and b are equal\n";
if (b != c)
cout << "b and c are not equal\n";
if (bb)
cout << "c is greater than b\n";
if (a <= b)
cout << "a is less than or equal to b\n";
if (a >= b)
cout << "a is greater than or equal to b\n";
system("pause");
return 0;
}
//swap (deque overload)
#include
#include
using namespace std;
int main()
{
unsigned int i;
list foo(3, 100); // three ints with a value of 100
list bar(5, 200); // five ints with a value of 200
swap(foo, bar);
cout << "foo contains:";
for (list::iterator it = foo.begin(); it != foo.end(); ++it)
cout << ' ' << *it;
cout << '\n';
cout << "bar contains:";
for (list::iterator it = bar.begin(); it != bar.end(); ++it)
cout << ' ' << *it;
cout << '\n';
system("pause");
return 0;
}
自定义类测试：
#include
#include
using namespace std;
class Myclass
{
public :
Myclass(int a, int b_) :b(b_)
{
this->a = a;
}
void fun()
{
cout << "My fun" << endl;
}
int b;
private:
int a;
};
int main()
{
listlst;
Myclass *p = new Myclass(5,6);
lst.push_back(p);
lst.front()->fun();
cout << lst.front()->b << endl;
system("pause");
return 0;
}
待续。。。。。。。