slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
13.2 The Standard Template Library (STL) PowerPoint Presentation
Download Presentation
13.2 The Standard Template Library (STL)

Loading in 2 Seconds...

play fullscreen
1 / 48

13.2 The Standard Template Library (STL) - PowerPoint PPT Presentation


  • 97 Views
  • Uploaded on

13.2 The Standard Template Library (STL). 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

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about '13.2 The Standard Template Library (STL)' - reba


Download Now An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
outline
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
arrays
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;

array t n
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

array t n1
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 T

array<T, N>::reference T &

array<T, N>::const_reference T const &

array<T, N>::pointer T *

array<T, N>::const_pointer T const *

array<T, N>::iterator

array<T, N>::const_iterator

array<T, N>::reverse_iterator

array<T, N>::const_reverse_iterator

array<T, N>::size_typesize_t

array<T, N>::difference_typeptrdiff_t

array t n2
array<T, N>

Member functions include:

  • The eight iterators

begin end rbegin rend cbegincendcrbegincrend

iteratorbegin() noexcept;

const_iteratorbegin() const noexcept;

const_iteratorcbegin() const noexcept;

  • Capacity

constexprsize_typesize() noexcept;

constexprsize_typemax_size()noexcept;

constexprboolempty() noexcept;

array t n3
array<T, N>

Member functions include:

  • Element access

reference operator[](size_type);

const_referenceoperator[]( size_type) const;

reference at(size_type);

const_reference at ( size_type ) const;

reference front();

const_reference front() const;

reference back();

const_referenceback() const;

pointer data() noexcept;

const_pointerdata() const noexcept;

array t n4
array<T, N>

Member functions include:

  • Modifiers

void fill(const_reference);

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

array t n5
array<T, N>

Example:

#include <array>

int main() {

std::array<int, 5> v;

for ( inti = 0; i < 5; ++i ) {

v[i] = i;

}

for ( autoitr = v.begin(); itr != v.end(); ++itr ) {

*itr = (*itr)^2;

}

v.fill( 7 );

int *ptr = v.data();

return 0;

}

vector t
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

vector t1
vector<T>

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

vector<T>::value_type T

vector<T>::reference T &

vector<T>::const_reference T const &

vector<T>::pointer T *

vector<T>::const_pointer T const *

vector<T>::iterator

vector<T>::const_iterator

vector<T>::reverse_iterator

vector<T>::const_reverse_iterator

vector<T>::allocator_type allocate<value_type>

vector<T>::size_typesize_t

vector<T>::difference_typeptrdiff_t

vector t2
vector<T>

Member functions include:

  • Constructors

explicit vector();

explicit vector(size_type);

vector(size_type, const_reference);

template < class InputIterator>

vector( InputIteratorfirst, InputIteratorlast );

vector( vector const & );

vector( vector && );

vector(initializer_list<value_type> );

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

vector t4
vector<T>

Member functions include:

  • The eight iterators

begin end rbegin rend cbegincendcrbegincrend

  • Each has the various signatures:

iteratorbegin() noexcept;

const_iteratorbegin() const noexcept;

const_iteratorcbegin() const noexcept;

vector t5
vector<T>

Member functions include:

  • Capacity

size_typesize() const noexcept;

size_typecapacity() const noexcept;

size_typemaxsize() const noexcept;

void resize( size_type);

void resize( size_type, const_reference);

boolempty() const noexcept;

boolempty() const noexcept;

void reserve( size_type);

void shrink_to_fit();

vector t6
vector<T>

Member functions include:

  • Element access

reference operator[](size_type);

const_referenceoperator[]( size_type) const;

reference at(size_type);

const_reference at ( size_type ) const;

reference front();

const_reference front() const;

reference back();

const_referenceback() const;

pointer data() noexcept;

const_pointerdata() const noexcept;

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

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

vector t9
vector<T>

Member functions include:

  • Allocator

allocator_typeget_allocator() const noexcept;

  • Non-member function overloads

template < typename T >

void swap( vector<T> &, vector<T> & );

template < typename T >

