21CSC101T

Object Oriented Design and Programming

UNIT-5
Standard Template Library
 What is STL???

• The Standard Template Library (STL) is a set of C++ template classes to

provide common programming data structures and functions
• such as lists, stacks, arrays, etc.
• It is a library of container classes, algorithms, and iterators.
• It is a generalized library and so, its components are parameterized.
• A working knowledge of template classes is a prerequisite for working
with STL.
 Why use STL???
• STL offers an assortment of containers
• STL publicizes the time and storage complexity of its containers
• STL containers grow and shrink in size automatically
• STL provides built-in algorithms for processing containers
• STL provides iterators that make the containers and algorithms flexible and efficient.
• STL is extensible which means that users can add new containers and new algorithms
such that:
– STL algorithms can process STL containers as well as user defined containers
– User defined algorithms can process STL containers as well user defined
containers
 C++ Standard Template Libraries
• In 1990, Alex Stepanov and Meng Lee of Hewlett Packard Laboratories extended
C++ with a library of class and function templates which has come to be known as
the STL.
• In 1994, STL was adopted as part of ANSI/ISO Standard C++.
 The C++ Standard Template Libraries

• STL had three basic components:

– Containers
Generic class templates for storing collection of data.
– Algorithms
Generic function templates for operating on containers.
– Iterators
• Generalized ‘smart’ pointers that facilitate use of containers.
• They provide an interface that is needed for STL algorithms to operate
on STL containers.
• String abstraction was added during standardization.
 STL has four
components

Containers Iterators Algorithms Functions

 STL Containers

Sequence and Associative Containers

 Containers
• Containers or container classes store objects and data.
• There are in total seven standard “first-class” container
classes and three container adaptor classes and only seven
header files that provide access to these containers or
container adaptors.
– Sequence Containers
– Container Adaptors
– Associative Containers
– Unordered Associative Containers
 Sequence Containers

• vector
Implement data structures which • list
can be accessed in a sequential • deque
manner. • arrays
• forward-list
Topic : Sequence Container: Vector List
 Sequence Containers: Vector
• Vectors are same as dynamic arrays with the ability to resize itself
automatically when an element is inserted or deleted, with their
storage being handled automatically by the container.
• Vector elements are placed in contiguous storage so that they can be
accessed and traversed using iterators.
• In vectors, data is inserted at the end.
• Inserting at the end takes differential time, as sometimes there may
be a need of extending the array.
• Removing the last element takes only constant time because no
resizing happens.
• Inserting and erasing at the beginning or in the middle is linear in
time.
 Functions
associated with
the vector

Iterators Capacity Element access Modifiers

 functions associated with the vector

Iterators
begin() end() rbegin() rend() cbegin() cend() crbegin() crend()

Returns a Returns a
Returns a reverse iterator Returns a
Returns an reverse iterator Returns a constant reverse constant reverse
pointing to the constant iterator iterator pointing
Returns an iterator pointing pointing to the iterator pointing
theoretical Returns a pointing to the to the theoretical
iterator pointing to the theoretical last element in to the last
element constant iterator theoretical element
to the first element that the vector element in the
preceding the pointing to the element that preceding the
element in the follows the last (reverse vector (reverse
first element in first element in follows the last first element in
vector element in the beginning). It beginning). It
the vector the vector. element in the the vector
vector moves from last (considered as moves from last
to first element vector. to first element (considered as
reverse end) reverse end)

The iterator functions in vectors handle the data inside the vector, not the index of the elements directly.

If you specifically need the index of elements, you can use a traditional loop with an index variable
// C++ program to illustrate the iterators in vector
#include <iostream>
#include <vector>

using namespace std;

int main()
{
vector<int> g1;
Output:
for (int i = 1; i <= 5; i++)
g1.push_back(i); Output of begin and end: 1 2 3 4 5
Output of cbegin and cend: 1 2 3 4 5
cout << "Output of begin and end: "; Output of rbegin and rend: 5 4 3 2 1
for (auto i = g1.begin(); i != g1.end(); ++i) Output of crbegin and crend : 5 4 3 2 1
cout << *i << " ";

cout << "\nOutput of cbegin and cend: ";

for (auto i = g1.cbegin(); i != g1.cend(); ++i)
cout << *i << " ";

cout << "\nOutput of rbegin and rend: ";

for (auto ir = g1.rbegin(); ir != g1.rend(); ++ir)
cout << *ir << " ";

cout << "\nOutput of crbegin and crend : ";

for (auto ir = g1.crbegin(); ir != g1.crend(); ++ir)
cout << *ir << " ";

return 0;
}
 functions associated with the vector

Capacity

size() max_size() capacity() resize(n) empty() shrink_to_fit() reserve()

Returns the size Reduces the

Returns the of the storage capacity of the Requests that
Returns the maximum space currently Resizes the container to fit the vector
number of number of allocated to the container so Returns whether its size and capacity be at
elements in the elements that vector that it contains the container is destroys all least enough to
vector. the vector can expressed as ‘n’ elements. empty. elements contain n
hold. number of beyond the elements.
elements. capacity.
shrink_to_fit(): If reserve(): If you know you're
So, max_size() gives you capacity(): It tells you going to need a big box to put a
you have extra
the upper limit of your lot of smaller boxes in, you can
storage capability, while how many smaller space inside the
big box that you're reserve the big box in advance to
capacity() tells you how boxes the big box can not using, you can make sure it's big enough. This
shrink the big box way, you won't have to get a
much space you're hold now without to fit exactly the bigger box later when you need
currently using./used needing to get a number of smaller more space.
boxes inside it.
bigger box
// C++ program to illustrate the capacity function in vector
#include <iostream>
#include <vector>

using namespace std;

int main()
{
vector<int> g1;

for (int i = 1; i <= 5; i++)

g1.push_back(i); Output:
Size : 5
cout << "Size : " << g1.size(); Capacity : 8
cout << "\nCapacity : " << g1.capacity();
Max_Size : 4611686018427387903
cout << "\nMax_Size : " << g1.max_size();
Size : 4
// resizes the vector size to 4 Vector is not empty
g1.resize(4); Vector elements are: 1 2 3 4

// prints the vector size after resize()

cout << "\nSize : " << g1.size();

// checks if the vector is empty or not

if (g1.empty() == false)
cout << "\nVector is not empty";
else
cout << "\nVector is empty";

// Shrinks the vector

g1.shrink_to_fit();
cout << "\nVector elements are: ";
for (auto it = g1.begin(); it != g1.end(); it++)
cout << *it << " ";

return 0;
}
 functions associated with the vector

Element access

reference
at(g) front() back() data()
operator [g]

Returns a direct
Returns a Returns a Returns a pointer to the
Returns a memory array
reference to the reference to the reference to the reference to the
element at element at last element in used internally by
first element in the vector to store
position ‘g’ in the position ‘g’ in the the vector
the vector its owned
vector vector
elements.
// C++ program to illustrate the element accesser in vector
#include <bits/stdc++.h>
using namespace std;

