Chapter 33: STL Introduction

What is STL?

The Standard Template Library (STL) is a powerful library in C++ that provides a set of common classes and functions for data structures and algorithms. It includes:

• Containers: Data structures like vectors, lists, and sets.
• Iterators: Objects used to traverse elements in containers.
• Algorithms: Functions for operations like searching, sorting, and manipulating data.

Components of STL

1. Containers

Containers are data structures that store collections of objects. The main types of containers in STL are:

• Sequence Containers: Maintain the order of elements.
  • vector: Dynamic array.
  • deque: Double-ended queue.
  • list: Doubly linked list.
• Associative Containers: Store elements in a specific order.
  • set: Collection of unique keys, sorted by keys.
  • map: Collection of key-value pairs, sorted by keys.
  • multiset: Collection of keys, allowing duplicates, sorted by keys.
  • multimap: Collection of key-value pairs, allowing duplicates, sorted by keys.
• Unordered Containers: Store elements in no particular order.
  • unordered_set: Collection of unique keys, hashed by keys.
  • unordered_map: Collection of key-value pairs, hashed by keys.
  • unordered_multiset: Collection of keys, allowing duplicates, hashed by keys.
  • unordered_multimap: Collection of key-value pairs, allowing duplicates, hashed by keys.

2. Iterators

Iterators are objects that point to elements in containers. They provide a way to access and traverse elements in containers.

• Input Iterators: Read-only access to a sequence.
• Output Iterators: Write-only access to a sequence.
• Forward Iterators: Read and write access, can move forward.
• Bidirectional Iterators: Read and write access, can move forward and backward.
• Random Access Iterators: Read and write access, can move in any direction.

3. Algorithms

Algorithms are functions that perform operations on containers. They are implemented as template functions and work with iterators.

• Non-modifying Algorithms: Do not change the elements in the container.
  • find, count, equal, mismatch
• Modifying Algorithms: Change the elements in the container.
  • copy, swap, replace, fill
• Sorting and Searching Algorithms: Sort and search elements in the container.
  • sort, binary_search, lower_bound, upper_bound
• Numeric Algorithms: Perform numeric operations.
  • accumulate, inner_product, partial_sum

Example Usage

Using a Vector Container

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

int main()
{
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // Display elements
    for (int val : vec)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    // Sort elements in descending order
    std::sort(vec.begin(), vec.end(), std::greater<int>());

    // Display sorted elements
    for (int val : vec)
    {
        std::cout << val << " ";
    }
    std::cout << std::endl;

    return 0;
}

Using an Iterator

#include <iostream>
#include <vector>

int main()
{
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // Use an iterator to traverse the vector
    for (std::vector<int>::iterator it = vec.begin(); it != vec.end(); ++it)
    {
        std::cout << *it << " ";
    }
    std::cout << std::endl;

    return 0;
}

Using an Algorithm

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

int main()
{
    std::vector<int> vec = {1, 2, 3, 4, 5};

    // Find an element
    auto it = std::find(vec.begin(), vec.end(), 3);
    if (it != vec.end())
    {
        std::cout << "Element found: " << *it << std::endl;
    }
    else
    {
        std::cout << "Element not found" << std::endl;
    }

    return 0;
}

Conclusion

The STL is a powerful tool in C++ that provides a wide range of functionalities for managing data structures and algorithms. Understanding and utilizing STL components can greatly enhance your programming efficiency and effectiveness.