stl（转）

STL的叫法是“容器”，标准库里面容器不多，数组、链表、红黑树，实现都不负责thread safe、mutable之类，对比下Java的，选择很多，也挺混乱。。

序列容器：动态数组vector，双端队列deque（本质是动态数组加索引），链表list。
关联容器：set，map，multiset，multimap，bitset（叫bit_array更合适）。
容器适配器：stack，queue，priority_queue。

除了bitset，都用到模板，声明大概是这样的：

STL Standard Containers，点击加号展开！
template < class T, class Allocator = alloc<T> > class vector;
template < class T, class Allocator = alloc<T> > class deque;
template < class T, class Allocator = alloc<T> > class list;

template < class Key, class Compare = less<Key>,
            class Allocator = alloc<Key> > class set;
template < class Key, class Compare = less<Key>,
            class Allocator = alloc<Key> > class multiset;
           
template < class Key, class T, class Compare = less<Key>,
            class Allocator = alloc<pair<const Key,T> > > class map; 
template < class Key, class T, class Compare = less<Key>,
            class Allocator = alloc<pair<const Key,T> > > class multimap;

STL Container Adaptors，点击加号展开！
template < class T, class Container = deque<T> > class stack;
template < class T, class Container = deque<T> > class queue;
template < class T, class Container = vector<T>,
            class Compare = less<typename Container::value_type> > class priority_queue;

C++是注重效率的，所以STL很强调一点就是amortized的性能，下面的表很不错，还可以用来速查： 

			Sequence containers			Associative containers
Headers			<vector>	<deque>	<list>	<set>		<map>		<bitset>
Members		complex	vector	deque	list	set	multiset	map	multimap	bitset
	constructor	*	constructor	constructor	constructor	constructor	constructor	constructor	constructor	constructor
	destructor	O(n)	destructor	destructor	destructor	destructor	destructor	destructor	destructor
	operator=	O(n)	operator=	operator=	operator=	operator=	operator=	operator=	operator=	operators
iterators	begin	O(1)	begin	begin	begin	begin	begin	begin	begin
	end	O(1)	end	end	end	end	end	end	end
	rbegin	O(1)	rbegin	rbegin	rbegin	rbegin	rbegin	rbegin	rbegin
	rend	O(1)	rend	rend	rend	rend	rend	rend	rend
capacity	size	*	size	size	size	size	size	size	size	size
	max_size	*	max_size	max_size	max_size	max_size	max_size	max_size	max_size
	empty	O(1)	empty	empty	empty	empty	empty	empty	empty
	resize	O(n)	resize	resize	resize
element access	front	O(1)	front	front	front
	back	O(1)	back	back	back
	operator[]	*	operator[]	operator[]				operator[]		operator[]
	at	O(1)	at	at
modifiers	assign	O(n)	assign	assign	assign
	insert	*	insert	insert	insert	insert	insert	insert	insert
	erase	*	erase	erase	erase	erase	erase	erase	erase
	swap	O(1)	swap	swap	swap	swap	swap	swap	swap
	clear	O(n)	clear	clear	clear	clear	clear	clear	clear
	push_front	O(1)		push_front	push_front
	pop_front	O(1)		pop_front	pop_front
	push_back	O(1)	push_back	push_back	push_back
	pop_back	O(1)	pop_back	pop_back	pop_back
observers	key_comp	O(1)				key_comp	key_comp	key_comp	key_comp
	value_comp	O(1)				value_comp	value_comp	value_comp	value_comp
operations	find	O(log n)				find	find	find	find
	count	O(log n)				count	count	count	count	count
	lower_bound	O(log n)				lower_bound	lower_bound	lower_bound	lower_bound
	upper_bound	O(log n)				upper_bound	upper_bound	upper_bound	upper_bound
	equal_range	O(log n)				equal_range	equal_range	equal_range	equal_range
unique members			capacity reserve		splice remove remove_if unique merge sort reverse					set reset flip to_ulong to_string test any none

 

			Container Adaptors
Headers			<stack>	<queue>
Members			stack	queue	priority_queue
	constructor	*	constructor	constructor	constructor
capacity	size	O(1)	size	size	size
	empty	O(1)	empty	empty	empty
element access	front	O(1)		front
	back	O(1)		back
	top	O(1)	top		top
modifiers	push	O(1)	push	push	push
	pop	O(1)	pop	pop	pop

set、map一般会实现成红黑树，这就是它的模板声明里面不需要一个类似Equal_to之类的functor来判断找到Key没有的原因：它调用两次Compare来判断等于。要是不用排序这个特性，只看效率搜索树一般比不过哈希表。
还有一点STL里面iterator是一等公民，主要为了很多算法的效率和封装统一接口，但全是iterator我个人觉得用起来有点不舒服。。

C++0x里面会有基于哈希表的unordered_xxx系列（就是现在很多实现里面的hash_xxx），tuple（Variadic templates）等登场。

C++ TR1 Containers，点击加号展开！
template < class Key, class HashFcn = hash<Key>,
            class EqualKey = equal_to<Key>, class Allocator = alloc<Key> > class hash_set;            
template < class Key, class HashFcn = hash<Key>,
            class EqualKey = equal_to<Key>, class Allocator = alloc<Key> > class hash_multiset;
    
template < class Key, class HashFcn = hash<Key>, class T,
            class EqualKey = equal_to<Key>, class Allocator = alloc<pair<const Key, T> > > class hash_map;    
template < class Key, class HashFcn = hash<Key>, class T,
            class EqualKey = equal_to<Key>, class Allocator = alloc<pair<const Key, T> > > class hash_multimap;
    
template <class Types> class tuple;

最后，除了容器，<algorithm>也是STL中很重要的部分，其实STL最初做出来是想秀泛型算法的。。
Java里面java.util.Collections类做类似的事情。


References：
http://www.cplusplus.com/reference/stl/
http://www.sgi.com/tech/stl/table_of_contents.html
http://www.stlchina.org/
http://www.stlchina.org/documents/EffectiveSTL/index.html