int main()
{
vector<int> g1;

for (int i = 1; i <= 10; i++)

g1.push_back(i * 10); Output:
Reference operator [g] : g1[2] = 30
cout << "\nReference operator [g] : g1[2] = " << g1[2]; at : g1.at(4) = 50
front() : g1.front() = 10
cout << "\nat : g1.at(4) = " << g1.at(4); back() : g1.back() = 100
The first element is 10
cout << "\nfront() : g1.front() = " << g1.front();

cout << "\nback() : g1.back() = " << g1.back();

// pointer to the first element

int* pos = g1.data();

cout << "\nThe first element is " << *pos;

return 0;
}
 functions associated with the vector

Modifiers

assign() push_back() pop_back() insert() erase() swap() clear() emplace() emplace_back()

It is used to
It is used to It is used to insert a new
It assigns new It inserts new remove swap the It is used to It extends the element into
It is used to elements elements from contents of one the vector
value to the It pushes the pop or remove remove all the container by
vector elements into a before the a container vector with elements of the inserting new container, the
elements from element at the from the another vector new element is
elements by vector from the a vector from vector element at
replacing old back specified specified of same type. container position added to the
the back. position position or Sizes may end of the
ones
range. differ. vector
 Sequence Container: List

• Lists are sequence containers that allow non-contiguous memory

allocation.
• As compared to vector, list has slow traversal, but once a position
has been found, insertion and deletion are quick.
• Normally, when we say a List, we talk about doubly linked list.
• For implementing a singly linked list, we use forward list.
#include <iostream>
#include <list> cout << "\nList 2 (gqlist2) is : ";
#include <iterator>
using namespace std;
cout << "\nList 1 (gqlist1) is : ";
//function for printing the elements in a list showlist(gqlist1);
void showlist(list <int> g)
{
showlist(gqlist2);
list <int> :: iterator it; cout << "\ngqlist1.front() : " << gqlist1.front();
for(it = g.begin(); it != g.end(); ++it)
cout << '\t' << *it;
cout << "\ngqlist1.back() : " << gqlist1.back();
cout << '\n'; cout << "\ngqlist1.pop_front() : ";
}
int main() gqlist1.pop_front();
{ showlist(gqlist1);
list <int> gqlist1, gqlist2;
for (int i = 0; i < 10; ++i) cout << "\ngqlist2.pop_back() : ";
{ gqlist2.pop_back();
gqlist1.push_back(i * 2);
gqlist2.push_front(i * 3); showlist(gqlist2);
} cout << "\ngqlist1.reverse() : ";
gqlist1.reverse();
showlist(gqlist1);
cout << "\ngqlist2.sort(): ";
gqlist2.sort();
showlist(gqlist2);
return 0;
}
The output of the above program is :

List 1 (gqlist1) is : 0 2 4 6 8 10 12 14 16 18
List 2 (gqlist2) is : 27 24 21 18 15 12 9 6 3 0
gqlist1.front() : 0
gqlist1.back() : 18
gqlist1.pop_front() : 2 4 6 8 10 12 14 16 18
gqlist2.pop_back() : 27 24 21 18 15 12 9 6 3
gqlist1.reverse() : 18 16 14 12 10 8 6 4 2
gqlist2.sort(): 3 6 9 12 15 18 21 24 27
 functions associated with the Lists

front() back() push_front(g) push_back(g) pop_front() pop_back()

Adds a new Removes the first Removes the last

Returns the value Returns the value Adds a new
element ‘g’ at the element of the list, element of the list,
of the first element of the last element element ‘g’ at the
beginning of the and reduces size and reduces size
in the list. in the list . end of the list.
list . of the list by 1. of the list by 1
 functions associated with the Lists

begin() end() rbegin() rend() cbegin() cend() crbegin() crend()

returns a constant
end() function returns a constant reverse iterator
returns a reverse returns a constant
begin() function returns an iterator reverse iterator which points to
returns a reverse iterator which random access returns a constant
returns an iterator pointing to the which points to the theoretical
iterator which points to the iterator which random access
pointing to the theoretical last the last element of element preceding
points to the last position before the points to the iterator which points
first element of element which to the end of the list. the list i.e reversed the first element in
element of the list. beginning of the beginning of the
the list follows the last beginning of the list i.e. the
list. list.
element. container. reverse end of the
list.
 functions associated with the Lists

empty() insert() erase() assign() remove()

Inserts new elements Assigns new elements

Removes a single Removes all the elements
Returns whether the list is in the list before the to list by replacing
element or a range of from the list, which are
empty(1) or not(0). element at a specified current elements and equal to given element.
elements from the list.
position. resizes the list.
 functions associated with the Lists

reverse() size() list resize() sort()

Returns the number of Used to resize a list Sorts the list in

Reverses the list.
elements in the list. container. increasing order.
 functions associated with the Lists

max_size() unique() emplace_front() emplace_back() clear()

function is used to
insert a new function is used to
Removes all element into the insert a new function is used to
Returns the duplicate element into the remove all the
maximum number list container, the
consecutive new element is list container, the elements of the list
of elements a list elements from the new element is container, thus
container can hold. added to the
list. beginning of the added to the end making it size 0.
list. of the list.
 functions associated with the Lists
operator= swap() splice() merge() emplace()

This operator is This function is

used to assign used to swap the Used to transfer Extends list by
new contents to contents of one Merges two inserting new
elements from one sorted lists into
the container by list with another list to another. element at a given
replacing the list of same type one position.
existing contents. and size.
 MCQ
• 1. In which classes we can define the list and vector classes?
A. Abstract classes
B. child classes
C. STL classes
D. String classes
• 2. Which of the following are the components of STL?
A. Algorithms
B. containers
C. function, iterators
D. All of these
• 3. Which of the following is to provide a different interface for
sequential containers?
A. container adopters
B. sequence containers
C. queue
D. Associative Containers
• 4. By STL how many components it has been kept?
A. 3
B. 4
C.1
D. unlimited
 Sequence Containers: Deque
�Double ended queues are sequence containers with the feature of expansion and
contraction on both the ends.
�They are similar to vectors, but are more efficient in case of insertion and deletion of
elements. Unlike vectors, contiguous storage allocation may not be guaranteed.
�Double Ended Queues are basically an implementation of the data structure double
ended queue. A queue data structure allows insertion only at the end and deletion
from the front.
�This is like a queue in real life, wherein people are removed from the front and added
at the back. Double ended queues are a special case of queues where insertion and
deletion operations are possible at both the ends.
�The functions for deque are same as vector, with an addition of push and pop
operations for both front and back.
 Methods of Deque

deque insert() rbegin() rend() cbegin() max_size() assign() resize()

Returns a
Returns a constant iterator
Inserts an pointing to the
Returns a reverse iterator Returns the
element. And first element of
reverse iterator which points to maximum Assign values to
returns an the container, Function which
which points to the position number of the same or
iterator that that is, the changes the size
the last element before the elements that a different deque
points to the first iterator cannot of the deque.
of the deque beginning of the deque container container.
of the newly be used to
(i.e., its reverse deque (which is can hold.
inserted modify, only
beginning). considered its
elements. traverse the
reverse end).
deque.
#include <iostream>
#include <deque>
using namespace std;

void showdq(deque <int> g)

{
deque <int> :: iterator it;
for (it = g.begin(); it != g.end(); ++it)
cout << '\t' << *it;
cout << '\n';
}

int main() OUTPUT:

