vector<int> data(10);
//下面两个 for 循环的效果是一样的
for (int i = 0; i < data.size(); i++)
  cout << data[i] << endl;  // 使用下标访问元素

for (vector<int>::iterator iter = data.begin(); iter != data.end(); iter++)
  cout << *iter << endl;  // 使用迭代器访问元素
// 在C++11后可以使用 auto iter = data.begin() 来简化上述代码

#include<vector>                       //头文件

vector<typename> name;                 //相当于长度可以变化的一维数组

vector<vector<typename> > name;        //相当于长度可以变化的一维数组

vector<typename> Arrayname[arraySize]; 
//一维长度固定为arraySize，Arrayname[0]~Arrayname[arraySize-1]中每一个都是一个vector容器

//typename可以是任何基本类型，例如int,double,char,结构体等，也可以是STL标准容器，例如vector,set,queue等

// 1. 创建空vector; 常数复杂度
vector<int> v0;
// 1+. 这句代码可以使得向vector中插入前3个元素时，保证常数时间复杂度
v0.reserve(3);
// 2. 创建一个初始空间为3的vector，其元素的默认值是0; 线性复杂度
vector<int> v1(3);
// 3. 创建一个初始空间为3的vector，其元素的默认值是2; 线性复杂度
vector<int> v2(3, 2);
// 4. 创建一个初始空间为3的vector，其元素的默认值是1，
// 并且使用v2的空间配置器; 线性复杂度
vector<int> v3(3, 1, v2.get_allocator());
// 5. 创建一个v2的拷贝vector v4， 其内容元素和v2一样; 线性复杂度
vector<int> v4(v2);
// 6. 创建一个v4的拷贝vector v5，其内容是{v4[1], v4[2]}; 线性复杂度
vector<int> v5(v4.begin() + 1, v4.begin() + 3);
// 7. 移动v2到新创建的vector v6，不发生拷贝; 常数复杂度; 需要 C++11
vector<int> v6(std::move(v2));  // 或者 v6 = std::move(v2);

//1.通过下标访问
vector<int> m;
//直接访问m[index],index从0到m.size()-1

//2.通过迭代器访问
vector<int>::iterator it;
//迭代器就像STL容器的“指针”，可以用*it访问vector中的元素

//m[i]和*(m.begin()+i)等价

#include<stdio.h>
#include<vector>
using namespace std;
int main()
{
    vector<int> vi;
    for(int i=1;i<=5;i++) vi.push_back(i);
    //1
    vector<int>::iterator it = vi.begin();
    for(int i=0;i<5;i++)
    {
        printf("%d",*(it+i)); //输出 1 2 3 4 5
    }
    //2
    for(vector<int>::iterator it = vi.begin();it!=vi.end();it++)
    {
        printf("%d",*it);    //输出 1 2 3 4 5
    }
    return 0;
}

#include <deque>

std::deque<int> dq1;              // 空双端队列
std::deque<char> dq2(5, 'A');     // 包含5个'A'
std::deque<int> dq3 = {1,2,3};    // 列表初始化（C++11）

// 头尾操作示例
std::deque<int> dq;
dq.push_front(2);    // 头部插入：dq = [2]
dq.push_back(3);     // 尾部插入：dq = [2,3]
dq.pop_front();      // 删除头部：dq = [3]

// 随机访问示例
dq[0] = 5;          // 修改第一个元素

#include<set>
set<typename> name;    //set数组的定义和vector相同
set<typename> Arrayname[arraySize];

set<typename>::iterator it;   //这样就得到了迭代器，可以通过*it来访问set

#include <stdio.h>
#include <set>
using namespace std;
int main()
{
    set<int> st;
    st.insert(1);
    st.insert(5);
    st.insert(3);
    st.insert(3);
    for(set<int>::iterator it = st.begin();it != st.end();it++)
    {
        printf("%d",*it);
    }
    return 0;
}
//输出结果：1 3 5

// 现存可用的元素
set<int> available;
// 需要大于等于的值
int x;

