Page No.

Experiment No.:12 Date:__________

Aim : To study standard template library (STL)

Theory:

STL comprises several key components:

● Containers: These are data structures that store collections of objects.

Containers are broadly classified into several types, including:
○ Sequence Containers: These maintain the order of elements and
allow access via sequential iteration. Examples include vector, deque,
and list.
○ Associative Containers: These store elements formed as key-value
pairs, enabling efficient retrieval based on keys. They include set, map,
multiset, and multimap.
○ Unordered Containers: These provide average constant time
complexity for insertions and lookups by using hash tables. Examples
are unordered_set and unordered_map.
● Iterators: Iterators act as pointers that provide a uniform way to traverse the
elements of containers. They enable the manipulation of container elements
in a consistent manner, regardless of the underlying data structure. The STL
defines several iterator types, including input iterators, output iterators,
forward iterators, bidirectional iterators, and random-access iterators.
● Algorithms: The STL includes a rich library of algorithms that can operate on
the elements of containers. These algorithms cover a wide range of
operations such as searching, sorting, transforming, and manipulating data.
They are designed to work seamlessly with iterators, enabling powerful and
flexible data processing capabilities.
● Functors: Functors are objects that can be called as if they are functions. In
the context of the STL, functors enable custom behavior in algorithms,
allowing users to define specific operations for sorting or searching based on
their requirements.

2. Benefits of Using STL

● Efficiency: STL provides well-optimized algorithms and data structures,

improving the performance of software applications. The efficiency of these
components often rivals hand-crafted implementations.
● Reusability: By leveraging templates, STL allows developers to write generic
code that works with any data type. This enhances code reusability and
reduces redundancy.
● Maintainability: STL promotes clean and readable code by abstracting
complex operations and data structures. The use of standardized interfaces
makes it easier for developers to understand and maintain codebases.
● Portability: Being part of the C++ Standard Library, STL is portable across
different platforms and compilers, ensuring consistency in behavior and
performance.

STL Name Roll No

 Page No.

3. Complexity and Performance

STL components come with well-defined performance characteristics, often

expressed in terms of time complexity. Understanding these complexities is crucial
for selecting the appropriate container or algorithm based on the application's needs.
For instance, operations such as insertion, deletion, and lookup have varying
complexities across different container types, influencing the choice of data
structures for specific use cases.

4. Customizing STL Components

STL allows for customization through the use of user-defined types, enabling
developers to create specialized containers, iterators, and algorithms. By
overloading operators and implementing required interfaces, custom types can
seamlessly integrate with the STL.

STL Name Roll No

 Page No.

Program 12[A]:Write a C++ program to implement standard library vector sequence

container

Program: cout<<"\nAfter resize() vector size =

