Getting Started with C++20 Ranges: Write Cleaner and Safer Loops

If you've ever written a loop that filters, transforms, or slices a collection manually, you know how verbose and error-prone it can get.

C++20 introduces the <ranges> library, which allows you to express these operations clearly and safely, using a declarative and composable style.

In this article, we'll walk through the essentials of C++20 ranges — focusing on real-world use cases that will make your code shorter, safer, and more readable.

✅ What Are Ranges?

At a high level, ranges combine the container and the algorithm into a single, chainable expression.

Instead of writing this:

std::vector<int> result; for (int x : input) { if (x % 2 == 0) { result.push_back(x * x); } } 

You can now write:

auto result = input | std::views::filter([](int x) { return x % 2 == 0; }) | std::views::transform([](int x) { return x * x; }); 

This is concise, expressive, and lazy-evaluated, meaning no unnecessary copies unless you actually use the results.

✅ Basic Setup

To use ranges, include:

#include <ranges> #include <vector> #include <iostream> 

Make sure your compiler supports C++20. For GCC or Clang, you may need to pass -std=c++20.

✅ Practical Example: Filtering Even Numbers

std::vector<int> data = {1, 2, 3, 4, 5, 6}; auto evens = data | std::views::filter([](int x) { return x % 2 == 0; }); for (int x : evens) { std::cout << x << " "; } // Output: 2 4 6 

No need to write an explicit if in the loop — just describe what you want.

✅ Transforming Values: Square Each Number

auto squares = data | std::views::transform([](int x) { return x * x; }); for (int x : squares) { std::cout << x << " "; } // Output: 1 4 9 16 25 36 

Perfect for applying a function to every element.

✅ Combining Views: Filter and Then Transform

Here's where ranges shine — chaining multiple views:

auto even_squares = data | std::views::filter([](int x) { return x % 2 == 0; }) | std::views::transform([](int x) { return x * x; }); for (int x : even_squares) { std::cout << x << " "; } // Output: 4 16 36 

This kind of code used to take 5+ lines and intermediate containers — now it's just one pipeline.

✅ Taking and Dropping Elements

You can slice ranges without dealing with iterators:

auto first_three = data | std::views::take(3); for (int x : first_three) { std::cout << x << " "; } // Output: 1 2 3 

Likewise:

auto skip_two = data | std::views::drop(2); for (int x : skip_two) { std::cout << x << " "; } // Output: 3 4 5 6 

No begin() + n needed!

✅ Converting Views to Containers

Views are lazy — they don’t create new containers unless you explicitly request one:

std::vector<int> result( even_squares.begin(), even_squares.end() ); 

Alternatively, use a helper library like range-v3 or std::ranges::to in C++23.

✅ Why Should You Use Ranges?

✅ Removes boilerplate loops

✅ Avoids intermediate containers

✅ Makes intent clearer

✅ Encourages functional composition

✅ More type-safe than raw iterators

⚠️ Gotchas

• Views don’t own data — if the original container goes out of scope, the view becomes invalid.
• Not all STL algorithms are ranges-enabled yet (std::ranges::sort, etc. is available though).
• May have compilation issues on older compilers or incomplete standard libraries.

Final Thoughts

C++20 ranges bring modern, declarative iteration to C++.

If you've ever felt envious of LINQ in C#, or Python list comprehensions — this is your new best friend in C++.

✍️ Summary

• std::views::filter, transform, take, drop are your new loop tools
• Ranges let you focus on what to do, not how
• Safer, more elegant, and often faster than manual loops

Have you tried ranges in your own codebase yet? Let me know how it changed your workflow — or what hurdles you're running into.

Follow me for more modern C++ tips — and feel free to share your favorite ranges trick in the comments!