Object Oriented Programming Using C++: C++ STL Programming.pptx

 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.
Introduction to STL

 Containers
 Vector: Dynamic array.
 List: Doubly linked list.
 Algorithms
 Sort: Sorting elements.
 Find: Searching elements.
 Iterators
 Input Iterators: Read-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.
Components of STL
 Map: Key-value pairs.
 Set: Unique values collection.
 Transform: Modifying elements.
 Many more for various operations.
 Output Iterators: Write-only traversal.

STL Containers
Sequence
Containers
vector
forward_list
deque
Associative
Containers
set
multiset
map
multimap
Container
Adapters
stack
queue
priority_queue
Unordered Associative
Containers
unordered_set
unordered_multiset
unordered_map
unordered_multimap
STL Containers
list
C++ array

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,
expandable array
Quick random access (by index number)
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
accessed at either end
Quick random access (using index number).
Quick insert or erase (push and pop) at either the beginning
or the end

Container Adapters
Container Implementation Characteristic
stack Can be implemented
as vector, list, or deque
Insert (push) and remove (pop) at one end only
queue Can be implemented
as list or deque
Insert (push) at one end and remove (pop) at other end
priority_queue Can be implemented
as vector or deque
Insert (push) in random order at one end and remove (pop) in
sorted order from other end

Associative Containers
Container Characteristic Advantages and Disadvantages
set Stores only the key objects
Only one key of each value allowed
The set is used to store unique elements.
The data is stored in a particular order
(increasing order, by default).
multiset Stores only the key objects
Multiple key values allowed
Multiset is similar to a set but also
allows duplicate values.
map Associates key object with value object
Only one key of each value allowed
The map contains elements in the form of unique key-
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
Multiple key values allowed
Multimap is similar to a map but allows duplicate key-
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

#include <iostream>
#include <algorithm> //for find()
using namespace std;
int arr[] = { 11, 00, 22, 33, 44, 55, 66, 77 };
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
if((ptr-arr) < 8)
cout << "First object with value 33 found at offset " << (ptr-arr) << endl;
else
cout << "Not Found" << endl;
return 0;
}
Example 1: Using find() Algorithm

#include <iostream>
#include <algorithm> //for count()
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 2: Using count() Algorithm

#include <iostream>
#include <algorithm>
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 foundn";
else
cout << "Match Found at Index " << (ptr - source) << endl;
return 0;
}
Example 3: Using search() Algorithm

#include <iostream>
// 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 4: Using sort() Algorithm

#include <iostream>
#include <algorithm> // for sort()
#include <functional> // for greater<>
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 5: Using greater<>() Function Object

#include <iostream>
#include <string> // for strcmp()
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 6: Using Custom Function Object

#include <iostream>
#include <algorithm> // for merge()
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;
}
Example 7: Using merge() Algorithm

 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.
Adding _if to Algorithms

#include <iostream>
#include <string>
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;
}
Example 8: Using find_if() 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:
The for_each() Algorithm

#include <iostream>
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) << ' ';
}
Example 9: Using for_each() 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[].
The transform() Algorithm

#include <iostream>
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
return (in * 2.54); // return result
}
Example 10: Using transform() Algorithm

 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.
Vector

#include <iostream>
#include <vector>
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;
}
Example 11: Using vector Container

#include <iostream>
#include <vector>
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 12: Using swap(), empty(), back(), and pop_back()

#include <iostream>
#include <vector>
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>
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: ";
cout << v[i] << ' '; // 100 110 115 120 130
v.erase( v.begin()+2 ); // erase element 2
cout << "nAfter erasure: ";
cout << v[i] << ' '; // 100 110 120 130
cout << endl; return 0; }
Example 14: 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.
Using insert() and erase()

 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).
List

#include <iostream>
#include <list>
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 15: Using list Container

#include <iostream>
#include <list>
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
}
cout << endl; return 0;
}
Example 16: Using deque(), merge(), and unique()

 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.
Deque

#include <iostream>
#include <deque>
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;
}
Example 17: Using dque

 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.
 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
float* ptr = start_address;
for(int j=0; j<SIZE; j++)
cout << *ptr++;

 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:
Iterators as Smart Pointers

 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;
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;
Capabilities of Different Iterator Categories

 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.
Iterator Types Accepted by Containers

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

 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:
Data Access using iterators

#include <iostream>
#include <list>
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 18: Data Access using iterators

#include <iostream>
#include <list>
int main() {
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 19: Data Insertion using iterators
* operator works on the
left side of the equal
sign as well as the right

#include <iostream>
#include <list>
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 20: Using find() Algorithm and Iterator
A list iterator is only a
bidirectional iterator, so you
can’t perform arithmetic with it

#include <iostream>
#include <vector>
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 21: Using find() Algorithm and Iterator
You can do arithmetic with random
access iterators, such as those used
with vectors and queues

#include <iostream>
#include <vector>
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;
}
Example 22: Using copy() Algorithm and Iterator

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

 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: Map

 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: Set

 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: Queue

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.
Common STL Containers: Stack

 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.
STL Iterators

#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;
}
Example 1: Using Iterator
Page 1

 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.
Using Iterators to Manipulate Containers

#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;
}
Example 2: Modifying Elements in a List
Page 1

Common Algorithms
 Sorting algorithms (std::sort)
 Searching algorithms (std::find)
 Transforming algorithms (std::transform)
 And many more...
STL Algorithms

 Example: Sorting a vector
 Syntax: std::sort(begin, end)
 In-place sorting
 Sorting data using std::sort.
Sorting with std::sort

 Searching for an element
 Syntax: std::find(begin, end, value)
 Returns an iterator to the found element or end()
 Finding elements in a list.
Searching with std::find

 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.
Transforming with std::transform

#include <iostream>
#include <vector>
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 << " "; }
std::cout << std::endl; return 0;
}
Example 3: using std::transform
Page 1

Accumulating with 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;
}
Example 4: using std::accumulate
Page 1

 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
Applying Algorithms to Container Data

Object Oriented Programming Using C++: C++ STL Programming.pptx

More Related Content

Similar to Object Oriented Programming Using C++: C++ STL Programming.pptx (20)

More from RashidFaridChishti (20)

Recently uploaded (20)

Object Oriented Programming Using C++: C++ STL Programming.pptx