1. Generic Programming Using the C++ Standard Template Library

2. Traditional programming approach Data Structures + Algorithms = Programs Quote from the renowned computer scientist Niklaus Wirth

3. Generic approach Design algorithms to deal with abstractions of data structures rather than specific data structures Fit the abstractions onto each of the real data structures used in programs and the same algorithm should work with all the data structures

4. Abstract Data Structures What operations are common to many data structures? What operations are useful to support many different algorithms? Think about data structures that don’t rely on specifics.

5. Abstraction of a Sequence Fundamental operations on a sequence – Generate a sequence – Access each item in the sequence in turn. Other useful operations – Search the sequence for a particular item – Sort the items in the sequence – Etc.

6. The Standard Template Library The STL provides programmers with a library of common data structures and a set of fundamental algorithms that operate on them STL is based around – Containers classes providing abstract data structures – Iterators traverse the containers – Algorithms process the information in the containers Additional components for flexibility and portability: – Function objects encapsulate a function as an object – Adaptors provide an existing component with a different interface – Allocators encapsulate the memory model of the machine

7. STL The C++ Standard Template Library (STL) is now a part of the Standard Libraries. It is a newer part, so it is often still referred to it as if it is a different thing. References – Free pdf of “Designing Components with the C++ STL” by Ulrich Breymann from – http://www.informatik.hs-bremen.de/~brey/stlbe.html – Complete STL documentation - http://www.sgi.com/tech/stl/http://www.sgi.com/tech/stl/ – D R Musser - http://www.cs.rpi.edu/~musser/gp/index.htmhttp://www.cs.rpi.edu/~musser/gp/index.htm

8. Containers Data structures that manage a collection of elements and are responsible for the allocation and deallocation of those elements. Typically have constructors and destructors along with operations for inserting and deleting elements. Two types: – Sequence Containers, e.g., vectors, lists, priority queues – Associative Containers, e.g., maps, sets

9. Iterators Iterators are like generic pointers. They save algorithm writers the worry of having to deal with the internals of containers. They come in various types: – Random access, Bidirectional, Forward, Reverse, Input and Output. Some containers support only certain iterator types (you can't for example randomly access a list). Often use iterators with begin and end operations on containers e.g. vector ::iterator vi = v.begin() iterator vi placed at beginning of int vector v

10. Algorithms Operate on containers. They fall into 6 groups – Search algorithms - search(), count_if(), etc. – Sorting algorithms - sort(), merge(), etc. – Deletion algorithms - remove(), unique(), etc. – Numeric algorithms - partial_sum(), inner_product(), etc. – Generation algorithms - generate(), for_each(), etc. – Relational algorithms - equal(), min(), etc. Algorithms usually take as their first 2 arguments iterators to mark the range of elements to be operated on. For example, to replace 'A' by 'B' in a string str one could do :- replace(str.begin(), str.end(), 'A', 'B');

11. Common operations on containers push_back – appends an item at the end of a containing pop_back – deletes the last item from the end of a container front and back access the first and last items in a container size is the number of items in the container

12. Vector Behaves like an array, but can grow itself as necessary. Can be accessed using [ ] like an array Can be accessed using iterators as for all containers Good for sequential or random access, poor for insertion and deletion anywhere other than the end. capacity is the total number of items that the container can hold without requiring reallocation. See example stlvect1.cpp

13. Lists Insert and remove from list using push_back and pop_back as for vectors Also push_front and pop_front which operate on the front of the list container. remove(x) – removes all the x items from the list Good for insertion and deletion of items in a list, but can only access sequentially.

14. Maps & Sets Maps are associative containers Map entries are pair of values – key, value map – keys must be unique multimap – duplicate keys allowed set – collection of unique keys multiset – as set but duplicates allowed

15. Iterators Iterators are the glue that connect algorithms to containers Iterators provide access to the containers. Similar to a pointer accessing an array Used to traverse across the containers Iterators can be – incremented – dereferenced using ‘*’ to access the item in the container

16. Iterator Types Every standard container defines two associated iterator types: – container-type:: const iterator – container-type:: iterator Where container-type is the container type, such as vector We use the iterator type if we want to change the values stored in the container We use the const iterator type if we just need read access

17. Algorithms Non-Mutating Sequence Operations – Algorithms like count and search which do not modify the iterator or its associated container. Mutating Sequence Operations – Algorithms like copy, reverse, or swap which may modify a container or its iterator. Searching and Sorting – Sorting, searching, and merging algorithms, such as stable sort, binary search, and merge. Set Operations – Mathematical set operations, such as set union and set intersection. These algorithms only work on sorted containers