需要查询全面的stl可点击：

cplusplus（好久没更新了）

cppreference（标准，可能打不开）

cppreference（中文，好打开）

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被认为是相等的,如果:

1. 它们具有相同的容量
2. 所有相同位置的元素相等.

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（堆栈）

操作

语法:

所有的这些操作可以被用于堆栈. 相等指堆栈有相同的元素并有着相同的顺序。

empty

语法:

如当前堆栈为空，empty() 函数 返回 true 否则返回false.

pop

语法:

pop() 函数移除堆栈中最顶层元素。

相关主题:
top(),

push

Syntax:

 push() 函数将 val 值压栈，使其成为栈顶的第一个元素。如:

    stack<int> s;

    for( int i=0; i < 10; i++ )

      s.push(i);

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

语法:

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

语法:

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

语法:

assign()函数用start和end指示的范围为双向队列赋值，或者设置成num个val。

at

语法:

at()函数返回一个引用，指向双向队列中位置pos上的元素。

back

语法:

back()返回一个引用，指向双向队列中最后一个元素。

begin

语法:

begin()函数返回一个迭代器，指向双向队列的第一个元素。

clear

语法:

clear()函数删除双向队列中所有元素。

empty

语法:

empty()返回真如果双向队列为空，否则返回假。

end

语法:

end()函数返回一个迭代器，指向双向队列的尾部。

erase

语法:

erase()函数删除pos位置上的元素，或者删除start和end之间的所有元素。返回值是一个iterator，指向被删除元素的后一个元素。

front

语法:

front()函数返回一个引用，指向双向队列的头部。

get_allocator

语法:

get_allocator()函数返回双向队列的配置器。

insert

语法:

insert()在pos前插入num个val值，或者插入从start到end范围内的元素到pos前面。

max_size

语法:

max_size()返回双向队列能容纳的最大元素个数。

pop_back

语法:

pop_back()删除双向队列尾部的元素。

pop_front

语法:

pop_front()删除双向队列头部的元素。

push_back

语法:

push_back()函数在双向队列的尾部加入一个值为val的元素。

push_front

语法:

push_front()函数在双向队列的头部加入一个值为val的元素。

rbegin

语法:

rbegin()返回一个指向双向队列尾部的逆向迭代器。

rend

语法:

rend()返回一个指向双向队列头部的逆向迭代器。

resize

语法:

resize()改变双向队列的大小为num，另加入的元素都被填充为val。

size

语法:

size()函数返回双向队列中的元素个数。

swap

语法:

swap()函数交换target和现双向队列中元素。

C++ deque(双向队列)

Constructors

语法:

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

语法:

assign()函数用start和end指示的范围为双向队列赋值，或者设置成num个val。

at

语法:

at()函数返回一个引用，指向双向队列中位置pos上的元素。

back

语法:

back()返回一个引用，指向双向队列中最后一个元素。

begin

语法:

begin()函数返回一个迭代器，指向双向队列的第一个元素。

clear

语法:

clear()函数删除双向队列中所有元素。

empty

语法:

empty()返回真如果双向队列为空，否则返回假。

end

语法:

end()函数返回一个迭代器，指向双向队列的尾部。

erase

语法:

erase()函数删除pos位置上的元素，或者删除start和end之间的所有元素。返回值是一个iterator，指向被删除元素的后一个元素。

front

语法:

front()函数返回一个引用，指向双向队列的头部。

get_allocator

语法:

get_allocator()函数返回双向队列的配置器。

insert

语法:

insert()在pos前插入num个val值，或者插入从start到end范围内的元素到pos前面。

max_size

语法:

max_size()返回双向队列能容纳的最大元素个数。

pop_back

语法:

pop_back()删除双向队列尾部的元素。

pop_front

语法:

pop_front()删除双向队列头部的元素。

push_back

语法:

push_back()函数在双向队列的尾部加入一个值为val的元素。

push_front

语法:

push_front()函数在双向队列的头部加入一个值为val的元素。

rbegin

语法:

rbegin()返回一个指向双向队列尾部的逆向迭代器。

rend

语法:

rend()返回一个指向双向队列头部的逆向迭代器。

resize

语法:

resize()改变双向队列的大小为num，另加入的元素都被填充为val。

size

语法:

size()函数返回双向队列中的元素个数。

swap

语法:

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

语法:

如当前堆栈为空，empty() 函数 返回 true 否则返回false.

pop

语法:

pop() 函数移除堆栈中最顶层元素。

相关主题:
top(),

push

Syntax:

 push() 函数将 val 值压栈，使其成为栈顶的第一个元素。如:

    stack<int> s;

    for( int i=0; i < 10; i++ )

      s.push(i);

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

语法:

top() 函数返回对栈顶元素的引用. 举例,如下代码显现和清空一个堆栈。

    while( !s.empty() ) {

      cout << s.top() << " ";

      s.pop();

    }

C++ set

插入时自动排序

set不允许容器中有重复的元素

multiset允许容器中有重复的元素

关联容器实现能快速查找（ O(log n) 复杂度）的数据结构。

插入时自动排序

set不允许容器中有重复的元素

multiset允许容器中有重复的元素

begin

语法:

返回指向当前集合中第一个元素的迭代器。

clear

语法:

清除当前集合中的所有元素

count

语法:

返回当前集合中出现的某个值的元素的数目。

empty

语法:

如果当前集合为空，返回true；否则返回false。

end

语法:

返回指向当前集合中最后一个元素的迭代器。

equal_range

语法:

返回集合中与给定值相等的上下限的两个迭代器。

erase

语法:

说明：

● 删除i元素；

● 删除从start开始到end结束的元素；

● 删除等于key值的所有元素（返回被删除的元素的个数）。
 

find

语法:

在当前集合中查找等于key值的元素，并返回指向该元素的迭代器；如果没有找到，返回指向集合最后一个元素的迭代器。

get_allocator

语法:

返回当前集合的分配器。

insert

语法:

说明：

● 在迭代器i前插入val；

● 将迭代器start开始到end结束返回内的元素插入到集合中；

● 在当前集合中插入val元素，并返回指向该元素的迭代器和一个布尔值来说明val是否成功的被插入了。

（应该注意的是在集合(Sets)中不能插入两个相同的元素。)
 

lower_bound

语法:

返回一个指向大于或者等于key值的第一个元素的迭代器。

指向首个不小于 key 的元素的迭代器。若找不到这种元素，则返回尾后迭代器（见 end() ）。
 

key_comp

语法:

返回一个用于元素间值比较的函数对象。

max_size

语法:

返回当前集合能容纳元素的最大限值。

rbegin

语法:

返回指向当前集合中最后一个元素的反向迭代器。

rend

语法:

返回指向集合中第一个元素的反向迭代器。

size

语法:

返回当前集合中元素的数目。

swap

语法:

交换当前集合和object集合中的元素。

upper_bound

语法:

在当前集合中返回一个指向大于Key值的元素的迭代器。

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