Object-oriented programming B, Lecture 11e. 1 Chapter 5. The Standard Template Library. 5.1. Overview of main STL components. The Standard Template Library (STL) has been developed by Alexander Stepanov, Meng Lee, and David Musser at Hewlett-Packard Research Labs in the early nineties. Today STL becomes a part of the Standard C++ Library together with I/O streams, the C standard library, etc. STL is a general purpose library of generic algorithms and generic data structures - containers that can be plugged together and used in an application. Special STL components, called iterators and being generalized C/C++ pointers, “connect” containers and algorithms and allow them working together effectively. The STL containers include the most commonly used and most valuable data structures, such as vectors, deques, lists, sets, and maps. The template algorithm components include a broad range of fundamental algorithms for the most common kinds of data manipulations, such as searching, sorting, and merging. The STL generally avoids inheritance and virtual functions in favour of using templates. STL contains six major kinds of components: first of all, three key STL components - containers, generic algorithms, and iterators, as well as three auxiliary ones - function objects, adapters, and allocators ( Fig. 5.1). Adaptors Containers Function objects Iterators Allocators Algorithms Fig. 5.1. The STL components and their main relationships. All STL components are defined in the namespace std. Containers are used to manage collections of objects of certain type. Different containers have different abilities, such as internal data structure (arrays, linked lists, binary trees), category of iterators provided, effectiveness of inserting/removing elements, and so on. Containers have own member functions to provide some restricted processing own elements (inserting/removing elements, etc.). Iterators are used to step through the elements of collections of objects. These collections may be containers or subset of containers. Iterators offer common interface for any arbitrary container type. For example, the operator++ lets the iterator step to the next element in the collection. This is done independently of the internal structure of the collection (array, tree, etc). This is because every container class provides its own iterator type being actually a kind of smart pointer that translates the call "go to the next element" into whatever is appropriate. Algorithms are used to provide broad scope of processing the elements of collections. For example, they can search, sort, or simply use the elements for different purposes. Object-oriented programming B, Lecture 11e. 2 Algorithms use iterators, therefore an algorithm has to be written only once to work with arbitrary containers because the iterator interface is common for all container types. Most of the STL algorithms are provided in the standard header <algorithm>, and some in the header <numeric>. Function objects are used in algorithms as functional arguments, and in sorted associative containers as template parameters. The STL function objects covers fundamental operations: arithmetic, relational, and logical. They are provided in the standard header <functional>. Adaptors are used for modifying the interface of another components - containers, iterators, and function objects. For example, the container adaptors using the fundamental container classes are actually new containers with specific abilities: stack, queue, and priority queue. Another example is so-called binders - a category of function adaptors that help us construct a wider variety of function objects. Allocators are used in STL instead of new and delete for the allocation and deallocation of memory and represent a special memory model. Every STL container class uses a class Allocator to encapsulate information about the memory model used: pointers/constant pointers, references/constant references, sizes of objects, allocation and deallocation functions, etc. The STL defines a default allocator being sufficient in most programs. 5.2. Introduction to the STL containers. In STL, containers are objects that store collections of other objects, all of the same type T. There are two categories of fundamental (so-called first-class) STL container types: - sequence containers; - sorted associative containers. The STL provides also three above-mentioned container adaptor classes - stack, queue, and priority_queue that modify (adapt) the interface of an underlying first-class container to behave in a particular way (e.g., stack adaptor creates a LIFO list). 5.2.1. Sequence containers. Computational complexity. Sequence containers are ordered collections in which every element has a certain position. This position depends on the time and place of the insertion, but is independent of the value of the element. That is, sequence containers provide a strictly linear arrangement that preserves the relative positions into which the elements are inserted. A few words about terminology. A sequence (often called a range) is fixed by the pair of iterators: first iterator refers to the first element of the sequence, and the second refers to a one-beyond-the-last hypothetical element (Fig. 5.2). Such a sequence is called “half open”, and traditional mathematical notation for a half-open range is [first, last). … next position after the end of the container first last Fig. 5.2. A sequence (range) delimited by the pair of iterators. For algorithms that work on containers of size n, we can consider the maximum time (or the worst-case time) T(n) that an algorithm could take. Instead of trying to develop a precise formula for T(n), we can find a simple asymptotic function that provides an upper bound on the function T(n). For example, we might have the following inequality: T(n) ≤ cn, Object-oriented programming B, Lecture 11e. 3 for some constant c and all sufficiently large n (say, for n ≥ N ). This relation can be written using so-called big Oh notation: T(n) = O(n). In this case algorithm is said to have a linear time bound or, more simply, to be linear time. If T(n) ≤ c (or T(n) = O(1)), the algorithm is said to have a constant time bound or to be constant time. In this case we can talk about so-called random access. It means that the time to reach the nth element of the sequence is constant, i.e., time does not depend on n. The following graphs illustrate these cases: T c*n T(n) c c T(n) time T - running N n N n a) constant time bound b) linear time bound Fig. 5.3. Asymptotic estimations of the computational complexity The STL first-class sequence container types are as follows: - vector<T>, providing random access to any element of a sequence of varying length, with rapid (constant time) insertions and deletions at the end; - deque<T>, (it's pronounced deck) also providing random access to any element of a sequence of varying length, with rapid insertions and deletions at front or back; - list<T>, doubly-linked list providing only linear-time (O(n))access to a sequence of varying length, but with rapid insertions and deletions at any position in the sequence. The header files for these containers are as follows: <vector>, <deque>, <list>. Actually, the STL involves two other sequence containers: - T a[n], that is, ordinary C++ array types, which provide random access to a sequence of fixed length n; - the class basic_string (or simply string) placed in the header <string>. Unlike ordinary arrays, class string provides the STL container interface. The class string objects can be considered as containers of characters. 5.2.2. Sorted associative containers. Sorted associative containers provide ability for fast retrieval of objects from the collection based on keys that stored in the item (or in some cases are the items themselves). The sorted associative containers are based on one general approach to associative retrieval, which is to keep keys sorted according to some total order, such as numeric order if the items are numbers or lexicographical order if the keys are strings, and use a binary search algorithm. These containers can be implemented with balanced binary search trees. (another approach is hashing.) STL has four sorted associative container types: - set<Key>, which supports unique keys (contains at most one of each key value) and provides for fast retrieval of the keys themselves; therefore, each element serves as both a sort key and a value; Object-oriented programming B, Lecture 11e. 4 - multiset<Key>, which supports duplicate keys (possibly contains multiple copies of the same key value) and provides for fast retrieval of the keys themselves; - map<Key,T>, which supports unique keys (of type Key) and provides for fast retrieval of another type T (mapped value) based on the keys (rapid key-based lookup); a map is also called an associative array. An associative array can be thought as an array for which the index need not be an integer. - multimap<Key,T>, which supports duplicate keys (of type Key) and provides for fast retrieval of another type T based on the keys; multimap allows duplicate elements for a given key and is also called a dictionary. A good example of multimap could be a phone book, since one person can have several phone numbers. So, set and multiset can be seen as degenerate associative arrays/dictionary in which no value is associated with a key. Both map and multimap are contained in the header file <map>, as well as both set and multiset are contained in the header file <set>. 5.2.3. Common container operations. Each STL container has associated member functions, like push_back in the vector container. They ensure minimal functionality. Some of them are common for all containers. They include, in particular: • default constructor to provide a default initialization of the container; • copy constructor that initialize the container to be a copy of an existing container of the same type; • operator = that assigns one container to another; • empty that returns true if there are no elements in the container, false otherwise; • size that returns the number of elements currently in the container, and so on.