#include<iostream> "<<v.size();
#include<conio.h> v.clear();
#include<vector> cout<<"\nAfter clear() function :";
using namespace std; display(v);
void display(vector <int> &); cout<<"\nIs vector empty =
int main(){ "<<v.empty();
vector <int> v; getch();
cout<<"\nInitial size() = return 0;
"<<v.size(); }
cout<<"\nInitial capacity() = void display(vector <int> & v)
"<<v.capacity(); {
v.push_back(10); for(int i=0;i<v.size();i++)
v.push_back(20); {
v.push_back(30); cout<<" "<<v.at(i);
v.push_back(40); }
v.push_back(50); }
cout<<"\nAfter push_back() size()
= "<<v.size(); Output:
cout<<"\nAfter push_back()
capacity() = "<<v.capacity();
cout<<"\nDisplay vector elements
after push_back() :";
display(v);
cout<<"\nFrist element of vector
= "<<v.front();
cout<<"\nLast element of vector
= "<<v.back();
vector<int>::iterator itr=v.begin();
itr = itr + 5;
v.insert(itr,60);
cout<<"\nDisplay vector elements
after insertion :";
display(v);
v.pop_back();
cout<<"\nDisplay vector elements
after pop_back() :";
display(v);
v.erase(v.begin()+2,v.begin()+4);
cout<<"\nDisplay vector elements
after erase() :";
display(v);
v.resize(10;
Program 12[B]:Write a C++ program to implement standard library list sequence
container

STL Name Roll No

 Page No.

Program: merging :";

#include<iostream> display(list3);
#include<conio.h> list3.reverse();
#include<list> cout<<"\nList3 elements after
using namespace std; reversing :";
void display(list <int> &); display(list3);
int main(){ list3.push_back(9);
list <int> list1; list3.push_back(9);
list <int> list2; cout<<"\nUpdated list3
list <int> list3; elements :";
cout<<"\nsize of list1 = display(list3);
"<<list1.size(); list3.unique();
list1.push_front(2); cout<<"\nAfter removing
list1.push_front(1); duplicates from list3 elements are :";
list1.push_back(3); display(list3);
list1.push_back(4); list3.remove(9);
cout<<"\nList1 elements after cout<<"\nAfter removing all 9's
push_front() and push_back() :"; from list3 elements :";
display(list1); display(list3);
list1.pop_front(); list2.swap(list3);
cout<<"\nAfter removing front cout<<"\nAfter swapping list2 : ";
element of list1 : "; display(list2);
display(list1); cout<<"\nAfter swapping list3 : ";
list1.insert(list1.begin(),1); display(list3);
cout<<"\nAfter inserting an
element at begining of list1 : "; list3.assign(list2.begin(),list2.end());
display(list1); cout<<"\nAfter assiging list2
list2.push_front(5); elements to lsit3 :";
list2.push_front(6); display(list3);
list2.push_back(9); getch();
list2.push_back(8); return 0;
list2.push_back(7); }
cout<<"\nList2 elements after void display(list <int> & v){
push_front() and push_back() :"; list<int> :: iterator p;
display(list2); for(p = v.begin(); p!=v.end(); ++p)
list2.sort(); cout<<" "<<*p;
cout<<"\nList2 elements after }
sorting :";
display(list2);
list1.splice(list1.end(),list2);
cout<<"\nList1 elements after
splicing :";
display(list1);
list3.merge(list1);
cout<<"\nList3 elements after

Output:

STL Name Roll No

 Page No.

STL Name Roll No

 Page No.

Program 12[C]:Write a C++ program to implement standard library deque sequence

container

Program: Output:
#include<iostream>
#include<conio.h>
#include<deque>
using namespace std;
void display(deque <double> &);
int main(){
deque <double> d;
d.push_front(2.2);
d.push_front(3.5);
d.push_back(1.1);
cout<<"\nDeque elements
after insertion are as follows :";
display(d);
d.pop_front();
cout<<"\nDeque elements
after pop_front() are as follows :";
display(d);
d[1]=3.3;
cout<<"\nDeque elements
after subscript insertion using [] are
as follows :";
display(d);
getch();
return 0;
}
void display(deque <double> & d1){
for(int i=0;i<d1.size();i++)
{
cout<<" "<<d1[i];
}
}

STL Name Roll No

 Page No.

Program 12[D]:Write a C++ program to implement standard library stack adapter

class

Program: {
#include<iostream> s.push(i);
#include<conio.h> cout<<s.top()<<" ";
#include<vector> }
#include<list> }
#include<deque>
#include<stack> template<class T>
using namespace std; void popelement(T & s)
template<class T> void {
pushelement(T & s); while(!s.empty())
template<class T> void popelement(T {
& s); cout<<s.top()<<" ";
int main(){ s.pop();
stack <int> dequestack; }
stack <int,vector<int> > }
vectorstack;
stack <int,list<int> > liststack; Output:
cout<<"\npushing elements
onto dequestack : ";
pushelement(dequestack);
cout<<"\npushing elements
onto vectorstack : ";
pushelement(vectorstack);
cout<<"\npushing elements
onto liststack : ";
pushelement(liststack);
cout<<"\
n------------------------------------------------"
;
cout<<"\npopping element from
dequestack : ";
popelement(dequestack);
cout<<"\npopping element from
vectorstack : ";
popelement(vectorstack);
cout<<"\npopping element from
liststack : ";
popelement(liststack);
getch();
return 0;
}
template<class T>
void pushelement(T & s){
for(int i=0;i<10;i++)

STL Name Roll No

 Page No.

Program 12[E]:Write a C++ program to implement standard library queue adapter

class template

Program: Output:
#include<iostream>
#include<conio.h>
#include<queue>
using namespace std;
int main(){
queue <double> q;
q.push(1.1);
q.push(2.2);
q.push(3.3);
cout<<"\nPopping elements from
queue : ";
while(!q.empty()){
cout<<q.front()<<" ";
q.pop();
}
getch();
return 0;
}

STL Name Roll No

 Page No.

Program 12[F]:Your code

Program: Output:

Conclusion:

STL Name Roll No