Generic Programming in the STL and Beyond David R. Musser Rensselaer Polytechnic Institute

Generic programming starts with algorithms

Lift Minimal requirements: works with maximal family of types Concrete algorithm: requires specific data type Less specialized: works with more than one type A 0 A 1 Lift A m Remove an unneeded requirement on the type Generic algorithm... Start here

Maximal with respect to what?

Lift Maintain usefulness of the algorithm – make efficiency part of the requirements Concrete algorithm A 0 A 1 Lift A m Generic algorithm...

float max_element(float a[], int N) { if (N == 0) throw MaxElementEmptyArrayError; int first = 0; float max = a[0]; while (++first < N) if (max < a[first]) max = a[first]; return max; }

int max_element(float a[], int first, int last) { if (first == last) return first; int result = first; while (++first != last) if (a[result] < a[first]) result = first; return result; }

float_list_node* max_element(float_list_node* first, float_list_node* last) { if (first == last) return first; float_list_node* result = first; while (first->next != last) if (result->data data) result = first; return result; }

int max_element(float a[], int first, int last) { if (first == last) return first; int result = first; while (++first != last) if (a[result] < a[first]) result = first; return result; }

template int max_element(E a[], int first, int last) { if (first == last) return first; int result = first; while (++first != last) if (a[result] < a[first]) result = first; return result; }

template T* max_element(T* first, T* last) { if (first == last) return first; T* result = first; while (++first != last) if (*result < *first) result = first; return result; }

template ForwardIterator max_element(ForwardIterator first, ForwardIterator last) { if (first == last) return first; ForwardIterator result = first; while (++first != last) if (*result < *first) result = first; return result; }

int a[] = {6, 3, 7, 5}; int* ai = max_element(a, a+4); vector v(a, a+4); vector ::iterator vi = max_element(v.begin(), v.end()); list x(a, a+4); list ::iterator li = max_element(x.begin(), x.end());...

Forward Container Concept max_element Generic algorithm on jk jk k = ++j *j = 3 *k = 7 ++i *i i==j

What is a concept?

Concept IntensionExtension Requirement 1 Requirement 2. Requirement N Abstraction 1 Abstraction 2. Abstraction K.

Polygon Concept IntensionExtension Closed plane figure N sides...

Container Concept IntensionExtension Must be a type whose objects can store other objects (elements) Must have an associated iterator type that can be used to iterate through the elements.... vector, for any T deque for any T list for any T slist for any T set for any T map for any T self_adjusting_bag

A Algorithm A works with every type T in concept C Definition: an algorithm is generic if it works with every type in a concept “works”: is correct and efficient C T … …

What does it mean to refine a concept?

Requirement 1 Requirement 2... Requirement N refine Requirement 1 Requirement 2... Requirement N Requirement N+1 Abstraction 1 Abstraction 2... Abstraction K... Abstraction 1 Abstraction 3... Abstraction 2... Abstraction K... More Requirements, Fewer Abstractions

Polygon Concept Closed plane figure N sides refine Closed plane figure N sides N = 3 Triangle Concept...

Requirement 1 Requirement 2... Requirement N refine Requirement 1 Requirement 2... Requirement N Requirement N+1 Abstraction 1 Abstraction 2... Abstraction K... Abstraction 1 Abstraction 3... Abstractions that remain are ones that are more specialized.

Polygon Concept Closed plane figure N sides refine Closed plane figure N sides Equal side lengths Equilateral Polygon Concept...

Container Concept refine Forward Container Concept Reversible Container Concept Random Access Container Concept

Forward Container Concept IntensionExtension Container Intension Elements must be arranged in a definite order Iterator type must model Forward Iterator concept... vector for any T deque for any T list for any T slist for any T set for any T map for any T self_adjusting_bag

Reversible Container Concept IntensionExtension Forward Container Intension Must have an associated reverse iterator type Iterator and reverse iterator types must model Bidirectional Iterator concept... vector for any T deque for any T list for any T set for any T map for any T slist for any T

Random Access Container Concept IntensionExtension Reversible Container Intension Iterator types must model Random Access Iterator concept... vector for any T deque for any T list for any T set for any T map for any T

A more refined concept permits better algorithms

refine A Algorithm B can be more efficient than A (B doesn’t have to work with as many types as A) B C D

For any Polygon P Circumference(P) = sum = 0; for s in sides(P) sum += length(s) For any Equilateral Polygon P Circumference(P) = N * side_length(P)

