C++ Programming Standard Library Strings Containers

Organization The SL library is organized into several parts. STL (Standard Template Library): Containers Iterators Algorithms Strings Streams Already explained in the previous presentation Numerics Internationalization Will not be explained in this course

Strings String classes enable you to use strings as normal types that cause no problems for the user Different from “ordinary strings” of type char* or const char* Copy, assignment and compare functions, as for fundamental types, are already available - no worry about memory corruption Defined in the header <string> Type: std::string - chain of characters of char type

String Operations Assignment: String size: Search in a string: Conversion to C-string (char*): std::string s = "abcd"; std::string t = s; t += “efgh”; std::string s = "abcd"; int size = s.size(); std::string s = "abcd"; int pos = s.find("bc"); std::string s = "abcd"; char* cs = s.c_str();

STL STL = Standard Template Library The heart of SL Provides a variety of collection classes that meet different needs, together with several algorithms that operate on them Programmers can forget about programming dynamic arrays, search algorithms etc. Just need to choose the appropriate container and call its functions to process data All components are templates Can be used for arbitrary element types Extremely efficient Cooperation of different well-structured components: Containers, iterators and algorithms

Containers Manage a collection of elements Sequence containers = ordered collections in which every element has a certain position (independent of the value) Vector: 1 dimensional array List: doubly linked list Associative containers = sorted collections (the actual position of an element depends on its value) Set / Multiset: Element sorted according to their own value Map / Multimap: Elements are key/value pairs, sorted accordingly

Vector In the header <vector> Type: std::vector<T> - where T is the element type Useful functions: push_back(elem) Add an element at the end at(idx) or [idx] Return the idx-th element front(), back() Return the first, the last element size() Return the vector size clear() Remove all elements #include <iostream> #include <vector> int main () { std::vector<int> myVector; myVector.push_back(3); myVector.push_back(4); std::cout << myVector[0] << std::endl; myVector.at(1) = 5; std::cout << myVector.back() << std::endl; myVector.clear(); return 0; }

List In the header <list> Type: std::list<T> - where T is the element type Useful functions: push_front(elem), push_back(elem) Add an element at the beginning, at the end pop_front(), pop_back() Remove the element at the beginning, at the end front(), back(), size(),clear() Same as for vector #include <iostream> #include <list> int main () { std::list<int> myList; myList.push_front(3); myList.push_front(2); myList.push_back(4); myList.pop_front(); myList.pop_back(); std::cout << myList.front() << std::endl; std::cout << myList.back() return 0; } Note that some methods are common to both vector and list (and also other containers): size(), clear(), ...

Iterators Iterator = object that can “iterate”(navigate) over elements It represents a certain position in a container All containers provide the same basic functions that allow iterators to navigate over their elements Functions defined for all containers: begin(), end() Return an iterator that represents the beginning, the end of elements in the container. The end is the position behind the last element v.begin() v.end() T vector it

Iterators Header files: All containers define their own iterator type, there is no special header for using container iterators Types: container_type::iterator container_type::const_iterator Basic operations: Operator * Returns the element of the actual position Operator ++ Lets the iterator step forward to the next element Operators == and != Return the result whether two iterators represents the same position or not Operator = Assign an iterator (the position of the element to which it refers)

Iterators - Example #include <iostream> #include <vector> int main() { std::vector<int> myVector; // ... fill the vector here // Iterating over vector elements std::vector<int>::iterator it; for ( it = myVector.begin(); it != myVector.end(); ++it ) { int i = *it; std::cout << "i = " << i << std::endl; } return 0;

When to Use which Container Vector By default, you should use a vector If you need to access the N-th element Insertion and removal can be costly Very efficient when browsing the container List If you need to insert or remove an element often in the middle Inclusion in constant time Access to the N-th element by iterating from the 1st Map If you need an element via a key A list maintained sorted when inserting new elements Associative list