The Containers at a Glance: What Each One Is Good At

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> v;
    v.push_back(30);
    v.push_back(10);
    v.push_back(20);
    std::cout << "vector:";
    for (int x : v) std::cout << ' ' << x;
    std::cout << " | v[1] = " << v[1] << '\n';
}

vector: 30 10 20 | v[1] = 10

Its question: "what is at position i?", answered in one step, plus cheap adding at the end. It is the default container, and the one to reach for first.

#include <iostream>
#include <string>

int main()
{
    std::string s = "cat";
    s += "fish";
    s.push_back('!');
    std::cout << "string: " << s << " | size " << s.size() << " | s[0] = " << s[0] << '\n';
}

string: catfish! | size 8 | s[0] = c

Its question: the vector's, for text. It also knows text jobs such as joining with += and searching for a word. No '\0' to manage, and no buffer that can overflow.

#include <array>
#include <iostream>

int main()
{
    std::array<int, 3> a = {30, 10, 20};
    std::cout << "array:";
    for (int x : a) std::cout << ' ' << x;
    std::cout << " | size is always " << a.size() << '\n';
}

array: 30 10 20 | size is always 3

Its question: position i, for a count you know when you write the program. It is a C array that knows its own size, with no growing at all.

#include <deque>
#include <iostream>

int main()
{
    std::deque<int> d;
    d.push_back(30);
    d.push_front(10);
    d.push_back(20);
    std::cout << "deque:";
    for (int x : d) std::cout << ' ' << x;
    std::cout << " | d[0] = " << d[0] << '\n';
}

deque: 10 30 20 | d[0] = 10

Its question: "add or remove at either end", in one step each, and still position i. A deque (say "deck", a double-ended queue) is what a vector would be if adding at the front were cheap too.

#include <iostream>
#include <list>

int main()
{
    std::list<int> l = {30, 20};
    auto it = l.begin();
    ++it;
    l.insert(it, 10);
    std::cout << "list:";
    for (int x : l) std::cout << ' ' << x;
    std::cout << '\n';
}

list: 30 10 20

Its question: "insert or remove right here", where you already stand, without moving any other element. It cannot answer "what is at position i?" quickly: it has no l[1] at all. It is the linked list you wrote by hand in C.

#include <iostream>
#include <stack>

int main()
{
    std::stack<int> s;
    s.push(30);
    s.push(10);
    s.push(20);
    std::cout << "stack pops:";
    while (!s.empty()) {
        std::cout << ' ' << s.top();
        s.pop();
    }
    std::cout << '\n';
}

stack pops: 20 10 30

Its question: "what was added last?". Like a pile of plates, the last one on is the first one off. Undo buttons and the C call stack you met in the C track work this way.

#include <iostream>
#include <queue>

int main()
{
    std::queue<int> q;
    q.push(30);
    q.push(10);
    q.push(20);
    std::cout << "queue pops:";
    while (!q.empty()) {
        std::cout << ' ' << q.front();
        q.pop();
    }
    std::cout << '\n';
}

queue pops: 30 10 20

Its question: "what was added first?". It is a line at a shop counter: whoever arrived first is served first.

#include <iostream>
#include <queue>

int main()
{
    std::priority_queue<int> pq;
    pq.push(30);
    pq.push(10);
    pq.push(20);
    std::cout << "priority_queue pops:";
    while (!pq.empty()) {
        std::cout << ' ' << pq.top();
        pq.pop();
    }
    std::cout << '\n';
}

priority_queue pops: 30 20 10

Its question: "what is the biggest right now?", even while new elements keep arriving. It is an emergency room: the most urgent case goes next, whoever came first.

#include <iostream>
#include <set>

int main()
{
    std::set<int> s = {30, 10, 20, 10};
    std::multiset<int> m = {30, 10, 20, 10};
    std::cout << "set:";
    for (int x : s) std::cout << ' ' << x;
    std::cout << " | multiset:";
    for (int x : m) std::cout << ' ' << x;
    std::cout << " | is 20 in the set? " << s.count(20) << '\n';
}

set: 10 20 30 | multiset: 10 10 20 30 | is 20 in the set? 1

Its question: "is x here?", fast, with everything kept sorted. A set keeps one copy of each value, so the second 10 was dropped. A multiset keeps repeats.

#include <iostream>
#include <map>
#include <string>

int main()
{
    std::map<std::string, int> price;
    price["tea"] = 30;
    price["bun"] = 10;
    price["egg"] = 20;
    std::cout << "map:";
    for (const auto& p : price) std::cout << ' ' << p.first << '=' << p.second;
    std::cout << " | egg costs " << price["egg"] << '\n';
}

map: bun=10 egg=20 tea=30 | egg costs 20

Its question: "what goes with this key?". A map is a set of keys, each carrying a value, kept sorted by key: bun comes out first because it is first alphabetically. A multimap allows one key to appear more than once.

#include <iostream>
#include <string>
#include <unordered_map>
#include <unordered_set>

int main()
{
    std::unordered_set<int> seen = {30, 10, 20};
    std::unordered_map<std::string, int> stock = {{"tea", 30}, {"bun", 10}};
    std::cout << "unordered_set:";
    for (int x : seen) std::cout << ' ' << x;
    std::cout << " | is 10 seen? " << seen.count(10);
    std::cout << " | buns in stock: " << stock["bun"] << '\n';
}

unordered_set: 20 10 30 | is 10 seen? 1 | buns in stock: 10

Its question: the set's and the map's, faster on average, when you never need the elements in order. The order they print in comes from hashing, not from you or from sorting. Another compiler's library may print a different order, so never rely on it.