vector<T> v; //默认构造函数

vector(v.begin(),v.end()); //将 v [ begin(), end() )区间中的元素拷贝给本身

vector(n,elem); //构造函数将n个elem拷贝给本身

vector(const vector &vec); 拷贝构造函数

vector赋值

vector& operator = (const vector &vec); //重载等号操作符

assign(beg,end); //将 [ beg, end ) 区间中的数据拷贝赋值给本身

assign(n,elem); //将n个elem拷贝赋值给本身

vector容量和大小

empty(); //判断容器是否为空

capacity(); //容器的容量

size(); //返回容器中元素的个数

resize(int num); //重新指定容器长度为num，若容器变长，则以默认值0填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。

resize(int num,elem); //重新指定容器长度为num，若容器变长，则以elem值填充新位置
//如果容器变短，则末尾超出容器长度的元素被删除

vector的插入和删除

push_back(elem); //尾部插入元素elem

pop_back(); //删除最后一个元素

insert(const_iterator pos,elem); //迭代器指向位置pos插入元素elem

insert(const_iterator pos,int count,elem); //迭代器指向位置pos插入count个元素elem

erase(sonst_iterator pos); //删除迭代器指向的元素

erase(const_iterator start,const_iterator end); //删除迭代器从start至end之间的元素

clear(); //删除容器中所有元素

vector数据存取

at(int idx); //返回索引 idx 所指的数据

operator[]; //返回索引 idx 所指的数据

front(); //返回容器中第一个数据元素

back() //返回容器中最后一个数据元素

vector互换容器

swap(vec); //将vec与本身元素交换

巧用swap收缩：vector<int>(v).swap(v);

vector预留空间

reserve(int len); //容器预留len个元素长度，预留位置不初始化，元素不可访问。

vector存放内置数据类型

#include<iostream>
using namespace std;
#include<vector>
#include<algorithm> //标准算法头文件

void myPrint(int val)
{
    cout << val << endl;
}

void test1()
{
    //创建一个容器，数组
    vector<int> v;
    //插入数据
    v.push_back(10);
    v.push_back(20);
    v.push_back(30);

    //通过迭代器访问容器中的数据
    //vector<int>::iterator itbegin = v.begin();  //起始迭代器，指向第一个元素
    //vector<int>::iterator itend = v.end();  //结束迭代器，指向最后一个元素的下一个位置

    //第一种遍历方式
  /*  while (itbegin != itend)
    {
        cout << *itbegin << endl;
        itbegin++;
    }*/

    //第二种遍历方式
  /*  for (vector<int>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout << *it << endl;
    }*/

    //第三种遍历方式 使用STL提供的遍历算法
    for_each(v.begin(), v.end(), myPrint);
}

int main()
{
    test1();
    system("pause");
    return 0;
}

vector存放自定义数据类型

#include<iostream>
using namespace std;
#include<string>
#include<vector>
#include<algorithm> //标准算法头文件

