2CPP16 - STL


Published on

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.

Published in: Software, Technology, Education
  • Be the first to comment

  • Be the first to like this

No Downloads
Total views
On SlideShare
From Embeds
Number of Embeds
Embeds 0
No embeds

No notes for slide

2CPP16 - STL

  2. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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. 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.