1. Programming with ANSI C ++
A Step-by-Step Approach
Prof. Bhushan Trivedi
Director
GLS Institute of Computer Technology

2. Chapter 15 Standard Template Library (STL)

3. The STL
STL is Standard Template Library, a collection of generic software component (generic containers) and generic algorithms, glued by objects called Iterators.
STL is a different type of library.
It has quite a large number of non member functions designed to work on multiple classes of container types.

4. The non member advantage
Feasible to implement all operations in most efficient manner
many useful algorithms like find(), replace(), merge(), sort() are implemented in STL
Being non member function they can be used with any container even a newly designed one

5. The generic software components
These containers are classes which can in turn contain other objects.
Sequence containers
Vector, List, DeQueue
Sorted associative containers
Set, Map, Multi-set, Multi-map
Adapted containers
Stack , Queue

6. The Iterators These are pointer like objects
They are categorized into various categories unlike pointers.
The generic algorithms are written to work on iterators objects rather then any data structure.
Containers are also designed in terms of iterators rather then normal pointers.

7. Types of Iterators Find algorithm works on input Iterators
sort is defined to require Random Access Iterators
list (the doubly linked list) container is defined to have Bi-directional Iterator
Thus sort can not be used with list!

8. Generic programming
Idea of Generic Programming has nothing to do with C++!
It is a mechanism of designing generic software components like Vector, list, deque and so on.
Unlike normal programming practice, Generic algorithms are not designed having any software component in mind.

9. Generic programming
Designed keeping in mind minimum level of requirements.
Can work with many variants of different software components
The software components (containers) and algorithms are connected to each other by Iterators as mentioned earlier

10. The object based model The inefficiency of object oriented model
The model presented by STL offers similar advantages with more efficient architecture
The generality achieved here is by templates, Iterators and good design rather then having class hierarchy
5/26/2018
The C2C Programme

11. The Containers
STL provides tested and debugged software components available readily.
They are reusable in the sense that we can use them as a building block for any other software development projects.

12. Advantages of containers
Small in number
Generality
Efficient, Tested, debugged and standard
Portability and reusability
Automatically adjusting growth
Similar behavior to built-in types
Extensibility

13. Advantages of Generic Algorithms
readymade from STL.
Using the best of the breed mechanisms to be as efficient as possible
Standardized so have more acceptability then proprietary algos
Similar semantics are designed for all these algorithms.

14. Iterators We need efficient methods to traverse these containers
Iterators provide us the way to do that
The Functional interface and pointer like interface
The array to be accessed using pointers
The get() and put() used by files

15. Iterators
The Iterators are provided by the STL designers for finer control.
They are not only provided, they are open to the programmer

16. Iterators Programmers can
define and use Iterators like pointers to the component objects,
dereference them
assign them and so on like pointers.

17. Why not Pointers?
The reason is that although in most of the cases the iterators are implemented as pointers, one can choose the more fitting implementation for a special case.

18. The Efficiency of Iterators
Open design:- having Iterators open to programmers to manipulate
Address manipulation by which the job is possible to be done in minimum steps
We can have additional checks possible before applying algorithm to contents like checking to see if the sort algorithm is provided with Random Access Iterators and nothing else

19. The Vector
#include <vector> vector <Student> vs; vector <int> vi; vi.push_back(12); //inserting at the end of vector! Student Lara(1,"Brian Charles Lara"); vs.push_back(Lara);

20. The List operations Implemented using doubly linked list.
Insertion at random place is most efficient
constant time operation at every location in the list.
Vector has only constant time operation in the end
deque in the beginning and at the end and not at every place

21. The Dequeue
deque <Student> ds; ds.push_front(Lara);

22. The Sorted Associative Containers
Three is a need for a container which always remains sorted.
All database indexes are examples of such container.
Every element inserted in sorted order automatically
object which is inserted must obey some form of ordering using operator <() const
5/26/2018
The C2C Programme

23. The Map
It is a container which can have two items, a key and a value stored in itself.
It is automatically sorted on the key item at the time of insertion
The key item must have some form of ordering.
For a user defined objects, it is important to overload operator < as const to have ordering

24. The Set The set is collection of keys only in sorted form.
When we are interested only in verifying if a key is a valid we can use sets
We can insert all keys and when the key is referenced we can see if key belongs to inserted data or not.

25. Algorithms: Find int *pos = find(IntArray, IntArray+6, 3);
StudentIndex = find(vs.begin(),vs.end(), Maradona);
ListIndex = find(ls.begin(),ls.end(),Tiger);
DeqIndex = find(ds.begin(),ds.end(),Steffi);
Find returns same type of Iterator which is passed as first and second argument.
5/26/2018
The C2C Programme

26. Algorithms: Find
Find() can work with all the types of containers because the Iterators expected are of category called Input Iterators which are supported by all containers.

27. Algorithm: Copy
copy(vs.begin(),vs.end(),AnotherVector.begin()); copy(vs.begin(),vs.end(),ds.begin()) copy(vs.begin(),vs.end(),ls.begin()); copy has three arguments. The first two arguments are same type of iterators indicating a range of values. The third Iterator can be of different type then type of first two Iterators