Generic Programming

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 dont 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.informa
  tik.hs-bremen.de/brey/stlbe.html
• Complete STL documentation - http//www.sgi.com/te
  ch/stl/
• D R Musser - http//www.cs.rpi.edu/musser/gp/inde
  x.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. vectorltintgtiterator 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-typeconst iterator
• container-typeiterator
• Where container-type is the container type, such
  as vectorltintgt
• 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