Video

Lecture

Object Oriented
Programming
STL Programming
Engr. Rashid Farid Chishti
[email protected]
https://youtube.com/rfchishti
https://sites.google.com/site/chishti

International Islamic University H-10, Islamabad, Pakistan

http://www.iiu.edu.pk 1
Introduction to STL
 What is STL?
 STL stands for Standard Template Library.
 It's a powerful set of C++ template classes to provide general-purpose classes and
functions with templates.
 A crucial part of C++ for data manipulation and algorithm development.
 Purpose of STL
 Simplify and accelerate software development.
 Reusable, generic data structures and algorithms.
 Improve code quality and maintainability.
 Benefits of Using STL:
 Saves development time.
 Increases code readability.
 Maximizes code reuse.
 Enhances code performance.
Components of STL
 Containers
 Vector: Dynamic array.  Map: Key-value pairs.
 List: Doubly linked list.  Set: Unique values collection.
 Algorithms
 Sort: Sorting elements.  Transform: Modifying elements.
 Find: Searching elements.  Many more for various operations.
 Iterators
 Input Iterators: Read-only traversal.  Output Iterators: Write-only traversal.

 Forward Iterators: Supports both reading and writing values in a forward direction.
 Bidirectional Iterators: reading and writing values in forward and backward directions.
 Random Access Iterator: Supports reading and writing values in any order.
 Functors
 Function Objects: Callable objects.
 Custom operations using operator overloading.
STL Containers

STL Containers

Sequence Container Associative Unordered Associative

Containers Adapters Containers Containers

C++ array
set unordered_set
vector stack
multiset unordered_multiset
list queue
map unordered_map
forward_list
priority_queue
multimap unordered_multimap
deque
Sequence Containers
Container Characteristic Advantages and Disadvantages
C++ array Fixed size Quick random access (by index number)
Slow to insert or erase in the middle
Size cannot be changed at runtime

vector Relocating, Quick random access (by index number)

expandable array Slow to insert or erase in the middle
Quick to insert or erase at end

list Doubly linked list Quick to insert or delete at any location

Quick access to both ends
Slow random access

deque Like vector, but can be Quick random access (using index number).
accessed at either end Slow to insert or erase in the middle
Quick insert or erase (push and pop) at either the
beginning or the end
Container Adapters
Container Implementation Characteristic
stack Can be implemented Insert (push) and remove (pop) at one end only
as vector, list, or deque

queue Can be implemented Insert (push) at one end and remove (pop) at other end
as list or deque

priority_queue Can be implemented Insert (push) in random order at one end and remove (pop) in
as vector or deque sorted order from other end
Associative Containers
Container Characteristic Advantages and Disadvantages
set Stores only the key objects The set is used to store unique elements.
Only one key of each value allowed The data is stored in a particular order
(increasing order, by default).

multiset Stores only the key objects Multiset is similar to a set but also
Multiple key values allowed allows duplicate values.

map Associates key object with value object The map contains elements in the form of unique key-
Only one key of each value allowed value pairs. Each key can be associated with only
one value. It establishes a one-to-one mapping. The
key-value pairs are inserted in increasing order of the
keys.
multimap Associates key object with value object Multimap is similar to a map but allows duplicate key-
Multiple key values allowed value pairs to be inserted. Ordering is again done
based on keys.
Some Typical STL Algorithms
Algorithm Purpose
find Returns first element equivalent to a specified value
count Counts the number of elements that have a specified value
equal Compares the contents of two containers and returns true if all corresponding elements are equal
search It commonly used to find a subsequence within a specified range of elements.
copy Copies a sequence of values from one container to another
swap Exchanges a value in one location with a value in another
iter_swap Exchanges a sequence of values in one location with a sequence of values in another location
fill Copies a value into a sequence of locations
sort Sorts the values in a container according to a specified ordering
merge Combines two sorted ranges of elements to make a larger sorted range
accumulate Returns the sum of the elements in a given range
for_each Executes a specified function for each element in the container
Example 1: Using find() Algorithm
#include <iostream>
#include <algorithm> //for find()
using namespace std;
int arr[] = { 11, 22, 33, 44, 55, 66, 77, 88 };

