1 / 10

Basic C++ Sequential Container Features

Basic C++ Sequential Container Features. Contain elements of a parameterized type Ordered (non-overlapping) ranges of elements A location can ’ t be within more than one container Adding and copying elements is by value A container owns the elements in it

tcoombs
Download Presentation

Basic C++ Sequential Container Features

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. Basic C++ Sequential Container Features • Contain elements of a parameterized type • Ordered (non-overlapping) ranges of elements • A location can’t be within more than one container • Adding and copying elements is by value • A container owns the elements in it • Container’s destructor destroys what it contains • Provide interfaces to contained values • Functions to add/remove values, e.g., push_back • May provide other container-specific operations, e.g. some have operator[] for random access • Obeys “principle of least surprise” (no []for list)

  2. Containers Provide Their Own Iterators • Containers declare various associated iterator types • // try to use const_iterators whenever you can • vector<int>::iterator i; // iterator over non-const • vector<int>::const_iterator ci; // iterator over const • They also give iterator accessor/factory methods for beginning of and just past the end of container range • // v is previously declared as vector<int> v; • auto ci = v.cbegin(); // use a const_iterator • while (ci != v.cend()) { // compare to const_iterator • cout << *ci << endl; // does not modify v • ++ci; • }

  3. More About Container Iterators • Iterators generalize different uses of pointers • Most importantly, define left-inclusive intervals over the ranges of elements in a container [begin, end) • Interface between algorithms and data structures • Algorithm manipulates iterators, not containers • An iterator’s value can represent 3 kinds of states: • dereferencable (points to a valid location in a range) • past the end (points just past last valid location in a range) • singular (points to nothing) • What’s an example of a pointer in each of these states? • Can construct, compare, copy, and assign iterators so that native and library types can inter-operate

  4. Properties of Iterator Intervals • valid intervals can be traversed safely with an iterator • An empty range [p,p) is valid • If [first, last) is valid and non-empty, then [first+1, last) is also valid • Proof: iterative induction on the interval • If[first, last) is valid • and position mid is reachable fromfirst • and last is reachable from mid • then [first, mid) and [mid, last) are also valid • If [first, mid) and [mid, last) are valid, then [first, last) is valid • Proof: divide and conquer induction on the interval

  5. The forward_list Container • Implements a singly linked list of elements • Elements not have to be contiguous in memory • No random access, can only iterate forward • Can only grow at front of forward_list • Insertion at front is constant time, but many other operations are linear in number of elements • Insertion into the middle of the list is constant time, but finding a position within the list is linear time

  6. The vector Container • Implements a dynamically sized array of elements • Elements are (almost certainly) contiguous in memory • Random access and can iterate forward or backward • Can only grow at back of vector (reallocates as needed) • Many operations are constant time, such as whether or not the container is empty, how many elements it currently holds, etc. • Pushing at the back is “amortized” constant time (occasional reallocations averaged over all pushes)

  7. The list Container • Implements a doubly linked list of elements • Elements do not have to be contiguous in memory • No random access, but can iterate forward or backward • Can grow at front or back of list

  8. The deque Container • Implements a double-ended queue of elements • Elements do not have to be contiguous in memory • But must be accessible in constant time (random access) • Still can iterate forward or backward • Still can grow at front or back of deque

  9. Rules of Thumb for Sequential Containers • Use a vector most of the time (if you can) • Often balances simplicity, efficiency, flexibility well • But, use a list (or maybe a forward_list) instead if you need to insert in the middle of a container • Or use a deque to insert at both ends • Watch out for when iterators may be invalidated • Use specialized containers only when needed • E.g., an array if you need a fixed sized container • E.g., a string if you’re only working with characters • E.g., a stack or queue container adapter if you want to restrict the container interface that can be used

  10. An Advanced Topic: Emplacement • Insertion may involve extra overhead for copying • vector<string> courses; • courses.push_back (“cse332”); // 2 constructor calls • If the compiler and STL library you are using supports emplacement, it may be more efficient (if that matters) • vector<string> courses; • courses.emplace_back (“cse332”); // 1 constructor call • // due to forwarding

More Related