{
deque <int> gquiz; The deque gquiz is : 15 20 10 30
gquiz.push_back(10); gquiz.size() : 4
gquiz.push_front(20);
gquiz.max_size() : 4611686018427387903
gquiz.push_back(30);
gquiz.at(2) : 10
gquiz.push_front(15);
cout << "The deque gquiz is : "; gquiz.front() : 15
showdq(gquiz); gquiz.back() : 30
gquiz.pop_front() : 20 10 30
cout << "\ngquiz.size() : " << gquiz.size(); gquiz.pop_back() : 20 10
cout << "\ngquiz.max_size() : " << gquiz.max_size();

cout << "\ngquiz.at(2) : " << gquiz.at(2);

cout << "\ngquiz.front() : " << gquiz.front();
cout << "\ngquiz.back() : " << gquiz.back();

cout << "\ngquiz.pop_front() : ";

gquiz.pop_front();
showdq(gquiz);

cout << "\ngquiz.pop_back() : ";

gquiz.pop_back();
showdq(gquiz);

return 0;
}
 Methods of Deque

push_front() push_back() pop_front() pop_back() front() back() clear() erase() empty() size()

Is used to Is used to return

Is used to
remove the size of the
This function is Is used to pop Is used to pop Is used to Is used to remove all the Is used to check
This function is elements from a deque container
used to push or remove or remove reference the reference the elements of the if the deque
used to push container from or the number
elements into a elements from a elements from a first element of last element of deque container is
elements into a the specified of elements in
deque from the deque from the deque from the the deque the deque container, thus empty or not.
deque from the position or the deque
front. front. back. container. container. making its size
back. range. container.
0.
 Sequence Containers: Array
�The introduction of array class from C++11 has offered a better alternative for C-
style arrays. The advantages of array class over C-style array are :-
�Array classes knows its own size, whereas C-style arrays lack this property. So
when passing to functions, we don’t need to pass size of Array as a separate
parameter.
�With C-style array there is more risk of array being decayed into a pointer. Array
classes don’t decay into pointers
�Array classes are generally more efficient, light-weight and reliable than C-style
arrays.
�
 Operations on array

at() get() operator[]

This function This is similar

This function This function is not the to C-style
is used to is also used to member of arrays. This
access the access the array class but method is also
elements of elements of overloaded used to access
array. array. function from array
class tuple. elements.
Array get() function in C++ STL
• The array::get() is a built-in function in C++ STL which returns a reference to the i-th
element of the array container.
• Syntax:
• get(array_name) Parameters: The function accepts two mandatory parameters which are
described below.
• i – position of an element in the array, with 0 as the position of the first element.
• arr_name – an array container.
• Return Value: The function returns a reference to the element at the specified position in
the array
• Time complexity: O(1)
// // C++ code to demonstrate working of array, to() and get()
#include<iostream>
#include<array> // for array, at()
#include<tuple> // for get()
using namespace std;
int main()
{
// Initializing the array elements
array<int,6> ar = {1, 2, 3, 4, 5, 6};

// Printing array elements using at()

cout << "The array elements are (using at()) : ";
for ( int i=0; i<6; i++) Output:
cout << ar.at(i) << " "; The array elements are (using at()) : 1 2 3 4 5 6
cout << endl; The array elements are (using get()) : 1 2 3 4 5 6
The array elements are (using operator[]) : 1 2 3 4
// Printing array elements using get() 5 6
cout << "The array elements are (using get()) : ";
cout << get<0>(ar) << " " << get<1>(ar) << " ";
cout << get<2>(ar) << " " << get<3>(ar) << " ";
cout << get<4>(ar) << " " << get<5>(ar) << " ";
cout << endl;

// Printing array elements using operator[]

cout << "The array elements are (using operator[]) : ";
for ( int i=0; i<6; i++)
cout << ar[i] << " ";
cout << endl;

return 0; }
 Operations on array

front() back()

This returns the This returns

first element of the last element
array. of array.
// C++ code to demonstrate working of front() and back()
#include<iostream>
#include<array> // for front() and back()
using namespace std;
int main()
{
// Initializing the array elements
array<int,6> ar = {1, 2, 3, 4, 5, 6};
Output:
// Printing first element of array
First element of array is : 1
cout << "First element of array is : "; Last element of array is : 6
cout << ar.front() << endl;

// Printing last element of array

cout << "Last element of array is : ";
cout << ar.back() << endl;

return 0;

}
 Operations on array

size() max_size()

It returns the number of elements in It returns the maximum number of

array. This is a property that C-style elements array can hold i.e, the
arrays lack. size with which array is declared.
// C++ code to demonstrate working of size() and max_size()
#include<iostream>
#include<array> // for size() and max_size()
using namespace std;
int main()
{
// Initializing the array elements
array<int,6> ar = {1, 2, 3, 4, 5, 6}; Output:
The number of array elements is : 6
// Printing number of array elements Maximum elements array can hold is : 6
cout << "The number of array elements is : ";
cout << ar.size() << endl;

// Printing maximum elements array can hold

cout << "Maximum elements array can hold is : ";
cout << ar.max_size() << endl;

return 0;

}
 Operations on array

size() max_size()

It returns the number of elements in It returns the maximum number of

array. This is a property that C-style elements array can hold i.e, the
arrays lack. size with which array is declared.
swap() :- The swap() swaps all elements of one array with other.

for (int i=0; i<6; i++)

// C++ code to demonstrate working of swap() cout << ar1[i] << " ";
#include<iostream> cout << endl;
// Swapping ar1 values with ar
#include<array> // for swap() and array ar.swap(ar1);
using namespace std;
int main() // Printing 1st and 2nd array after swapping
cout << "The first array elements after swapping are : ";
{ for (int i=0; i<6; i++)
cout << ar[i] << " ";
// Initializing 1st array cout << endl;
cout << "The second array elements after swapping are : ";
array<int,6> ar = {1, 2, 3, 4, 5, 6}; for (int i=0; i<6; i++)
cout << ar1[i] << " ";
// Initializing 2nd array cout << endl;
return 0;
array<int,6> ar1 = {7, 8, 9, 10, 11, 12}; }

// Printing 1st and 2nd array before

swapping
cout << "The first array elements before
swapping are : ";
for (int i=0; i<6; i++)
cout << ar[i] << " ";
cout << endl;
cout << "The second array elements
before swapping are : ";
Output:
The first array elements before swapping are : 1 2 3 4 5 6
The second array elements before swapping are : 7 8 9 10 11 12
The first array elements after swapping are : 7 8 9 10 11 12
The second array elements after swapping are : 1 2 3 4 5 6
 Operations on array

empty() fill()

This function returns

This function is used to
true when the array size
fill the entire array with
is zero else returns
a particular value.
false.
// C++ code to demonstrate working of empty() and fill()
#include<iostream>
#include<array> // for fill() and empty()
using namespace std;
int main()
{
array<int,6> ar; // Declaring 1st array
array<int,0> ar1; // Declaring 2nd array
ar1.empty()? cout << "Array empty":
cout << "Array not empty";
cout << endl; // Checking size of array if it is empty
// Filling array with 0
ar.fill(0); Output:
// Displaying array after filling Array empty
cout << "Array after filling operation is : "; Array after filling operation is : 0 0 0 0 0 0
for ( int i=0; i<6; i++)
cout << ar[i] << " ";
return 0;
}
MCQ

