STL Introduction in C++

STL means Standard Template Library. It provides generic components that can work with different data types.

For example, instead of creating your own dynamic array, you can use std::vector.

#include <vector>

std::vector<int> numbers;

The same vector can be used with different data types.

The main parts of STL include:

• Containers – store collections of data.
• Iterators – provide a way to access elements.
• Algorithms – perform operations such as sorting and searching.
• Function Objects – objects that can behave like functions.
• Allocators – support memory allocation for containers.

Containers, iterators, and algorithms are especially important for beginners.

STL provides reusable and tested components for common programming tasks.

• Reduces the amount of code.
• Provides ready-to-use data structures.
• Provides common algorithms.
• Supports generic programming.
• Makes programs easier to maintain.
• Works with many different data types.

Containers are objects used to store collections of values.

Common STL containers include:

STL provides many algorithms for common operations.

Some commonly used algorithms are:

• sort()
• find()
• reverse()
• count()
• max()
• min()
• binary_search()

Most standard algorithms are available through the <algorithm> header.

A vector is a dynamic array that can automatically change its size.

#include <vector>

std::vector<int> numbers;

numbers.push_back(10);
numbers.push_back(20);
numbers.push_back(30);

The vector now contains three integers.

Vector elements can be accessed using indexes.

#include <iostream>
#include <vector>

int main() {

    std::vector<int> numbers = {
        10, 20, 30
    };

    std::cout <<
        numbers[0];

    return 0;
}

The first element has index 0.

The push_back() function adds an element to the end of a vector.

std::vector<int> numbers;

numbers.push_back(10);
numbers.push_back(20);
numbers.push_back(30);

The vector becomes:

10 20 30

The size() function returns the number of elements in a container.

std::vector<int> numbers = {
    10, 20, 30, 40
};

std::cout <<
    numbers.size();

Output:

4

An iterator is an object that can be used to move through elements of an STL container.

std::vector<int> numbers = {
    10, 20, 30
};

for(
    auto it = numbers.begin();
    it != numbers.end();
    ++it
) {

    std::cout <<
        *it << " ";
}

begin() returns an iterator to the first element and end() represents the position just after the last element.

A range-based for loop provides a simple way to traverse an STL container.

std::vector<int> numbers = {
    10, 20, 30
};

for(int value : numbers) {

    std::cout <<
        value << " ";
}

This is often easier to read than manually using iterators.

The sort() algorithm sorts elements in ascending order by default.

#include <algorithm>
#include <vector>

std::vector<int> numbers = {
    40, 10, 30, 20
};

std::sort(
    numbers.begin(),
    numbers.end()
);

The resulting order is:

10 20 30 40

The find() algorithm searches for a value in a range.

#include <algorithm>
#include <vector>

std::vector<int> numbers = {
    10, 20, 30
};

auto result =
    std::find(
        numbers.begin(),
        numbers.end(),
        20
    );

if(
    result != numbers.end()
) {

    std::cout <<
        "Found";
}

The reverse() algorithm reverses the elements in a range.

std::vector<int> numbers = {
    10, 20, 30
};

std::reverse(
    numbers.begin(),
    numbers.end()
);

The vector becomes:

30 20 10

The count() algorithm counts how many times a value occurs in a range.

std::vector<int> numbers = {
    10, 20, 10, 30, 10
};

int total =
    std::count(
        numbers.begin(),
        numbers.end(),
        10
    );

std::cout <<
    total;

Output:

3

A set stores unique values. Its elements are maintained in sorted order according to its comparison rules.

#include <set>

std::set<int> numbers;

numbers.insert(30);
numbers.insert(10);
numbers.insert(20);
numbers.insert(10);

The duplicate 10 is not stored twice.

A map stores data as key-value pairs.

#include <map>

std::map<int, std::string> students;

students[101] =
    "Rahul";

students[102] =
    "Priya";

Here, the student ID is the key and the student's name is the value.

The std::pair type stores two related values.

#include <utility>

std::pair<int, std::string> student;

student.first = 101;
student.second = "Rahul";

The first value is accessed using first and the second using second.

A stack follows the LIFO principle: Last In, First Out.

#include <stack>

std::stack<int> numbers;

numbers.push(10);
numbers.push(20);
numbers.push(30);

std::cout <<
    numbers.top();

Output:

30

A queue follows the FIFO principle: First In, First Out.

#include <queue>

std::queue<int> numbers;

numbers.push(10);
numbers.push(20);
numbers.push(30);

std::cout <<
    numbers.front();

Output:

10

A deque is a double-ended queue. It supports efficient insertion and removal at both ends.

#include <deque>

std::deque<int> numbers;

numbers.push_back(20);
numbers.push_front(10);

for(int value : numbers) {

    std::cout <<
        value << " ";
}

Output:

10 20

Many STL containers provide common member functions.

STL algorithms can also be used with strings because strings provide iterators.

#include <algorithm>
#include <iostream>
#include <string>

int main() {

    std::string name =
        "rahul";

    std::reverse(
        name.begin(),
        name.end()
    );

    std::cout <<
        name;

    return 0;
}

The same general algorithm can operate on different suitable ranges.

STL is based heavily on templates. This allows many containers and algorithms to work with different data types.

std::vector<int> numbers = {
    10, 20, 30
};

std::vector<double> prices = {
    10.5, 20.5, 30.5
};

std::vector<std::string> names = {
    "Rahul",
    "Priya"
};

The same container concept can be used with different types.

Different STL components are declared in different standard headers.

• Forgetting to include the required header.
• Forgetting the std:: namespace qualifier when needed.
• Accessing a vector using an invalid index.
• Dereferencing an iterator that is equal to end().
• Assuming that every container stores elements in the same order.
• Using the wrong container for a particular requirement.
• Modifying a container while using an iterator without understanding iterator invalidation rules.
• Confusing stack LIFO behavior with queue FIFO behavior.

Different containers are designed for different types of operations.

The appropriate choice depends on the operations your program needs to perform.

• Choose a container according to the required operations.
• Prefer STL containers instead of manually managing basic dynamic collections.
• Use standard algorithms when they match the task.
• Use range-based for loops when they improve readability.
• Use const when data should not be modified.
• Check iterator validity before dereferencing.
• Understand the performance characteristics of containers and algorithms.
• Keep STL code simple and readable.

#include <algorithm>
#include <iostream>
#include <vector>

int main() {

    std::vector<int> marks = {
        75, 92, 68, 85, 92
    };

    std::sort(
        marks.begin(),
        marks.end()
    );

    std::cout <<
        "Sorted marks: ";

    for(int mark : marks) {

        std::cout <<
            mark << " ";
    }

    int total =
        std::count(
            marks.begin(),
            marks.end(),
            92
        );

    std::cout <<
        "\n92 occurs "
        << total
        << " times.";

    return 0;
}

This example uses a vector, the sort() algorithm, a range-based loop, and the count() algorithm.

#include <algorithm>
#include <iostream>
#include <vector>

int main() {

    std::vector<int> numbers = {
        40, 10, 30, 20
    };

    std::sort(
        numbers.begin(),
        numbers.end()
    );

    for(int number : numbers) {

        std::cout <<
            number << " ";
    }

    return 0;
}

STL provides powerful reusable tools for C++ programming. Once you understand containers, iterators, and algorithms, you can solve many programming problems with less code and clearer logic.