// 查找最小的大于等于x的元素
set<int>::iterator it = available.lower_bound(x);
if (it == available.end()) {
  // 不存在这样的元素，则进行相应操作……
} else {
  // 找到了这样的元素，将其从现存可用元素中移除
  available.erase(it);
  // 进行相应操作……
}

map<key,value> mp;
//字符串映射到整型，必须使用string而不能用char数组
map<string,int> mp;
//将set容器映射到字符串
map<set<int>, string> mp;

//1.通过下标访问
map<char,int> mp;
//直接使用mp['c']来访问对应的整数，map中的键是唯一的。
#include <stdio.h>
#include <map>
using namespace std;
int main()
{
    map<char,int> mp;
    mp['c']=20;
    mp['c']=30;
    printf("%d\n",mp['c']);  //输出30
    return 0;
}

//2.通过迭代器访问
map<key,value>::iterator it;
//map可以使用it->first来访问键，使用it->second来访问值。
#include <stdio.h>
#include <map>
using namespace std;
int main()
{
    map<char,int> mp;
    mp['m']=20;
    mp['r']=30;
    mp['a']=40;
    for(map<char,int>::iterator it = mp.begin();it!=mp.end();it++)
    {
        printf("%c %d\n",it->first,it->second);
    }        
    return 0;
}
// 输出：map会以键从小到大的顺序自动排序
// a 40
// m 20
// r 30

#include<stack>
std::stack<TypeName> name;  // 使用默认底层容器 deque，数据类型为 TypeName
std::stack<TypeName, Container> name;  // 使用 Container 作为底层容器

std::stack<TypeName> s2(s1);        // 将 s1 复制一份用于构造 s2

#include<queue>
std::queue<TypeName> name;  // 使用默认底层容器 deque，数据类型为 TypeName
std::queue<TypeName, Container> name;  // 使用 Container 作为底层容器

std::queue<TypeName> q2(q1);  // 将 s1 复制一份用于构造 q2

#include<queue>
priority_queue<TypeName> name;             // 数据类型为 TypeName
priority_queue<TypeName, Container> name;  // 使用 Container 作为底层容器
priority_queue<TypeName, Container, Compare> name;
// 使用 Container 作为底层容器，使用 Compare 作为比较类型

// 自定义排序
std::vector<int> vec = {3,1,4,2};
std::sort(vec.begin(), vec.end(), [](int a, int b){ return a > b; }); // 降序排列

// 去重操作
std::sort(vec.begin(), vec.end());
auto last = std::unique(vec.begin(), vec.end());
vec.erase(last, vec.end());

// 查找元素
auto it = std::find(vec.begin(), vec.end(), 3);
if (it != vec.end()) std::cout << "Found: " << *it;

#include <utility>
//可以在定义时直接完成 pair 的初始化。
pair<int, double> p0(1, 2.0);
//也可以使用先定义，后赋值的方法完成 pair 的初始化。
pair<int, double> p1;   // 默认构造：int=0, double=0.0
p1.first = 1;
p1.second = 2.0;
//还可以使用 std::make_pair 函数。该函数接受两个变量，并返回由这两个变量组成的 pair。
pair<int, double> p2 = make_pair(1, 2.0);
//在 C++11 以及之后的版本中，make_pair 可以配合 auto 使用，以避免显式声明数据类型。
auto p3 = make_pair(3.14, "PI");          // 自动推导类型（C++11）

#include <string>

std::string str1;                // 空字符串
std::string str2 = "Hello";      // 用C风格字符串初始化
std::string str3(5, 'A');        // 创建含5个'A'的字符串，输出"AAAAA"
std::string str4(str2, 1, 3);    // 从str2下标1开始取3个字符，输出"ell"

//1. 通过下标访问
str[index]
//2. 通过迭代器访问
string::iterator it;
//可以通过*it访问string里的每一位
for(string::iterator it= str.begin();it!=str.end();it++){
    printf("%c",*it);
}
//string和vector一样，支持直接对迭代器进行加减某个字，str.begin()+3