int main(){
int* ptr;
ptr = find(arr, arr+8, 33) ; //find first 33
// The 1st parameter is the iterator of (or in this case the pointer to)
the
// first value to be examined
// The 2nd parameter is the iterator of (or in this case the pointer to)
the
// last value to be examined

cout << "First object with value 33 found at offset " << (ptr-arr) <<
endl;
return 0;
Example 2: Using count() Algorithm
#include <iostream>
#include <algorithm> //for count()
using namespace std;
int arr[] = { 33, 22, 33, 44, 33, 55, 66, 77};

int main() {
int n = count(arr, arr+8, 33) ; //count number of 33’s
cout << "There are " << n << " 33's in arr." << endl;
return 0;
}
Example 3: Using search() Algorithm
#include <iostream>
#include <algorithm>
using namespace std;
int source[] = { 11, 44, 33, 11, 22, 33, 11, 22, 44 };
int pattern[] = { 11, 22, 33 };

int main(){
int* ptr;
ptr = search(source, source+9, pattern, pattern+3) ;

if(ptr == source+9) //if past-the-end

cout << "No match found\n";
else
cout << "Match Found at Index " << (ptr - source) << endl;

return 0;
}
Example 4: Using sort() Algorithm
#include <iostream>
#include <algorithm>
using namespace std;
//array of numbers
int arr[] = {45, 2, 22, -17, 0, -30, 25, 55};

int main(){
sort(arr, arr+8); // sort the numbers
for(int j=0; j<8; j++) // display sorted array
cout << arr[j] <<' ';
cout << endl;
return 0;
}
Example 5: Using greater<>() Function Object
#include <iostream>
#include <algorithm> // for sort()
#include <functional> // for greater<>
using namespace std;
double fdata[] = { 19.2, 87.4, 33.6, 55.0, 11.5, 42.2 }; // array of doubles

int main(){
sort( fdata, fdata+6, greater<double>() ); // sort the doubles
for(int j=0; j<6; j++) // display sorted doubles
cout << fdata[j] << ' ';

cout << endl;

return 0;
}
Example 6: Using Custom Function Object
#include <iostream>
#include <string> // for strcmp()
#include <algorithm>
using namespace std;
char* names[] = { "George", "Penny", "Estelle", "Don", "Mike", "Bob" };
bool alpha_comp(char*, char*); // custom function object
declaration

int main(){
sort(names, names+6, alpha_comp); // sort the strings
for(int j=0; j<6; j++) // display sorted strings
cout << names[j] << endl;
return 0;
}
bool alpha_comp(char* s1, char* s2){ // returns true if s1<s2
return ( strcmp(s1, s2)<0 ) ? true : false;
}
Example 7: Using merge() Algorithm
#include <iostream>
#include <algorithm> // for merge()
using namespace std;
int src1[] = { 2, 3, 4, 6, 8 };
int src2[] = { 1, 3, 5 };
int dest[8];

int main(){

// merge src1 and src2 into dest

merge(src1, src1+5, src2, src2+3, dest);

for(int j=0; j<8; j++) // display dest

cout << dest[j] << ' ';

cout << endl;

return 0;
}
Adding _if to Algorithms
 Some algorithms have versions that end in _if.
 These algorithms take an extra parameter called a predicate, which is a function object or a
function.
 For example, the find() algorithm finds all elements equal to a specified value.
 We can also create a function that works with the find_if() algorithm to find elements with
any arbitrary characteristic.
 Our example uses string objects.
 The find_if() algorithm is supplied with a user-written isDon() function to find the first string
in an array of string objects that has the value “Don”.
 Our next program implements this concept.
Example 8: Using find_if() Algorithm
#include <iostream>
#include <string>
#include <algorithm>
using namespace std;
string names[] = { "George", "Estelle", "Don", "Mike", "Bob" };
bool isDon(string name) { // returns true if name == "Don"
return name == "Don";
}
int main() {
string* ptr;
ptr = find_if( names, names+5, isDon );
if(ptr==names+5)
cout << "Don is not on the list.\n";
else
cout << "Don is element " << (ptr-names) << " on the list.\n";

return 0;
}
The for_each() Algorithm
 The for_each() algorithm allows you to do something to every item in a container.
 You write your own function to determine what that “something” is.
 Your function can’t change the elements in the container, but it can use or display their
values.
 Here’s an example in which for_each() is used to convert all the values of an array from
inches to centimeters and display them.
 We write a function called in_to_cm() that multiplies a value by 2.54, and use this function’s
address as the third argument to for_each().
 Here’s the listing for FOR_EACH:
Example 9: Using for_each() Algorithm
#include <iostream>
#include <algorithm>
using namespace std;
void in_to_cm(double); // declaration
int main() {
double inches[] = { 3.5, 6.2, 1.0, 12.75, 4.33 }; // array of inches
values
for_each(inches, inches+5, in_to_cm); // output as centimeters

cout << endl;

return 0;
}

void in_to_cm(double in){ // convert and display as

centimeters
cout << (in * 2.54) << ' ';
}
The transform() Algorithm
 The transform() algorithm does something to every item in a container, and places the
resulting values in a different container (or the same one).
 Again, a user-written function determines what will be done to each item.
 The return type of this function must be the same as that of the destination container.
 Our example is similar to FOR_EACH, except that instead of displaying the converted values,
our in_to_cm() function puts the centimeter values into a different array, centi[].
 The main program then displays the contents of centi[].
Example 10: Using transform() Algorithm
#include <iostream>
#include <algorithm>
using namespace std;

int main(){
double inches[] = { 3.5, 6.2, 1.0, 12.75, 4.33 }; // array of inches
values
double centi[5];
double in_to_cm(double); // prototype
transform(inches, inches+5, centi, in_to_cm); // transform into
array centi[]
for(int j=0; j<5; j++) // display array
centi[]
cout << centi[j] << ' ';
cout << endl;
return 0;
}

double in_to_cm(double in) { // convert inches to centimeters

Vector
 You can think of vectors as smart arrays.
 They manage storage allocation for you, expanding and contracting the size of the vector as
you insert or erase data.
 The insert() and erase() member functions insert or remove an element from an

arbitrary location in a container.

 These functions aren’t very efficient with vectors, since all the elements above the

insertion or erasure must be moved to make space for the new element or close up the
space where the erased item was.
 However, insertion and erasure may nevertheless be useful if speed is not a factor.

 You can use vectors much like arrays, accessing elements with the [] operator.
 Such random access is very fast with vectors.
 It’s also fast to add (or push) a new data item onto the end (the back) of the vector. When
this happens, the vector’s size is automatically increased to hold the new item.
Example 11: Using vector Container
#include <iostream>
#include <vector>
using namespace std;
int main() {
vector<int> v ; // create a vector of integers
v.push_back(10) ; // use push_back() to put values at end of array
v.push_back(11);
v.push_back(12);
v.push_back(13);

v[0] = 20; // use operator[] to read or write values

v[3] = 23;
for(int j=0; j < v. size(); j++) // display vector contents
cout << v[j] << ' '; // it will show 20 11 12 23 on screen

cout << endl;

return 0;
}
Eg 12: Using swap(), empty(), back(), and pop_back()
#include <iostream>
#include <vector>
using namespace std;
int main(){
double arr[] = { 1.1, 2.2, 3.3, 4.4 }; // an array of doubles
vector<double> v1(arr, arr+4); // initialize vector to array
vector<double> v2(4); // empty vector of size 4
v1.swap(v2); // swap contents of v1 and v2
while( !v2.empty() ){ // until vector is empty,
cout << v2.back() << ' '; // display the last element
v2.pop_back(); // remove the last element
} // output: 4.4 3.3 2.2 1.1
cout << endl;
return 0;
}
Eg 13: Using swap(), empty(), back(), and pop_back()
#include <iostream>
#include <vector>
using namespace std;
int main(){
double arr[] = { 1.1, 2.2, 3.3, 4.4 }; // an array of doubles
vector<double> v1(arr, arr+4); // initialize vector to array
vector<double> v2(4); // empty vector of size 4
v1.swap(v2); // swap contents of v1 and v2
while( !v2.empty() ){ // until vector is empty,
cout << v2.back() << ' '; // display the last element
v2.pop_back(); // remove the last element
} // output: 4.4 3.3 2.2 1.1
cout << endl;
return 0;
}
Example 14: Using insert() and erase()
#include <iostream>
#include <vector>
using namespace std;
int main() {
unsigned int i; int arr[] = {100,110,120,130}; // an array of integers
vector<int> v(arr, arr+4); // initialize vector to array
cout << "Before insertion: ";
for(i=0; i<v.size(); i++) // display all elements
cout << v[i] << ' '; // 100 110 120 130
v.insert( v.begin()+2, 115); // insert 115 at element 2
cout << "\nAfter insertion: ";
for(i=0; i<v.size(); i++) // display all elements
cout << v[i] << ' '; // 100 110 115 120 130
v.erase( v.begin()+2 ); // erase element 2
cout << "\nAfter erasure: ";
for(i=0; i<v.size(); i++) // display all elements
cout << v[i] << ' '; // 100 110 120 130
cout << endl; return 0; }
Using insert() and erase()
 The insert() member function takes two arguments:
 the place where an element will be inserted in a container,

 and the value of the element.

 We add 2 to the begin() member function to specify element 2 (the third element) in the
vector.
 The elements from the insertion point to the end of the container are moved upward to
make room, and the size of the container is increased by 1.

 The erase() member function removes the element at the specified location.
 The elements above the deletion point are moved downward, and the size of the

container is decreased by 1.
List
 An STL list container is a doubly linked list, in which each element contains a pointer not
only to the next element but also to the preceding one.
 The container stores the address of both the front (first) and the back (last) elements,
which makes for fast access to both ends of the list.
 Insertion and deletion of elements are fast and efficient compared to some other data
structures, such as vectors or arrays, especially when dealing with elements in the middle of
the list.
 Unlike vectors, lists don't require reallocation when elements are added or removed. This
can be advantageous in scenarios where the number of elements changes frequently.
 Unlike arrays or vectors, lists do not support constant-time random access to elements.
Accessing elements by index takes linear time because you have to traverse the list from the
beginning or end to reach the desired position.
 Doubly-linked lists have a higher memory overhead compared to vectors because each
element in the list requires storage for the data and two pointers (prev and next).
Example 15: Using list Container
#include <iostream>
#include <list>
using namespace std;
int main() {
list<int> ilist;
ilist.push_back(30); // push items on back {30}
ilist.push_back(40); // {30, 40}
ilist.push_front(20); // push items on front {20, 30, 40}
ilist.push_front(10); // {10 ,20, 30, 40}
int size = ilist.size(); // number of items = 4
for(int j=0; j<size; j++){
cout << ilist.front() << ' '; // read item from front
ilist.pop_front(); // pop item off front
}
cout << endl;
return 0;
}
Example 16: Using deque(), merge(), and unique()
#include <iostream>
#include <list>
using namespace std;
int main(){
int j; list<int> list1, list2;
int arr1[] = { 40, 30, 20, 10 }; int arr2[] = { 15, 20, 25, 30, 35 };
for(j=0; j<4; j++) list1.push_back( arr1[j] ); // list1: 40, 30, 20, 10
for(j=0; j<5; j++) list2.push_back( arr2[j] ); // list2: 15, 20, 25, 30,
35
list1.reverse(); // reverse list1: 10 20
30 40
list1.merge(list2); // merge list2 into list1: 10 15 20 20 25 30 30 35 40
list1.unique(); // remove duplicate 20 and 30 list1: 10 15 20 25
30 35 40
int size = list1.size();
while( !list1.empty() ) {
cout << list1.front() << ' '; // read item from front 10 15 20 25 30 35
40
list1.pop_front(); // pop item off front
Deque
 A deque is like a vector in some ways and like a linked list in others. Like a vector, it supports
random access using the [] operator.
 However, like a list, a deque can be accessed at the front as well as the back. It’s a sort of
double-ended vector, supporting push_front(), pop_front() and front().
 Memory is allocated differently for vectors and queues. A vector always occupies a
contiguous region of memory. If a vector grows too large, it may need to be moved to a new
location where it will fit. A deque, on the other hand, can be stored in several non-
contiguous areas; it is segmented.
 A member function, capacity(), returns the largest number of elements a vector can
store without being moved, but capacity() isn’t defined for deques because they don’t need
to be moved.
Example 17: Using dque
#include <iostream>
#include <deque>
using namespace std;
int main(){
deque<int> deq;
deq.push_back(30); // push items on back {30}
deq.push_back(40); // {30,40}
deq.push_back(50); // {30,40,50}
deq.push_front(20); // push items on front {20,30,40,50}
deq.push_front(10); // {10,20,30,40,50}
deq[2] = 33; // change middle item {10,20,33,40,50}

for(int j=0; j<deq.size(); j++)

cout << deq[j] << ' '; // display items 10,20,33,40,50
cout << endl;

return 0;
}
Sequence Containers
Iterators
 Iterators are central to the operation of the STL. The role played by iterators is
 As a smart pointer

 as a connection between algorithm and container.

Iterators as Smart Pointers

 In C++, we use a pointer or the [] operator to access data from an array.

 For example, in the following code a pointer ptr iterates through an array and accesses

values of each element.

float* ptr = start_address;
for(int j=0; j<SIZE; j++)
cout << *ptr++;

 Here, we dereference the pointer ptr with the * operator to obtain the value of the item it
points to and increment it with the ++ operator so it points to the next item.
Iterators as Smart Pointers
 Plain C++ pointers face limitations with more sophisticated containers, particularly when
items are not contiguous in memory.
 For non-contiguous structures like linked lists, incrementing a pointer becomes complex as
items are not necessarily adjacent.
 Storing a pointer to a container element may lead to issues if the container is modified
(insertions or deletions), affecting the validity of the stored pointer.
 Smart pointers provide a solution to these problems by wrapping member functions around
ordinary pointers.
 These smart pointers can handle non-contiguous memory or changes in element locations.
 Overloading operators like ++ and * allows smart pointers to operate on elements within
their containers, offering a solution to challenges posed by dynamic container
modifications.
 Here’s how that might look, in skeleton form:
Iterator categories
 If an algorithm needs only to step forward through a container, reading (but not writing to)
one item after another, it can use an input iterator to connect itself to the container.
Actually, input iterators are typically used, not with containers, but when reading from files
or cin.
 If an algorithm steps through the container in a forward direction but writes to the
container instead of reading from it, it can use an output iterator. Output iterators are
typically used when writing to files or cout.
 If an algorithm steps along forward and may either read from or write to a container, it
must use a forward iterator.
 If an algorithm must be able to step both forward and back through a container, it must use
a bidirectional iterator.
 if an algorithm must access any item in the container instantly, it must use a random access
iterator. Random access iterators are like arrays, in that you can access any element. They
can be manipulated with arithmetic operations, as in iter2 = iter1 + 7;
Capabilities of Different Iterator Categories

 You can see, all iterators support ++ operator for stepping forward through the container.
 The input iterator can use the * operator on the right side of the equal sign (but not on
 the left): value = *iter;
 The output iterator can use the * operator only on the right: *iter = value;
Iterator Types Accepted by Containers

 STL automatically makes a bidirectional iterator for list, because that’s what a list requires.
 An iterator to a vector or a deque is automatically created as a random-access iterator.
Type of Iterator Required by Algorithms

The replace() algorithm

requires a forward iterator,
but it will work with a
bidirectional or a random
access iterator as well
Data Access using iterators
 In containers that provide random access iterators (vector and queue) it’s easy to iterate
through the container using the [] operator.
 Containers such as lists, which don’t support random access, require a different approach.
 A more practical approach is to define an iterator for the container.
 The next program shows how that might look:
Example 18: Data Access using iterators
#include <iostream>
#include <list>
#include <algorithm>
using namespace std;
int main() {
int arr[] = { 2, 4, 6, 8 };
list<int> theList;
for(int k=0; k<4; k++) // fill list with array elements
theList.push_back( arr[k] );

list<int>::iterator it; // iterator to list-of-ints

for(it = theList.begin(); it != theList.end(); it++)

cout << *it << ' '; // display the list
cout << endl;
return 0;
}
Example 19: Data Insertion using iterators
#include <iostream>
#include <list> * operator works on the
using namespace std; left side of the equal
int main() { sign as well as the right
list<int> iList(5); // empty list holds 5 ints
list<int>::iterator it; // iterator
int data = 0;

// fill list with data

for(it = iList.begin(); it != iList.end(); it++)
*it = data += 2;

// display list
for(it = iList.begin(); it != iList.end(); it++)
cout << *it << ' ';

cout << endl; return 0;

}
Example 20: Using find() Algorithm and Iterator
#include <iostream> A list iterator is only a
#include <algorithm>
#include <list> bidirectional iterator, so you
using namespace std; can’t perform arithmetic with it
int main() {
list<int> theList(5); // empty list holds 5 ints
list<int>::iterator it; // iterator
int data = 0;

for(it = theList.begin(); it != theList.end(); it++) // fill list

with data
*it = data += 2; // 2, 4, 6, 8, 10

it = find(theList.begin(), theList.end(), 8); // look for

number 8

if( it != theList.end() ) cout << "Found 8.\n" ;

else cout << "Did not find 8.\n";
return 0;
Example 21: Using find() Algorithm and Iterator
#include <iostream> You can do arithmetic with random
#include <algorithm>
#include <vector> access iterators, such as those used
using namespace std; with vectors and queues
int main() {
vector<int> v(5); // empty vector can hold 5 ints
vector<int>::iterator it; // iterator
int data = 0;

for(it = v.begin(); it != v.end(); it++) // fill vector with data

*it = data += 2; // 2, 4, 6, 8, 10

it = find(v.begin(), v.end(), 8); // look for number 8

if( it != v.end() ) cout << "Found 8 at Index " << (it-v.begin() )

<<endl;
else cout << "Did not find 8.\n";
return 0;
}
Example 22: Using copy() Algorithm and Iterator
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int main(){
int beginRange, endRange;
int arr[] = { 11, 13, 15, 17, 19, 21, 23, 25, 27, 29 };

vector<int> v1(arr, arr+10); // initialized vector

vector<int> v2(10); // uninitialized vector

cout << "Enter range to be copied (example: 2 5): ";

cin >> beginRange >> endRange;

vector<int>::iterator iter1 = v1.begin() + beginRange;

vector<int>::iterator iter2 = v1.begin() + endRange;
vector<int>::iterator iter3;
Example 22: Using copy() Algorithm and Iterator
// copy range from v1 to v2
iter3 = copy( iter1, iter2, v2.begin() ); // (it3 -> last item copied)
iter1 = v2.begin(); //

while(iter1 != iter3)// iterate through range in v2, displaying values

cout << *iter1++ << ' ';

cout << endl;

return 0;
}
Using Reverse Iterator
 Suppose you want to iterate backward through a container, from the end to the beginning.
You might think you could say something like
list<int>::iterator iter; // normal iterator
iter = iList.end(); // start at end
while( iter != iList.begin() ) //go to beginning
cout << *iter-- << ' '; // decrement
iterator

but unfortunately this doesn’t work. (For one thing, the range will be wrong (from n to 1,
 instead of from n–1 to 0).
 To iterate backward you can use a reverse iterator. The ITEREV program shows an example
 where a reverse iterator is used to display the contents of a list in reverse order.
Common STL Containers: Map
 Advantages:
 Fast Search Time: The elements in a map are stored in a sorted order based on their
keys. This allows for efficient binary search operations, resulting in fast retrieval of
elements.
 Automatic Sorting: The map automatically sorts its elements based on the keys. This can
be a significant advantage when the data needs to be maintained in a sorted order
without the need for manual sorting.
 Unique Keys: Each key in a map must be unique. This property ensures that there are no
duplicate keys, which can be useful in scenarios where uniqueness is crucial.
 Associative Relationships: The map allows you to establish associations between keys
and values. So, it is easy to implement and work with key-value pairs in your program.
 Dynamic Size: The size of a map can change dynamically as elements are inserted or
removed. This dynamic nature is useful when the number of elements in the container is
not known in advance.
Common STL Containers: Map
 Disadvantages:
 Memory Overhead: The underlying data structure of a map typically involves the use of
pointers and dynamic memory allocation, which can result in a higher memory overhead
compared to some other containers.
 Slower Insertion and Deletion: Inserting or deleting elements in a map involves
maintaining the sorted order of the elements, which can make these operations slower
compared to unordered containers like unordered_map.
 Not Cache-Friendly: The memory access patterns of a binary search tree, on which a map
is based, may not be as cache-friendly as some other data structures. This can lead to
slightly slower performance in certain scenarios.
 Limited Iteration Performance: While searching for a specific element is efficient,
iterating over all elements in a map may not be as fast as in some other containers,
especially when compared to contiguous memory structures.
Common STL Containers: Set
 Advantages:
 Sorted Order: std::set maintains elements in sorted order, which can be advantageous in
scenarios where you need to iterate through elements in a specific order.
 Unique Elements: std::set ensures that all elements are unique. This can simplify certain
algorithms and prevent duplicate entries.
 Efficient Lookup: Searching for an element in a set has a time complexity of O(log n),
making it efficient for applications that require quick lookups.
 Dynamic Size: std::set dynamically adjusts its size, making it suitable for situations where
the number of elements can change during runtime.
Common STL Containers: Set
 Disadvantages:
 No Duplicate Elements: While the uniqueness of elements can be an advantage, it can
also be a limitation if you need to store multiple occurrences of the same value.
 Insertion Overhead: Inserting elements into a std::set can have a higher time complexity
(O(log n)) compared to other containers like std::unordered_set. If frequent insertions
and removals are necessary, an std::unordered_set might be a better choice.
 Limited Operations: std::set does not support direct access or modification of individual
elements. You can only insert and remove elements, but not change them directly. If you
need to modify elements, you may need to erase and insert again.
 Memory Overhead: std::set may have a higher memory overhead compared to other
containers due to the need to maintain a sorted order. If memory efficiency is crucial,
you might want to consider alternatives.
 Iterating Complexity: Although elements are in sorted order, iterating through them has
a time complexity of O(n), where n is the size of the set. If frequent iteration is a primary
concern, other containers like std::vector may be more suitable.
Common STL Containers: Queue
 Advantages:
 Efficient for FIFO Operations: Queues are designed to efficiently handle elements in a
first-in, first-out manner.
 Easy to Use: It provides a simple and easy-to-use interface, with member functions like
push(), pop(), front(), and empty().
 Memory Management: STL queues handle memory management internally, so
developers don't need to worry about memory allocation and deallocation when adding
or removing elements.
 Thread Safety: In a multithreaded environment, STL queues (like other containers in STL)
are generally thread-safe, meaning they can be safely used in concurrent programs
without the need for additional synchronization.
 Standardized Interface: Being part of the C++ Standard Template Library, queues in STL
provide a standardized interface. This allows for consistency and portability across
different C++ implementations.
Common STL Containers: Queue
 Disadvantages:
 Fixed Size: STL queues have a fixed size once created. If dynamic resizing is required,
developers may need to implement their own logic or choose a different container type.
 No Random Access: Unlike some other data structures, queues do not provide random
access to elements. Access is limited to the front and back of the queue, which might be
a limitation in certain scenarios.
 Limited Functionality: While queues are excellent for FIFO operations, they may not be
the best choice for scenarios that require operations like sorting or searching. Other data
structures, such as vectors or lists, might be more suitable for such cases.
 Overhead: There might be a slight overhead associated with using a queue due to the
additional functionality it provides. For simple scenarios, this overhead may be
unnecessary.
 Dependency on STL: If you're working in an environment where STL is not available or
not desired, using STL containers, including queues, might not be an option.
Common STL Containers: Stack
Stack
 Characteristics:
 LIFO (Last-In, First-Out) data structure
 Typically implemented using deque or vector.
 Use Cases:
 When you need to implement a stack or perform operations like depth-first search.
STL Iterators
 What are Iterators?
 Iterators are objects that allow you to traverse the elements of a container.
 Iterators act as pointers to elements within a container.
 Types of Iterators
 begin(): Points to the first element.
 end(): Points one past the last element.
 different containers may have additional types of iterators (e.g., rbegin(), rend() for reverse iteration).
 How to Use Iterators
 Initialize an iterator using begin().
 Iterate through the container elements using a loop.
 Terminate the loop when the iterator reaches end().
 Code Example: Iterating through a Vector
 Next code demonstrates how to use iterators to iterate through a vector
 Benefits of Iterators
 Advantages of using iterators are abstraction, compatibility with various containers, and ease of use.
Example 1: Using Iterator
#include <iostream>
#include <vector>

int main() {
std::vector<int> v1 = { 1, 2, 3, 4, 5 };
// Using iterators to traverse the vector
for (std::vector<int>::iterator it = v1.begin(); it != v1.end(); ++it) {
std::cout << *it << " ";
}
return 0;
}

Page
Using Iterators to Manipulate Containers
 Iterators provide a way to access and manipulate each element of the container
sequentially, allowing you to update, insert, or delete elements as needed.
 This approach is often used for tasks like searching and replacing specific elements, filtering
data, or applying transformations to elements within the container without the need for
explicit loops.
 It can make code more efficient and concise by abstracting away the iteration logic and
providing a clean way to interact with container elements.
 Examples of common modifications:
 Inserting elements.
 Deleting elements.
 Modifying elements.
Example 2: Modifying Elements in a List
#include <iostream>
#include <list>
int main() {
std::list<int> myList = { 1, 2, 3, 4, 5 };

// Using iterators to modify elements

std::list<int>::iterator it = myList.begin();
++it; // Move to the second element

// Modify the second element

*it = 42;

// Display the modified list

for (const int& value : myList) {
std::cout << value << " ";
}
return 0;
} Page
STL Algorithms
Common Algorithms
 Sorting algorithms (std::sort)
 Searching algorithms (std::find)
 Transforming algorithms (std::transform)
 And many more...
Sorting with std::sort
 Example: Sorting a vector
 Syntax: std::sort(begin, end)
 In-place sorting
 Sorting data using std::sort.
Searching with std::find
 Searching for an element
 Syntax: std::find(begin, end, value)
 Returns an iterator to the found element or end()
 Finding elements in a list.
Transforming with std::transform
 Applying a function to elements
 Syntax: std::transform(begin1, end1, begin2, operation)
 Modifies elements or creates a new container
 • Example 6: Applying algorithms for data transformation.
Example 3: using std::transform
#include <iostream>
#include <vector>
#include <algorithm>
int doubleValue(int x) { return 2 * x; } // Function to double a value
int main() {
std::vector<int> num = { 1, 2, 3, 4, 5 };
// Create a destination vector to store the transformed values
std::vector<int> transformedNumbers(num.size());
// Use std::transform to double each element in the 'numbers' vector and
store
// the result in 'transformedNumbers'
std::transform(num.begin(), num.end(), transformedNumbers.begin(),
doubleValue);
// Print the original and transformed vectors
std::cout << "Original numbers: ";
for (int num : numbers) { std::cout << num << " "; }
std::cout << "\nTransformed numbers: ";
for (int num : transformedNumbers) { std::cout << num << " "; } Page
std::cout << std::endl; return 0;
Accumulating with std::accumulate
Example 4: using std::accumulate
#include <iostream>
#include <vector>
#include <numeric>
int main() {
std::vector<int> numbers = { 1, 2, 3, 4, 5 };
// Use std::accumulate to sum all the elements in the 'numbers' vector
int sum = std::accumulate(numbers.begin(), numbers.end(), 0);

// Print the original vector and the accumulated sum

std::cout << "Original numbers: ";
for (int num : numbers) {
std::cout << num << " ";
}

std::cout << "\nSum of numbers: " << sum << std::endl;

return 0;
} Page
Applying Algorithms to Container Data
 How to apply algorithms to different container types (e.g., vector, list)
 Using iterators to specify the range
 Be mindful of container requirements (e.g., random access for sorting)

Algorithm Complexity
 Discuss time and space complexity of algorithms
 Help choose the right algorithm for specific tasks
 Example: O(N log N) for std::sort

Benefits of STL Algorithms

 Code reusability and readability
 Improved maintainability
 Enhanced efficiency through optimized implementations