Container refine Forward Container Reversible Container Random Access Container enables generic algorithms copy, equal, transform, … enables find, merge, fill, replace, remove, unique, rotate, max_element, … enables reverse, partition, rotate, inplace_merge, … enables sort, binary_search, rotate random_shuffle, … Requires Input Iterators Forward Iterators Bidirectional Iterators Random Access Iterators

Container refine Forward Container Reversible Container Random Access Container enables generic algorithms copy, equal, transform, … enables find, merge, fill, replace, remove, unique, rotate, max_element, … enables reverse, partition, rotate, inplace_merge, … enables sort, binary_search, rotate, random_shuffle, … Requires Input Iterators Forward Iterators Bidirectional Iterators Random Access Iterators

Container Forward Container Reversible Container Random Access Container Sequence Front Insertion Sequence Back Insertion Sequence Vector Deque Slist List …

Concept C IntensionExtension A models C  A is in Extension of C A  A satisfies Intension of C (A makes R, …, R true) R, …, R N1 1N...

Output Iterator Forward Iterator Bidirectional Iterator Random Access Iterator Vector iterator Input Iterator Deque iterator Slist iterator List iterator Istream iterator Ostream iterator

template ForwardIterator max_element(ForwardIterator first, ForwardIterator last) { if (first == last) return first; ForwardIterator result = first; while (++first != last) if (*result < *first) result = first; return result; }

template Iterator max_element(Iterator first, Iterator last) { if (first == last) return first; Iterator result = first; while (++first != last) if (*result < *first) result = first; return result; }

int a[] = {6, 3, 7, 5}; int* ai = max_element(a, a+4); vector v(a, a+4); vector ::iterator vi = max_element(v.begin(), v.end()); list x(a, a+4); list ::iterator li = max_element(x.begin(), x.end());

int a[] = {6, 3, 7, 5}; assert int* models Forward Iterator; int* ai = max_element(a, a+4); vector v(a, a+4); assert vector ::iterator models Forward Iterator; vector ::iterator vi = max_element(v.begin(), v.end()); list x(a, a+4); assert list ::iterator models Forward Iterator; list ::iterator li = max_element(x.begin(), x.end());

template Assume that T satisfies Intension of C when checking uses of T in the algorithm. We need to use both the syntactic and the semantic properties listed in the intension. assert T models C; Check that T satisfies Intension of C. Should check that both the syntactic and the semantic requirements are satisfied.

What’s this about semantic requirements?

template ForwardIterator max_element(ForwardIterator first, ForwardIterator last) { if (first == last) return first; ForwardIterator result = first; while (++first != last) if (*result < *first) result = first; return result; }

template ForwardIterator max_element(ForwardIterator first, ForwardIterator last, StrictWeakOrder compare){ if (first == last) return first; ForwardIterator result = first; while (++first != last) if (compare(*result,*first)) result = first; return result; }

Strict Weak Order: assumed in all STL sorting-related algorithms

<:T  T  bool Transitive[E/<] E(x,y)  not(x<y) & not(y<x) Binary Relation for all x: not(x < x) Irreflexive for all x, y, z: x < y & y < z implies x < z Transitive Strict Partial Order Strict Weak Order Functor

Irreflexive Transitive Transitive[E/<] E(x,y)  not(x<y) & not(y<x) Strict Weak Order for all x, y: x < y | y < x | x = y Trichotomy Total Order Sufficient for all STL sorting-related generic algorithms Not needed!

vector v; // Put some elements in v: // Sort v into descending order: sort(v.begin(), v.end(), greater_equal ()); // Why doesn’t the above call // terminate?

vector v; // Put some elements in v: // Sort v into descending order: sort(v.begin(), v.end(), greater ()); // Now we get here - that’s better!

vector v; // Put some elements in v:... // Sort v into descending order: assert greater models Strict Weak Order; sort(v.begin(), v.end(), greater ());

ContainerIteratorAlgorithmFunctorAdaptorAllocator STL Concepts

ContainerIteratorAlgorithmFunctorAdaptorAllocator Boost Graph Library Concepts Graph Visitor BFS Visitor DFS Visitor Uniform Cost Visitor See

Graph Algorithm Graph Algorithm + Visitor = More Specialized Algorithm Visitor BFS Visitor DFS Visitor Uniform Cost Visitor Algorithm DFS + topological_sort_visitor = Topological Sort + cycle_detection_visitor = Cycle Detector

Let’s summarize

Lift Concrete algorithms A 0 A 1 Lift A m Generic algorithms. Concept Taxonomy Useful Data and Algorithm Abstractions – a Generic Library C requires... template <typename T models C>... assert T models C Making Concepts First Class Constructs... for formal checking of syntactic and semantic properties and using them in software engineering Algorithms, Concepts & Challenges