1. Containers Overview and Class Vector
Container Types
Sequence Containers
Associative Containers
Adapter Classes
Stack Container
Queue Container
Priority Queue Container
Set Container
Map Container
C++ Arrays
Vectors
Templated Insertion Sort
Template Classes
Store Class

2. C++ STL provides 10 container classes
4 additional types considered “near-containers”
array
string
bitset
valarray
Extensions to Standard
slist
rope – huge strings
unordered_set, unordered_map, unordered_multiset, unordered_multimap

3. Container Categories
Sequence Containers
Adapter Containers
Associative Containers
Vector
Stack
Set, Multiset
Deque
Queue
Map, Multimap
List
Priority Queue

4. Sequence Containers
A sequence container stores data by position in linear order 1st element, 2nd element, and so forth

5. Associative Containers
Associative containers store elements by key
Ex: name, SS #, or part number
A program accesses an element in an associative container by its key
May bear no relationship to the location of the element in the container
Access by key O(lg N)
Implementation?

6. Use a sequence container as underlying storage structure
Adapter Classes
Use a sequence container as underlying storage structure
E.g. Stack and Queue use Deque
Design Pattern: Adapter
Adapter’s interface provides a restricted set of operations from underlying storage structure
How is stack restricted?
queue?

7. A stack allows access at only one end of sequence, called the top.
Stack Containers
A stack allows access at only one end of sequence, called the top. C A
top
Push A B
Push B
Push
(a)
Pop
(b)

8. A queue is a container that allows access only at front and back
Queue Containers
A queue is a container that allows access only at front and back A B C D E
back
front
Insert
Delete

9. Priority Queue Containers
priority queue -- HPFO
Push elements in any order -- pop operation removes the largest (or smallest) value

10. A set is a collection of unique values, called keys or set members.
Set Containers
A set is a collection of unique values, called keys or set members.

11. A map is a storage structure that implements a key-value relationship.
Map Containers
A map is a storage structure that implements a key-value relationship.

12. C++ Arrays
Fixed-size collection – homogenous
Stores the n (size) elements in contiguous block

13. Evaluating an Array as a Container
Size is fixed at the time of its declaration
Does an array know its size?
C++ arrays do not allow the assignment of one array to another
Requires loop structure with the array size as an upper bound
*or* what algorithm?

14. Vectors

15. Create an empty vector. Default.
CLASS vector
Constructors
<vector>
vector ();
Create an empty vector. Default.
vector (size_type n, const T& value = T ());
Create a vector with n elements equal to “value”. If the value argument is omitted, the elements are filled with the default value for type T. Type T must have a default constructor, and the default value of type T is specified by the notation T ().

16. vector (InputIter first, InputIter last);
CLASS vector
Constructors
<vector>
vector (InputIter first, InputIter last);
Initialize the vector using the range [first, last) first and last are input iterators (can be read).

17. Return the value of the item at the rear of the vector.
CLASS vector
Operations
<vector>
T& back ();
Return the value of the item at the rear of the vector.
Precondition: The vector must contain at least one element.
const T& back () const;
Constant version of back().
bool empty () const;
Return true if the vector is empty and false otherwise.

18. T& operator[ ] (size_type i);
CLASS vector
Operations
<vector>
T& operator[ ] (size_type i);
Allow the vector element at index i to be retrieved or modified.
Precondition: The index, i, must be in the range  i < n, where n is the number of elements in the vector.
Postcondition: If the operator appears on the left side of an assignment statement, the expression on the right side modifies the element referenced by the index.
const T& operator[ ] (size_type i) const;
Constant version of the index operator.

19. void push_back (const T& value);
CLASS vector
Operations
<vector>
void push_back (const T& value);
Add a value at the rear of the vector.
Postcondition: The vector has a new element at the rear and its size increases by 1.
void pop_back ();
Remove the item at the rear of the vector.
Precondition: The vector is not empty.
Postcondition: The vector has a new element at the rear or is empty.

