13.2 The Standard Template Library (STL)

ECE 250 Algorithms and Data Structures

Douglas Wilhelm Harder, M.Math. LELDepartment of Electrical and Computer EngineeringUniversity of WaterlooWaterloo, Ontario, Canada

ece.uwaterloo.cadwharder@alumni.uwaterloo.ca

© 2006-2013 by Douglas Wilhelm Harder. Some rights reserved.

13.2 The Standard Template Library (STL)

2Standard Template Library

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

3Standard Template Library

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;

4Standard Template Library

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

5Standard Template Library

array<T, N>

To make return types more standard, the C++ STL defines specific member types associated with each class:

array<T, N>::value_type Tarray<T, N>::reference T &array<T, N>::const_referenceT const &array<T, N>::pointerT *array<T, N>::const_pointer T

const *array<T, N>::iteratorarray<T, N>::const_iteratorarray<T, N>::reverse_iteratorarray<T, N>::const_reverse_iteratorarray<T, N>::size_type size_tarray<T, N>::difference_type

ptrdiff_t

6Standard Template Library

array<T, N>

Member functions include:– The eight iterators

begin end rbegin rend cbegin cend crbegin crend

iterator begin() noexcept;const_iterator begin() const noexcept;const_iterator cbegin() const noexcept;

– Capacityconstexpr size_type size() noexcept;constexpr size_type max_size() noexcept;constexpr bool empty() noexcept;

7Standard Template Library

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;

8Standard Template Library

array<T, N>

Member functions include:– Modifiers

void fill( const_reference );void swap( array & ) noexcept( ... );

9Standard Template Library

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;}

10Standard Template Library

bitset<N>

11Standard Template Library

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

12Standard Template Library

vector<T>

To make return types more standard, the C++ STL defines specific member types associated with each class:

vector<T>::value_type Tvector<T>::reference T &vector<T>::const_reference T const &vector<T>::pointer T *vector<T>::const_pointer T const *vector<T>::iteratorvector<T>::const_iteratorvector<T>::reverse_iteratorvector<T>::const_reverse_iteratorvector<T>::allocator_type

allocate<value_type>vector<T>::size_type size_tvector<T>::difference_type ptrdiff_t

13Standard Template Library

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> );

14Standard Template Library

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};

15Standard Template Library

vector<T>

Member functions include:– The eight iterators

begin end rbegin rend cbegin cend crbegin crend

– Each has the various signatures:iterator begin() noexcept;const_iterator begin() const noexcept;const_iterator cbegin() const noexcept;

16Standard Template Library

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();

17Standard Template Library

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;

18Standard Template Library

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();

19Standard Template Library

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> );

20Standard Template Library

vector<T>

Member functions include:– Allocator

allocator_type get_allocator() const noexcept;

– Non-member function overloadstemplate < 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

21Standard Template Library

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

22Standard Template Library

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;

23Standard Template Library

vector<T, Alloc>

An allocator class must have specific member types and functions:

template <class T>class Allocator { public: typedef T value_type; typedef T * pointer; typedef const T * const_pointer; typedef T & reference; typedef const T & const_reference; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef propagate_on_container_move_assignment true_type;

template <class U> struct rebind { typedef Allocator<U> other; };

24Standard Template Library

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 );};

25Standard Template Library

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 usingstd::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

http://stackoverflow.com/questions/826569/compelling-examples-of-custom-c-stl-allocators

From the point of view of portability, all the machine-specific things which relate to the notion of address, pointer, and so on, are encapsulated within a tiny, well-understood mechanism.

Alex Stepanov, designer of the STL

26Standard Template Library

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;

27Standard Template Library

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;

28Standard Template Library

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;

29Standard Template Library

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;

30Standard Template Library

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

31Standard Template Library

Weakly Ordered Containers

Which are which?

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

Items per equivalence class Simple Container Associative ContainerAt most one set mapAn arbitrary number multiset multimap

32Standard Template Library

set<Key>

To make return types more standard, the C++ STL defines specific member types associated with each class:

set<Key>::key_type Keyset<Key>::value_typeKeyset<Key>::reference Key &set<Key>::const_reference Key

const &set<Key>::pointer Key *set<Key>::const_pointer Key

const *set<Key>::iteratorset<Key>::const_iteratorset<Key>::reverse_iteratorset<Key>::const_reverse_iteratorset<Key>::size_type size_tset<Key>::difference_type

ptrdiff_t

33Standard Template Library

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;

34Standard Template Library

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;

35Standard Template Library

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;

36Standard Template Library

unordered_set<Key>

This is a simple container with unordered elements– Random access is Q(1)

The elements stored are uniqueThe user can specify the method of allocation

37Standard Template Library

unordered_set<Key>

To make return types more standard, the C++ STL defines specific member types associated with each class:

key_type Keyvalue_type Keyhasher hash<Key>key_equal equal_to<Key>reference Key &const_reference Key const &pointer Key *const_pointer Key const *iteratorconst_iteratorlocal_iteratorconst_local_iteratorallocator_type

allocate<value_type>size_type size_tdifference_type ptrdiff_t

38Standard Template Library

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>, ... );

39Standard Template Library

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> );

40Standard Template Library

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;

41Standard Template Library

unordered_set<Key>

Member functions include:– Capacity

size_type size() const noexcept;size_type maxsize() const noexcept;bool empty() const noexcept;

42Standard Template Library

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;

43Standard Template Library

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 && );

44Standard Template Library

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 & );

45Standard Template Library

unordered_set<Key>

Member functions include:– Allocator

allocator_type get_allocator() const noexcept;

– Non-member function overloadstemplate < 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

46Standard Template Library

Summary

Data Structure STL ContainersArray array<T, N> bitset<N>

vector<T, A> vector<bool, A>Linked lists 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>

47Standard Template Library

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

48Standard Template Library

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.