. STL: C++ Standard Library

Main Ideas u General purpose: generic data structures & algorithms, templates u Flexibility: Allows for many combinations of algorithm-container u Simple & uniform interface: interface through templates (not inheritence) u Efficiency u Reference:

Components u Containers: data structures vector, list, map, set, deque u Adaptors: high-level data structure stack, queue, priority_queue u Iterators: allow access into containers u Algorithms: base algorithms sort, copy, search, min, max, … u Streams: input/output u String

Quick Facts Vector  Implements an array of objects of type T  Allows random-access to array  Can grow on as needed basis Map  “Associative Array”: maps keys to values  Implemented as balanced binary tree

Example I – ShapeManager revisited #include using namespace std; class Shape { public: virtual void draw() = 0; virtual ~Shape() {}; }; class Circle : public Shape { public: void draw() { cout << "Circle::draw\n"; } ~Circle() { cout << "~Circle\n"; } }; class Triangle : public Shape { public: void draw() { cout << "Triangle::draw\n"; } ~Triangle() { cout << "~Triangle\n"; } }; class Square : public Shape { public: void draw() { cout << "Square::draw\n"; } ~Square() { cout << "~Square\n"; } };

typedef std::vector Container; typedef Container::iterator Iter; int main() { Container shapes; shapes.push_back(new Circle); shapes.push_back(new Square); shapes.push_back(new Triangle); for(int k = 0;k < shapes.size();k++ ) shapes[i]->draw(); //use operator[] for(Iter j = shapes.begin(); j != shapes.end(); j++) delete *j; //use iterator and dereferencing } ///:~ Example I – ShapeManager revisited

Example II – unique word counter #include using namespace std; int main(int argc, char* argv[]) { ifstream source(argv[1]); string word; set words; while(source >> word) words.insert(word); copy(words.begin(), words.end(), ostream_iterator (cout, "\n")); cout << "Number of unique words:" << words.size() << endl; } ///:~

Containers u Holds copies of elements u Assumes Copy Ctor & operator = u The standard defines the interface, not the implementation u Two main classes  Sequential containers: list, vector,....  Associative containers: map, multimap, set...

Sequential Containers u Maintain a linear sequence of objects Types of operations u Access/insertion/deletion of elements at the front/end of sequence u Random access to elements

Sequential Containers list - a linked list of objects  Efficient insertion/deletion in front/end/middle vector - an extendable sequence of objects  Efficient insertion/deletion at end  Random access deque – double-ended queue  Efficient insertion/deletion at front/end  Random access

Sequential Container Interface u size(), empty() u push_front(x), push_back(x) u front(), back() u pop_front(), pop_back() vector & deque u operator[](int index)

Associative Containers u Maintain a collection of keys u Requires order on keys (less-than operator) u Keys can be accessed based on their order (Typical) Implementation: u red-black binary trees u O(log n) time for access/insert/delete

Associative Containers Set u A set of unique keys Map u Associate a value to key (associative array) u Unique value of each key Multiset Multimap u Same, but allow multiple values

Example #include using namespace std; typedef map WordMap; typedef WordMap::iterator WMIter; int main(int argc, char* argv[]) { ifstream in(argv[1]); WordMap wordmap; string word; while(in >> word) wordmap[word]++; for(WMIter w = wordmap.begin(); w != wordmap.end(); w++) cout << (*w).first << ": " << (*w).second.val() << endl; } ///:~ class Count { int i; public: Count() : i(0) {} void operator++(int) { i++; } int& val() { return i; } };

Associative Containers & Order u Associative containers use operator< as default order u We can control order by using our own comparison function u To understand this issue, we need to use function object

Function Objects A class that implements operator() Advantages: u Use the template mechanism (class versus function) u Enable accumulating information in the function object

Example template class less { public: bool operator()(T& lhs, T& rhs) { return lhs < rhs; } }; less cmp; // declare an object if( cmp(1,2) ) … if( less ()(1,2) ) … Creates temporary objects, and then call operator()

Function Object Bases u Base classes for the functions objects are defined in STL. u These provide standard names for the arguments and return types. template class less : public binary_function { … }

Function Object Bases template struct unary_function { typedef Arg argument_type; typedef Res return_type; }; template struct binary_function { typedef Arg first_argument_type; typedef Arg2 second_argument_type; typedef Res return_type; };

Using Comparators template > class set { … } … set s1; set > s2;// same type set s3; MyComp cmp; set s4(cmp); Creates a new MyComp object. Use given MyComp object.

STL Iterators u Iterators are allow to traverse sequences u Methods  operator*  operator++, and operator— u Different types of iterators - to support read, write and random access u Containers define their own iterator types u Changing the container can invalidate the iterator

Iterator Types u Output: write only and can write only once u Input: read many times each item u Forward supports both read and write u Bi-directional support also decrement u Random supports random access (just like C pointer)

Iterators & Containers Bidirectional iterators: u list, map, set Random access iterators: u vector, deque Input/output/forward iterators: u iostreams

Iterators and Containers T::iterator – iterator type for type T begin() – front of the container end() – element after last Container C … Container::iterator i for( i = C.begin(); i != C.end(); i++) // do something with *i

Iterators & Streams Can access iostreams through iterators: istream_iterator in(cin); istream_iterator endOfInput; ostream_iterator out(cout); while( in != endOfInput ) { string s = *in++; *out++ = s; *out++ = “ “; } see useStreamIterators.cpp

Sequence Adapters u Adapters of basic containers u Very easy, but limited interface stack  provides push, pop, top, size and empty queue  also provides back priority_queue u provides same interface as stack u uses a compare function object

Algorithms Overview u Sequence operations  Non modifying: for_each, find, count, search, mismatch, equal  Modifying: transform, copy, swap, replace, fill, generate, remove, unique, reverse, rotate, random_shuffle u Sorted sequences operations  sort, lower_bound, upper_bound, equal_range, binary_search, merge, includes, set_union, intersection, difference, symmetric_difference

Algorithms u Most STL algorithms works on sequences u Sequences are passed as two iterators:  beginning element  element one after last u Algorithms depend on iterator type not on container type pq sequence [p,q)

Copy template Out copy(In first, In last, Out res) { while (first != last) *res++ = *first++; return res; } See useCopy.cpp

Non-modifying Sequence Algorithms  In find(In first, In last, const T& val) find the first occurence of val in the sequence  In find_if(In first, In last, Pred p) find the first element satisfying p  I1 find_first_of(I1 f1, I1 l1, I2 f2, I2 l2) find the first match between two sequences.  I1 search( I1 f1, I1 l1, I2 f1, I2 l2 ) search for the sequence f2...l2 inside f1..l1

Sorted Sequence Algorithms  sort(In first, In last[, class cmp]) find the first occurence of val in the sequence  In lower_bound(In first, In last, T const & val[, class cmp]) find the first element not less than val  bool binary_search(In first, In last, T const & val[, class cmp]) check if val appears in the sequence  Out merge( I1 f1, I1 l1, I2 f1, I2 l2, Out out ) merge two sorted sequences and write the merged sequence onto the output iterator out