Creating Views using std::ranges::subrange

Advantages of std::ranges::subrange Over Raw Pointers

What are the advantages of using std::ranges::subrange over raw pointers?

Abstract art representing computer programming

Using std::ranges::subrange offers several advantages over raw pointers, particularly in terms of safety, expressiveness, and functionality.

Here’s a breakdown of why std::ranges::subrange is often a better choice:


  • Bounds Checking: std::ranges::subrange provides bounds checking through its iterator and sentinel, reducing the risk of out-of-bounds errors compared to raw pointers.
  • Non-Ownership: It explicitly expresses non-ownership, clarifying that the subrange does not manage the lifetime of the data, unlike raw pointers, which can lead to ambiguity.


  • Clear Intent: std::ranges::subrange makes it clear that the code is working with a view of a range of elements, enhancing code readability and maintainability.
  • Range Operations: It integrates seamlessly with the ranges library, allowing the use of powerful range-based algorithms and views, making the code more expressive and concise.


  • Iterator Support: std::ranges::subrange works with any type of iterator, not just pointers. This means you can create subranges from various container types.
  • Slicing: You can easily create views of subsets of containers, including non-contiguous subranges, which is more complex with raw pointers.

Error Prevention

  • Reduced Risk of Dangling Pointers: std::ranges::subrange helps avoid common pointer pitfalls, such as dangling pointers, by working directly with iterators.
  • Easier Debugging: Issues related to range errors are easier to debug with std::ranges::subrange due to its clear bounds and iterator support.

Integration with Modern C++

  • Compatibility with Algorithms: std::ranges::subrange is fully compatible with modern C++ algorithms, enabling more efficient and readable code.
  • Structured Bindings: Supports structured bindings for better code structure and readability.

In summary, std::ranges::subrange provides a safer, more expressive, and more functional alternative to raw pointers, making your code easier to understand, maintain, and debug.

The following two programs implement the same functionality. The first uses raw pointers:

#include <iostream>

void print_range(int* begin, int* end) {
  for (int* ptr = begin; ptr != end; ++ptr) {
    std::cout << *ptr << ", ";

int main() {
  int arr[] = {1, 2, 3, 4, 5};
  print_range(arr + 1, arr + 4);  
2, 3, 4,

Using std::ranges::subrange looks like this:

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

void print_range(std::ranges::subrange<
  std::vector<int>::iterator> view) {
  for (int n : view) {
    std::cout << n << ", ";

int main() {
  std::vector<int> vec{1, 2, 3, 4, 5};
  std::ranges::subrange view{
    vec.begin() + 1, vec.end() - 1};  
2, 3, 4,

Answers to questions are automatically generated and may not have been reviewed.

A computer programmer
Part of the course:

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Free, unlimited access

This course includes:

  • 124 Lessons
  • 550+ Code Samples
  • 96% Positive Reviews
  • Regularly Updated
  • Help and FAQ
Free, Unlimited Access

Professional C++

Comprehensive course covering advanced concepts, and how to use them on large-scale projects.

Screenshot from Warhammer: Total War
Screenshot from Tomb Raider
Screenshot from Jedi: Fallen Order
Contact|Privacy Policy|Terms of Use
Copyright © 2024 - All Rights Reserved