1 / 48

13.2 The Standard Template Library (STL)

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

reba
Télécharger la présentation

13.2 The Standard Template Library (STL)

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. Content is provided to you AS IS for your information and personal use only. Download presentation by click this link. While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server. During download, if you can't get a presentation, the file might be deleted by the publisher.

E N D

Presentation Transcript

  1. 13.2 The Standard Template Library (STL)

  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

  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;

  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

  5. 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

  6. 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;

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

  8. array<T, N> Member functions include: • Modifiers void fill(const_reference); void swap( array & )noexcept( ... );

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

  10. bitset<N>

  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

  12. 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

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

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

  15. 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;

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

  17. 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;

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

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

  20. 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

  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

  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;

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

  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_typemax_size() const nothrow; template <class U, class... Args> void construct( U* p, Args&&... args ); template <class U> voiddestroy ( U* p ); };

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

  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;

  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;

  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;

  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;

  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

  31. 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

  32. 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

  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;

  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;

  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;

  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

  37. 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

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

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

  40. 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;

  41. unordered_set<Key> Member functions include: • Capacity size_typesize() const noexcept; size_typemaxsize() const noexcept; boolempty() const noexcept;

  42. 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;

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

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

  45. 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

  46. Summary

  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

  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.

More Related