class Person
{
public:
    Person(string name, int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

    string m_Name;
    int m_Age;
};

//存放自定义数据类型
//void test1()
//{
//    vector<Person>v;
//
//    Person p1("aa", 10);
//    Person p2("bb", 20);
//    Person p3("cc", 30);
//
//    v.push_back(p1);
//    v.push_back(p2);
//    v.push_back(p3);
//
        //遍历
//    for (vector<Person>::iterator it = v.begin(); it != v.end(); it++)
//    {
//        //cout << "name is: " << (*it).m_Name << "age is: " << (*it).m_Age << endl;
//        cout << "name is: " << it->m_Name << "age is: " <<it->m_Age << endl;
//    }
//}


//存放自定义数据类型 指针
void test2()
{
    vector<Person*>v;

    Person p1("aa", 10);
    Person p2("bb", 20);
    Person p3("cc", 30);

    v.push_back(&p1);
    v.push_back(&p2);
    v.push_back(&p3);

    //遍历
    for (vector<Person*>::iterator it = v.begin(); it != v.end(); it++)
    {
        cout<<"name is: "<<(*it)->m_Name << "age is: " << (*it)->m_Age << endl;
    }
}

int main()
{
    //test1();
    test2();
   
    system("pause");
    return 0;
}

vector容器嵌套

类似二维数组

//容器嵌套容器
void test1()
{
    vector<vector<int>> v;

    //创建小容器
    vector<int> v1;
    vector<int> v2;
    vector<int> v3;

    //向容器中添加数据
    for (int i = 0; i < 4; i++)
    {
        v1.push_back(i + 1);
        v2.push_back(i + 2);
        v3.push_back(i + 3);
    }

    //将小容器插入到大容器中
    v.push_back(v1);
    v.push_back(v2);
    v.push_back(v3);

    //通过大容器遍历所有数据
    for (vector<vector<int>>::iterator it=v.begin(); it != v.end(); it++)
    {
        for (vector<int>::iterator vit = (*it).begin(); vit != (*it).end(); vit++)
        {
            cout << *vit << " ";
        }
        cout << endl;
    }
}

string容器

string和char*区别：

char*是一个指针
string是一个类，类内部封装了char*，管理这个字符串，是一个char*型的容器。

string构造函数

1，string(); //创建空字符串例如：string str;

string(const char* s); //使用字符串s初始化

2，string(const string& str); //使用一个string对象初始化另一个string对象

3，string(int n,char c); //使用n个字符初始化

string赋值操作

string& operator= (const char* s); //char*类型字符串赋值给当前字符串

string& operator= (const string &s); //把字符串s赋给当前字符串

string& operator= (char c); //把字符赋给当前字符串

string& assign(const char* s); //把字符串s赋给当前字符串

string& assign(const char* s,int n); //把字符串s的前n个字符赋给当前字符串

string& assign(const string &s); //把字符串s赋给当前字符串

string& assign(int n,char c); //用n个字符c赋给当前字符串

string字符串拼接

string& operator+= (const char* str); //重载+=操作符

string& operator+= (const char c); //重载+=操作符

string& operator+= (const string& str); //重载+=操作符

string& append(const string &s); //重载+=操作符

string& append(const char *s); //把字符串s连接到当前字符串结尾

string& append(const char *s,int n); //把字符串s的前n个字符连接到当前字符串结尾

string& append(const string &s,int pos,int n); //把字符串s中从pos开始的前n个字符连接到字符串结尾

string查找和替换

int find(const string& str,int pos = 0) const; //从pos开始查找str第一次出现的位置

int find(const char* s,int pos = 0 ) cosnt; //从pos开始查找s第一次出现的位置

int find(const char * s,int pos,int n) cosnt; //从pos开始查找s前n个字符第一次出现的位置

int find(const char* c,int pos = 0 ) cosnt; //查找字符c第一次出现的位置

int rfind(const string& str,int pos = npos)cosnt; //从pos开始查找str最后一次出现的位置

int rfind(const char* s,int pos = npos ) cosnt; //从pos开始查找s最后一次出现的位置

int rfind(const char * s,int pos,int n) cosnt; //从pos开始查找s前n个字符最后一次位置

int rfind(const char* c,int pos = 0 ) cosnt; //查找字符c最后一次出现的位置

string& replace(int pos,int n,const string& str); //替换从pos开始n个字符为字符串str

string& replace(int pos,int n,const char* s); //替换从pos开始n个字符为字符串s

string字符串比较

int conpare(const string &s) const; //与字符串s比较

int conpare(const char *s) cosnt; //与字符串s比较

string字符存取

char& opreator[](int n); //通过[]方法获取字符

char& at(int n); //通过at方法获取字符

string插入和删除

string& insert(int pos,cosnt char* s); //插入字符串

string& insert(int pos,cosnt string& str); //插入字符串

string& insert(int pos,int n,char c); //在指定位置插入n个字符

string& erase(int pos,int n = npos); //删除从pos开始的n个字符

string字串

string substr(int pos = 0,int n = npos) const; //返回由pos开始的n个字符组成的字符串

deque

双端数组，可以对头端进行插入删除操作。

deque与vector区别：

vector对于头部的插入删除效率低，数据量越大，效率越低
vector访问元素时的速度会比deque快,这和两者内部实现有关
deque相对而言，对头部的插入删除速度回比vector快

deque构造函数

deque<T> deqT; //默认构造形式

deque(beg,end); //构造函数将 [ beg, end ) 区间中的元素拷贝给本身

deque(n,elem); //构造函数将n个elem拷贝给本身

deque(const deque &deq); //拷贝构造函数

deque赋值操作

deque& operator = (const deque &deq); //重载等号操作符

assign(beg,end); //将 [ beg, end ) 区间中的数据拷贝赋值给本身

assign(n,elem); //将n个elem拷贝赋值给本身

deque大小操作

deque.empty(); //判断容器是否为空

deque.size(); //返回容器中元素的个数

deque.resize(int num); //重新指定容器长度为num，若容器变长，则以默认值填充新位置

//如果容器变短，则末尾超出容器长度的元素被删除。

deque.resize(int num,elem); //重新指定容器长度为num，若容器变长，以elem值填充新位置
//如果容器变短，则末尾超出容器长度的元素被删除

deque的插入和删除

两端插入操作

push_back(elem); //尾部插入元素elem

push_front(elem); //头部插入元素elem

pop_back(); //删除最后一个元素

pop_front(); //删除第一个元素

指定位置操作

insert(pos,elem); //在pos位置插入elem的拷贝，返回新数据的位置

insert(pos, n ,ele); //在pos位置插入n个elem，无返回值

insert(pos,beg,end); //在pos位置插入 [ beg , end ) 区间的数据，无返回值

erase(beg,end); //删除 [ beg.end ) 区间的数据，返回下一个数据的位置

erase(pos); //删除 pos 位置的数据，返回下一个数据的位置

clear(); //删除容器中所有元素

deque数据存取

at(int idx); //返回索引 idx 所指的数据

operator[]; //返回索引 idx 所指的数据

front(); //返回容器中第一个数据元素

back() //返回容器中最后一个数据元素

deque排序

sort(iterator beg,iterator end) //对beg和end区间内元素进行排序

stack

先进后出的数据结构。

stack构造函数

stack<T> stk; //stack采用模板类实现, stack对象的默认构造形式

stack(const stack &stk); //拷贝构造函数

stack赋值操作

stack& operator = (const stack &stk); //重载等号操作符

stack数据存取

push(elem); //向栈顶添加元素

pop(); //从栈顶移除第一个元素

top(); //返回栈顶元素

stack大小操作

empty(); //判断堆栈是否为空

size(); //返回栈的大小

queue

先进先出的数据结构。

queue构造函数

queue<T> que; //queue采用模板类实现, queue对象的默认构造形式

queue(const queue &que); //拷贝构造函数

queue赋值操作

queue& operator = (const queue &que); //重载等号操作符

queue数据存取

push(elem); //向队尾添加元素

pop(); //从队头移除第一个元素

back(); //返回最后一个元素

front(); //返回第一个元素

queue大小操作

empty(); //判断队列是否为空

size(); //返回队列的大小

list

功能：将数据进行链式存储

链表（list）是一种物理存储单元上非连续的存储结构，数据元素的逻辑顺序是通过链表中的指针链接实现的。

链表的组成：链表由—系列结点组成

结点的组成：一个是存储数据元素的数据域，另一个是存储下一个结点地址的指针域

STL中的链表是—个双向循环链表

list有一个重要的性质，插入操作和删除操作都不会造成原有list迭代器的失效，这在vector是不成立的。

list构造函数

list<T> lst; //list采用采用模板类实现对象的默认构造形式

list(beg,end); //构造函数将 [ beg , end ) 区间中的元素拷贝给本身

list(n,elem); //构造函数将n个elem拷贝给本身

list(const,list &lst); //拷贝构造函数

list赋值和交换

assign(beg,end); //将 [ beg , end ) 区间中的数据拷贝赋值给本身

assign(n,elem); //将n个elem拷贝赋值给本身

list& operator = (const list &lst); //重载等号操作符

swap(lst); //将lst与本身的元素互换

list大小操作

empty(); //判断容器是否为空

size(); //返回容器中元素的个数

resize(num); //重新指定容器长度为num，若容器变长，则以默认值填充新位置。

//如果容器变短，则末尾超出容器长度的元素被删除。

resize(num,elem); //重新指定容器长度为num，若容器变长，则以elem值填充新位置
//如果容器变短，则末尾超出容器长度的元素被删除

list插入和删除

push_back(elem); //尾部插入元素elem

push_front(elem); //头部插入元素elem

pop_back(); //删除最后一个元素

pop_front(); //删除第一个元素

insert(pos,elem); //在pos位置插入elem的拷贝，返回新数据的位置

insert(pos, n ,ele); //在pos位置插入n个elem，无返回值

insert(pos,beg,end); //在pos位置插入 [ beg , end ) 区间的数据，无返回值

erase(beg,end); //删除 [ beg.end ) 区间的数据，返回下一个数据的位置

erase(pos); //删除 pos 位置的数据，返回下一个数据的位置

clear(); //删除容器中所有元素

remove(elem); //删除容器中所有与elem值匹配的元素

list数据存取

front(); //返回第一个元素

back(); //返回最后一个元素

list反转和排序

reverse(); //反转

sort(); //排序

set / multiset

简介：所有元素都会在插入时自动被排序。

本质：set/multiset属于关联式容器,底层结构是用二叉树实现。

set 和 multiset区别：set不允许容器中有重复的元素，multiset允许容器中有重复的元素。

set构造和赋值

set<T> st; //默认构造函数

set(const set &st); //拷贝构造函数

set& operator = (const set &st); //重载等号操作符

set大小交换

size(); //返回容器中元素的个数

empty(); //判断容器是否为空

swap(st); //将st与本身的元素互换

set插入和删除

insert(elem); //插入elem

erase(beg,end); //删除 [ beg.end ) 区间的所有元素，返回下一个元素的迭代器

erase(pos); //删除 pos迭代器所指的元素，返回下一个元素的迭代器

clear(); //删除容器中所有元素

erase(elem); //删除容器中值为elem的元素

set查找和统计

find(key); //查找key是否存在，若存在则返回该键的元素的迭代器；

//若不存在，返回set.end

count(key); //统计key的元素个数

set排序

利用仿函数进行排序

class MyCompare
{
public:
    bool operator()(int v1,int v2)
        {
            return v1>v2;
        }
};

//指定由大到小
set<int,MyCompare> s;

自定义数据类型的排序要利用仿函数，说明按照什么规则进行排序。

pari对组创建

pair<type,type> p (value1,value2);

pair<type,type> p = make_pair(value1,value2);

map / multimap

简介：

map中所有元素都是pair
pair中第一个元素为key (键值)，起到索引作用，第二个元素为value (实值)
所有元素都会根据元素的键值自动排序

本质：

map / multimap属于关联式容器，底层结构是用二叉树实现。

优点：

可以根据key值快速找到value值map和multimap

区别：

map不允许容器中有重复key值元素
multimap允许容器中有重复key值元素

map构造和赋值

map<T1,T2> mp; //默认构造函数

map(const map &mp); //拷贝构造函数

map& operator = (const map &mp); //重载等号操作符

map大小和交换

size(); //返回容器中元素的个数

empty(); //判断容器是否为空

swap(st); //交换两个集合容器

map插入和删除

insert(elem); //插入

erase(beg,end); //删除 [ beg.end ) 区间的所有元素，返回下一个元素的迭代器

erase(pos); //删除 pos迭代器所指的元素，返回下一个元素的迭代器

clear(); //删除容器中所有元素

erase(key); //删除容器中值为key的元素

map查找和统计