1

STL – Standard Template Library

•Standard – Guaranteed to be available on all compilers

implement the Standard•Template library

– All components are templates, can be used for arbitrary element types.

2

STL Entities•Entities:

– Container classes•Sequence containers•Associative ordered containers

– Iterators– Generic algorithms– Function objects (functors)– Other (not covered here)

•Allocators•Adaptors

3

Old Structure

Queue

List

Stack

hashalgorithm

Algorithm

algorithm

algorithm

4

New Structure with STL

AlgorithmQueue

List Stackhash

The iterator is a bridge between Container and Algorithm

Iterator

5

Concepts• A concept is a set of abstractions

– Defined by a set of requirements

• Example: a container concept– {vector<T>, list<T>,set<K>, map<K,T>, … }

• generic algorithms : algorithms that work correctly and efficiently for every abstraction in a concept

Definition: Container refines Basic-container;uses Input-iterator;introduces begin(containers) -> iterators, end(containers) -> iterators, size(containers) -> naturals, empty(containers) -> bool;requires (for c: containers) size(c) = size(range(c, begin(c), end(c))), empty(c) = (size(c) = 0), valid(range(c, begin(c), end(c))).

6

Container• A template, parameterized on element type• Represents a group of homogeneous objects• Two main types:

– Sequence containers : vector, deque, list– Associative containers: set, multiset, map, Multimap

• All containers support:– bool empty() const;– iterator begin() const;– iterator end() const;– int size() const;

• Containers are characterized by complexity metrics– # of operations for insertion, deletion– # of operations for lookup

7

Iterator• Points to one node in a list

– Advances to next node– Compares with other iterators

• Special value denotes “one past end”• Make heavily use of operator overloading.

• Iterator hierarchy

8

Iterator Example

#include <list> // list class library using namespace std;

void squareList(list<int>& nums) { list<int>::iterator it;

for(it=nums.begin(); it != nums.end(); it++) *it = *it * *it; // Modify each element. }

9

Sequence Containers•vector<T>

– Random access, variable size, constant insertion time.– Description: http://www.sgi.com/tech/stl/Vector.html

•deque<T> – Random access, variable size– Description: http://www.sgi.com/tech/stl/Deque.html

•list<T>: – Bidirectional access, access time O(n), constant insertion

time – Description: http://www.sgi.com/tech/stl/List.html

10

Simple Example - list#include <iostream>#include <list>using namespace std;int main(){ list<int> myContainer; list<int>::iterator it; myContainer.push_front(10); myContainer.push_front(20); myContainer.push_back(30); myContainer.push_back(40); for(it=myContainer.begin(); it!=myContainer.end(); it++) cout << *it << endl; myContainer.remove(30); // requires operator== myContainer.find(20);

return 0;{

11

Associative containers• Containers based on keys•set<key>

– keys and data are the same, unique keys– Description: http://www.sgi.com/tech/stl/set.html

•multiset<key>– keys and data are the same, non-unique keys– Description: http://www.sgi.com/tech/stl/multiset.html

•map<key,T>– keys and data are paired, unique keys– Description: http://www.sgi.com/tech/stl/Map.html

•multimap<key,T>: – keys and data are pared, non-unique keys– Description: http://www.sgi.com/tech/stl/Multimap.html

12

Example - Map• We will define a map of class Person

class Person { string m_sName; int m_iAge; public: typedef unsigned key; Person (const string sName, const int iAge): m_sName (sName), m_iAge (iAge) {}; Person () : m_iAge (0) {}; Person (const Person & p): m_sName (p.m_sName), m_iAge (p.m_iAge) {}; Person & operator= (const Person & rhs) {…} GetName () const { return m_sName; }; int GetAge () const { return m_iAge; }; };

13

Mapclass People}public: map<Person::key, Person> m_mapPerson; typedef pair<Person::key,Person> PersonPair; friend ostream& operator<<(ostream & s, const People & o){ map<Person::key,Person>::const_iterator it; for(it=o.m_mapPerson.begin();it!=o.m_mapPerson.end(); it++) s << (*it).first << ":" << (*it).second << endl; return s; }

void insert(Person::key k, Person p){ m_mapPerson[k] = p; } };

