Chapter 11.顺序容器forward_list[c++11]
2012-09-18 00:09
302 查看
前向链表简介
前向链表是用单链表实现的,可在常量时间内在链表中做插入或删除操作
list比之forward_list,双向链表要消耗额外的空间存储每个元素和在插入和删除元素时一个轻微的更高的时间开销,所以forward_list更有效率,虽然只能向前遍历。
forward_list是唯一的标准容器中故意不给出size()成员函数的,这样是为了更高效而考虑,可以用distance(c.begin(),c.end())来得到forward_list的大小,这将消耗一个线性时间,而如果同list一样实现size()成员函数的话,那样要消耗一些额外的存储空间[用于链表中的内部计数得出size()]和使得插入和删除元素时有一个轻微的效率降低,实现size()要消耗一个常量的时间。
构造函数
//empty (default)
1.explicit forward_list ( const allocator_type& alloc = allocator_type() );
//copy
2.forward_list ( const forward_list& fwdlst );
forward_list ( const forward_list& fwdlst, const allocator_type& alloc );
//move
3.forward_list ( forward_list&& fwdlst );
forward_list ( forward_list&& fwdlst, const allocator_type& alloc );
//size
4.explicit forward_list ( size_type n );
//fill
5.explicit forward_list ( size_type n, const value_type& val, const allocator_type& alloc = allocator_type() );
//range
6.template < class InputIterator >
forward_list ( InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type() );
//initializer list
7.forward_list ( initializer_list<value_type> il, const allocator_type& alloc = allocator_type() );
Possible output:
forward_list constructor examples:
first:
second 0 0 0 0
third: 77 77 77
fourth: 77 77 77
fifth: 77 77 77
sixth: 77 77 77
seventh: 3 52 25 90
operator=
函数原型:
1.forward_list& operator= ( const forward_list& fwdlst );//copy
2.forward_list& operator= ( forward_list&& fwdlst );//move
3.forward_list& operator= ( initializer_list<value_type> il );//initializer list
Output:
first: 5 5 5
second: 10 10 10
Iterators
Output:
mylist contains: 11 20 30 40 50
Capacity
Element access
Modifiers
//assign
//range
1.template <class InputIterator>
void assign ( InputIterator first, InputIterator last );
//fill
2.void assign ( size_type n, const value_type& val );
//initializer list
3.void assign ( initializer_list<value_type> il );
//emplace_front
1.template <class... Args>
void emplace_front (Args&&... args);
Output:
mylist contains: (30,c) (20,b) (10,a)
//emplace_after
template <class... Args>
iterator emplace_after ( const_iterator position, Args&&... args );
Output:
mylist contains: (100,x) (200,y) (300,z)
//insert_after
1.iterator insert_after ( const_iterator position, const value_type& val );
2.iterator insert_after ( const_iterator position, value_type&& val );
3.iterator insert_after ( const_iterator position, size_type n, const value_type& val );
4.template <class InputIterator>
iterator insert_after ( const_iterator position, InputIterator first, InputIterator last );
5.iterator insert_after ( const_iterator position, initializer_list<value_type> il );
Output:
mylist contains: 10 1 2 3 20 20 11 22 33
//erase_after
1.iterator erase ( const_iterator position );
2.iterator erase ( const_iterator position, const_iterator last );
Output:
mylist contains: 10 30
Operations
//splice_aftermoves the elements in the range (first,last) to position in 3
1.
void splice_after ( const_iterator position, forward_list& fwdlst );//移动是fwdlst里的所有元素到position
void splice_after ( const_iterator position, forward_list&& fwdlst );
2.
void splice_after ( const_iterator position, forward_list& fwdlst, const_iterator i );//移动的是i的后一元素
void splice_after ( const_iterator position, forward_list&& fwdlst, const_iterator i );
3.
void splice_after ( const_iterator position, forward_list& fwdlst,//移动的是fwdlst里的(first,last)到position
const_iterator first, const_iterator last );
void splice_after ( const_iterator position, forward_list&& fwdlst,
const_iterator first, const_iterator last );
Output:
first contains: 30 10 2 3
second contains: 20 1
//merge
1.void merge ( forward_list& fwdlst );
void merge ( forward_list&& fwdlst );
2.template <class Compare>
void merge ( forward_list& fwdlst, Compare comp );
template <class Compare>
void merge ( forward_list&& fwdlst, Compare comp );
Output:
first contains: 1.4 2.9 3.1 3.1 4.2 7.7
first contains: 7.7 7.1 6.2 4.2 3.7 3.1 3.1 2.9 1.4
Observers
get_allocator
Global functions
//operators(forward_list) just like array container
1.template <class T, class Alloc>
bool operator== ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
2.template <class T, class Alloc>
bool operator!= ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
3.template <class T, class Alloc>
bool operator< ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
4.template <class T, class Alloc>
bool operator> ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
5.template <class T, class Alloc>
bool operator>= ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
6.template <class T, class Alloc>
bool operator<= ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
//swap
template <class T, class Alloc>
void swap ( forward_list<T,Alloc>& lhs,
forward_list<T,Alloc>& rhs );
前向链表是用单链表实现的,可在常量时间内在链表中做插入或删除操作
list比之forward_list,双向链表要消耗额外的空间存储每个元素和在插入和删除元素时一个轻微的更高的时间开销,所以forward_list更有效率,虽然只能向前遍历。
forward_list是唯一的标准容器中故意不给出size()成员函数的,这样是为了更高效而考虑,可以用distance(c.begin(),c.end())来得到forward_list的大小,这将消耗一个线性时间,而如果同list一样实现size()成员函数的话,那样要消耗一些额外的存储空间[用于链表中的内部计数得出size()]和使得插入和删除元素时有一个轻微的效率降低,实现size()要消耗一个常量的时间。
构造函数
//empty (default)
1.explicit forward_list ( const allocator_type& alloc = allocator_type() );
//copy
2.forward_list ( const forward_list& fwdlst );
forward_list ( const forward_list& fwdlst, const allocator_type& alloc );
//move
3.forward_list ( forward_list&& fwdlst );
forward_list ( forward_list&& fwdlst, const allocator_type& alloc );
//size
4.explicit forward_list ( size_type n );
//fill
5.explicit forward_list ( size_type n, const value_type& val, const allocator_type& alloc = allocator_type() );
//range
6.template < class InputIterator >
forward_list ( InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type() );
//initializer list
7.forward_list ( initializer_list<value_type> il, const allocator_type& alloc = allocator_type() );
eg: // constructors used in the same order as described above: std::forward_list<int> first; // default: empty std::cout << "first:"; for (int& x: first) std::cout << " " << x; std::cout << std::endl; std::forward_list<int> second (4); // fill: 4 "default-constructed" int's std::cout << "second:"; for (int& x: second) std::cout << " " << x; std::cout << std::endl; std::forward_list<int> third (3,77); // fill: 3 sevety-sevens std::cout << "third:"; for (int& x: third) std::cout << " " << x; std::cout << std::endl; std::forward_list<int> fourth (third.begin(), third.end()); // range initialization std::cout << "fourth:"; for (int& x: fourth) std::cout << " " << x; std::cout << std::endl; std::forward_list<int> fifth (fourth); // copy constructor std::cout << "fifth:"; for (int& x: fifth) std::cout << " " << x; std::cout << std::endl; std::forward_list<int> sixth (std::move(fifth)); // move ctor. (fifth wasted) std::cout << "sixth:"; for (int& x: sixth) std::cout << " " << x; std::cout << std::endl; std::forward_list<int> seventh = {3, 52, 25, 90}; // initializer_list constructor std::cout << "seventh:"; for (int& x: seventh) std::cout << " " << x; std::cout << std::endl;
Possible output:
forward_list constructor examples:
first:
second 0 0 0 0
third: 77 77 77
fourth: 77 77 77
fifth: 77 77 77
sixth: 77 77 77
seventh: 3 52 25 90
operator=
函数原型:
1.forward_list& operator= ( const forward_list& fwdlst );//copy
2.forward_list& operator= ( forward_list&& fwdlst );//move
3.forward_list& operator= ( initializer_list<value_type> il );//initializer list
eg: #include <forward_list> template<class Container>//一个自定义的类模板 Container by_two (const Container& x) { Container temp(x); for (auto& x:temp) x*=2; return temp; } int main () { std::forward_list<int> first (4); // 4 ints std::forward_list<int> second (3,5); // 3 ints with value 5 first = second; // copy assignment second = by_two(first); // move assignment std::cout << "first: "; for (int& x : first) std::cout << " " << x; std::cout << std::endl; std::cout << "second: "; for (int& x : second) std::cout << " " << x; std::cout << std::endl;
Output:
first: 5 5 5
second: 10 10 10
Iterators
before_begin | Return iterator to before beginning |
begin | Return iterator to beginning |
end | Return iterator to end |
cbefore_begin | Return const_iterator to before beginning //just like before_begin |
cbegin | Return const_iterator to beginning |
cend | Return const_iterator to end |
eg: //before_begin 不能被解引用,用于emplace_after, insert_after, erase_after or splice_after std::forward_list<int> mylist = {20, 30, 40, 50}; mylist.insert_after ( mylist.before_begin(), 11 ); std::cout << "mylist contains:"; for ( int& x: mylist ) std::cout << " " << x;
Output:
mylist contains: 11 20 30 40 50
Capacity
empty | Test whether array is empty |
max_size | maximum size |
front | Access first element |
assign | Assign content |
emplace_front | Construct and insert element at beginning//construct with args |
emplace_after | Construct and insert element |
insert_after | Insert elements |
erase_after | Erase elements |
swap | Swap content//algorithm exists swap, and the same behavior. |
clear | Clear content |
resize | Change size |
push_front | Insert element at beginning→list、forward_list and deque unique |
pop_front | Delete first element→list、forward_list and deque unique |
//range
1.template <class InputIterator>
void assign ( InputIterator first, InputIterator last );
//fill
2.void assign ( size_type n, const value_type& val );
//initializer list
3.void assign ( initializer_list<value_type> il );
eg: first.assign (4,15); // 15 15 15 15 fill second.assign (first.begin(),first.end()); // 15 15 15 15 range first.assign ( {77, 2, 16} ); // 77 2 16 initializer_list
//emplace_front
1.template <class... Args>
void emplace_front (Args&&... args);
eg: std::forward_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 << ")";
Output:
mylist contains: (30,c) (20,b) (10,a)
//emplace_after
template <class... Args>
iterator emplace_after ( const_iterator position, Args&&... args );
eg: std::forward_list< std::pair<int,char> > mylist; auto it = mylist.before_begin(); it = mylist.emplace_after ( it, 100, 'x' ); it = mylist.emplace_after ( it, 200, 'y' ); it = mylist.emplace_after ( it, 300, 'z' ); std::cout << "mylist contains:"; for (auto& x: mylist) std::cout << " (" << x.first << "," << x.second << ")";
Output:
mylist contains: (100,x) (200,y) (300,z)
//insert_after
1.iterator insert_after ( const_iterator position, const value_type& val );
2.iterator insert_after ( const_iterator position, value_type&& val );
3.iterator insert_after ( const_iterator position, size_type n, const value_type& val );
4.template <class InputIterator>
iterator insert_after ( const_iterator position, InputIterator first, InputIterator last );
5.iterator insert_after ( const_iterator position, initializer_list<value_type> il );
eg: std::array<int,3> myarray = { 11, 22, 33 }; std::forward_list<int> mylist; std::forward_list<int>::iterator it; it = mylist.insert_after ( mylist.before_begin(), 10 ); // 10 // ^ <- it it = mylist.insert_after ( it, 2, 20 ); // 10 20 20 // ^ it = mylist.insert_after ( it, myarray.begin(), myarray.end() ); // 10 20 20 11 22 33 // ^ it = mylist.begin(); // ^ it = mylist.insert_after ( it, {1,2,3} ); // 10 1 2 3 20 20 11 22 33 // ^ std::cout << "mylist contains:"; for (int& x: mylist) std::cout << " " << x;
Output:
mylist contains: 10 1 2 3 20 20 11 22 33
//erase_after
1.iterator erase ( const_iterator position );
2.iterator erase ( const_iterator position, const_iterator last );
eg: std::forward_list<int> mylist = {10, 20, 30, 40, 50}; // 10 20 30 40 50 auto it = mylist.begin(); // ^ it = mylist.erase_after(it); // 10 30 40 50 // ^ it = mylist.erase_after(it,mylist.end()); // 10 30 // ^ std::cout << "mylist contains:"; for (int& x: mylist) std::cout << " " << x;
Output:
mylist contains: 10 30
Operations
splice_after | Move elements from another forward_list |
remove | Remove elements with specific value//algorithm exists one operating between two iterators. |
remove_if | Remove elements fulfilling condition//same |
unique | Remove duplicate values//same |
merge | Merge sorted lists |
sort | Sort elements in container |
reverse | Reverse the order of elements |
1.
void splice_after ( const_iterator position, forward_list& fwdlst );//移动是fwdlst里的所有元素到position
void splice_after ( const_iterator position, forward_list&& fwdlst );
2.
void splice_after ( const_iterator position, forward_list& fwdlst, const_iterator i );//移动的是i的后一元素
void splice_after ( const_iterator position, forward_list&& fwdlst, const_iterator i );
3.
void splice_after ( const_iterator position, forward_list& fwdlst,//移动的是fwdlst里的(first,last)到position
const_iterator first, const_iterator last );
void splice_after ( const_iterator position, forward_list&& fwdlst,
const_iterator first, const_iterator last );
eg: std::forward_list<int> first = { 1, 2, 3 }; std::forward_list<int> second = { 10, 20, 30 }; auto it = first.begin(); // points to the 1 first.splice_after ( first.before_begin(), second ); // first: 10 20 30 1 2 3 // second: (empty) // "it" still points to the 1 (now first's 4th element) second.splice_after ( second.before_begin(), first, first.begin(), it); // first: 10 2 3 // second: 20 30 1 first.splice_after ( first.before_begin(), second, second.begin() ); // first: 30 10 2 3 // second: 20 1 // * notice that what is moved is AFTER the iterator std::cout << "first contains:"; for (int& x: first) std::cout << " " << x; std::cout << std::endl; std::cout << "second contains:"; for (int& x: second) std::cout << " " << x;
Output:
first contains: 30 10 2 3
second contains: 20 1
//merge
1.void merge ( forward_list& fwdlst );
void merge ( forward_list&& fwdlst );
2.template <class Compare>
void merge ( forward_list& fwdlst, Compare comp );
template <class Compare>
void merge ( forward_list&& fwdlst, Compare comp );
eg: std::forward_list<double> first = {4.2, 2.9, 3.1}; std::forward_list<double> second = {1.4, 7.7, 3.1}; std::forward_list<double> third = {6.2, 3.7, 7.1}; first.sort(); second.sort(); first.merge(second); std::cout << "first contains:"; for (double& x: first) std::cout << " " << x; std::cout << std::endl; first.sort (std::greater<double>()); third.sort (std::greater<double>()); first.merge (third, std::greater<double>()); std::cout << "first contains:"; for (double& x: first) std::cout << " " << x;
Output:
first contains: 1.4 2.9 3.1 3.1 4.2 7.7
first contains: 7.7 7.1 6.2 4.2 3.7 3.1 3.1 2.9 1.4
Observers
get_allocator
Global functions
operators (forward_list) | Global relational operator functions for forward_list |
swap (forward_list) | Exchanges the contents of two forward_list containers//没有实际的移动,只是交换数据的引用 |
1.template <class T, class Alloc>
bool operator== ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
2.template <class T, class Alloc>
bool operator!= ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
3.template <class T, class Alloc>
bool operator< ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
4.template <class T, class Alloc>
bool operator> ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
5.template <class T, class Alloc>
bool operator>= ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
6.template <class T, class Alloc>
bool operator<= ( const forward_list<T,Alloc>& lhs, const forward_list<T,Alloc>& rhs );
//swap
template <class T, class Alloc>
void swap ( forward_list<T,Alloc>& lhs,
forward_list<T,Alloc>& rhs );
eg: std::forward_list<int> first = {10, 20, 30}; std::forward_list<int> second = {100, 200}; std::forward_list<int>::iterator it; swap(first,second);
相关文章推荐
- 顺序容器forward_list[c++11]
- STL容器分析--forward_list(C++11)
- 顺序容器(vector、deque、list、forward_list、array 、string)
- Chapter 7.顺序容器list
- 【STL】STL之顺序容器:vector、deque、list、forward_list、array、string
- Chapter 10.顺序容器array[c++11]
- C++11新特性应用--介绍几个新增的便利算法(更改容器中元素顺序的算法)
- 顺序容器之list
- C++顺序容器vector、deque、list
- STL 笔记(一) 顺序容器 vector、list、deque
- Effective C++ (8) 顺序容器vector,list,deque
- STL顺序容器-list
- 顺序容器vector、list、deque的区别
- 【STL】容器 > 顺序容器 > list(双向链表)
- list(链表)常用成员(顺序容器)
- STL顺序容器(vector,list,deque)测试
- STL1—顺序容器vector list deque的基本知识
- STL学习笔记6— —容器forward_list
- C++11中std::forward_list单向链表的使用
- 15 STL中容器双向链表list和单向链表forward_list