需要查询全面的stl可点击：
C++ Vectors
构造函数
语法:
vector(); vector( size_type num, const TYPE &val ); vector( const vector &from ); vector( input_iterator start, input_iterator end ); |
C++ Vectors可以使用以下任意一种参数方式构造:
- 无参数 - 构造一个空的vector,
- 数量(num)和值(val) - 构造一个初始放入num个值为val的元素的Vector
- vector(from) - 构造一个与vector from 相同的vector
- 迭代器(start)和迭代器(end) - 构造一个初始值为[start,end)区间元素的Vector(注:半开区间).
举例,下面这个实例构造了一个包含5个值为42的元素的Vector
vector<int> v1( 5, 42 );
运算符
语法:
v1 == v2 v1 != v2 v1 <= v2 v1 >= v2 v1 < v2 v1 > v2 v[] |
C++ Vectors能够使用标准运算符: ==, !=, <=, >=, <, 和 >. 要访问vector中的某特定位置的元素可以使用 [] 操作符.
两个vectors被认为是相等的,如果:
- 它们具有相同的容量
- 所有相同位置的元素相等.
vectors之间大小的比较是按照词典规则.
相关内容: at().
assign函数
语法:
void assign( input_iterator start, input_iterator end ); void assign( size_type num, const TYPE &val ); |
assign() 函数要么将区间[start, end)的元素赋到当前vector,或者赋num个值为val的元素到vector中.这个函数将会清除掉为vector赋值以前的内容.
at函数
语法:
TYPE at( size_type loc ); |
at() 函数 返回当前Vector指定位置loc的元素的引用. at() 函数 比 [] 运算符更加安全, 因为它不会让你去访问到Vector内越界的元素. 例如, 考虑下面的代码:
vector<int> v( 5, 1 );
for( int i = 0; i < 10; i++ ) {
cout << "Element " << i << " is " << v[i] << endl;
}
这段代码访问了vector末尾以后的元素,这将可能导致很危险的结果.以下的代码将更加安全:
vector<int> v( 5, 1 );
for( int i = 0; i < 10; i++ ) {
cout << "Element " << i << " is " << v.at(i) << endl;
}
取代试图访问内存里非法值的作法,at() 函数能够辨别出访问是否越界并在越界的时候抛出一个异常.
相关内容: [] 操作符
back 函数
语法:
TYPE back(); |
back() 函数返回当前vector最末一个元素的引用.例如:
vector<int> v;
for( int i = 0; i < 5; i++ ) {
v.push_back(i);
}
cout << "The first element is " << v.front()
<< " and the last element is " << v.back() << endl;
这段代码产生如下结果:
The first element is 0 and the last element is 4
相关内容: front().
begin 函数
语法:
iterator begin(); |
begin()函数返回一个指向当前vector起始元素的迭代器.例如,下面这段使用了一个迭代器来显示出vector中的所有元素:
vector<int> v1( 5, 789 );
vector<int>::iterator it;
for( it = v1.begin(); it != v1.end(); it++ )
cout << *it << endl;
相关内容: end().
capacity 函数
语法:
size_type capacity(); |
capacity() 函数 返回当前vector在重新进行内存分配以前所能容纳的元素数量.
clear 函数
语法:
void clear(); |
clear()函数删除当前vector中的所有元素.
empty 函数
语法:
bool empty(); |
如果当前vector没有容纳任何元素,则empty()函数返回true,否则返回false.例如,以下代码清空一个vector,并按照逆序显示所有的元素:
vector<int> v;
for( int i = 0; i < 5; i++ ) {
v.push_back(i);
}
while( !v.empty() ) {
cout << v.back() << endl;
v.pop_back();
}
相关内容: size()
end 函数
语法:
iterator end(); |
end() 函数返回一个指向当前vector末尾元素的下一位置的迭代器.注意,如果你要访问末尾元素,需要先将此迭代器自减1.
相关内容: begin()
erase 函数
语法:
iterator erase( iterator loc ); iterator erase( iterator start, iterator end ); |
erase函数要么删作指定位置loc的元素,要么删除区间[start, end)的所有元素.返回值是指向删除的最后一个元素的下一位置的迭代器.例如:
// 创建一个vector,置入字母表的前十个字符
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
int size = alphaVector.size();
vector<char>::iterator startIterator;
vector<char>::iterator tempIterator;
for( int i=0; i < size; i++ )
{
tartIterator = alphaVector.begin();
alphaVector.erase( startIterator );
// Display the vector
for( tempIterator = alphaVector.begin(); tempIterator != alphaVector.end(); tempIterator++ )
cout << *tempIterator;
cout << endl;
}
这段代码将会显示如下输出:
BCDEFGHIJ
CDEFGHIJ
DEFGHIJ
EFGHIJ
FGHIJ
GHIJ
HIJ
IJ
J
相关内容: pop_back().
front 函数
语法:
TYPE front(); |
front()函数返回当前vector起始元素的引用
相关内容: back().
get_allocator 函数
语法:
allocator_type get_allocator(); |
get_allocator() 函数返回当前vector的内存分配器.
insert 函数
语法:
iterator insert( iterator loc, const TYPE &val ); void insert( iterator loc, size_type num, const TYPE &val ); void insert( iterator loc, input_iterator start, input_iterator end ); |
insert() 函数有以下三种用法:
- 在指定位置loc前插入值为val的元素,返回指向这个元素的迭代器,
- 在指定位置loc前插入num个值为val的元素
- 在指定位置loc前插入区间[start, end)的所有元素 .
举例:
//创建一个vector,置入字母表的前十个字符
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
//插入四个C到vector中
vector<char>::iterator theIterator = alphaVector.begin();
alphaVector.insert( theIterator, 4, 'C' );
//显示vector的内容
for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ )
cout << *theIterator;
这段代码将显示:
CCCCABCDEFGHIJ
max_size 函数
语法:
size_type max_size(); |
max_size() 函数返回当前vector所能容纳元素数量的最大值(译注:包括可重新分配内存).
pop_back
语法:
void pop_back(); |
pop_back()函数删除当前vector最末的一个元素,例如:
vector<char> alphaVector;
for( int i=0; i < 10; i++ )
alphaVector.push_back( i + 65 );
int size = alphaVector.size();
vector<char>::iterator theIterator;
for( int i=0; i < size; i++ ) {
alphaVector.pop_back();
for( theIterator = alphaVector.begin(); theIterator != alphaVector.end(); theIterator++ )
cout << *theIterator;
cout << endl;
}
这段代码将显示以下输出:
ABCDEFGHI
ABCDEFGH
ABCDEFG
ABCDEF
ABCDE
ABCD
ABC
AB
A
相关内容: erase().
push_back 函数
语法:
void push_back( const TYPE &val ); |
push_back()添加值为val的元素到当前vector末尾
rbegin 函数
语法:
reverse_iterator rbegin(); |
rbegin函数返回指向当前vector末尾的逆迭代器.(译注:实际指向末尾的下一位置,而其内容为末尾元素的值,详见逆代器相关内容)
rend 函数
语法:
reverse_iterator rend(); |
rend()函数返回指向当前vector起始位置的逆迭代器.
reserve 函数
语法:
void reserve( size_type size ); |
reserve()函数为当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size)
resize 函数
语法:
void resize( size_type size, TYPE val ); |
resize() 函数改变当前vector的大小为size,且对新创建的元素赋值val
size 函数
语法:
size_type size(); |
size() 函数返回当前vector所容纳元素的数目
相关内容: empty()
swap 函数
语法:
void swap( vector &from ); |
swap()函数交换当前vector与vector from的元素
C++ Stacks（堆栈）
语法:
| == <= >= < > != |
所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。
语法:
| bool empty(); |
如当前堆栈为空，empty() 函数 返回 true 否则返回false.
语法:
| void pop(); |
pop() 函数移除堆栈中最顶层元素。
相关主题:
top(),
Syntax:
| void push( const TYPE &val ); |
push() 函数将 val 值压栈，使其成为栈顶的第一个元素。如:
stack<int> s;
for( int i=0; i < 10; i++ )
s.push(i);
语法:
| size_type size(); |
size() 函数返当前堆栈中的元素数目。如:
stack<int> s;
for( int i=0; i < 10; i++ )
s.push(i);
cout << "This stack has a size of " << s.size() << endl;
语法:
| TYPE &top(); |
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。
while( !s.empty() ) {
cout << s.top() << " ";
s.pop();
}
C++ Queue(队列)
back
语法:
TYPE &back(); |
back()返回一个引用，指向队列的最后一个元素。
empty
语法:
bool empty(); |
empty()函数返回真(true)如果队列为空，否则返回假(false)。
front
语法:
TYPE &front(); |
front()返回队列第一个元素的引用。
pop
语法:
void pop(); |
pop()函数删除队列的一个元素。
push
语法:
void push( const TYPE &val ); |
push()函数往队列中加入一个元素。
size
语法:
size_type size(); |
size()返回队列中元素的个数。
C++ deque(双向队列)
Constructors
语法:
| deque(); deque( size_type size ); deque( size_type num, const TYPE &val ); deque( const deque &from ); deque( input_iterator start, input_iterator end ); |
C++ Deques能用以下方式创建:
- 无参，创建一个空双向队列
- size - 创建一个大小为size的双向队列
- num and val - 放置num个val的拷贝到队列中，
- from - 从from创建一个内容一样的双向队列
- start 和 end - 创建一个队列，保存从start到end的元素。
例如，下列代码创建并显示一个双向队列：
// 创建一个双向队列，里面有10个1
deque dq( 10, 1 );
// 创建一个迭代器
deque::iterator iter;
// 显示这个双向队列
for( iter = dq.begin(); iter != dq.end(); iter++ ){
cout << *iter << endl;
}
Operators
语法:
| [] |
你可以使用[]操作符访问双向队列中单个的元素。
assign
语法:
| void assign( input_iterator start, input_iterator end); void assign( Size num, const TYPE &val ); |
assign()函数用start和end指示的范围为双向队列赋值，或者设置成num个val。
at
语法:
| reference at( size_type pos ); |
at()函数返回一个引用，指向双向队列中位置pos上的元素。
back
语法:
| reference back(); |
back()返回一个引用，指向双向队列中最后一个元素。
begin
语法:
| iterator begin(); |
begin()函数返回一个迭代器，指向双向队列的第一个元素。
clear
语法:
| void clear(); |
clear()函数删除双向队列中所有元素。
empty
语法:
| bool empty(); |
empty()返回真如果双向队列为空，否则返回假。
end
语法:
| iterator end(); |
end()函数返回一个迭代器，指向双向队列的尾部。
erase
语法:
| iterator erase( iterator pos ); iterator erase( iterator start, iterator end ); |
erase()函数删除pos位置上的元素，或者删除start和end之间的所有元素。返回值是一个iterator，指向被删除元素的后一个元素。
front
语法:
| reference front(); |
front()函数返回一个引用，指向双向队列的头部。
get_allocator
语法:
| allocator_type get_allocator(); |
get_allocator()函数返回双向队列的配置器。
insert
语法:
| iterator insert( iterator pos, size_type num, const TYPE &val ); void insert( iterator pos, input_iterator start, input_iterator end ); |
insert()在pos前插入num个val值，或者插入从start到end范围内的元素到pos前面。
max_size
语法:
| size_type max_size(); |
max_size()返回双向队列能容纳的最大元素个数。
pop_back
语法:
| void pop_back(); |
pop_back()删除双向队列尾部的元素。
语法:
| void pop_front(); |
pop_front()删除双向队列头部的元素。
push_back
语法:
| void push_back( const TYPE &val ); |
push_back()函数在双向队列的尾部加入一个值为val的元素。
语法:
| void push_front( const TYPE &val ); |
push_front()函数在双向队列的头部加入一个值为val的元素。
rbegin
语法:
| reverse_iterator rbegin(); |
rbegin()返回一个指向双向队列尾部的逆向迭代器。
rend
语法:
| reverse_iterator rend(); |
rend()返回一个指向双向队列头部的逆向迭代器。
resize
语法:
| void resize( size_type num, TYPE val ); |
resize()改变双向队列的大小为num，另加入的元素都被填充为val。
size
语法:
| size_type size(); |
size()函数返回双向队列中的元素个数。
swap
语法:
| void swap( deque &target ); |
swap()函数交换target和现双向队列中元素。
C++ deque(双向队列)
Constructors
语法:
| deque(); deque( size_type size ); deque( size_type num, const TYPE &val ); deque( const deque &from ); deque( input_iterator start, input_iterator end ); |
C++ Deques能用以下方式创建:
- 无参，创建一个空双向队列
- size - 创建一个大小为size的双向队列
- num and val - 放置num个val的拷贝到队列中，
- from - 从from创建一个内容一样的双向队列
- start 和 end - 创建一个队列，保存从start到end的元素。
例如，下列代码创建并显示一个双向队列：
// 创建一个双向队列，里面有10个1
deque dq( 10, 1 );
// 创建一个迭代器
deque::iterator iter;
// 显示这个双向队列
for( iter = dq.begin(); iter != dq.end(); iter++ ){
cout << *iter << endl;
}
Operators
语法:
| [] |
你可以使用[]操作符访问双向队列中单个的元素。
assign
语法:
| void assign( input_iterator start, input_iterator end); void assign( Size num, const TYPE &val ); |
assign()函数用start和end指示的范围为双向队列赋值，或者设置成num个val。
at
语法:
| reference at( size_type pos ); |
at()函数返回一个引用，指向双向队列中位置pos上的元素。
back
语法:
| reference back(); |
back()返回一个引用，指向双向队列中最后一个元素。
begin
语法:
| iterator begin(); |
begin()函数返回一个迭代器，指向双向队列的第一个元素。
clear
语法:
| void clear(); |
clear()函数删除双向队列中所有元素。
empty
语法:
| bool empty(); |
empty()返回真如果双向队列为空，否则返回假。
end
语法:
| iterator end(); |
end()函数返回一个迭代器，指向双向队列的尾部。
erase
语法:
| iterator erase( iterator pos ); iterator erase( iterator start, iterator end ); |
erase()函数删除pos位置上的元素，或者删除start和end之间的所有元素。返回值是一个iterator，指向被删除元素的后一个元素。
front
语法:
| reference front(); |
front()函数返回一个引用，指向双向队列的头部。
get_allocator
语法:
| allocator_type get_allocator(); |
get_allocator()函数返回双向队列的配置器。
insert
语法:
| iterator insert( iterator pos, size_type num, const TYPE &val ); void insert( iterator pos, input_iterator start, input_iterator end ); |
insert()在pos前插入num个val值，或者插入从start到end范围内的元素到pos前面。
max_size
语法:
| size_type max_size(); |
max_size()返回双向队列能容纳的最大元素个数。
pop_back
语法:
| void pop_back(); |
pop_back()删除双向队列尾部的元素。
pop_front
语法:
| void pop_front(); |
pop_front()删除双向队列头部的元素。
push_back
语法:
| void push_back( const TYPE &val ); |
push_back()函数在双向队列的尾部加入一个值为val的元素。
push_front
语法:
| void push_front( const TYPE &val ); |
push_front()函数在双向队列的头部加入一个值为val的元素。
rbegin
语法:
| reverse_iterator rbegin(); |
rbegin()返回一个指向双向队列尾部的逆向迭代器。
rend
语法:
| reverse_iterator rend(); |
rend()返回一个指向双向队列头部的逆向迭代器。
resize
语法:
| void resize( size_type num, TYPE val ); |
resize()改变双向队列的大小为num，另加入的元素都被填充为val。
size
语法:
| size_type size(); |
size()函数返回双向队列中的元素个数。
swap
语法:
| void swap( deque &target ); |
swap()函数交换target和现双向队列中元素。
C++ Lists(链表)
赋值(assign)
语法:
void assign( input_iterator start, input_iterator end ); void assign( size_type num, const TYPE &val ); |
assign()函数以迭代器start和end指示的范围为list赋值或者为list赋值num个以val为值的元素。
相关主题:
insert(),
back
语法:
reference back(); |
back()函数返回一个引用，指向list的最后一个元素。
相关主题:
front(), pop_back(),
begin
语法:
iterator begin(); |
begin()函数返回一个迭代器，指向list的第一个元素。例如，
// 创建一个元素类型是字符的链表
list<char> charList;
for( int i=0; i < 10; i++ )
charList.push_front( i + 65 );
// 显示这个链表
list<char>::iterator theIterator;
for( theIterator = charList.begin(); theIterator != charList.end(); theIterator++ )
cout << *theIterator;
相关主题:
end(),
clear
语法:
void clear(); |
clear()函数删除list的所有元素。
empty
语法:
bool empty(); |
empty()函数返回真(true)如果链表为空，否则返回假。例如：
list<int> the_list;
for( int i = 0; i < 10; i++ )
the_list.push_back( i );
while( !the_list.empty() ) {
cout << the_list.front() << endl;
the_list.pop_front();
}
end
语法:
iterator end(); |
end()函数返回一个迭代器，指向链表的末尾。
相关主题:
begin(),
erase
语法:
iterator erase( iterator pos ); iterator erase( iterator start, iterator end ); |
erase()函数删除以pos指示位置的元素, 或者删除start和end之间的元素。 返回值是一个迭代器，指向最后一个被删除元素的下一个元素。
front
语法:
reference front(); |
front()函数返回一个引用，指向链表的第一个元素。
list<int> the_list;
for( int i = 0; i < 10; i++ )
the_list.push_back( i );
while( !the_list.empty() ) {
cout << the_list.front() << endl;
the_list.pop_front();
}
相关主题:
back(),
get_allocator
语法:
allocator_type get_allocator(); |
get_allocator()函数返回链表的配置器。
insert
语法:
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的位置。返回值是一个迭代器，指向被插入的元素。
max_size
语法:
size_type max_size(); |
max_size()函数返回链表能够储存的元素数目。
merge
语法:
void merge( list &lst ); void merge( list &lst, Comp compfunction ); |
merge()函数把自己和lst链表连接在一起，产生一个整齐排列的组合链表。如果指定compfunction，则将指定函数作为比较的依据。
pop_back
语法:
void pop_back(); |
pop_back()函数删除链表的最后一个元素。
相关主题:
pop_front(),
pop_front
语法:
void pop_front(); |
pop_front()函数删除链表的第一个元素。
相关主题:
pop_back(),
push_back
语法:
void push_back( const TYPE &val ); |
push_back()将val连接到链表的最后。例如：
list<int> the_list;
for( int i = 0; i < 10; i++ )
the_list.push_back( i );
相关主题:
push_front(),
push_front
Syntax:
void push_front( const TYPE &val ); |
push_front()函数将val连接到链表的头部。
相关主题:
push_back(),
rbegin
语法:
reverse_iterator rbegin(); |
rbegin()函数返回一个逆向迭代器，指向链表的末尾。
相关主题:
rend(),
remove
语法:
void remove( const TYPE &val ); |
remove()函数删除链表中所有值为val的元素。例如
// 创建一个链表，元素是字母表的前10个元素
list<char> charList;
for( int i=0; i < 10; i++ )
charList.push_front( i + 65 );
// 删除所有'E'的实例
charList.remove( 'E' );
remove_if
语法:
void remove_if( UnPred pr ); |
remove_if()以一元谓词pr为判断元素的依据，遍历整个链表。如果pr返回true则删除该元素。
rend
语法:
reverse_iterator rend(); |
rend()函数迭代器指向链表的头部。
resize
语法:
void resize( size_type num, TYPE val ); |
resize()函数把list的大小改变到num。被加入的多余的元素都被赋值为val
reverse
语法:
void reverse(); |
reverse()函数把list所有元素倒转。
size
语法:
size_type size(); |
size()函数返回list中元素的数量。
排序(sort)
语法:
void sort(); void sort( Comp compfunction ); |
sort()函数为链表排序，默认是升序。如果指定compfunction的话，就采用指定函数来判定两个元素的大小。
splice
语法:
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指定范围。
swap
语法:
void swap( list &lst ); |
swap()函数交换lst和现链表中的元素。
unique
语法:
void unique(); void unique( BinPred pr ); |
unique()函数删除链表中所有重复的元素。如果指定pr，则使用pr来判定是否删除。
// 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;
}输出结果
mylist contains: 2.72 12.15 72.25
使用list_name.unique(pr);函数时注意，若返回ture，则删除参与比较的俩个元素中较后的一个；
List与vector相比：
list可以去掉重复，去掉一个特定元素，（双链表）可以对首元素进行操作，可以用list_name.reverse()翻转链表；（记得考虑效率问题）；
C++ Stacks（堆栈）
操作
语法:
| == <= >= < > != |
所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。
empty
语法:
| bool empty(); |
如当前堆栈为空，empty() 函数 返回 true 否则返回false.
pop
语法:
| void pop(); |
pop() 函数移除堆栈中最顶层元素。
相关主题:
top(),
push
Syntax:
| void push( const TYPE &val ); |
push() 函数将 val 值压栈，使其成为栈顶的第一个元素。如:
stack<int> s;
for( int i=0; i < 10; i++ )
s.push(i);
size
语法:
| size_type size(); |
size() 函数返当前堆栈中的元素数目。如:
stack<int> s;
for( int i=0; i < 10; i++ )
s.push(i);
cout << "This stack has a size of " << s.size() << endl;
top
语法:
| TYPE &top(); |
top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。
while( !s.empty() ) {
cout << s.top() << " ";
s.pop();
}
C++ set
插入时自动排序
set不允许容器中有重复的元素
multiset允许容器中有重复的元素
关联容器实现能快速查找（ O(log n) 复杂度）的数据结构。
插入时自动排序
set不允许容器中有重复的元素
multiset允许容器中有重复的元素
begin
语法:
| iterator begin(); |
返回指向当前集合中第一个元素的迭代器。
clear
语法:
| void clear(); |
清除当前集合中的所有元素
语法:
| size_type count( const key_type &key ); |
返回当前集合中出现的某个值的元素的数目。
empty
语法:
| bool empty(); |
如果当前集合为空，返回true；否则返回false。
end
语法:
| const_iterator end(); |
返回指向当前集合中最后一个元素的迭代器。
语法:
| pair equal_range( const key_type &key ); |
返回集合中与给定值相等的上下限的两个迭代器。
erase
语法:
| void erase( iterator i ); void erase( iterator start, iterator end ); size_type erase( const key_type &key ); |
说明：
● 删除i元素；
● 删除从start开始到end结束的元素；
● 删除等于key值的所有元素（返回被删除的元素的个数）。
语法:
| iterator find( const key_type &key ); |
在当前集合中查找等于key值的元素，并返回指向该元素的迭代器；如果没有找到，返回指向集合最后一个元素的迭代器。
get_allocator
语法:
| allocator_type get_allocator(); |
返回当前集合的分配器。
insert
语法:
| iterator insert( iterator i, const TYPE &val ); void insert( input_iterator start, input_iterator end ); pair insert( const TYPE &val ); |
说明：
● 在迭代器i前插入val；
● 将迭代器start开始到end结束返回内的元素插入到集合中；
● 在当前集合中插入val元素，并返回指向该元素的迭代器和一个布尔值来说明val是否成功的被插入了。
（应该注意的是在集合(Sets)中不能插入两个相同的元素。)
语法:
| iterator lower_bound( const key_type &key ); |
返回一个指向大于或者等于key值的第一个元素的迭代器。
指向首个不小于 key 的元素的迭代器。若找不到这种元素，则返回尾后迭代器（见 end() ）。
语法:
| key_compare key_comp(); |
返回一个用于元素间值比较的函数对象。
max_size
语法:
| size_type max_size(); |
返回当前集合能容纳元素的最大限值。
rbegin
语法:
| reverse_iterator rbegin(); |
返回指向当前集合中最后一个元素的反向迭代器。
rend
语法:
| reverse_iterator rend(); |
返回指向集合中第一个元素的反向迭代器。
size
语法:
| size_type size(); |
返回当前集合中元素的数目。
swap
语法:
| void swap( set &object ); |
交换当前集合和object集合中的元素。
语法:
| iterator upper_bound( const key_type &key ); |
在当前集合中返回一个指向大于Key值的元素的迭代器。
语法:
| value_compare value_comp(); |
返回一个用于比较元素间的值的函数对象。
Set可以数数，可以删除某个值为k的元素，可以找到某个值为k的元素（返回指向其的迭代器）；可以使用lower_bound/ upper_bound来找出不小于/不大于k的元素（返回指向其的迭代器）；
set容器排序（默认从小到大）
#include <set>
class MyCompare
{
public:
bool operator()(int v1, int v2) {
return v1 > v2;
}
};
void test01()
{
set<int> s1;
s1.insert(10);
s1.insert(40);
s1.insert(20);
s1.insert(30);
s1.insert(50);
//默认从小到大
for (set<int>::iterator it = s1.begin(); it != s1.end(); it++) {
cout << *it << " ";
}
cout << endl;
//指定排序规则
set<int, MyCompare> s2;
s2.insert(10);
s2.insert(40);
s2.insert(20);
s2.insert(30);
s2.insert(50);
for (set<int, MyCompare>::iterator it = s2.begin(); it != s2.end(); it++) {
cout << *it << " ";
}
cout << endl;
}
int main() {
test01();
system("pause");
return 0;
}C++ Map
map中所有元素都是pair pair中第一个元素为key（键值），起到索引作用，第二个元素为value（实值） 所有元素都会根据元素的键值自动排序
C++ Maps 被用作储存“关键字/值”对,可以根据key值快速找到value值
begin
语法:
iterator begin(); |
begin()函数返回一个迭代器指向map的第一个元素。
clear
语法:
void clear(); |
clear()函数删除map中的所有元素。
count
语法:
size_type count( const KEY_TYPE &key ); |
count()函数返回map中键值等于key的元素的个数。
empty
语法:
bool empty(); |
empty()函数返回真(true)如果map为空，否则返回假(false)。
end
语法:
iterator end(); |
end()函数返回一个迭代器指向map的尾部。
equal_range
Syntax:
pair equal_range( const KEY_TYPE &key ); |
equal_range()函数返回两个迭代器——一个指向第一个键值为key的元素，另一个指向最后一个键值为key的元素。
erase
语法:
void erase( iterator pos ); void erase( iterator start, iterator end ); size_type erase( const KEY_TYPE &key ); |
erase()函数删除在pos位置的元素，或者删除在start和end之间的元素，或者删除那些值为key的所有元素。
find
语法:
iterator find( const KEY_TYPE &key ); |
find()函数返回一个迭代器指向键值为key的元素，如果没找到就返回指向map尾部的迭代器。
get_allocator
语法:
allocator_type get_allocator(); |
get_allocator()函数返回map的配置器。
insert
语法:
iterator insert( iterator pos, const pair<KEY_TYPE,VALUE_TYPE> &val ); void insert( input_iterator start, input_iterator end ); pair<iterator, bool> insert( const pair<KEY_TYPE,VALUE_TYPE> &val ); |
insert()函数：
- 插入val到pos的后面，然后返回一个指向这个元素的迭代器。
- 插入start到end的元素到map中。
- 只有在val不存在时插入val。返回值是一个指向被插入元素的迭代器和一个描述是否插入的bool值。
key_comp
语法:
key_compare key_comp(); |
key_comp()函数返回一个比较key的函数。
lower_bound
语法:
iterator lower_bound( const KEY_TYPE &key ); |
lower_bound()函数返回一个迭代器，指向map中键值>=key的第一个元素。
max_size
语法:
size_type max_size(); |
max_size()函数返回map能够保存的最大元素个数。
rbegin
语法:
reverse_iterator rbegin(); |
rbegin()函数返回一个指向map尾部的逆向迭代器。
rend
语法:
reverse_iterator rend(); |
rend()函数返回一个指向map头部的逆向迭代器。
size
语法:
size_type size(); |
size()函数返回map中保存的元素个数。
swap
语法:
void swap( map &obj ); |
swap()交换obj和现map中的元素。
upper_bound
语法:
iterator upper_bound( const KEY_TYPE &key ); |
upper_bound()函数返回一个迭代器，指向map中键值>key的第一个元素。
value_comp
语法:
value_compare value_comp(); |
value_comp()函数返回一个比较元素value的函数。
Map与set一样可以使用lower_bound/ upper_bound来找出不小于/不大于k的元素（返回指向其的迭代器）；
map建立与输出；
#include<bits/stdc++.h>
using namespace std;
void printMap(map<int, int>&m)
{
for (map<int, int>::iterator it = m.begin(); it != m.end(); it++)
{
cout << "key = " << it->first << " value = " << it->second << endl;
}
cout << endl;
}
void test01()
{
map<int, int>m; //默认构造
m.insert(pair<int, int>(1, 10));
m.insert(pair<int, int>(2, 20));
m.insert(pair<int, int>(3, 30));
printMap(m);
map<int, int>m2(m); //拷贝构造
printMap(m2);
map<int, int>m3;
m3 = m2; //赋值
printMap(m3);
}
int main() {
test01();
system("pause");
return 0;
}
输出结果：
key = 1 value = 10
key = 2 value = 20
key = 3 value = 30
key = 1 value = 10
key = 2 value = 20
key = 3 value = 30
key = 1 value = 10
key = 2 value = 20
key = 3 value = 30