Introduction to STL Containers

In C++ programming, the Standard Template Library (STL) provides a rich collection of container classes that offer various data structures and algorithms for storing and manipulating data. Container classes in the STL are designed to provide efficient and easy-to-use data structures for different needs.

STL containers are divided into three main categories based on their functionality:

1. Sequence Containers: These containers store collections of elements in a specific order. Examples include std::vector, std::list, and std::deque.

2. Associative Containers: These containers provide a way to store elements in a sorted order and allow fast retrieval based on the element's value. Examples include std::set, std::map, and std::multiset.

3. Unordered Containers: These containers use hash functions to store elements and provide fast insertion, deletion, and search operations. Examples include std::unordered_set, std::unordered_map, and std::unordered_multiset.

Sequence Containers

Let's start by exploring the sequence containers. Sequence containers store elements in a linear manner, allowing efficient insertion and deletion operations at both ends. Here are three commonly used sequence containers:

• std::vector: This container provides a dynamic array-like structure that can grow or shrink in size. It allows fast random access to elements and is efficient for adding or removing elements at the end.

• std::list: This container implements a doubly-linked list, allowing fast insertion and deletion at any position. However, random access to elements is slower compared to std::vector.

• std::deque: This container is similar to std::vector but also allows efficient insertion and deletion at both ends.

Let's take a look at an example that demonstrates the usage of a std::vector:

1#include <iostream>
2#include <vector>
3
4int main() {
5    std::vector<int> numbers;
6
7    // Add elements to the vector
8    numbers.push_back(1);
9    numbers.push_back(2);
10    numbers.push_back(3);
11
12    // Print the elements
13    for (int n : numbers) {
14        std::cout << n << " ";
15    }
16    std::cout << std::endl;
17
18    return 0;
19}

In this example, we include the <iostream> and <vector> header files to access the functionalities of std::vector. We create a vector numbers and add elements to it using the push_back() function. Finally, we use a loop to print each element.

The output of this program will be:

11 2 3

This example demonstrates the basic usage of a std::vector. You can perform various operations on vectors, such as accessing elements by index, inserting or removing elements at any position, and more.

Associative Containers

Next, let's explore the associative containers. Associative containers store elements in a sorted order, based on the values of the elements. They provide efficient search operations and fast retrieval of elements.

One commonly used associative container is std::set, which stores a collection of unique elements in a sorted order. Here's an example that demonstrates the usage of std::set:

1#include <iostream>
2#include <set>
3
4int main() {
5    std::set<int> numbers;
6
7    // Add elements to the set
8    numbers.insert(3);
9    numbers.insert(1);
10    numbers.insert(2);
11
12    // Print the elements
13    for (int n : numbers) {
14        std::cout << n << " ";
15    }
16    std::cout << std::endl;
17
18    return 0;
19}

In this example, we include the <iostream> and <set> header files to access the functionalities of std::set. We create a set numbers and add elements to it using the insert() function. Finally, we use a loop to print each element.

The output of this program will be:

11 2 3

This example demonstrates the basic usage of a std::set. You can perform various operations on sets, such as searching for elements, inserting or removing elements, checking the size of the set, and more.

Unordered Containers

Lastly, let's explore the unordered containers. Unordered containers use hash functions to store elements and provide fast insertion, deletion, and search operations. One commonly used unordered container is std::unordered_map, which stores key-value pairs. Here's an example that demonstrates the usage of std::unordered_map:

1#include <iostream>
2#include <unordered_map>
3
4int main() {
5    std::unordered_map<std::string, int> ages;
6
7    // Add elements to the unordered_map
8    ages["John"] = 25;
9    ages["Lisa"] = 30;
10    ages["Mark"] = 35;
11
12    // Print the elements
13    for (const auto& pair : ages) {
14        std::cout << pair.first << ": " << pair.second << "\n";
15    }
16
17    return 0;
18}

In this example, we include the <iostream> and <unordered_map> header files to access the functionalities of std::unordered_map. We create an unordered_map ages that stores name-age pairs. We add elements to the unordered_map using the [key] = value syntax. Finally, we use a loop to print each pair.

The output of this program will be:

1John: 25
2Lisa: 30
3Mark: 35

This example demonstrates the basic usage of a std::unordered_map. You can perform various operations on unordered_maps, such as accessing elements by key, inserting or removing elements, checking the size of the map, and more.

STL containers provide a wide range of functionality for storing and manipulating data in C++. By understanding the different types of containers and their capabilities, you can choose the right container for your specific needs and write more efficient and effective code.