Container
I. Overview
1. Intro
The Containers library is a generic collection of class templates and algorithms that allow programmers to easily implement common data structures
2. types
- sequence containers : vector, deque, list, array. forward,list
- associative containers : map, set, multiset, multimap
- unordered associative containers : unordered_associative containers
3. container adaptors
stack, queue, priority_queue;
II. Iterator
1. Intro
An iterator is any object that, pointing to some element in a range of elements (container or array), has the ability to iterate through the elements of that range using a set of operators(with at least the increment (++) and dereference (*) operators)
2. Iterator categories
Input and output iterators
the most limited types of iterators: they can perform sequential single-pass input or output operations.
Forward iterators
- they have all the functionality of input iterators and -if they are not constant iterators- also the functionality of output iterators
- they are limited to one direction in which to iterate through a range (forward).
- All standard containers support at least forward iterator types.
Bidirectional iterators
- they are like forward iterators
- they can also be iterated through backwards.
Random-access iterators
- they implement all the functionality of bidirectional iterators
- they also have the ability to access ranges non-sequentially: distant elements can be accessed directly by applying an offset value to an iterator without iterating through all the elements in between.
- These iterators have a similar functionality to standard pointers (pointers are iterators of this category).
the properties of random-access iterator category
- Can be incremented
a++
- Supports equality/inequality comparisons
a == b; a != b
- Can be dereferenced as an rvalue
*a
- Can be dereferenced as an lvalue
*a == t
- Can be decremented
a--
- Supports arithmetic operators + and -
a + n; a - n;
- Supports inequality comparisons (<, >, <= and >=) between iterators
- Supports compound assignment operations += and -=
- Supports offset dereference operator ([])
a[n]
- ! Each container may define its own specific iterator type able to iterate through it and access its elements.
- iterator of
vector
is random-accesse type iterator
- iterator of
3. functions
cont.begin()
//Returns an iterator pointing to the **first element** in the sequence
cont.rbegin()
//Returns an iterator pointing to the first element in the reversed sequence (i.e. the last element)
cont.end()
//Returns an iterator pointing to the **past-the-end element** in the sequence
void advance (InputIterator& it, Distance n);
//eqto using operator+ for n times, if n > cont.size() it will cross border
distance (InputIterator first, InputIterator last);
//Calculates the number of elements between first and last [first, last)
BidirectionalIterator prev (BidirectionalIterator it, typename \
iterator_traits<BidirectionalIterator>::difference_type n = 1);
ForwardIterator next (ForwardIterator it, typename iterator_traits<ForwardIterator>::difference_type n = 1);
vector<int>::iterator it = v.begin();// v = {0,1,2,3,4};
advance(it,2); //*it = 2
v[2]; // v[2] == 1
III. Vector
Member Function
1. constructor
//default (1)
explicit vector (const allocator_type& alloc = allocator_type());
//fill (2)
explicit vector (size_type n);
vector (size_type n, const value_type& val, const allocator_type& alloc = allocator_type());
//range (3)
template <class InputIterator>
vector (InputIterator first, InputIterator last, const allocator_type& alloc = allocator_type());
//copy (4)
vector (const vector& x);
vector (const vector& x, const allocator_type& alloc);
//move (5)
vector (vector&& x);
vector (vector&& x, const allocator_type& alloc);
//initializer list (6)
vector (initializer_list<value_type> il, const allocator_type& alloc = allocator_type());
vector<int> v1(3); // 0 0 0
vector<int> v2(3,5); //5 5 5
string s = "Hello";
vector<char> v3(s.begin(), s.end()); //H e l l o
vector<char> v4(v3); //H e l l o
2. Iterators
cont.begin()
cont.end()
cont.rbegin()
3. Element Access
cont.at(index) //return *a reference* to the requested element;
//cont.at(index) = value; cout << cont.at(index)
cont[index]
cont.front() //return *a reference* to the first element
cont.back() //return *a reference* to the last element
4. Capacity
cont.empty() // return true if the container is empty
`cont.size() // returns the number of elements in the container
5. Modifiers
cont.clear() //erases all elements
iterator insert( iterator pos, const T& value );
//inserts value before pos
iterator insert( const_iterator pos, size_type count, const T& value );
//inserts count copies of the value before pos
iterator erase (const_iterator pos);
//Removes from the vector a **single** element pointed bt pos
iterator erase (const_iterator first, const_iterator last);
//Removes a range of elements *[first,last)*
cont.push_back(T& val) //Adds a new element "val" at the end of the vector
void pop_back()
//Removes the last element in the vector, effectively reducing the container size by one.
void swap (vector& x);
/* Exchanges the content of the container by the content of x, which is another vector object of the same type. Sizes may differ.*/
//insert
#include <iostream>
#include <vector>
vector<int> v = {1,2,3,4};
auto it = v.begin();
v.insert(it, 0); //v = {0,1,2,3,4}
v.insert(v.end(),3,0); // v = {0,1,2,3,4,0,0,0}
//erase
IV. Map
1. Overview
- the key value are generally used to sort and uniquely identify the elements, while the mapped values store he content associated to this key.
- the type of key and mapped value may differ
- key and mapped value are grouped together in a pair type
pair<const Key, T>
2. Iterators
- a bidirectional iterator to value_type
cont.begin()
cont.end()
cont.rbegin()
3. Element Access
cont.at(key)
return a reference to the requested element; cont.at(index) = value;
cout << cont.at(index)
cont[key]
4. Capacity
cont.empty()
return true if the container is empty
cont.size()
returns the number of elements in the container
5. Modifiers
cont.clear()
erases all elements
iterator insert( iterator pos, const T& value );
inserts value before pos
iterator insert( const_iterator pos, size_type count, const T& value );
inserts count copies of the value before pos
iterator erase (const_iterator pos);
Removes from the vector a single element pointed bt pos
size_type erase (const key_type& k);
iterator erase (const_iterator first, const_iterator last);
Removes a range of elements [first,last)
void swap (vector& x);
Exchanges the content of the container by the content of x, which is another vector object of the same type. Sizes may differ.
6. operations
iterator find (const key_type& k);
Searches the container for an element with a key equivalent to k and returns an iterator to it if found, otherwise it returns an iterator to map::end.
7. traverse
for (auto it : a) {
cout << it.first << " " << it.second << endl;
}
V. Set
1. Overview
- Sets are containers that store unique elements following a specific order.
- the elements are always const i.e. it can not be modified
- the elements in a set are always sorted following a specific strict weak ordering criterion indicated by its internal comparison object
- unordered_set is faster
VI. Unordered Set
1. Overview
Unordered sets are containers that store unique elements in no particular order
2. Constructor
//empty (1)
explicit unordered_set ( size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
explicit unordered_set ( const allocator_type& alloc );
//range (2)
template <class InputIterator>
unordered_set ( InputIterator first, InputIterator last,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
//copy (3)
unordered_set ( const unordered_set& ust );
unordered_set ( const unordered_set& ust, const allocator_type& alloc );
//move (4)
unordered_set ( unordered_set&& ust );
unordered_set ( unordered_set&& ust, const allocator_type& alloc );
//initializer list (5)
unordered_set ( initializer_list<value_type> il,
size_type n = /* see below */,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& alloc = allocator_type() );
3.Element lookup
iterator find ( const key_type& k );
size_type count ( const key_type& k ) const;
4.Modifiers
- insert
//(1)
pair<iterator,bool> insert ( const value_type& val );
//(2)
pair<iterator,bool> insert ( value_type&& val );
//(3)
iterator insert ( const_iterator hint, const value_type& val );
//(4)
iterator insert ( const_iterator hint, value_type&& val );
//(5)
template <class InputIterator>
void insert ( InputIterator first, InputIterator last );
//(6)
void insert ( initializer_list<value_type> il );
- erase
VII. Forward List
1. Overview
- Forward lists are implemented as singly-linked lists
- Drawback
- they lack direct access to the elements by their position
2. Member Functions
Constructor
//default (1)
explicit forward_list (const allocator_type& alloc = allocator_type());
//fill (2)
explicit forward_list (size_type n);
explicit forward_list (size_type n, const value_type& val,
const allocator_type& alloc = allocator_type());
//range (3)
template <class InputIterator>
forward_list (InputIterator first, InputIterator last,
const allocator_type& alloc = allocator_type());
//copy (4)
forward_list (const forward_list& fwdlst);
forward_list (const forward_list& fwdlst, const allocator_type& alloc);
//move (5)
forward_list (forward_list&& fwdlst);
forward_list (forward_list&& fwdlst, const allocator_type& alloc);
//initializer list (6)
forward_list (initializer_list<value_type> il,
const allocator_type& alloc = allocator_type());
Operator =
Assigns new contents to the container, replacing its current contents.
3.Iterators
before_begin
Return iterator to before beginning
It is meant to be used as an argument for member functionsemplace_after
,insert_after
,erase_after
orsplice_after
, to specify the beginning of the sequencebegin
Return iterator to beginning
end
Return iterator to end
cbefore_begin
Return const_iterator to before beginning
cbegin
Return const_iterator to beginning
cend
Return const_iterator to end
4. Capacity
empty
Test whether array is empty
max_size
Return maximum size
5.Element access
front
Access first element
6.Modifiers
assign
Assign content
Assigns new contents to the forward_list container, replacing its current contents, and modifying its size accordingly.
//range (1)
template <class InputIterator>
void assign (InputIterator first, InputIterator last);
//fill (2)
void assign (size_type n, const value_type& val);
//initializer list (3)
void assign (initializer_list<value_type> il);
emplace_front
Construct and inserts a new element at the beginningpush_front
Insert a new element at beginningpop_front
Delete first elementemplace_after
Construct and insert elementinsert_after
Insert elements
//(1)
iterator insert_after ( const_iterator position, const value_type& val );
//(2)
iterator insert_after ( const_iterator position, value_type&& val );
//(3)
iterator insert_after ( const_iterator position, size_type n, const value_type& val );
//(4)
template <class InputIterator>
iterator insert_after ( const_iterator position, InputIterator first, InputIterator last );
//(5)
iterator insert_after ( const_iterator position, initializer_list<value_type> il );
erase_after
Erase elementsswap
Swap content between two forward_listresize
Change sizeclear
Clear content
7. Operations
splice_after
Transfers elements from fwdlst into the container inserting them after the element pointed by position.
//entire list (1)
void splice_after (const_iterator position, forward_list& fwdlst);
void splice_after (const_iterator position, forward_list&& fwdlst);
//single element (2)
void splice_after (const_iterator position, forward_list& fwdlst, const_iterator i);
void splice_after (const_iterator position, forward_list&& fwdlst, const_iterator i);
//element range (3)
void splice_after (const_iterator position, forward_list& fwdlst,
const_iterator first, const_iterator last);
void splice_after (const_iterator position, forward_list&& fwdlst,
const_iterator first, const_iterator last);
remove
Remove elements with specific value (public member function )remove_if
Remove elements fulfilling condition (public member function template )unique
Remove duplicate values (public member function )merge
Merge sorted lists (public member function )sort
Sort elements in container (public member function )reverse
Reverse the order of elements
VIII. List
1. Overview
- List containers are implemented as doubly-linked lists
2. Member Function
similar to forward_list
3. Iterators
begin
end
4. Element access:
front
Access first element
back
Access last element
5. Modifiers
assign
assign a new content to containerpush_front
insert element at beginningpop_front
push_back
pop_back
insert
insert new elements before the element at the specified position.
//single element (1)
iterator insert (const_iterator position, const value_type& val);
//fill (2)
iterator insert (const_iterator position, size_type n, const value_type& val);
//range (3)
template <class InputIterator>
iterator insert (const_iterator position, InputIterator first, InputIterator last);
//move (4)
iterator insert (const_iterator position, value_type&& val);
//initializer list (5)
iterator insert (const_iterator position, initializer_list<value_type> il);
6. Operations
splice
transfer elements from list to listremove
remove elements with specific valueunique
remove duplicate valuesmerge
Merges x into the list by transferring all of its elements at their respective ordered positions into the container
//(1)
void merge (list& x);
void merge (list&& x);
//(2)
template <class Compare>
void merge (list& x, Compare comp);
template <class Compare>
void merge (list&& x, Compare comp);
sort
sort elements in some orderreverse
IX. Queue
X. Stack
Member Functions
- constructor
//initialize (1)
explicit stack (const container_type& ctnr);
//move-initialize (2)
explicit stack (container_type&& ctnr = container_type());
//allocator (3)
template <class Alloc> explicit stack (const Alloc& alloc);
//init + allocator (4)
template <class Alloc> stack (const container_type& ctnr, const Alloc& alloc);
//move-init + allocator (5)
template <class Alloc> stack (container_type&& ctnr, const Alloc& alloc);
//copy + allocator (6)
template <class Alloc> stack (const stack& x, const Alloc& alloc);
//move + allocator (7)
template <class Alloc> stack (stack&& x, const Alloc& alloc);
empty
Test whether container is emptysize
Return sizetop
Access next elementpush
Insert elementemplace
Construct and insert elementpop
Remove top elementswap
Swap contents
XI. Array
1. Overview
- Arrays are fixed-size sequence containers: they hold a specific number of elements ordered in a strict linear sequence.
- Arrays have a fixed size and do not manage the allocation