Containers
Definition:
A data structure.
Provided by the STL for stores
and manages collections of objects efficiently.
Use template classes, which automatically
handle:
- Memory
management
- Insertion
& deletion
- Searching
& sorting
- Iteration
over elements
- Use
ready-made data structures like arrays, lists, stacks, queues,
sets, and maps.
Classification of Containers
C++ containers are mainly
classified into three categories:
|
Type |
Description |
Examples |
|
Sequence Containers |
Store data in linear order
(like arrays or lists). |
vector, list, deque, array,
forward_list |
|
Associative Containers |
Store data in key-value or
unique ordered form. |
set, map, multiset, multimap |
|
Unordered Containers |
Store data in hash table
(unordered, fast access). |
unordered_set, unordered_map,
unordered_multiset, unordered_multimap |
I.
Sequence Containers
These store elements in sequence
(order of insertion).
a) vector
- Dynamic
array (auto-resizing).
Example:-
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> v = {10, 20, 30};
v.push_back(40); // Add
element
v.pop_back(); // Remove
last element
cout << v[0]; //
Access
}
Advantages: Fast random access
Disadvantage: Slow insertion/deletion in the middle
b) list
- Doubly
linked list.
- Sequential
access (no random access).
Example:-
#include <list>
#include <iostream>
using namespace std;
int main() {
list<int> l = {1, 2, 3};
l.push_front(0);
l.push_back(4);
l.remove(2);
for(int x : l) cout << x << " ";
}
Advantages: Fast insertion/deletion anywhere
Disadvantage: Slow random access
c) deque
- Double-ended
queue (insert/remove from both ends).
- A combination of vector and list.
Example:-
#include <deque>
using namespace std;
int main() {
deque<int> d = {10, 20, 30};
d.push_front(5);
d.push_back(40);
}
Advantages: Fast insert/delete at both ends
Disadvantage: Slightly more overhead than vector
d) array
- Fixed-size
array introduced in C++11.
- Faster
and safer than traditional arrays.
Example
#include <array>
using namespace std;
int main() {
array<int, 3> arr = {1, 2, 3};
cout << arr.at(1); // safer access
}
e) forward_list
- Singly
linked list (C++11).
- Uses
less memory than list.
II.
Associative Containers
Store data in a sorted order
using balanced binary trees.
Types:-
a) set
- Stores
unique elements, automatically sorted.
Example
#include <set>
using namespace std;
int main() {
set<int> s = {10, 5, 20};
s.insert(15);
for (int x : s) cout << x << " ";
}
Output: 5 10 15 20
b) multiset
- Allows
duplicate elements, sorted order.
c) map
- Stores
key-value pairs, unique keys, sorted by key.
Example
#include <map>
using namespace std;
int main() {
map<int, string> m;
m[1] = "One";
m[2] = "Two";
for (auto p : m) cout << p.first << " → " <<
p.second << endl;
}
Output:-
1 → One
2 → Two
d) multimap
- Multiple
values for same key.
III.
Unordered Containers
They are implemented using Hash
Table(elements are not sorted, but access is very fast).
Types
unordered_set
- Unique
elements, unordered.
Example:-
#include <unordered_set>
using namespace std;
int main() {
unordered_set<int> us = {10, 20, 30};
us.insert(40);
for (auto x : us) cout << x << " ";
}
Output:-
40 30 20 10
🔹 unordered_map
- Key-value
pairs, unique keys.
Example:-
#include <unordered_map>
using namespace std;
int main() {
unordered_map<string, int> um;
um["apple"] = 10;
um["banana"] = 20;
for (auto p : um) cout << p.first << " = "
<< p.second << endl;
}
Output:-
banana = 20
apple = 10
|
Need |
Best Container |
|
Fast random access |
vector |
|
Frequent insert/delete |
list |
|
Unique sorted values |
set |
|
Key-value mapping |
map |
|
Unordered fast lookup |
unordered_map |
|
Stack operations |
stack |
|
Queue operations |
queue |
====================================================================
0 Comments