1.Which of the following does not support any insertion or deletion?

a) Array
b) Vector
c) Dequeue
d) List

2) Which of the following header file is required to use deque container in

C++?
a)<queue>
b)<deque>
c)<dqueue>
d)<cqueue>

3) What is the correct output of the given code snippets?

a)10 20 30
b)Garbage Value
c)Syntax error
d)Runtime error
4.Which of the following class template are based on arrays?
a) vector
b) list
c) dequeue
d) both vector & dequeue
Topic : STL Stack
 STL Stack
• Stacks are a type of container adaptors with LIFO(Last In First Out) type of working, where a new element is
added at one end and (top) an element is removed from that end only.

• Stack uses an encapsulated object of either vector or deque (by default) or list (sequential container class)
as its underlying container, providing a specific set of member functions to access its elements.

Stack Syntax:-
• For creating a stack, we must include the <stack> header file in our code. We then use this syntax to define
the std::stack:

• template <class Type, class Container = deque<Type> > class stack;Type – is the Type of element contained
in the std::stack. It can be any valid C++ type or even a user-defined type.
Example:

#include <iostream>
#include <stack>
using namespace std;
int main() {
OUTPUT : 22 21
stack<int> stack;
stack.push(21);
stack.push(22);
stack.push(24);
stack.push(25);

stack.pop();
stack.pop();
while (!stack.empty()) {
cout << stack.top() <<" ";
stack.pop();
}
}
 Functions associated with stack

empty() size() top() push(g) pop()

Returns a
Adds the element Deletes the top
Returns whether Returns the size of reference to the
‘g’ at the top of the most element of
the stack is empty the stack top most element
stack the stack
of the stack

Time Complexity Time Complexity Time Complexity : Time Complexity : Time Complexity
: O(1) : O(1) O(1) O(1) : O(1)
// CPP program to demonstrate working of STL stack
#include <iostream>
#include <stack>
using namespace std;

void showstack(stack <int> s)

{
while (!s.empty())
{
cout << '\t' << s.top();
s.pop();
}
cout << '\n';
}

int main ()
{
stack <int> s;
Output:
s.push(10); The stack is : 1 5 20 30 10
s.push(30); s.size() : 5
s.push(20);
s.push(5); s.top() : 1
s.push(1); s.pop() : 5 20 30 10
cout << "The stack is : ";
showstack(s);

cout << "\ns.size() : " << s.size();

cout << "\ns.top() : " << s.top();

cout << "\ns.pop() : ";

s.pop();
showstack(s);

return 0;
}
 List of functions of Stack
top()

empty()

push()

swap()

emplace()
stack::top() top() function is used to
reference the top(or the newest) // Application of top() function
#include <iostream>
element of the stack.
#include <stack>
Syntax : using namespace std;
stackname.top()
int main()
Parameters: No value is needed to {
pass as the parameter. int sum = 0;
Return Value: Direct reference to the stack<int> mystack;
mystack.push(1);
top element of the stack
mystack.push(8);
container. mystack.push(3);
mystack.push(6);
mystack.push(2);
OUTPUT : 20
// Stack becomes 1, 8, 3, 6, 2
Time Complexity: O(n) while (!mystack.empty()
Auxiliary Space: O(n) sum = sum + mystack.top();
mystack.pop();
}
cout << sum;
return 0;
}
1. What is the Standard Template Library?
a) Set of C++ template classes to provide common programming data structures and functions
b) Set of C++ classes
c) Set of Template functions used for easy data structures implementation
d) Set of Template data structures only.
Answer: a
STL expanded as Standard Template Library is set of C++ template classes to provide common
programming data structures and functions.

2. How many components STL has?

a) 1
b) 2
c) 3
d) 4
Answer : d

3. What are Container Adaptors?

a) Containers that implements data structures which can be accessed sequentially
b) Containers that implements sorted data structures for fast search in O(logn)
c) Containers that implements unsorted(hashed) data structures for quick search in O(1)
d) Containers that provide a different interface for sequential containers.
Answer: d
Container Adaptors is the subset of Containers that provides a different interface for sequential containers.
Topic :Associative Containers: Map,
Multimap
 Associative Containers: Map, Multimap

• STL components are now part of standard c++

library defined in namespace std

• The standard template library (STL) contains

– Containers
– Algorithms
– Iterators
 Containers supported by STL
Containers are objects that hold data
 Associative containers

• They are designed to support direct access to

elements using keys
• Not sequential
• There are four types
– Set
– Multiset
– Map
– Multimap
• Store data in a structure called tree which
facilitates fast searching, deletion and insertion
• Slow for random access and inefficient for sorting
 Associative Container

• Associative containers implement sorted data

structures that can be quickly searched (O(log n)
complexity).
• Set collection of unique keys, sorted by keys
• map collection of key-value pairs, sorted by keys,
keys are unique

• Multiset collection of keys, sorted by keys

• Multimap collection of key-value pairs, sorted by
keys
 Associative containers

• Set and Multiset

– Store number of items and provide operations
for manipulating them using the values as keys
– Difference between set and multiset
• Multiset allows duplicates , but set does not allow
– Map and multimap
• Used to store pairs of items – one called the key
and the other called the value
– Difference between map and multimap
• Map allows only one key for a given value while
multimap permits multiple keys
 Member Functions &Element Access
• Here are following points to be noted related to various functions
we used in the above example −
• The push_back( ) member function inserts value at the end of the
vector, expanding its size as needed.
• The size( ) function displays the size of the vector.
• The function begin( ) returns an iterator to the start of the vector.
• The function end( ) returns an iterator to the end of the vector.
• Accessing elements
• at(g) – Returns a reference to the element at position ‘g’ in the
vector
• front() – Returns a reference to the first element in the vector
• back() – Returns a reference to the last element in the vector
Other functions
• empty : This method returns true if the list is empty else returns
false.
• size : This method can be used to find the number of elements
present in the list.
• front and back : front() is used to get the first element of the list
from the start while back() is used to get the first element of the list
from the back.
• swap: Swaps two list, if there is exception thrown while swapping
any element, swap() throws exception. Both lists which are to be
swapped must be of the same type, i.e you can’t swap list of an
integer with list of strings.
• reverse: This method can be used to reverse a list completely.
• sort: sort method sorts the given list. It does not create new sorted
list but changes the position of elements within an existing list to
sort it.
24
 Algorithms

• Retrieve or Non-mutating Algorithms

• Mutating Algorithms
• Sorting Algorithms
• Set Algorithms
• Relational Algorithms
 Non Mutating Algorithms
• Adjacent_find –adj pairs
• Count-occurrence of a value
• Count_if—no.of elements that matches a predicate
• Equal-if two ranges are equal
• Find-first occurrence of a value
• Find_end
• Find_first_of()
• Find_if()- find the elements that matches a predicate
• For_each()- apply an operation to each element
• Mismatch()
• Search_ch()
• Search_n()
 Mutating Algorithms

• Copy()
• Copy_backward()
 Algorithms : find()
