Standard Structure

std::deque

// 1. 双端队列
// 2. 由N段连续的内存区域组成，支持在首尾插入删除元素
// 3. 已添加的内存区域的内存地址不会变动，作为对比，vector会不断地改变内存地址
// 4. 完全取代std::vector并且各方面性能都要强于std::vector
std::deque<int> mque;

// ADD
mque.push_back(11);
mque.push_back(22);
mque.push_front(33);
mque.push_front(44);
// DELETE
// 如果mque为空，则抛出异常
mque.pop_front();
mque.pop_back();
// UPDATE
mque[0] = 2000;

for (auto i = mque.cbegin(); i != mque.cend(); ++i) {
    std::cout << *i << std::endl;
}

// If the number is smaller than the %deque's current size the %deque is 
// truncated, otherwise default constructed elements are appended
mque.resize(10);

std::queue

// 队列，装饰std::deque而来
std::queue<int> mque;

// ADD
mque.push(11);
mque.push(22);
mque.push(33);
// DELETE
mque.pop();
// CHECK
std::cout << mque.front() << "  " << mque.back() << std::endl;

std::stack

// 栈，装饰std::deque而来
std::stack<int> mque;

// ADD
mque.push(11);
mque.push(22);
mque.push(33);
// DELETE
mque.pop();
// CHECK
std::cout << mque.top() << std::endl;

std::list

// 双向列表，缺点在于不支持任意位置的随机访问
std::list<int> mlist;

// ADD
mlist.emplace_front(11);
mlist.emplace_back(22);
mlist.insert(mlist.begin(), 33);
// DELETE
mlist.erase(++mlist.cbegin());
// UPDATE
*mlist.begin()=2000;
*(++mlist.begin())=3000;
// mlist.end()指向的是mlist末尾元素的下一个元素
*(--mlist.end())=100;

for (auto i = mlist.begin(); i != mlist.end(); ++i) {
    std::cout << *i << std::endl;
}

std::set

// 1. 值默认按照从小到大排列
// 2. 值是唯一的
// 3. 内部使用了平衡二叉查找树算法
std::set<int> mset;

// ADD
mset.emplace(3000);
mset.emplace(1000);
mset.emplace(2000);
mset.emplace(2000);
// DELETE
mset.erase(2000);

for (auto i = mset.cbegin(); i != mset.cend(); ++i) {
    std::cout << *i << std::endl;
}

set::multiset

和std::set唯一的不同在于值可以重复

std::multiset

// 1. 值是无序的
// 2. 值是唯一的
// 3. 内部使用了hash算法
std::multiset<int> oset;

oset.emplace(3000);
oset.emplace(1000);
oset.emplace(2000);
oset.emplace(2000);

oset.erase(2000);

for (auto i = oset.cbegin(); i != oset.cend(); ++i) {
    std::cout << *i << std::endl;
}

std::unordered_multiset

和std::unordered_set唯一的不同在于值可以重复

std::map

// 1. 键值对默认是按照键的从小到大排列
// 2. 元素的键是唯一的
// 3. 内部使用了平衡二叉查找树算法
std::map<int, std::string> omap;

// ADD
// 如果插入多个相同键的键值对，只有第一个有效
omap.emplace(2000, "abcd");
omap.emplace(std::pair<int, std::string>(3000, "aaaa"));
// DELETE
omap.erase(3000);
// UPDATE
// 当修改的键不存在时自动插入该键值对
omap[4000] = "bbbb";
omap[5000] = "cccc";

for (auto i = omap.cbegin(); i != omap.cend(); ++i) {
    std::cout << i->first << "  " << i->second << std::endl;
}

std::multimap

和std::map唯一不同的地方在于std::multimap允许重复的键

std::unordered_map

// 1. 键值对是无序的
// 2. 元素的键是唯一的
// 3. 内部使用了hash算法，所以查询效率高
std::unordered_map<int, std::string> umap;

// ADD
// 如果插入多个相同键的键值对，只有第一个有效
umap.emplace(2000, "abcd");
umap.emplace(std::pair<int, std::string>(3000, "aaaa"));
// DELETE
umap.erase(3000);
// UPDATE
// 当修改的键不存在时自动插入该键值对
umap[4000] = "bbbb";
umap[5000] = "cccc";

for (auto i = umap.cbegin(); i != umap.cend(); ++i) {
    std::cout << i->first << "  " << i->second << std::endl;
}

std::unordered_multimap

和std::unordered_map唯一不同的地方在于std::unordered_multimap允许重复的键