booloperator==( const vector<T> &, const vector<T> & );

    • Includes the relational operators !=, <, <=, >, and >=
    • Uses a lexicographical comparison
vector bool
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
vector t alloc
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;

vector t alloc1
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_tsize_type;

typedef std::ptrdiff_tdifference_type;

typedefpropagate_on_container_move_assignmenttrue_type;

template <class U>

struct rebind {

typedef Allocator<U> other;

};

vector t alloc2
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_typemax_size() const nothrow;

template <class U, class... Args>

void construct( U* p, Args&&... args );

template <class U>

voiddestroy ( U* p );

};

vector t alloc3
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 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

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

linked lists
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;

stacks queues and deques
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;

weakly ordered containers
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;

weakly ordered containers1
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;

weakly ordered containers2
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
weakly ordered containers3
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
set key
set<Key>

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

set<Key>::key_typeKey

set<Key>::value_typeKey

set<Key>::reference Key&

set<Key>::const_referenceKeyconst &

set<Key>::pointer Key*

set<Key>::const_pointerKeyconst *

set<Key>::iterator

set<Key>::const_iterator

set<Key>::reverse_iterator

set<Key>::const_reverse_iterator

set<Key>::size_typesize_t

set<Key>::difference_typeptrdiff_t

priority queues
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;

hashed containers
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;

hashed containers1
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;

unordered set key
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

unordered set key1
unordered_set<Key>

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

key_typeKeyvalue_type Key hasher hash<Key>key_equalequal_to<Key> referenceKey &const_referenceKey const&pointer Key *const_pointer Key const* iteratorconst_iteratorlocal_iteratorconst_local_iteratorallocator_type allocate<value_type>size_typesize_tdifference_typeptrdiff_t

unordered set key2
unordered_set<Key>

Member functions include:

  • Constructors

explicit unordered_set(size_type,const hasher & = hasher(),constkey_equal & = key_equal(),constallocator_type & = allocator_type() );unordered_set(unordered_setconst& );unordered_set(unordered_set && );template <class InputIterator>unordered_set(InputIterator first, InputInterator last,...);unordered_set(initializer_list<value_type>, ...);

unordered set key3
unordered_set<Key>

Member functions include:

  • Assignment operator

unordered_set &operator=(unordered_setconst& );

unordered_set &operator=(unordered_set&& );

unordered_set&operator=(initializer_list<value_type> );

unordered set key4
unordered_set<Key>

Member functions include:

  • The four forward iterators

begin end cbegincend

  • Each has the various signatures:

iteratorbegin() noexcept;const_iteratorbegin() const noexcept;local_iteratorbegin(size_type);const_local_iteratorbegin(size_type) const;

unordered set key5
unordered_set<Key>

Member functions include:

  • Capacity

size_typesize() const noexcept;

size_typemaxsize() const noexcept;

boolempty() const noexcept;

unordered set key6
unordered_set<Key>

Member functions include:

  • Element lookup

iteratorfind(constkey_type & );

const_iteratorfind( constkey_type& )const;

size_typecount(constkey_type & );

pair<iterator,iterator> equal_range( constkey_type & );

pair<const_iterator,const_iterator>

equal_range( constkey_type & )const;

unordered set key7
unordered_set<Key>

Member functions include:

  • Modifiers

template <class... Args> iterator emplace( Args&&... );

template <class... Args> iteratoremplace_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&& );

unordered set key8
unordered_set<Key>

Member functions include:

  • Modifiers

iterator erase(const_iteratorposition );

iterator erase( reference );

iterator insert( const_iterator, const_iterator );

void clear()noexcept;

void swap(unordered_set & );

unordered set key9
unordered_set<Key>

Member functions include:

  • Allocator

allocator_typeget_allocator() const noexcept;

  • Non-member function overloads

template < typename T >

void swap( vector<T> &, vector<T> & );

template < typename T >

booloperator==( const vector<T> &, const vector<T> & );

    • Includes the relational operators !=, <, <=, >, and >=
    • Uses a lexicographical comparison
summary1
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
references
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.