• InputIterator find (InputIterator first, InputIterator last, const T& val);
• The find() algorithm looks for an element matching val between start and
end.
• If an element matching val is found, the return value Is an iterator that
points to that element. Otherwise, the return value is an iterator that points
to end.
#include <iostream>
#include <algorithm>
using namespace std;
int main () {
int myints[] = { 10, 20, 30, 40 };
int * p = find (myints, myints+4, 30);
if (p != myints+4) cout << "Element found in myints: " << *p << '\n';
else cout << "Element not found in myints\n“;
return 0; }
 Find() Algorithm
#include <vector>
#include <algorithm>
#include <iostream>
int key;
int arr[] = { 12, 3, 17, 8, 34, 56, 9 }; // standard C array
vector<int> v(arr, arr+7); // initialize vector with C array
vector<int>::iterator iter;
cout << ”enter value :”;
cin >> key;
iter=find(v.begin(),v.end(),key); // finds integer key in v
if (iter != v.end()) // found the element
cout << ”Element ” << key << ” found” << endl;
else
cout << ”Element ” << key << ” not in vector v” << endl;
 Find_If() Algorithm

#include <vector>
#include <algorithm>
#include <iostream>
Bool mytest(int n) { return (n>21) && (n <36); };
int arr[] = { 12, 3, 17, 8, 34, 56, 9 }; // standard C array
vector<int> v(arr, arr+7); // initialize vector with C array
vector<int>::iterator iter;
iter=find_if(v.begin(),v.end(),mytest);
// finds element in v for which mytest is true
if (iter != v.end()) // found the element
cout << ”found ” << *iter << endl;
else
cout << ”not found” << endl;
 Algorithm: count()
#include <iostream>
• count() returns the number of elements
in the given range that are equal to given #include <algorithm>
value. #include <vector>
• Syntax for count is: using namespace std;
• count(first ,last ,value) : This will int main ()
return number of the element in {
range defined int values[] =
• by iterators first and last ( excluded ) {5,1,6,9,10,1,12,5,5,5,1,8,9,7,46};
which are equal ( == ) the value int count_5 = count(values, values+15, 5);
/* now count_5 is equal to 4 */
vector<int> v(values, values+15);
int count_1 = count(v.begin(), v.end(), 1);
/* now count_1 is equal to */
return 0;
}
 Count_If() Algorithm

#include <vector> output

#include <algorithm> found 2 elements
#include <iostream>
Bool mytest(int n) { return (n>14) && (n <36); };
int arr[] = { 12, 3, 17, 8, 34, 56, 9 }; // standard C
array
vector<int> v(arr, arr+7); // initialize vector with C
array
int n=count_if(v.begin(),v.end(),mytest);
// counts element in v for which mytest is true
cout << ”found ” << n << ” elements” << endl;
Algorithms : search
• This function is used to perform searches for a given sequence in a
given range. There are two variations of the search():

• search(first1 ,last1 ,first2 ,last2) : This function searches for the

sequence defined by first2 and last2 in the range first1 and
last1(where last1 is excluded). If there is a match an iterator to the
first element of the sequence in the range [first1,last1] is returned,
else iterator to last1 is returned.
• search(first1 ,last1 ,first2 ,last2 ,cmp_functions) : Here
cmp_function is used to decide how to check the equality of two
elements, it is useful for non-numeric elements like strings and
objects.

7
Algorithms : Search Example 1
#include<iostream>
#include<algorithm> if (i != v1.end()) {
#include<vector> cout << "Sequence found at position: "
using namespace std; << distance(v1.begin(), i) << endl;
} else {
cout << "Sequence not found in v1" <<
int main() endl;
{ }
int inputs1[] = { 1,2,3,4,5,6,7,8};
int inputs2[] = { 2,3,4}; j = search(v1.begin() + 2, v1.end(), v2.begin
(), v2.end());
vector<int> v1(inputs1, inputs1+9);
vector<int> v2(inputs2, inputs2+3); // Output the result
if (j != v1.end()) {
vector<int>::iterator i ,j; cout << "Sequence found at position: "
<< distance(v1.begin(), j) << endl;
i = search(v1.begin(), v1.end(), v2.begin(), v2.end()); } else {
cout << "Sequence not found in v1 from
position 2 onwards" << endl;
/* now i points to the second element in v1 */ }

j = search(v1.begin()+2, v1.end(), v2.begin(), v2.end()); return 0;

}
/* j now points to the end of v1 as no sequence is equal to 2,3,4 in
[v1.begin()+2 ,v1.end()] */
}

8
Algorithms : sort()
• This function of the STL, sorts the contents of the given range.
There are two version of sort() :
• sort(start_iterator, end_iterator ) : sorts the range defined by
iterators start_iterator and end_iterator in ascending order.
• sort(start_iterator, end_iterator, compare_function) : this also
sorts the given range but you can define how the sorting should be
done by compare_function.

9
Algorithms : sort() Example 1
#include<iostream> v1.push_back(5);
#include<algorithm> v1.push_back(1);
#include<vector>
/* now the vector v1 is 8,4,5,1 */
using namespace std;
vector<int>::iterator i, j;
bool compare_function(int i, int j) i = v1.begin(); // i now points to beginning of the vector v1
{
j = v1.end(); // j now points to end of the vector v1
return i > j; // return 1 if i>j else 0
} sort(i,j); //sort(v1.begin() , v1.end() ) can also be used
bool compare_string(string i, string j) /* now the vector v1 is 1,4,5,8 */
{
return (i.size() < j.size()); /* use of compare_function */
} int a2[] = { 4,3,6,5,6,8,4,3,6 };

int main() sort(a2,a2+9,compare_function); // sorts a2 in descending order

{ /* here we have used compare_function which uses operator(>),
int arr[5] = {1,5,8,4,2}; that result into sorting in descending order */
sort(arr , arr+5);
// sorts arr[0] to arr[4] in ascending order /* compare_function is also used to sort
/* now the arr is 1,2,4,5,8 */ non-numeric elements such as*/

vector<int> v1; string s[]={"a" , "abc", "ab" , "abcde"};

v1.push_back(8); sort(s,s+4,compare_string);
/* now s is "a","ab","abc","abcde" */
v1.push_back(4);
}

10
 Algorithm: merge()
Combines the elements in the sorted ranges [first1,last1) and
[first2,last2), into a new range beginning at result with all its elements
sorted.
Syntax: OutputIterator merge (InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, OutputIterator result);
#include <iostream>
#include <algorithm>
#include <vector> The resulting vector contains: 5 10 10 15 20 20 25 30 40 50
using namespace std; Press any key to continue . . .
int main () {
int first[] = {5,10,15,20,25};
int second[] = {50,40,30,20,10};
vector<int> v(10);
sort (first,first+5);
sort (second,second+5);
merge (first,first+5,second,second+5,v.begin());
cout << "The resulting vector contains:";
for (std::vector<int>::iterator it=v.begin(); it!=v.end(); ++it)
cout << ' ' << *it; std::cout << '\n'; return 0; }
for_each
#include <iostream>
#include <algorithm>
using namespace std;
Syntax :
void in_to_cm(double); //declaration
int main() Function for_each (InputIterator
{ //array of inches values first, InputIterator last, Function
double inches[] = { 3.5, 6.2, 1.0, 12.75, fn);
4.33 };
//output as centimeters
for_each(inches, inches+5, in_to_cm); The for_each() algorithm
cout << endl; allows you to do something to
return 0; every item in a container. You
} write your own function to
void in_to_cm(double in) //convert and determine what that
display as centimeters
{
“something” is. Your function
cout << (in * 2.54) << ‘ ‘; can’t change the elements in
} the container, but it can use
The output looks like this: or display their values.
8.89 15.748 2.54 32.385 10.9982}