20. iterator erase (iterator pos); Erase the element pointed to by pos.
CLASS vector
Operations
<vector>
iterator erase (iterator pos);
Erase the element pointed to by pos.
Precondition: The vector is not empty.
Postcondition: The vector has one fewer element.
iterator erase (iterator first, iterator last);
Erase all elements within the iterator range [first, last).
Postcondition: The size decreases by the number of elements in the range.
Both invalidate iterators beyond range erased.

21. iterator insert (iterator pos, const T& value);
CLASS vector
Operations
<vector>
iterator insert (iterator pos, const T& value);
Insert value before pos, and return an iterator pointing to the position of the new value in the vector. The operation invalidates any existing iterators beyond pos.
Postcondition: The list has a new element.

22. void resize (size_type n, const T& fill = T());
CLASS vector
Operations
<vector>
void resize (size_type n, const T& fill = T());
Modify the size of the vector. If the size is increased, the value fill is added to the elements on the tail of the vector. If the size is decreased, the original values at the front are retained.
Postcondition: The vector has size n.
void reserve (size_type n);
Only will increase capacity.
Postcondition: capacity () >= n
size_type size () const;
Return the number of elements in the vector.

23. writeVector (const vector<T>& v) { size_t i, n = v.size ();
Output with Vectors
template <typename T>
void
writeVector (const vector<T>& v) {
// capture the size of the vector in n
size_t i, n = v.size ();
for (i = 0; i < n; ++i)
cout << v[i] << " ";
cout << endl; }

24. Declaring Vector Objects
// vector of size 5 containing the integer // value 2
vector<int> intVector (5, 2);
// vector of size 10; each element // contains the empty string
vector<string> strVector (10);

25. Adding and Removing Vector Elements12 -5 8 14
Before
v.size
() == 4 4 3 2 1
() == 5
After
v.push_back (10) 10
4.6
6.8
Before
v.size
() == 2 1
() == 1
After
v.pop_back ()

26. vector<int> v (arr, arr + 5); v.resize (10);// size is doubled
Resizing a Vector
int arr[5] = {7, 4, 9, 3, 1};
vector<int> v (arr, arr + 5);
// v initially has 5 integers
v.resize (10);// size is doubled
v.resize (4); // vector contracted; data // is lost

27. Can use with vector’s or arrays Count comparisons Best-case run time?
Insertion Sort
Can use with vector’s or arrays
Count comparisons
Best-case run time?
T(N) = N - 1 = O(N)
Worst-case?

28. Insertion Sort Algorithm
// sort a vector of type T using insertion // sort
template <typename T>
void insertionSort (vector<T>& v) {
// Place v[i] into the sublist v[0] ... // v[i-1], 1 <= i < n, so it is in the // correct position
size_t n = v.size ();

29. Insertion Sort Algorithm
for (size_t i = 1; i < n; ++i)
{ // Index j scans down list from v[i] // looking for correct position to // locate target. Assigns it to v[j]
size_t j = i;
T temp = v[i];
// Locate insertion point by scanning // downward as long as temp < v[j-1] // and we have not encountered the // beginning of the list

30. Insertion Sort Algorithm
while (j > 0 && temp < v[j-1]) {
// Shift elements up list to make // room for insertion
v[j] = v[j-1];
--j; }
// Location is found; insert temp
v[j] = temp;

31. Class Templates
Can templatize classes as well as functions
All container classes in STL are templates
Syntax
template <typename T1,
typename T2, … >
class ClassName
{ … }
Concrete Store <T> template example

32. Class Template Store
template <typename T>
class Store {
public:
// Ctor: init w/item or default T
Store (const T& item = T())
: m_value (item)
{ }
  T getValue () const {
return m_value; }

33. Class Template Store (Cont’d)
void setValue (const T& item) {
m_value = item; }
private:
T m_value; };
Use:
Store<double> s;
s.setValue (4.3);