This is an intermediate conversion course for C++, suitable for second year computing students who may have learned Java or another language in first year.

1. STANDARD TEMPLATE
LIBRARIES
Michael Heron

2. Introduction
• The great promise of object orientation is reusability.
• As of now, we haven’t done much re-using.
• In the same way that Java provides comprehensive
libraries of basic structures, so too does C++
• Through the mechanism of the Standard Template Library.

3. Standard Template Library
• The STL is not a part of the core C++ language.
• It’s a set of extended libraries that have nearly
ubiquitous applicability.
• They are defined in the C++ standard.
• It provides implementations of many of the
standard data types available in other languages.
• It is driven by the power of templates (as
discussed in the previous lecture).

4. Standard Template Library
• The STL subset that we are going to pay most
attention to is that of collections.
• Basic, core data structures.
• You’ll hear more about how these are internally implemented in
a later part of the module.
• The collection classes allow us to make use of
powerful, flexible data types without us having to
write them ourselves.
• There’s a considerable development burden in writing
objects that are genuinely reuseable.

5. Collections
• Much like an array, a collection holds a number of discreet
elements.
• Unlike an array, ordering cannot be assumed with many
collections.
• These classes are not designed to be base classes for
more specialised derived classes.
• Destructors for example are explictly designed to be non-virtual.

6. Collections
• Collections break down into three main
categories.
• Sequential, where order is maintained.
• List
• Vector
• Associative, where no order is guaranteed.
• Set
• Hash Map
• Adapter, which act as wrappers around other core
structures.
• Queue
• Stack

7. The Vector
• The Vector is defined in the std namespace.
• #include <vector> into your code.
• Vectors are resizeable arrays.
• You can just keep adding things in and they’ll expand to meet your
requirements.
• Basic structure for interacting with a vector is common to
all STL collections.

8. The Vector
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> *v = new vector<int>();
v->push_back (100);
v->push_back (200);
v->push_back (500);
for (int i = 0; i < v->size(); i++) {
cout << v->at (i) << endl;
}
return 0;
}

9. The Vector
• Useful methods:
• push_back – push an element to the back of the structure
• size – get the number of elements in the collection
• at – pull the element out at that specific position.
• Memory management of a container done during
accesses.

10. Vector Memory Management
• Two measures for collections are available.
• capacity – how many elements can the collection hold before new
space needs to be allocated.
• max_size – how many elements, in total, the collection can hold.
• Determined by the system.
• resize() and reserve() allow for fine-grained control over
capacity.

11. The List
• The list implements a doubly-linked list for traversal.
• Can go forwards and backwards.
• Basic structure for adding to a list the same as with a
vector.
• Can also push_front
• Traversal of the list done through an iterator.
• Possible for most of the STL classes.

12. Iterators
• Iterators are a common interface across container
classes.
• They represent an object that allows traversal through a collection.
• Obtained by using the following syntax:
• Collection<type>::iterator
• list<int>::iterator
• The iterator serves as the basis for more elegant output of
state date.

13. Iterators
#include <iostream>
#include <list>
using namespace std;
int main() {
list<int> *l = new list<int>();
list<int>::iterator i;
l->push_back (100);
l->push_front(200);
for (i = l->begin(); i != l->end(); i++) {
cout << *i << endl;
}
return 0;
}

14. Reversal Traversal
#include <iostream>
#include <list>
using namespace std;
int main() {
list<int> *l = new list<int>();
list<int>::reverse_iterator i;
l->push_back (100);
l->push_front(200);
for (i = l->rbegin(); i != l->rend(); i++) {
cout << *i << endl;
}
return 0;
}

15. Collections
• Most sequence collections also implement a sort function.
• Another time we need to overload an operator as part of C++
• < operator must be overloaded to permit sorting of custom objects
based on developer requirements.
• Many other useful functions available.
• Won’t cover these in the lecture – documentation available in many
places.

16. Algorithms
• STL also contains implementations for common
algorithms.
• Sort
• Searches
• Must #include <algorithm> to get access to methods.
• Many of these methods similarly require operators to be
overloaded.
• Curse you C++.

17. Vector with Iterator, Sort and
Search
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main() {
vector<int> *v = new vector<int>();
vector<int>::iterator i;
bool found;
v->push_back (200);
v->push_back (100);
v->push_back (500);
sort (v->begin(), v->end());
found = binary_search (v->begin(), v->end(), 200);
cout << "Value 200 found in Vector" << endl;
for (i = v->begin(); i < v->end(); i++) {
cout << *i << endl;
}
return 0;
}

18. Class Defined for Sorting
class Person {
private:
int age;
public:
Person();
Person (int x);
void set_age (int x);
int query_age();
bool operator< (Person &a);
};

19. Class Implementation
#include "Person.h"
Person::Person() :
age (18) {
}
Person::Person (int x) :
age (x) {
}
int Person::query_age() {
return age;
}
void Person::set_age (int na) {
age = na;
}
bool operator<(Person& a, Person& b) {
return a.query_age() < a.query_age();
}

20. Versus Java
• It seems like much more is needed to implement a C++
class for collections than in Java.
• The same amount of code is required for both.
• Java requires an implementation of compareTo.
• C++ requires an implementation of an overloaded < operator.

21. Why Use STL Classes?
• The STL classes are battle-hardened and battle-scarred
• They work.
• They make use of templates, and thus can handle any
appropriately defined object you devise.
• Most of the common data structures are available as part
of the STL.

22. Why Not Use Them?
• Well, no real reason not to…
• … for real code.
• Array manipulation exercises and data structure
creation are important ‘clarity’ topics.
• It’s always worth understanding how data structures are
implemented.
• Remember, C++ is all about how things are represented
internally.
• Best to learn how to ‘roll your own’ first.
• Then use the STL versions because they are more
complete.

23. Summary
• C++ provides implementations of most of the standard
data types.
• And also corresponding implementations of default operations such
as searchs and sorts.
• Vectors and lists permit the traversal of ordered data.
• Important to define user classes appropriately for sorting
and searching.