11
 Transform()
#include <iostream>
#include <algorithm> The transform() algorithm does something
using namespace std; to every item in a container, and places the
int main() resulting values in a different container (or
{ //array of inches values the same one).
double inches[] = { 3.5, 6.2, 1.0, 12.75, 4.33 }; Again, a user-written function determines
double centi[5]; what will be done to each item. The return
double in_to_cm(double); //prototype type of this function must be the same as
//transform into array centi[] that of the destination container.
transform(inches, inches+5, centi, in_to_cm);
for(int j=0; j<5; j++) //display array centi[]
cout << centi[j] << ‘ ‘;
cout << endl; Syntax:
return 0; OutputIterator transform (InputIterator
} first1, InputIterator last1,
double in_to_cm(double in) //convert inches to
centimeters
OutputIterator result, UnaryOperation
{ op);
return (in * 2.54); //return result
}
 Maps

• Associative container that associates

objects of type Key with objects of type
Data
– Sorted according to keys

• Map
– Stores (key, object) pairs
– Unimodal: duplicate keys not allowed
– AKA: table, associative array
 The STL Map Template

• map()
• map(const key_compare& comp)
• pair<iterator, bool> insert(const value_type&
x)
– Inserts x into the map
• iterator insert(iterator pos, const value_type&
x)
– Inserts x into the map, using pos as a hint to where it will be
inserted
• void insert(iterator, iterator)
– Inserts a range into the map
 STL Map Template
• void erase(iterator pos)
– Erases the element pointed to by pos
• size_type erase(const key_type& k)
– Erases the element whose key is k
• void erase(iterator first, iterator last)
– Erases all elements in a range
• iterator find(const key_type& k)
– Finds an element whose key is k.
• data_type& operator[](const key_type& k)
– Returns a reference to the object that is associated
with a particular key.
– If the map does not already contain such an
object, operator[] inserts the default object
data_type()
 Map Usage Example
#include <iostream>
#include<iterator>
#include <map>
#include <algorithm>
#include<cstring>
using namespace std;
map<const char*, int> months;
map<const char*, int>::iterator cur;
int main() {
months["january"] = 31;
months["february"] = 28;
months["march"] = 31;
months["april"] = 30;
months["may"] = 31;
months["june"] = 30;
months["july"] = 31;
months["august"] = 31;
months["september"] = 30;
months["october"] = 31;
months["november"] = 30;
months["december"] = 31;
cout << "june: " << months["june"] << endl;
cur = months.find("june"); first=key
second=value
cout << "Month " << cur->first<< ":" << cur->second << endl;
}
 Example Maps
#include <iostream>
#include <map>

using namespace std;

int main ()
{
map<int,string> m;
m.insert(pair<int,string>(5,"ABCD"));
m.insert(pair<int,string>(6,"EFGH"));
m.insert(pair<int,string>(7,"IJKL"));
cout << m.at(5)<<endl ;
cout << m.at(6) <<endl;
// prints value associated with key
5,6

/* note that the parameters in the above at() are the keys not the index */

cout << m[7]<<endl ; // prints value associated with key 7

m.at(1) = “abc"; // changes the value associated with key 5

m[6] = “XYZ"; // changes the value associated with key 6
cout<<m.at(5)<<endl;

cout << m.at(6) <<endl;

}
 Multi Set Example
#include<iostream>
#include <set>
using namespace std;
int main()
{
// multiset declare
multiset<int> s;
// Elements added to set
s.insert(12);
s.insert(10);
s.insert(2);
s.insert(10); // duplicate added
s.insert(90);
s.insert(85);
s.insert(75);
s.insert(90);
s.insert(95);
s.insert(45);
s.insert(80);
s.insert(45);
// Iterator declared to traverse
// set elements
 Function Objects
• Functors (Function Objects or Functionals) are simply put object + ().
• In other words, a functor is any object that can be used with () in the
manner of a function.
• This includes normal functions, pointers to functions, and class objects
for which the () operator (function call operator) is overloaded, i.e.,
classes for which the function operator()() is defined.
• Sometimes we can use a function object when an ordinary function
won't work. The STL often uses function objects and provides several
function objects that are very helpful.
• Function objects are another example of the power of generic
programming and the concept of pure abstraction. We could say that
anything that behaves like a function is a function. So, if we define an
object that behaves as a function, it can be used as a function.
 Function Objects
#include <iostream>
#include<vector>>
#include <algorithm>
using namespace std; function in class
class InCm {
public: obj of class to access function
void operator()(double in) use that obj as parameter
{
cout << (in * 2.54) << " ";
}
};
int main()
{
vector<double> inches;
inches.push_back(3.5);
inches.push_back(7);

InCm in_to_cm;
for_each (inches.begin(), inches.end(), in_to_cm);
cout << endl;
return 0;
}
 Advantages of function object

• Function object are "smart functions."

• Each function object has its own type.

• Function objects are usually faster than

ordinary functions.
 MCQ
• Which container can have the same keys?
a) map
b) multimap
c) unordered map
d) set
Answer: b
• Which container is used to keep priority based
elements?
a) queue
b) stack
c) set
d) priority queue
Answer: d
 MCQ
• How many components STL has?
a) 1
b) 2
c) 3
d) 4
Answer: d
Explanation: STL has four components namely Algorithms, Containers,
Functors and Iterators.
▪ Which of the following is correct about map and multimap?
a) Map can have same keys whereas multimap cannot
b) Implementation of maps and multimap are different
c) Multimap can have same keys whereas the map cannot
d) Average search time of map is greater than multimap
Answer: c
 MCQ

• Which header is need to be used with

function objects?
a) <function>
b) <functional>
c) <funct>
d) <functionstream>
Answer: b
Explanation: <functional> header is need
to be used with function objects.
Topic :STL Iterators
 STL has four
components

Containers Iterators Algorithms Functions

 STL Iterators

• Are used to point at the memory addresses of STL containers.

• They are primarily used in sequence of numbers, characters etc.
• They reduce the complexity and execution time of program.
 Operations of iterators

begin() end()

This function is used This function is used

to return to return
the beginning the after end
position of the position of the
container. container.
// C++ code to demonstrate the working of iterator, begin() and end()

#include<iostream>
#include<iterator> // for iterators
#include<vector> // for vectors
using namespace std;

int main()
{
vector<int> ar = { 1, 2, 3, 4, 5 }; Output:
// Declaring iterator to a vector
The vector elements are : 1 2 3 4 5
vector<int>::iterator ptr;

// Displaying vector elements using begin() and end()

cout << "The vector elements are : ";

for (ptr = ar.begin(); ptr < ar.end(); ptr++)

cout << *ptr << " ";

return 0;
}
advance() :- This function is used to increment the iterator position till the specified number mentioned in its
arguments.