14

functors• Motivation: Sometimes it is useful to pass

functions as parameters

– Usually results in messy/confusing code– Functions can’t hold a meaningful state

• STL’s solution: function objects (functors)

bool lessAbsoluteValue(float a, float b) {return abs(a) < abs(b);}bool (*mycomparison)(float, float);mycomparison = &lessAbsoluteValue;

void sort(bool(*cmpfunc)(float, float), std::vector<float>);

15

functors• Classes that implements the function call

operator (operator())

• Use example:– sort(x.begin(), x.end(), lessAbsoluteValue());

class lessAbsoluteValue { public: bool operator()(float a, float b) const { return abs(a) < abs(b); }};

16

Applying functors to a range

struct add {    add( int n) : m_n( n) {}    void operator()( int & value) {        value += m_n;    } private:    int m_n;};

int main() { int a[] = { 335, 33, 98, 39, 54, 24, 3 }; int nElements = sizeof(a) / sizeof(a[ 0]); std::for_each( a, a + nElements, add( 10));}

17

functor adaptors• wrapper functors that call member functions

– mem_fun: works on member functions through a pointer– mem_fun_ref: works on member functions through an

object or a reference– ptr_fun: works on global functions through a function

pointer

vector<SceneNode*> nodes;…sort(nodes.begin(), nodes.end(), mem_fun(&SceneNode::renderFirst));

18

Algorithms

• STL defines many different algorithms– Templated function of common operations on containers

• Four categories of algorithms:– Non-mutating algorithms– Mutating algorithms– Sorting algorithms– Generalized numerical algorithms

19

Non-mutating algorithms•find – looks for a specific item in a sequence

•for_each – applies a functor to a range of elements in a sequence

list<string> players;…if (find(players.begin(), players.end(), wantedName) != players.end()) { …}

template<class T> struct print { print(ostream& out) : os(out), count(0) {} void operator() (T x) { os << x << ' '; ++count; } ostream& os; int count; };… int A[] = {1, 4, 2, 8, 5, 7}; const int N = sizeof(A) / sizeof(int);print<int> P = for_each(A, A + N, print<int>(cout));

20

Mutating Algorithms•copy - Copies all elements in a specified

range to another range

•reverse(first, last) – Reverse the elements in the sequence

•rotate(first, middle, last) – Shifts elements until middle element is at the first position

•random_shuffle - Shuffles all elements in the range

// Copy the first 10 scores to the highscore table list<int> highcores;copy(scores.begin(), scores.begin()+10, highscores.begin());

21

Sorting algorithms•sort

– Sorts all the elements in a range (based on quicksort)– Uses operator< or a functor passed as an argument

class Player {public: bool operator<(const Player& p) { return this->score_ < p.score_; }…vector<Player> players;sort(players.begin(), players.end());

22

Generalized numerical algorithms

•accumulate(first, last, init)– Sums of all elements in a range, starting with initial value

•partial_sum(first, last, output)– Sequence of numbers created by adding all the elements up

to the nth element for each of the output elements•adjacent_difference(first, last, output)

– Sequence of differences between adjacent pairs•inner_product

– Calculates dot product for two different ranges

23

Algorithm+Container+Functor

#include <cstring> #include <algorithm> #include <iostream> using namespace std;

class CStringCompare { public: bool operator()(const char* s1, const char* s2) { return strcmp(s1, s2) < 0; } }; int main() { vector<string> cartoons; cartoons. push_back(“Mickey”); cartoons. push_back(“Minnie”); cartoons. push_back(“Goofy”); sort(cartoons.begin(), cartoons.end(), StringCompare()); for (int i = 0; i < numberOfArgs; ++i) cout << args[i] << endl; return 0; }

Output: GoofeyMickeyMinnie