1 / 17

Generic Programming

Generic Programming. Using the C++ Standard Template Library. Traditional programming approach. Data Structures + Algorithms = Programs Quote from the renowned computer scientist Niklaus Wirth. Generic approach.

darren
Download Presentation

Generic Programming

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. 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/ • D R Musser - http://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<int>::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<int> • 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

More Related