// C++ code to demonstrate the working of advance()

#include<iostream>
#include<iterator> // for iterators
#include<vector> // for vectors
using namespace std;
int main()
{
vector<int> ar = { 1, 2, 3, 4, 5 };

// Declaring iterator to a vector

vector<int>::iterator ptr = ar.begin(); Output:
The position of iterator after advancing is : 4
// Using advance() to increment iterator position
// points to 4
advance(ptr, 3);

// Displaying iterator position

cout << "The position of iterator after advancing is : ";
cout << *ptr << " ";

return 0;

}
 Operations of iterators

next() prev()

This function returns the This function returns the

new iterator that the new iterator that the
iterator would point iterator would point after
after advancing the decrementing the
positions mentioned in its positions mentioned in its
arguments. arguments.
// C++ code to demonstrate the working of next() and prev()
#include<iostream>
#include<iterator> // for iterators
#include<vector> // for vectors
using namespace std;
int main()
{
vector<int> ar = { 1, 2, 3, 4, 5 };

// Declaring iterators to a vector

vector<int>::iterator ptr = ar.begin();
vector<int>::iterator ftr = ar.end();

// Using next() to return new iterator

Output:
// points to 4 The position of new iterator using next() is : 4
auto it = next(ptr, 3); The position of new iterator using prev() is : 3
// Using prev() to return new iterator
// points to 3
auto it1 = prev(ftr, 3);

// Displaying iterator position

cout << "The position of new iterator using next() is : ";
cout << *it << " ";
cout << endl;

// Displaying iterator position

cout << "The position of new iterator using prev() is : ";
cout << *it1 << " ";
cout << endl;

return 0;
}
inserter() :- This function is used to insert the elements at any position in the container. It accepts 2
arguments, the container and iterator to position where the elements have to be inserted.
// C++ code to demonstrate the working of inserter()
#include<iostream>
#include<iterator> // for iterators
#include<vector> // for vectors
using namespace std;
int main()
{
vector<int> ar = { 1, 2, 3, 4, 5 };
vector<int> ar1 = {10, 20, 30};

// Declaring iterator to a vector Output:

vector<int>::iterator ptr = ar.begin(); The new vector after inserting elements is : 1 2 3 10 20 30 4 5
// Using advance to set position
advance(ptr, 3);

// copying 1 vector elements in other using inserter()

// inserts ar1 after 3rd position in ar
copy(ar1.begin(), ar1.end(), inserter(ar,ptr));

// Displaying new vector elements

cout << "The new vector after inserting elements is : ";
for (int &x : ar)
cout << x << " ";

return 0;
}
Topic : STL Algorithm
Function Objects
 STL has four
components

Containers Iterators Algorithms Functions

 STL Algorithms

• Are used to point at the memory addresses of STL containers.

• They are primarily used in sequence of numbers, characters etc.
• They reduce the complexity and execution time of program.
 STL ALgorithms

• STL has an ocean of algorithms, for all < algorithm > library functions
• Some of the most used algorithms on vectors and most useful one’s in
Competitive Programming are mentioned as follows :
– sort(first_iterator, last_iterator) – To sort the given vector.
– reverse(first_iterator, last_iterator) – To reverse a vector.
– *max_element (first_iterator, last_iterator) – To find the maximum element of a
vector.
– *min_element (first_iterator, last_iterator) – To find the minimum element of a
vector.
– accumulate(first_iterator, last_iterator, initial value of sum) – Does the summation of
vector elements

direct return sum no need of * to acess

 // Reversing the Vector
