ECE 250 Algorithms and Data Structures
13.2 The Standard
Template Library (STL)
Douglas Wilhelm Harder, M.Math. LEL
Department of Electrical and Computer Engineering
University of Waterloo
Waterloo, Ontario, Canada
ece.uwaterloo.ca
dwharder@alumni.uwaterloo.ca
© 2006-2013 by Douglas Wilhelm Harder. Some rights reserved.
Standard Template Library
2
Outline
In this topic, we will look at linked lists
–
–
–
–
–
–
–
The Node and List classes
Accessors and mutators
The implementation of various member functions
Stepping through a linked list
Defining the copy and assignment operator
Defining move constructors and move assignment operators
Discussed efficiencies
Standard Template Library
3
Arrays
The Standard Template Library has three variations on arrays:
template < typename T, size_t N >
class array;
template < typename T, class Alloc = allocator<T> >
class vector;
template < size_t N >
class bitset;
Standard Template Library
4
array<T, N>
This is a sequence container with a linear order
– Elements are accessed by their position
The memory allocation is contiguous
– Random access is Q(1)
The memory is allocated at compile time
Standard Template Library
5
array<T, N>
To make return types more standard, the C++ STL defines specific
member types associated with each class:
array<T,
array<T,
array<T,
array<T,
array<T,
array<T,
array<T,
array<T,
array<T,
array<T,
array<T,
N>::value_type
N>::reference
N>::const_reference
N>::pointer
N>::const_pointer
N>::iterator
N>::const_iterator
N>::reverse_iterator
N>::const_reverse_iterator
N>::size_type
N>::difference_type
T
T
T
T
T
&
const &
*
const *
size_t
ptrdiff_t
Standard Template Library
6
array<T, N>
Member functions include:
– The eight iterators
begin end rbegin
rend
cbegin
cend
crbegin
iterator begin() noexcept;
const_iterator begin() const noexcept;
const_iterator cbegin() const noexcept;
– Capacity
constexpr size_type size() noexcept;
constexpr size_type max_size() noexcept;
constexpr bool empty() noexcept;
crend
Standard Template Library
7
array<T, N>
Member functions include:
– Element access
reference operator[]( size_type );
const_reference operator[]( size_type ) const;
reference at( size_type );
const_reference at ( size_type ) const;
reference front();
const_reference front() const;
reference back();
const_reference back() const;
pointer data() noexcept;
const_pointer data() const noexcept;
Standard Template Library
8
array<T, N>
Member functions include:
– Modifiers
void fill( const_reference );
void swap( array & ) noexcept( ... );
Standard Template Library
9
array<T, N>
Example:
#include <array>
int main() {
std::array<int, 5> v;
for ( int i = 0; i < 5; ++i ) {
v[i] = i;
}
for ( auto itr = v.begin(); itr != v.end(); ++itr ) {
*itr = (*itr)^2;
}
v.fill( 7 );
int *ptr = v.data();
return 0;
}
Standard Template Library
10
bitset<N>
Standard Template Library
11
vector<T>
This is a sequence container with a linear order
– Elements are accessed by their position
The memory allocation is contiguous
– Random access is Q(1)
The array allocation is dynamic
– The size of the array can change at runtime
The user can specify the method of allocation
Standard Template Library
12
vector<T>
To make return types more standard, the C++ STL defines specific
member types associated with each class:
vector<T>::value_type
vector<T>::reference
vector<T>::const_reference
vector<T>::pointer
vector<T>::const_pointer
vector<T>::iterator
vector<T>::const_iterator
vector<T>::reverse_iterator
vector<T>::const_reverse_iterator
vector<T>::allocator_type
vector<T>::size_type
vector<T>::difference_type
T
T
T
T
T
&
const &
*
const *
allocate<value_type>
size_t
ptrdiff_t
Standard Template Library
13
vector<T>
Member functions include:
– Constructors
explicit vector();
explicit vector( size_type );
vector( size_type, const_reference );
template < class InputIterator >
vector( InputIterator first, InputIterator last );
vector( vector const & );
vector( vector && );
vector( initializer_list<value_type> );
Standard Template Library
14
vector<T>
Member functions include:
– Assignment operator
vector &operator=( vector const & );
vector &operator=( vector && );
vector &operator=( initializer_list<value_type> );
– The last lets us:
std::vector<int> v(10);
v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
Standard Template Library
15
vector<T>
Member functions include:
– The eight iterators
begin end rbegin
rend
cbegin
cend
crbegin
– Each has the various signatures:
iterator begin() noexcept;
const_iterator begin() const noexcept;
const_iterator cbegin() const noexcept;
crend
Standard Template Library
16
vector<T>
Member functions include:
– Capacity
size_type size() const noexcept;
size_type capacity() const noexcept;
size_type maxsize() const noexcept;
void resize( size_type );
void resize( size_type, const_reference );
bool empty() const noexcept;
bool empty() const noexcept;
void reserve( size_type );
void shrink_to_fit();
Standard Template Library
17
vector<T>
Member functions include:
– Element access
reference operator[]( size_type );
const_reference operator[]( size_type ) const;
reference at( size_type );
const_reference at ( size_type ) const;
reference front();
const_reference front() const;
reference back();
const_reference back() const;
pointer data() noexcept;
const_pointer data() const noexcept;
Standard Template Library
18
vector<T>
Member functions include:
– Modifiers
template < class Iterator >
void assign( Iterator, Iterator );
void assign( size_type, const_reference );
void assign( initializer_list<value_type> );
void push_back( const_reference );
void push_back( value_type&& );
void pop_back();
Standard Template Library
19
vector<T>
Member functions include:
– Modifiers
iterator insert( const_iterator position, const_reference );
iterator insert( const_iterator position, size_type n,
const_reference );
template < class Iterator >
iterator insert( const_iterator position,
Iterator first, Iterator last );
iterator insert( const_iterator position, value_type&& );
iterator insert( const_iterator position,
initializer_list<value_type> );
Standard Template Library
20
vector<T>
Member functions include:
– Allocator
allocator_type get_allocator() const noexcept;
– Non-member function overloads
template < typename T >
void swap( vector<T> &, vector<T> & );
template < typename T >
bool operator==( const vector<T> &, const vector<T> & );
• Includes the relational operators !=, <, <=, >, and >=
• Uses a lexicographical comparison
Standard Template Library
21
vector<bool>
One specialization of vector is for Boolean values:
– Normally, each bool occupies one byte
– Reasonable specializations of vector<bool> use one bit per entry
– One new function:
void flip() noexcept;
– A mechanism for referencing individual bits and interpreting them as
type bool
Standard Template Library
22
vector<T, Alloc>
One thing that has been overlooked is: how is memory allocated?
By default, memory allocation is performed using new[] and
delete[]
– What if this is too slow or inappropriate for a particular use of vector?
The actual class definition is:
template < typename T, class Alloc = allocator<T> >
class vector;
Standard Template Library
23
vector<T, Alloc>
An allocator class must have specific member types and functions:
template <class
class Allocator
public:
typedef
typedef
typedef
typedef
typedef
typedef
typedef
typedef
T>
{
T
T *
const T *
T &
const T &
std::size_t
std::ptrdiff_t
propagate_on_container_move_assignment
template <class U>
struct rebind {
typedef Allocator<U> other;
};
value_type;
pointer;
const_pointer;
reference;
const_reference;
size_type;
difference_type;
true_type;
Standard Template Library
24
vector<T, Alloc>
allocator() nothrow;
allocator ( const allocator & ) nothrow;
template <class U>
allocator( const allocator<U> & ) nothrow;
~allocator() throw;
pointer address( reference ) const noexcept;
const_pointer address( const_reference ) const noexcept;
pointer allocate( size_type, allocator<void>::const_pointer = 0 );
void deallocate( pointer, size_type );
size_type max_size() const nothrow;
template <class U, class... Args>
void construct( U* p, Args&&... args );
template <class U>
void destroy ( U* p );
};
Standard Template Library
25
vector<T, Alloc>
Why would you want a different allocator?
– Suppose you want persistent memory allocation—allocation that
continues from one execution of a program to the next
– Intel’s thread building blocks improve the performance of multithreaded
applications by using
std::vector< T, tbb::scalable_allocator<T> >
– Electronic Arts has a STL optimized for gaming software—memory
tends to be more restrictive on gaming platforms
– Tracking allocations and deallocations for debugging or efficiency
– Suppose you want to use memory-mapped files—addresses in memory
that are mapped not to RAM but to virtual memory
From the point of view of portability, all the machinespecific things which relate to the notion of address,
pointer, and so on, are encapsulated within a tiny, wellunderstood mechanism.
Alex Stepanov, designer of the STL
http://stackoverflow.com/questions/826569/compelling-examples-of-custom-c-stl-allocators
Standard Template Library
26
Linked Lists
The Standard Template Library has two variations on a linked list:
template < typename T, class Alloc = allocator<T> >
class list;
template < typename T, class Alloc = allocator<T> >
class forward_list;
Standard Template Library
27
Stacks, Queues, and Deques
The Standard Template Library has all three classes:
template < typename T, class Alloc = allocator<T> >
class deque;
template < typename T, class Container = deque<T> >
class stack;
template < typename T, class Container = deque<T> >
class queue;
Standard Template Library
28
Weakly Ordered Containers
Four containers are based on weak linear orderings:
template < typename Key,
class Compare = less<Key>,
class Alloc = allocator<Key>
> class set;
template < typename Key,
class Compare = less<Key>,
class Alloc = allocator<Key>
> class multiset;
Standard Template Library
29
Weakly Ordered Containers
Four containers are based on weak linear orderings:
template < typename Key,
typename T,
class Compare = less<Key>,
class Alloc = allocator< pair<const Key, T> >
> class map;
template < typename Key,
typename T,
class Compare = less<Key>,
class Alloc = allocator< pair<const Key, T> >
> class multimap;
Standard Template Library
30
Weakly Ordered Containers
What’s the difference?
– A simple container stores objects
– An associative containers stores an object related to a key were
accesses are performed using the key
– A weak ordering is a linear ordering of equivalence classes
•
•
•
•
With linear orderings, either a < b, a = b, or a > b
With weak orderings, either a < b, a ~ b, or a > b
That is, if a is neither less than or greater than b, it is equivalent to b
Example: people compared using their age in years
– The container may store either
• Only a single item per equivalence class, or
• Multiple items per equivalence class
Standard Template Library
31
Weakly Ordered Containers
Which are which?
Items per equivalence class
Simple Container
Associative Container
At most one
set
map
An arbitrary number
multiset
multimap
The class definitions:
– The class definitions for set and multiset are the same
– map and multimap are similar with:
• Two additional member functions for access via the keys
• Arguments for searching are based on keys
• Returns are based on what is being associated with the key
Standard Template Library
32
set<Key>
To make return types more standard, the C++ STL defines specific
member types associated with each class:
set<Key>::key_type
set<Key>::value_type
set<Key>::reference
set<Key>::const_reference
set<Key>::pointer
set<Key>::const_pointer
set<Key>::iterator
set<Key>::const_iterator
set<Key>::reverse_iterator
set<Key>::const_reverse_iterator
set<Key>::size_type
set<Key>::difference_type
Key
Key
Key
Key
Key
Key
&
const &
*
const *
size_t
ptrdiff_t
Standard Template Library
33
Priority Queues
The Standard Template Library has a priority queue classes:
template < typename T,
class Container = vector<T>,
class Compare
= less< typename Container::value_type> >
class priority_queue;
Standard Template Library
34
Hashed Containers
For containers are based on hashing:
template < typename Key,
class Hash = hash<Key>,
class Pred = equal_to<Key>,
class Alloc = allocator<Key>
> class unordered_set;
template < typename Key,
class Hash = hash<Key>,
class Pred = equal_to<Key>,
class Alloc = allocator<Key>
> class unordered_multiset;
Standard Template Library
35
Hashed Containers
For containers are based on hashing:
template < typename Key,
typename T,
class Hash = hash<Key>,
class Pred = equal_to<Key>,
class Alloc = allocator< pair<const Key, T> >
> class unordered_set;
template < typename Key,
typename T,
class Hash = hash<Key>,
class Pred = equal_to<Key>,
class Alloc = allocator< pair<const Key, T> >
> class unordered_multiset;
Standard Template Library
36
unordered_set<Key>
This is a simple container with unordered elements
– Random access is Q(1)
The elements stored are unique
The user can specify the method of allocation
Standard Template Library
37
unordered_set<Key>
To make return types more standard, the C++ STL defines specific
member types associated with each class:
key_type
value_type
hasher
key_equal
reference
const_reference
pointer
const_pointer
iterator
const_iterator
local_iterator
const_local_iterator
allocator_type
size_type
difference_type
Key
Key
hash<Key>
equal_to<Key>
Key &
Key const &
Key *
Key const *
allocate<value_type>
size_t
ptrdiff_t
Standard Template Library
38
unordered_set<Key>
Member functions include:
– Constructors
explicit unordered_set( size_type,
const hasher & = hasher(),
const key_equal & = key_equal(),
const allocator_type & = allocator_type() );
unordered_set( unordered_set const & );
unordered_set( unordered_set && );
template <class InputIterator>
unordered_set( InputIterator first, InputInterator last,
... );
unordered_set( initializer_list<value_type>, ... );
Standard Template Library
39
unordered_set<Key>
Member functions include:
– Assignment operator
unordered_set &operator=( unordered_set const & );
unordered_set &operator=( unordered_set && );
unordered_set &operator=( initializer_list<value_type> );
Standard Template Library
40
unordered_set<Key>
Member functions include:
– The four forward iterators
begin end cbegin cend
– Each has the various signatures:
iterator begin() noexcept;
const_iterator begin() const noexcept;
local_iterator begin( size_type );
const_local_iterator begin( size_type ) const;
Standard Template Library
41
unordered_set<Key>
Member functions include:
– Capacity
size_type size() const noexcept;
size_type maxsize() const noexcept;
bool empty() const noexcept;
Standard Template Library
42
unordered_set<Key>
Member functions include:
– Element lookup
iterator find( const key_type & );
const_iterator find( const key_type & ) const;
size_type count( const key_type & );
pair<iterator,iterator> equal_range( const key_type & );
pair<const_iterator,const_iterator>
equal_range( const key_type & ) const;
Standard Template Library
43
unordered_set<Key>
Member functions include:
– Modifiers
template <class... Args> iterator emplace( Args&&... );
template <class... Args>
iterator emplace_hint( const_iterator, Args&&... );
pair<iterator,bool> insert( reference& );
pair<iterator,bool> insert( value_type && );
pair<iterator,bool> insert( const_iterator, reference& );
pair<iterator,bool> insert( const_iterator, value_type && );
Standard Template Library
44
unordered_set<Key>
Member functions include:
– Modifiers
iterator erase( const_iterator position );
iterator erase( reference );
iterator insert( const_iterator, const_iterator );
void clear() noexcept;
void swap( unordered_set & );
Standard Template Library
45
unordered_set<Key>
Member functions include:
– Allocator
allocator_type get_allocator() const noexcept;
– Non-member function overloads
template < typename T >
void swap( vector<T> &, vector<T> & );
template < typename T >
bool operator==( const vector<T> &, const vector<T> & );
• Includes the relational operators !=, <, <=, >, and >=
• Uses a lexicographical comparison
Standard Template Library
46
Summary
Data Structure
Array
Linked lists
STL Containers
array<T, N>
bitset<N>
vector<T, A>
vector<bool, A>
forward_list<T, A>
list<T, A>
Stacks, etc.
stack<T, D>
queue<T, D>
deque<T, A>
Weakly ordered
set<K, C, A>
multiset<K, C, A>
map<K, T, C, A>
multimap<K, T, C, A>
Priority queue
propority_queue<T, V>
Hash tables
unordered_set<T, H, P, A>
unordered_mulitset<T, H, P, A>
unordered_map<K, T, H, P, A>
unordered_mulitmap<K, T, H, P, A>
Standard Template Library
47
Summary
We have looked at all the containers implemented in the STL
– These cover all data structures looked at in this class
– The most recent additions were singly linked lists and hash tables
Standard Template Library
48
References
Donald E. Knuth, The Art of Computer Programming, Volume 3: Sorting and Searching, 2nd
Ed., Addison Wesley, 1998, §5.4, pp.248-379.
Wikipedia, https://en.wikipedia.org/wiki/Linked_list
http://stackoverflow.com/error?aspxerrorpath=/questions/8848363/rvalue-reference-with-assignement-operator
These slides are provided for the ECE 250 Algorithms and Data Structures course. The
material in it reflects Douglas W. Harder’s best judgment in light of the information available to
him at the time of preparation. Any reliance on these course slides by any party for any other
purpose are the responsibility of such parties. Douglas W. Harder accepts no responsibility for
damages, if any, suffered by any party as a result of decisions made or actions based on these
course slides for any other purpose than that for which it was intended.