STL stands for the Standard Template Library. It is a collection of C++ template classes that provide common data structures and functions with which to manipulate them. These data structures include vectors, lists, queues, and stacks, among others. The functions provided by the STL include operations such as sorting, searching, and manipulating the data stored in these data structures. The STL is designed to be efficient, flexible, and easy to use, making it a valuable tool for C++ programmers.
STL has 4 components –
Algorithms
Containers
Functions
Iterators
Algorithms
An algorithm is a set of instructions or rules that are followed in order to perform a specific task or solve a problem. It is a step-by-step process for solving a problem or completing a task. Algorithms are used in many different fields, including computer science, mathematics, and engineering. They are essential for solving complex problems and making efficient use of resources.
Search algorithms, which are used to search for specific items or values in a dataset. These algorithms can be applied to various problems, such as finding a particular element in an array or searching for a specific route on a map.
Linear Search
Binary search
Hashing
There are many more such searching algorithms in the world of programming.
Sorting algorithms, which are used to organize a dataset in a specific order. These algorithms can be applied to various problems, such as sorting a list of numbers in ascending or descending order.
Bubble Sort
Selection Sort
Merge Sort
Quick Sort
There are various sorting algorithms, which differs in the Time & Space Complexity of the algorithms otherwise work of all such algorithms performs the same task.
This is not the end of algorithms, there are end number of algorithms with their defined functionalities and depending upon their purpose of use.
Containers
In the C++ programming language, the Standard Template Library (STL) includes a type of container called a vector. Vectors are sequences of elements that can be accessed using an index, and they provide efficient insertion, deletion, and resizing operations.
Some common types of STL containers include:
Sequence Containers
Vector
List
Deque
Array
Forward_list
Container Adaptors
Queue
Priority_queue
Stack
Associative Containers
Set
Multiset
Map
Multimap
Unordered Associated Containers
Unordered_set
Unordered_multiset
Unordered_map
Unordered_multimap
Functions
A function is a block of code that performs a specific task and is given a name. Functions are defined using the keyword ‘void’ or the data type of the value that the function will return, followed by the function's name and a set of parentheses ‘()’. The code that makes up the function is placed within a pair of braces ‘{}’. Here is an example of a simple C++ function that calculates the area of a rectangle :
int rectangle_area(int length, int width) {
return length * width;
}
In this example, the function is named ‘rectangle_area’, and it takes two arguments, ‘length’ and ‘width’, which are used to calculate the area of a rectangle. The function returns an ‘int’ value, which is the calculated area of the rectangle. To call the function, we would use its name followed by the values for the ‘length’ and ‘width’ arguments in the parentheses :
int main() {
// Calculate the area of a rectangle with length 5 and width 10
int area = rectangle_area(5, 10);
// Print the area to the console
std::cout << "The area of the rectangle is: " << area << std::endl;
return 0;
}
In this example, the ‘rectangle_area’ function is called with the values ‘5’ and ‘10’ for the ‘length’ and ‘width’ arguments, respectively. The function calculates the area of the rectangle and returns the result, which is then stored in the ‘area’ variable. Finally, the area value is printed to the console using the ‘cout’ statement.
The output of the above demonstration -
The area of the rectangle is: 50
Types of functions –
User Defined Function –
User-defined functions are user/customer-defined blocks of code specifically tailored to reduce complexity in large programs. They are also commonly known as "tailor-made functions" that are designed only to satisfy the situation the user is facing while reducing the complexity of the overall program.
Library Function –
Library functions are also called "built-in functions". These functions are part of a predefined compiler package and consist of special functions with special and different semantics. Built-in functions have the advantage that you can use them directly without defining them, whereas user-defined functions require you to declare and define the function before you can use it.
for example:
sqrt(), setw(), strcat(), etc.
There are two ways to pass parameters –
Pass by Value – In this parameter passing technique, the value of the actual parameter is copied into the function's formal parameter, and the two kinds of parameters are stored in different places. Therefore, changes made inside the function are not reflected in the caller's actual parameters.
Pass by Reference – Both the actual and formal parameters refer to the same location, so changes made within the function are actually reflected in the caller's actual parameter.
Iterators
In C++, an iterator is an object that allows you to traverse through the elements of a container, such as a vector or a list. It provides a way to access the elements of the container sequentially, without the need to know the underlying structure of the container. For example, you can use an iterator to iterate over the elements of a vector and print each element to the screen.
Here is an example of using an iterator to traverse through the elements of a vector in C++ -
#include <iostream>
#include <vector>
using namespace std;
int main()
{
// Create a vector and add some elements to it.
vector<int> myVector;
myVector.push_back(1);
myVector.push_back(2);
myVector.push_back(3);
// Get an iterator for the vector.
vector<int>::iterator it;
// Use the iterator to traverse through the vector and print each element.
cout << "Vector elements: ";
for (it = myVector.begin(); it != myVector.end(); it++)
{
cout << *it << " ";
}
cout << endl;
return 0;
}
Output –
Vector elements: 1 2 3
In this example, we create a vector and add some elements to it. Then we create an iterator for the vector using the ‘vector<int>::iterator’ type, which is a type that is defined by the vector class. We use this iterator to traverse through the elements of the vector, and print each element to the screen.
The ‘begin()’ and ‘end()’ methods of the vector are used to get the iterator that points to the first element of the vector and the iterator that points to the element that comes after the last element of the vector, respectively. The ‘*’ operator is used to dereference the iterator and get the value of the element that it points to.
Learn more about STL – Click here
List of C++ Container Function –
Also, read – Best C++ IDEs in 2023