// A C++ program to demonstrate working of sort(), reverse() reverse(vect.begin(), vect.end());
#include <algorithm>
#include <iostream> cout << "\nVector after reversing is: ";
#include <vector> for (int i=0; i<6; i++)
#include <numeric> //For accumulate operation cout << vect[i] << " ";
using namespace std;
cout << "\nMaximum element of vector is: ";
int main() cout << *max_element(vect.begin(), vect.end());
{
// Initializing vector with array values cout << "\nMinimum element of vector is: ";
int arr[] = {10, 20, 5, 23 ,42 , 15}; cout << *min_element(vect.begin(), vect.end());
int n = sizeof(arr)/sizeof(arr[0]);
vector<int> vect(arr, arr+n); // Starting the summation from 0
cout << "\nThe summation of vector elements is:
cout << "Vector is: "; ";
for (int i=0; i<n; i++) cout << accumulate(vect.begin(), vect.end(), 0);
cout << vect[i] << " ";
return 0;
// Sorting the Vector in Ascending order }
sort(vect.begin(), vect.end());

cout << "\nVector after sorting is: "; Output:

for (int i=0; i<n; i++) Vector before sorting is: 10 20 5 23 42 15 Vector after sorting
cout << vect[i] << " "; is: 5 10 15 20 23 42 Vector before reversing is: 5 10 15 20 23 42
Vector after reversing is: 42 23 20 15 10 5 Maximum element
of vector is: 42
Minimum element of vector is: 5
The summation of vector elements is: 115
count(first_iterator, last_iterator,x) – To count the occurrences of x in vector.
find(first_iterator, last_iterator, x) – Points to last address of vector ((name_of_vector).end()) if element is not
present in vector.
#include <algorithm>
// C++ program to demonstrate working of count() and find()
#include <iostream>
#include <algorithm>
#include <vector>#include <iostream>
using namespace #includestd;
<vector>
int main() using namespace std;
{
int main()
// Initializing
{ vector with array values
int arr[] = {10, 20, 5, //23, 42, 20,vector
Initializing 15};with array values
int arr[] = {10, 20, 5, 23 ,42, 20, 15};
int n = sizeof(arr) / sizeof(arr[0]);
vector<int> vect(arr,int n = sizeof(arr)/sizeof(arr[0]);
arr + n);
vector<int> vect(arr, arr+n);
cout << "Occurrences of 20 in vector : "; Output:
// Counts the occurrences of 20 from of
cout << "Occurrences 1st20 to
in vector : "; Occurrences of 20 in vector: 2
// last element Element found
// Counts the occurrences of 20 from 1st to
cout << count(vect.begin(), vect.end(),
// last element
20);
// find() returns iterator coutto<<last address if vect.end(), 20);
count(vect.begin(),
// element not present
// find() returns iterator to last address if
find(vect.begin(), vect.end(), 5) != vect.end() ? cout << "\nElement found" : cout << "\nElement not found";
// element not present
return 0; find(vect.begin(), vect.end(),5) != vect.end()?
} cout
<< "\nElement found":
cout <<
"\nElement not found";

return 0;
}
 merge() in C++ STL

• C++ offers in its STL library a merge() which is quite

useful to merge sort two containers into
a single container.
It is defined in header “algorithm“. It is implemented in
two ways.
• Syntax 1 : Using operator “<"
// C++ code to demonstrate the working of merge() implementation 1

#include <bits/stdc++.h>
using namespace std;

int main()
{
// initializing 1st container
vector<int> arr1 = { 1, 4, 6, 3, 2 };
Output:
// initializing 2nd container
vector<int> arr2 = { 6, 2, 5, 7, 1 }; The container after merging initial containers
is : 1 1 2 2 3 4 5 6 6 7
// declaring resultant container
vector<int> arr3(10);

// sorting initial containers

sort(arr1.begin(), arr1.end());
sort(arr2.begin(), arr2.end());

// using merge() to merge the initial containers

merge(arr1.begin(), arr1.end(), arr2.begin(), arr2.end(),
arr3.begin());

// printing the resultant merged container

cout << "The container after merging initial containers is : ";

for (int i = 0; i < arr3.size(); i++)

cout << arr3[i] << " ";
return 0;
}
 search() in c++ STL
• std::search is defined in the header file <algorithm> and used to find out the presence of a subsequence
satisfying a condition (equality if no such predicate is defined) with respect to another sequence.
• It searches the sequence [first1, last1) for the first occurrence of the subsequence defined by [first2, last2), and
returns an iterator to its first element of the occurrence, or last1 if no occurrences are found.
• It compares the elements in both ranges sequentially using operator== (version 1) or based on any given
predicate (version 2). A subsequence of [first1, last1) is considered a match only when this is true for all the
elements of [first2, last2). Finally, std::search returns the first of such occurrences.
• It can be used in either of the two versions, as depicted below :
1. For comparing elements using ==
2. For comparison based on a predicate (or condition)
vector2 is present at index

1. For comparing elements using ==

// C++ program to demonstrate the use of std::search
ForwardIterator1 search (ForwardIterator1 first1, ForwardIterator1 #include <iostream>
last1, ForwardIterator2 first2, ForwardIterator2 last2); #include <vector>
#include <algorithm>
using namespace std;
int main()
• first1: Forward iterator to beginning of first container to be {
searched into. int i, j;
last1: Forward iterator to end of first container to be searched into. // Declaring the sequence to be searched into
first2: Forward iterator to the beginning of the subsequence of vector<int> v1 = { 1, 2, 3, 4, 5, 6, 7 };
second container to be searched for. // Declaring the subsequence to be searched for
last2: Forward iterator to the ending of the subsequence of second vector<int> v2 = { 3, 4, 5 };
container to be searched for. // Declaring an iterator for storing the returning pointer
vector<int>::iterator i1;
// Using std::search and storing the result in
• Returns: an iterator to the first element of the first occurrence of // iterator i1
[first2, last2) in [first1, last1), or last1 i1 = std::search(v1.begin(), v1.end(), v2.begin(), v2.end());
if no occurrences are found. // checking if iterator i1 contains end pointer of v1 or not
if (i1 != v1.end()) {
cout << "vector2 is present at index " << (i1 - v1.begin());
} else {
cout << "vector2 is not present in vector1";
}
return 0;
}
Output:
vector2 is present at index 2
 For comparison based on a predicate (or condition) :
// C++ program to demonstrate the use of std::search
• ForwardIterator1 search (ForwardIterator1 first1, // with binary predicate
ForwardIterator1 last1, ForwardIterator2 first2, #include <iostream>
ForwardIterator2 last2, BinaryPredicate pred); #include <vector>
#include <algorithm>
• All the arguments are same as previous template, just one using namespace std;
more argument is added // Defining the BinaryPredicate function
bool pred(int i, int j) Output:
{ vector1 elements are greater than vector2 starting from
• pred: Binary function that accepts two elements as if (i > j)
position 3
arguments (one of each of the two containers, in the same {return 1;}
order), and returns a value convertible to bool. The else
returned value indicates whether the elements are {return 0;}
considered to match in the context of this function. The }
function shall not modify any of its arguments. This can int main()
either be a function pointer or a function object. {
int i, j;
• Returns: an iterator, to the first element of the first // Declaring the sequence to be searched into
occurrence of [first2, last2) satisfying a predicate, in [first1, vector<int> v1 = { 1, 2, 3, 4, 5, 6, 7 };
last1), or last1 if no occurrences are found. // Declaring the subsequence to be compared to based
// on predicate
vector<int> v2 = { 3, 4, 5 };
// Declaring an iterator for storing the returning pointer
vector<int>::iterator i1;
// Using std::search and storing the result in
// iterator i1 based on predicate pred
i1 = std::search(v1.begin(), v1.end(), v2.begin(), v2.end(), pred);
// checking if iterator i1 contains end pointer of v1 or not
if (i1 != v1.end()) {
cout << "vector1 elements are greater than vector2 starting "<< "from position " << (i1 - v1.begin());
} else {
cout << "vector1 elements are not greater than vector2 "<< "elements consecutively.";
}
return 0;
}
 for_each() in STL
// for_each example
• Apply function to range #include <iostream> // std::cout
#include <algorithm> // std::for_each
• Applies function fn to each of the elements in the #include <vector> // std::vector
range [first,last). void myfunction (int i) { // function:
• The behavior of this template function is equivalent to: std::cout << ' ' << i;
}
struct myclass { // function object type:
void operator() (int i) {std::cout << ' ' << i;}
} myobject;
int main ()
Output:
{
myvector contains: 10 20 30
std::vector<int> myvector; myvector contains: 10 20 30
myvector.push_back(10);
myvector.push_back(20);
• Parameters myvector.push_back(30);
first, last std::cout << "myvector contains:";
✔ Input iterators to the initial and final positions in a sequence. The range used is
[first,last), which contains all the elements between first and last, including the for_each (myvector.begin(), myvector.end(), myfunction);
element pointed by first but not the element pointed by last. std::cout << '\n';
Fn // or:
✔ Unary function that accepts an element in the range as argument.
std::cout << "myvector contains:";
This can either be a function pointer or a move constructible function object.
for_each (myvector.begin(), myvector.end(), myobject);
Its return value, if any, is ignored.
std::cout << '\n';
return 0;
}
Functors in C++
 Function objects
• Consider a function that takes only one argument.
• However, while calling this function we have a lot more information that
we would like to pass to this function, but we cannot as it accepts only one
parameter. What can be done?
• One obvious answer might be global variables.
• However, good coding practices do not advocate the use of global
variables and say they must be used only when there is no other
alternative.
• Functors are objects that can be treated as though they are a function or
function pointer.
• Functors are most commonly used along with STLs.
The functor allows an instance object of some class to be called
as if it were an ordinary function.
• Let us consider a function that takes one argument. We can
use this function as function object to do some task on a set of
data
#include <iostream> Output
#include <algorithm>
using namespace std;
int square(int x)
{

return x*x; //return square of x

}
int main()
{
int data[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};

transform(data, data+10, data, square);// array name, elements,

name, square and store #include <iostream>
#include <algorithm>
using namespace std;
for (int i = 0; i<10; i++) void square(int x)
cout << data[i] << endl; {
cout<<x*x<<endl;
} }
int main()
{
int data[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
for_each(data, data+10, square);

}
// A C++ program uses transform() in STL to add 1 to all elements of arr[]
#include <bits/stdc++.h>
using namespace std;

int increment(int x) { return (x+1); }

int main()
{
int arr[] = {1, 2, 3, 4, 5};
int n = sizeof(arr)/sizeof(arr[0]); Output:
2 3 4 5 6
// Apply increment to all elements of
// arr[] and store the modified elements
// back in arr[]
transform(arr, arr+n, arr, increment);

for (int i=0; i<n; i++)

cout << arr[i] << S" ";

return 0;
}