After 10 Years of C++, I Discovered These Hidden Gems in STL

Learning website for technical articles:https://www.chengxuchu.com

Hello everyone, I am a chef, a programmer who loves cooking and has obtained a chef qualification certificate.

STL accompanies C++ programmers in their daily development, but the most commonly used containers are often vector, map, set, and some of the most common algorithms. Many times, we only stay at the level of “usable” and overlook some very practical but easily ignored features in the standard library. Reflecting on my C++ development experience over the years, I found that mastering some tools earlier could have saved me a lot of detours. Here are a few STL usages that I think are particularly noteworthy.

1. `std::string_view` — Efficient String View

In the past, when handling strings, I always preferred to pass around std::string, which frequently triggered copies. Later, I discovered that std::string_view is more suitable. It does not manage data, just a view, making it particularly suitable for function parameters, avoiding unnecessary allocations.

#include <iostream>
#include <string>
#include <string_view>

void print_prefix(std::string_view sv) {
    std::cout << sv.substr(0, 5) << std::endl;
}

int main() {
    std::string s = "Hello, World!";
    print_prefix(s);         // Directly pass string
    print_prefix("Goodbye"); // Directly pass literal
}

This approach makes the interface more flexible and avoids the overhead of temporarily constructing std::string. It is especially useful in scenarios like logging systems and parsing configuration files.

2. `std::optional` — Clearly Expressing “May Not Exist”

Many people are accustomed to using special values (like -1 or null pointers) to indicate function failure or data absence. After C++17, std::optional provides a clearer way to express “there may be a value, or there may not be a value”.

#include <optional>
#include <iostream>

std::optional<int> find_index(int value) {
    if (value == 42) return 0;
    return std::nullopt;
}

int main() {
    auto result = find_index(100);
    if (result) {
        std::cout << "Found: " << *result << std::endl;
    } else {
        std::cout << "Not found\n";
    }
}

This way, the caller must explicitly handle the “no value” case, significantly improving code readability and safety.

3. `std::unordered_map::contains` — Concise Lookup Method

In the past, to check if a key exists in an unordered_map, it was always written as:

if (m.find(key) != m.end()) { ... }

After C++20, you can directly use contains:

if (m.contains(key)) {
    // More intuitive
}

Although it’s just a small change, the clarity of the code is significantly improved.

4. `std::erase_if` — The “Batch Cleanup Tool” for Containers

In the past, to delete elements from a container that meet certain conditions, it usually required manually writing remove_if + erase. Now the standard library directly provides std::erase_if, greatly simplifying the code:

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

int main() {
    std::vector<int> v = {1, 2, 3, 4, 5, 6};
    std::erase_if(v, [](int x) { return x % 2 == 0; });

    for (int x : v) std::cout << x << " "; // Output 1 3 5
}

This small change makes many container operations feel much more natural.

5. `std::scoped_lock` — Simplifying Multiple Lock Scenarios

When writing multithreaded code, it is often necessary to hold multiple mutexes at the same time. If using std::lock_guard, you have to be careful about deadlock issues. C++17 provides std::scoped_lock, which can lock multiple mutexes simultaneously and guarantees that deadlocks will not occur:

#include <mutex>

std::mutex m1, m2;

void func() {
    std::scoped_lock lock(m1, m2); // Locking simultaneously, safe
    // Critical section
}

It automatically unlocks when the scope ends, making it more concise than the combination of std::lock + std::lock_guard.

6. `std::iota` — Quickly Generating Continuous Sequences

Often, it is necessary to generate a continuous array starting from 0, which in the past might have required writing a loop. Using std::iota is more straightforward:

#include <numeric>
#include <vector>
#include <iostream>

int main() {
    std::vector<int> v(10);
    std::iota(v.begin(), v.end(), 0); // Fill 0..9

    for (int x : v) std::cout << x << " ";
}

This function is very convenient in algorithm competitions or when initializing index arrays.

7. `std::clamp` — Limiting Value Ranges

When writing value range limits, you often see something like:

if (x < 0) x = 0;
else if (x > 100) x = 100;

C++17 provides a more concise std::clamp:

x = std::clamp(x, 0, 100);

These kinds of tools make the code clearer and reduce the likelihood of errors.

The functionalities provided by STL are far more than what we use daily. The ones listed here are just a part of it, reflecting a thought: If the standard library can solve it, do not reinvent the wheel. These tools are often well-tested and optimized, resulting in cleaner code and lower error rates.

If you are also writing C++, take some time to revisit the standard library documentation; you may discover many previously overlooked “gems”.

After 10 Years of C++, I Discovered These Hidden Gems in STL

1. `<span>std::string_view</span>` — Efficient String View

2. `<span>std::optional</span>` — Clearly Expressing “May Not Exist”

3. `<span>std::unordered_map::contains</span>` — Concise Lookup Method

4. `<span>std::erase_if</span>` — The “Batch Cleanup Tool” for Containers

5. `<span>std::scoped_lock</span>` — Simplifying Multiple Lock Scenarios

6. `<span>std::iota</span>` — Quickly Generating Continuous Sequences

7. `<span>std::clamp</span>` — Limiting Value Ranges

Leave a Comment Cancel reply

1. <span>std::string_view</span> — Efficient String View

2. <span>std::optional</span> — Clearly Expressing “May Not Exist”

3. <span>std::unordered_map::contains</span> — Concise Lookup Method

4. <span>std::erase_if</span> — The “Batch Cleanup Tool” for Containers

5. <span>std::scoped_lock</span> — Simplifying Multiple Lock Scenarios

6. <span>std::iota</span> — Quickly Generating Continuous Sequences

7. <span>std::clamp</span> — Limiting Value Ranges

Related posts