I use Python in my work, and rarely need C++. So I need to compile this C++ cheatsheet for common STL containers/adapters, just in case I need them.

# vector

• Define a 1D vector: vector<int> arr = {1, 2, 3};
• Define a 2D vector: vector<vector<int>> mat = {{1, 2, 3}, {4, 5}};
• Define a 2D vector of size 3x4: vector<vector<int> > mat(3, vector<int>(4, 0));
• Add an element: arr.push_back(2);
• Insert an element: arr.insert(arr.begin(), -1);
• Insert another vector: vector<int> another = {1, 2, 3}; arr.insert(arr.begin(), another.begin(), another.end());
• Check its size: cout << arr.size();
• Check if vector is empty: cout << arr.empty();
• Slice a vector, i.e., get a sub-vector from an existing vector: vector<int> arr(10, 1); vector<int> new_vec(arr.begin(), arr.begin()+3); (this is end-exclusive, so the resulting vector has 3 elements)
• Sort a vector:
• In ascending order (the default): std::sort(arr.begin(), arr.end());
• In descending order (we need to use custom compare function): std::sort(arr.begin(), arr.end(), std::greater<int>());

Ref:

# string

• Define a string: string myStr = "hello";
• Get string size: myStr.size()
• Get sub-string: myStr.substr(0, 2) (Get the substring starting at index 0 and with length 2, end-exclusive style)
• Get sub-string: myStr.substr(1) (Get substring starting at index 1 till the end)
• Check if string is empty: myStr.empty();
• Generate a string with n same character ch: string(n, ch);
• Reverse a string: use std::reverse, std::reverse(myStr.begin(), myStr.end()).

Ref:

# set (works like a Python set)

set in C++ is typically implemented using balanced binary search tree.

• Define a set: set<int> x = {1, 2, 3};
• Add an element: x.insert(5);
• Check size: x.size()
• Check if set is empty: x.empty();
• Check if set contains a key: x.find(2) != x.end(); or x.count(2) != 0
• Initialize set from a vector of int: vector<int> arr = {1, 2, 1, 3}; set<int> my_set(arr.begin(), arr.end());

There is also unordered_set, which is different from set:

• The underlying implementation for set is binary search tree (BST), while the underlying implementation for unordered_set is hash table.
• The element in set is sorted so that their order is guaranteed, while for unordered_set, there is no guarantee for the element order.
• set requires less memory than unordered_set (unordered_set has to store a hash table).
• Search time is at most O(log(n)) for set, while for unordered_set, the search time is on average O(1), but may be O(n) in worst case (highly unlikely)

# map (works like a Python dict)

Typically implemented using balanced binary search tree.

• Define an empty map: map<int, string> items;

• Define a constant map: map<int, string> num2str = {{1, "ab"}, {2, "cd"}, {3, "ef"}};

• Add an element: items.insert({1, "apple"}); or items[1] = "apple";

• Remove an element: items.erase("apple");

• Access a key (no check): cout << items[1] << endl; (we have to make sure the key exists, otherwise it will be inserted silently)

• Access a key (with check): cout << items.at(4); (will error out)

• Show map element key and value:

for (auto item: items){
cout << item.first << " " << item.second << endl;
}


ref:

There is also unordered_map. The different between map and unordered_map is similar to the difference between set and unordered_set. So I will not elaborate on this.

Note that when map is defined using the const modifier, you can not access map element with operator [], since it is possible to alter map value when accessing map element like this, check this post for more details.

# queue

Queue is a data structure that provides FIFO (first in first out) feature. Element that is added first will also be removed first.

• Get queue size: queue<int> q; cout << q.size() << endl;
• Check if queue is empty: use q.empty() or q.size() == 0
• Get front element of queue: cout << q.front() << endl;
• Add element to queue: q.push(4);
• Pop up front element: q.pop();

# stack

Stack is the opposite of queue. It provides a LIFO (last in first out) data structure. Element that is added last will be removed first.

• Get stack size: stack<int> s; cout << s.size() << endl;
• Check if stack is empty: s.empty() or s.size() == 0
• Get top element from stack: cout << s.top() << endl; (note that getting top element when stack is empty leads to errors!)
• Add element to stack: s.push(1);
• Pop up element from stack: s.pop();

# tuple

Tuple can be used to different types of data.

• Create a tuple: std::make_tuple("abc", 2, 3);
• Get tuple element: std:get<0>(some_tuple); (get first element, really weird and unintuitive syntax!)

# pair

Pair can be used to hold two different data types conveniently.

• Create a pair: pair<int, string> my_pair = std::make_pair(2, "abc")
• Get pair element: my_pair.first and my_pair.second

Ref: