注：std::list C++11标准
list概述
template <class T, class Alloc = allocator<T> > class list;
list是一种序列容器，它允许在序列中的任意位置进行常数时间的插入和删除操作，并可以在两个方向上进行迭代（遍历）。
list容器是基于双链表实现的，可以将其包含的每个元素存储在不同且不相关的存储位置上。通过链接到前一个元素和后一个元素的每个元素的关联关系在链表内部保持顺序。
list与forward_list非常相似：主要的区别是forward_list对象是单向链表，因此只能单向（forward）迭代（遍历），占用空间更小也更高效。
与其他基本的标准序列容器(array、vector和deque)相比，list在任何位置进行插入、获取和移动元素等操作方面都表现得更好，因此在使用这些操作的算法中也表现得更好，比如排序算法。
与其他序列容器相比，list和forward_list的主要缺点是它们无法使用元素位置对元素直接访问。例如，要访问list中的第6个元素，必须从已知位置(如开始或结束)遍历到该位置，需要花费的时间与这些位置之间的距离呈线性关系。它们还要消耗一些额外的内存来保存将每个元素关联起来的链接信息（也就是指针）。
容器属性
- 顺序存储
顺序容器中的元素按照严格的线性顺序存储。各个元素通过使用它们在这个序列中的位置来访问。
- 双向链表
每个元素都保存了如何定位下一个和前一个元素的信息，允许在特定元素之前或之后(甚至在整个范围内)进行常数时间的插入和删除操作，但不允许直接随机访问。
- 分配器
容器使用allocator对象来动态处理其存储需求。
模板参数
- T
元素的类型。
别名为成员类型 list :: value_type。
- Alloc
用于定义分配模型的分配器对象的类型。默认情况下，使用allocator类模板，该模板定义最简单的内存分配模型，并且与值无关。
别名为成员类型 list :: allocator_type。
成员类型
| member type | definition | notes |
|---|---|---|
| value_type | The first template parameter (T) | |
| allocator_type | The second template parameter (Alloc) | defaults to: allocator<value_type> |
| reference | value_type& | |
| const_reference | const value_type& | |
| pointer | allocator_traits<allocator_type>::pointer | for the default allocator: value_type* |
| const_pointer | allocator_traits<allocator_type>::const_pointer | for the default allocator: const value_type* |
| iterator | a bidirectional iterator to value_type | convertible to const_iterator |
| const_iterator | a bidirectional iterator to const value_type | |
| reverse_iterator | reverse_iterator<iterator> | |
| const_reverse_iterator | reverse_iterator<const_iterator> | |
| difference_type | a signed integral type, identical to: iterator_traits<iterator>::difference_type | usually the same as ptrdiff_t |
| size_type | an unsigned integral type that can represent any non-negative value of difference_type | usually the same as size_t |
成员函数
- (constructor) 构造函数
| default (1) | explicit list (const allocator_type& alloc = allocator_type()); |
|---|---|
| fill (2) | explicit list (size_type n); |
| range (3) | template <class InputIterator>
list (InputIterator first, InputIterator last,
const allocator_type& alloc = allocator_type());
|
| copy (4) | list (const list& x); list (const list& x, const allocator_type& alloc); |
| move (5) | list (list&& x); list (list&& x, const allocator_type& alloc); |
| initializer list (6) | list (initializer_list<value_type> il,
const allocator_type& alloc = allocator_type()); |
构造函数示例：
// constructing lists #include <iostream> #include <list> int main () { // constructors used in the same order as described above: std::list<int> first; // empty list of ints std::list<int> second (4,100); // four ints with value 100 std::list<int> third (second.begin(),second.end()); // iterating through second std::list<int> fourth (third); // a copy of third // the iterator constructor can also be used to construct from arrays: int myints[] = {16,2,77,29}; std::list<int> fifth (myints, myints + sizeof(myints) / sizeof(int) ); std::cout << "The contents of fifth are: "; for (std::list<int>::iterator it = fifth.begin(); it != fifth.end(); it++) std::cout << *it << ' '; std::cout << '\n'; return 0; } Output: The contents of fifth are: 16 2 77 29
- (destructor) 析构函数
~list()
- operator= 赋值
| copy (1) | list& operator= (const list& x); |
|---|---|
| move (2) | list& operator= (list&& x); |
| initializer list (3) | list& operator= (initializer_list<value_type> il); |
赋值示例：
// assignment operator with lists #include <iostream> #include <list> int main () { std::list<int> first (3); // list of 3 zero-initialized ints std::list<int> second (5); // list of 5 zero-initialized ints second = first; first = std::list<int>(); std::cout << "Size of first: " << int (first.size()) << '\n'; std::cout << "Size of second: " << int (second.size()) << '\n'; return 0; } Output: Size of first: 0 Size of second: 3
- 迭代器
| 函数 | 函数原型 | 功能描述 |
| begin | iterator begin() noexcept; | Return iterator to beginning |
| const_iterator begin() const noexcept; | ||
| end | iterator end() noexcept; | Return iterator to end |
| const_iterator end() const noexcept; | ||
| rbegin | reverse_iterator rbegin() noexcept; | Return reverse iterator to reverse beginning |
| const_reverse_iterator rbegin() const noexcept; | ||
| rend | reverse_iterator rend() nothrow; | Return reverse iterator to reverse end |
| const_reverse_iterator rend() const nothrow; | ||
| cbegin | const_iterator cbegin() const noexcept; | Return const_iterator to beginning |
| cend | const_iterator cend() const noexcept; | Return const_iterator to end |
| crbegin | const_reverse_iterator crbegin() const noexcept; | Return const_reverse_iterator to reverse beginning |
| crend | const_reverse_iterator crend() const noexcept; | Return const_reverse_iterator to reverse end |
迭代器示例：
#include <iostream> #include <list> int main () { int myints[] = {75,23,65,42,13}; std::list<int> mylist (myints,myints+5); std::cout << "mylist contains:"; for (std::list<int>::iterator it=mylist.begin(); it != mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; ｝ Output: mylist contains: 75 23 65 42 13
- 容器大小或容量相关
| 函数 | 函数原型 | 功能描述 |
| empty | bool empty() const noexcept; | Test whether container is empty |
| size | size_type size() const noexcept; | Return size |
| max_size | size_type max_size() const noexcept; | Return maximum size |
- 成员访问
| 函数 | 函数原型 | 功能描述 |
| front | reference front(); | Access first element |
| const_reference front() const; | ||
| back | reference back(); | Access last element |
| const_reference back() const; |
成员访问示例：
// list::front #include <iostream> #include <list> int main () { std::list<int> mylist; mylist.push_back(77); mylist.push_back(22); // now front equals 77, and back 22 mylist.front() -= mylist.back(); std::cout << "mylist.front() is now " << mylist.front() << '\n'; return 0; } Output: mylist.front() is now 55 ------------------------------------------------------------------------------- // list::back #include <iostream> #include <list> int main () { std::list<int> mylist; mylist.push_back(10); while (mylist.back() != 0) { mylist.push_back ( mylist.back() -1 ); } std::cout << "mylist contains:"; for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end() ; ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: mylist contains: 10 9 8 7 6 5 4 3 2 1 0
- 添加、删除等修改相关操作
| 函数 | 函数原型 | 功能描述 |
| assign | template <class InputIterator> void assign (InputIterator first, InputIterator last); | Assign new content to container |
| void assign (size_type n, const value_type& val); | ||
| void assign (initializer_list<value_type> il); | ||
| emplace_front | template <class... Args> void emplace_front (Args&&... args); | Construct and insert element at beginning |
| emplace_back | template <class... Args> void emplace_back (Args&&... args); | Construct and insert element at the end |
| push_front | void push_front (const value_type& val); | Insert element at beginning |
| void push_front (value_type&& val); | ||
| pop_front | void pop_front(); | Delete first element |
| push_back | void push_back (const value_type& val); | Add element at the end |
| void push_back (value_type&& val); | ||
| pop_back | void pop_back(); | Delete last element |
| emplace | template <class... Args> iterator emplace (const_iterator position, Args&&... args); | Construct and insert element |
| insert | iterator insert (const_iterator position, const value_type& val); | Insert elements |
| iterator insert (const_iterator position, size_type n, const value_type& val); | ||
| template <class InputIterator> iterator insert (const_iterator position, InputIterator first, InputIterator last); | ||
| iterator insert (const_iterator position, value_type&& val); | ||
| iterator insert (const_iterator position, initializer_list<value_type> il); | ||
| erase | iterator erase (const_iterator position); | erase elements |
| iterator erase (const_iterator first, const_iterator last); | ||
| swap | void swap (list& x); | Swap content |
| resize | void resize (size_type n); | Change size |
| void resize (size_type n, const value_type& val); | ||
| clear | void clear() noexcept; | Clear content |
示例代码：
// list::assign #include <iostream> #include <list> int main () { std::list<int> first; std::list<int> second; first.assign (7,100); // 7 ints with value 100 second.assign (first.begin(),first.end()); // a copy of first int myints[]={1776,7,4}; first.assign (myints,myints+3); // assigning from array std::cout << "Size of first: " << int (first.size()) << '\n'; std::cout << "Size of second: " << int (second.size()) << '\n'; return 0; } Output: Size of first: 3 Size of second: 7 ------------------------------------------------------------------------------ // list::emplace_front #include <iostream> #include <list> int main () { std::list< std::pair<int,char> > mylist; mylist.emplace_front(10,'a'); mylist.emplace_front(20,'b'); mylist.emplace_front(30,'c'); std::cout << "mylist contains:"; for (auto& x: mylist) std::cout << " (" << x.first << "," << x.second << ")"; std::cout << std::endl; return 0; } Output: mylist contains: (30,c) (20,b) (10,a) ------------------------------------------------------------------------------ // list::emplace_back #include <iostream> #include <list> int main () { std::list< std::pair<int,char> > mylist; mylist.emplace_back(10,'a'); mylist.emplace_back(20,'b'); mylist.emplace_back(30,'c'); std::cout << "mylist contains:"; for (auto& x: mylist) std::cout << " (" << x.first << "," << x.second << ")"; std::cout << std::endl; return 0; } Output: mylist contains: (10,a) (20,b) (30,c) ------------------------------------------------------------------------------ // list::push_front #include <iostream> #include <list> int main () { std::list<int> mylist (2,100); // two ints with a value of 100 mylist.push_front (200); mylist.push_front (300); std::cout << "mylist contains:"; for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: 300 200 100 100 ------------------------------------------------------------------------------ // list::pop_front #include <iostream> #include <list> int main () { std::list<int> mylist; mylist.push_back (100); mylist.push_back (200); mylist.push_back (300); std::cout << "Popping out the elements in mylist:"; while (!mylist.empty()) { std::cout << ' ' << mylist.front(); mylist.pop_front(); } std::cout << "\nFinal size of mylist is " << mylist.size() << '\n'; return 0; } Output: Popping out the elements in mylist: 100 200 300 Final size of mylist is 0 ------------------------------------------------------------------------------ // list::push_back #include <iostream> #include <list> int main () { std::list<int> mylist; int myint; std::cout << "Please enter some integers (enter 0 to end):\n"; do { std::cin >> myint; mylist.push_back (myint); } while (myint); std::cout << "mylist stores " << mylist.size() << " numbers.\n"; return 0; } ------------------------------------------------------------------------------ // list::pop_back #include <iostream> #include <list> int main () { std::list<int> mylist; int sum (0); mylist.push_back (100); mylist.push_back (200); mylist.push_back (300); while (!mylist.empty()) { sum+=mylist.back(); mylist.pop_back(); } std::cout << "The elements of mylist summed " << sum << '\n'; return 0; } Output: The elements of mylist summed 600 ------------------------------------------------------------------------------ // list::emplace #include <iostream> #include <list> int main () { std::list< std::pair<int,char> > mylist; mylist.emplace ( mylist.begin(), 100, 'x' ); mylist.emplace ( mylist.begin(), 200, 'y' ); std::cout << "mylist contains:"; for (auto& x: mylist) std::cout << " (" << x.first << "," << x.second << ")"; std::cout << '\n'; return 0; } Output: mylist contains: (200,y) (100,x) ------------------------------------------------------------------------------ // inserting into a list #include <iostream> #include <list> #include <vector> int main () { std::list<int> mylist; std::list<int>::iterator it; // set some initial values: for (int i=1; i<=5; ++i) mylist.push_back(i); // 1 2 3 4 5 it = mylist.begin(); ++it; // it points now to number 2 ^ mylist.insert (it,10); // 1 10 2 3 4 5 // "it" still points to number 2 ^ mylist.insert (it,2,20); // 1 10 20 20 2 3 4 5 --it; // it points now to the second 20 ^ std::vector<int> myvector (2,30); mylist.insert (it,myvector.begin(),myvector.end()); // 1 10 20 30 30 20 2 3 4 5 // ^ std::cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: mylist contains: 1 10 20 30 30 20 2 3 4 5 ------------------------------------------------------------------------------ // erasing from list #include <iostream> #include <list> int main () { std::list<int> mylist; std::list<int>::iterator it1,it2; // set some values: for (int i=1; i<10; ++i) mylist.push_back(i*10); // 10 20 30 40 50 60 70 80 90 it1 = it2 = mylist.begin(); // ^^ advance (it2,6); // ^ ^ ++it1; // ^ ^ it1 = mylist.erase (it1); // 10 30 40 50 60 70 80 90 // ^ ^ it2 = mylist.erase (it2); // 10 30 40 50 60 80 90 // ^ ^ ++it1; // ^ ^ --it2; // ^ ^ mylist.erase (it1,it2); // 10 30 60 80 90 // ^ std::cout << "mylist contains:"; for (it1=mylist.begin(); it1!=mylist.end(); ++it1) std::cout << ' ' << *it1; std::cout << '\n'; return 0; } Output: mylist contains: 10 30 60 80 90 ------------------------------------------------------------------------------ // swap lists #include <iostream> #include <list> int main () { std::list<int> first (3,100); // three ints with a value of 100 std::list<int> second (5,200); // five ints with a value of 200 first.swap(second); std::cout << "first contains:"; for (std::list<int>::iterator it=first.begin(); it!=first.end(); it++) std::cout << ' ' << *it; std::cout << '\n'; std::cout << "second contains:"; for (std::list<int>::iterator it=second.begin(); it!=second.end(); it++) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: first contains: 200 200 200 200 200 second contains: 100 100 100 ------------------------------------------------------------------------------ // resizing list #include <iostream> #include <list> int main () { std::list<int> mylist; // set some initial content: for (int i=1; i<10; ++i) mylist.push_back(i); mylist.resize(5); mylist.resize(8,100); mylist.resize(12); std::cout << "mylist contains:"; for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } The code sets a sequence of 9 numbers as an initial content for mylist. It then uses resize first to set the container size to 5, then to extend its size to 8 with values of 100 for its new elements, and finally it extends its size to 12 with their default values (for int elements this is zero). Output: mylist contains: 1 2 3 4 5 100 100 100 0 0 0 0 ------------------------------------------------------------------------------ // clearing lists #include <iostream> #include <list> int main () { std::list<int> mylist; std::list<int>::iterator it; mylist.push_back (100); mylist.push_back (200); mylist.push_back (300); std::cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; mylist.clear(); mylist.push_back (1101); mylist.push_back (2202); std::cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: mylist contains: 100 200 300 mylist contains: 1101 2202
- 其他操作
| 函数 | 函数原型 | 功能描述 |
| splice | void splice (const_iterator position, list& x); void splice (const_iterator position, list&& x); | Transfer elements from list to list |
| void splice (const_iterator position, list& x, const_iterator i); void splice (const_iterator position, list&& x, const_iterator i); | ||
| void splice (const_iterator position, list& x, void splice (const_iterator position, list&& x, | ||
| remove | void remove (const value_type& val); | Remove elements with specific value |
| remove_if | template <class Predicate> void remove_if (Predicate pred); | Remove elements fulfilling condition. Removes from the container all the elements for which Predicate pred returns true. This calls the destructor of these objects and reduces the container size by the number of elements removed. The function calls pred(*i) for each element (where i is an iterator to that element). Any of the elements in the list for which this returns true, are removed from the container. |
| unique | void unique(); | Remove duplicate values. The version with no parameters (1), removes all but the first element from every consecutive group of equal elements in the container. Notice that an element is only removed from the list container if it compares equal to the element immediately preceding it. Thus, this function is especially useful for sorted lists. The second version (2), takes as argument a specific comparison function that determine the "uniqueness" of an element. In fact, any behavior can be implemented (and not only an equality comparison), but notice that the function will call binary_pred(*i,*(i-1)) for all pairs of elements (where i is an iterator to an element, starting from the second) and remove i from the list if the predicate returns true. The elements removed are destroyed. |
| template <class BinaryPredicate> void unique (BinaryPredicate binary_pred); | ||
| merge | void merge (list& x); void merge (list&& x); | Merge sorted lists. Merges x into the list by transferring all of its elements at their respective ordered positions into the container (both containers shall already be ordered). This function requires that the list containers have their elements already ordered by value (or by comp) before the call. Assuming such ordering, each element of x is inserted at the position that corresponds to its value according to the strict weak ordering defined by operator< or comp. The resulting order of equivalent elements is stable (i.e., equivalent elements preserve the relative order they had before the call, and existing elements precede those equivalent inserted from x). |
| template <class Compare> void merge (list& x, Compare comp); template <class Compare> void merge (list&& x, Compare comp); | ||
| sort | void sort(); | Sort elements in container |
| template <class Compare> void sort (Compare comp); | ||
| reverse | void reverse() noexcept; | Reverse the order of elements |
示例代码：
// splicing lists #include <iostream> #include <list> int main () { std::list<int> mylist1, mylist2; std::list<int>::iterator it; // set some initial values: for (int i=1; i<=4; ++i) mylist1.push_back(i); // mylist1: 1 2 3 4 for (int i=1; i<=3; ++i) mylist2.push_back(i*10); // mylist2: 10 20 30 it = mylist1.begin(); ++it; // points to 2 mylist1.splice (it, mylist2); // mylist1: 1 10 20 30 2 3 4 // mylist2 (empty) // "it" still points to 2 (the 5th element) mylist2.splice (mylist2.begin(),mylist1, it); // mylist1: 1 10 20 30 3 4 // mylist2: 2 // "it" is now invalid. it = mylist1.begin(); std::advance(it,3); // "it" points now to 30 mylist1.splice ( mylist1.begin(), mylist1, it, mylist1.end()); // mylist1: 30 3 4 1 10 20 std::cout << "mylist1 contains:"; for (it=mylist1.begin(); it!=mylist1.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; std::cout << "mylist2 contains:"; for (it=mylist2.begin(); it!=mylist2.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: mylist1 contains: 30 3 4 1 10 20 mylist2 contains: 2 ------------------------------------------------------------------------------- // remove from list #include <iostream> #include <list> int main () { int myints[]= {17,89,7,14}; std::list<int> mylist (myints,myints+4); mylist.remove(89); std::cout << "mylist contains:"; for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: mylist contains: 17 7 14 ------------------------------------------------------------------------------- // list::remove_if #include <iostream> #include <list> // a predicate implemented as a function: bool single_digit (const int& value) { return (value<10); } // a predicate implemented as a class: struct is_odd { bool operator() (const int& value) { return (value%2)==1; } }; int main () { int myints[]= {15,36,7,17,20,39,4,1}; std::list<int> mylist (myints,myints+8); // 15 36 7 17 20 39 4 1 mylist.remove_if (single_digit); // 15 36 17 20 39 mylist.remove_if (is_odd()); // 36 20 std::cout << "mylist contains:"; for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: mylist contains: 36 20 ------------------------------------------------------------------------------- // list::unique #include <iostream> #include <cmath> #include <list> // a binary predicate implemented as a function: bool same_integral_part (double first, double second) { return ( int(first)==int(second) ); } // a binary predicate implemented as a class: struct is_near { bool operator() (double first, double second) { return (fabs(first-second)<5.0); } }; int main () { double mydoubles[]={ 12.15, 2.72, 73.0, 12.77, 3.14, 12.77, 73.35, 72.25, 15.3, 72.25 }; std::list<double> mylist (mydoubles,mydoubles+10); mylist.sort(); // 2.72, 3.14, 12.15, 12.77, 12.77, // 15.3, 72.25, 72.25, 73.0, 73.35 mylist.unique(); // 2.72, 3.14, 12.15, 12.77 // 15.3, 72.25, 73.0, 73.35 mylist.unique (same_integral_part); // 2.72, 3.14, 12.15 // 15.3, 72.25, 73.0 mylist.unique (is_near()); // 2.72, 12.15, 72.25 std::cout << "mylist contains:"; for (std::list<double>::iterator it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: mylist contains: 2.72 12.15 72.25 ------------------------------------------------------------------------------- // list::merge #include <iostream> #include <list> // compare only integral part: bool mycomparison (double first, double second) { return ( int(first)<int(second) ); } int main () { std::list<double> first, second; first.push_back (3.1); first.push_back (2.2); first.push_back (2.9); second.push_back (3.7); second.push_back (7.1); second.push_back (1.4); first.sort(); second.sort(); first.merge(second); // (second is now empty) second.push_back (2.1); first.merge(second,mycomparison); std::cout << "first contains:"; for (std::list<double>::iterator it=first.begin(); it!=first.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: first contains: 1.4 2.2 2.9 2.1 3.1 3.7 7.1 *Notice how in the second merger, the function mycomparison (which only compares the integral parts) did not consider 2.1 lower than 2.2 or 2.9, so it was inserted right after them, before 3.1. ------------------------------------------------------------------------------- // list::sort #include <iostream> #include <list> #include <string> #include <cctype> // comparison, not case sensitive. bool compare_nocase (const std::string& first, const std::string& second) { unsigned int i=0; while ( (i<first.length()) && (i<second.length()) ) { if (tolower(first[i])<tolower(second[i])) return true; else if (tolower(first[i])>tolower(second[i])) return false; ++i; } return ( first.length() < second.length() ); } int main () { std::list<std::string> mylist; std::list<std::string>::iterator it; mylist.push_back ("one"); mylist.push_back ("two"); mylist.push_back ("Three"); mylist.sort(); std::cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; mylist.sort(compare_nocase); std::cout << "mylist contains:"; for (it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: mylist contains: Three one two mylist contains: one Three two ------------------------------------------------------------------------------- // reversing list #include <iostream> #include <list> int main () { std::list<int> mylist; for (int i=1; i<10; ++i) mylist.push_back(i); mylist.reverse(); std::cout << "mylist contains:"; for (std::list<int>::iterator it=mylist.begin(); it!=mylist.end(); ++it) std::cout << ' ' << *it; std::cout << '\n'; return 0; } Output: mylist contains: 9 8 7 6 5 4 3 2 1
- allocator
| 函数 | 函数原型 | 功能描述 |
| get_allocator | allocator_type get_allocator() const noexcept; | Get allocator |
重载的非成员函数
| 函数 | 函数原型 | 功能描述 |
| relational operators (list) | template <class T, class Alloc> bool operator== (const list<T,Alloc>& lhs, const list<T,Alloc>& rhs); | Relational operators for list |
| template <class T, class Alloc> bool operator!= (const list<T,Alloc>& lhs, const list<T,Alloc>& rhs); | ||
| template <class T, class Alloc> bool operator< (const list<T,Alloc>& lhs, const list<T,Alloc>& rhs); | ||
| template <class T, class Alloc> bool operator<= (const list<T,Alloc>& lhs, const list<T,Alloc>& rhs); | ||
| template <class T, class Alloc> bool operator> (const list<T,Alloc>& lhs, const list<T,Alloc>& rhs); | ||
| template <class T, class Alloc> bool operator>= (const list<T,Alloc>& lhs, const list<T,Alloc>& rhs); | ||
| swap(list) | template <class T, class Alloc> void swap (list<T,Alloc>& x, list<T,Alloc>& y); | Exchanges the contents of two lists |
参考、翻译：
http://www.cplusplus.com/reference/list/list/
1488
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
