Stdspansubspan Function In C++

Overview of the std::span class template

The std::span class template is a recent addition in C++20, serving as a lightweight, non-owning reference to a sequence of elements. It provides a means to interact with an array or a segment of it without unnecessary data duplication commonly found in pointers, offering improved safety and ease of use. Below is a detailed examination:

Key Characteristics:

• ✅ Non-owning View: Unlike containers such as std::This said, a span is not a container, and when it is based on C++ containers like discrete vector or std::array, a span does not own the data that it is pointing to. It is simply a view over a range of elements that clearly states that it doesn't take control of memory management.
• ✅ Contiguous Memory: The std::span works over sequences held in adjacent memory, like arrays, std::vector, or C arrays. It is intended to operate on the sequences of data that exist in the memory with no gaps between them.
• ✅ Templatized for Flexibility: The std::span is templated, which makes it work with any data type (integer, float data type, user-defined data types , etc) and with either static or dynamic size. Static extent: That's why if the size of the span is known at compile time, std::span can be of a fixed size. Dynamic extent: If the size is not known until runtime, then this is not a problem for std::span.
• ✅ The std::span is templated, which makes it work with any data type (integer, float data type, user-defined data types , etc) and with either static or dynamic size.
• ✅ Static extent: That's why if the size of the span is known at compile time, std::span can be of a fixed size.
• ✅ Dynamic extent: If the size is not known until runtime, then this is not a problem for std::span.

Benefits of using std::span for array-like data

Employing std::span in C++ for data resembling arrays presents several key benefits that set it apart from other programming languages. These advantages comprise safeguarding data, enhancing readability, and optimizing program efficiency.

Improved Type Safety

• ✅ The std::span is composed of both the address to the data and the size of the array and thus, it breaks the possibility of basic mistakes such as buffer overflow or out-of-bound access.
• ✅ With raw pointers, you must manually track the size, but std::span makes it always available while increasing safety and decreasing the number of bugs.

Simplified Function Parameters

• ✅ Functions that work with array-like data typically require two separate parameters: a pointer to the data and the size of the array that indicates how much data is available and how much of it was passed to the function. std::span makes the passing of both into a single parameter look easier.
• ✅ This not only makes the function signatures cleaner and easier to read but also prevents inconsistencies (e.g., passing the wrong size for the array).

Example:

void process_data(std::span<int> data);  // cleaner

Other Nonspecialized View (No Memory Management Consideration)

• ✅ The std:: span does not own reference to the specific memory it is referring to. It merely provides a view of the data, which means that there is no overhead of memory allocation or deallocation.
• ✅ It makes std::span lightweight and highly efficient, especially when passing large arrays/slices of data to function as it does not result in data copy.

Interoperability with Standard Containers

• ✅ std::span can be built from several types of containers, raw arrays, std::array, span from std::vector, or even std::initializer_list.
• ✅ This versatility makes std::span useful for writing modern C++ code, for maintaining legacy code, and for connecting them.

Example:

int arr[] = {1, 2, 3, 4, 5};
std::vector<int> vec = {6, 7, 8, 9, 10};
std::span<int> span_from_array(arr);    // from raw array
std::span<int> span_from_vector(vec);   // from vector

No Copies or Performance Overhead

• ✅ When passing an array-like data structure to a function using std::span, no data is copied. It's only a span thacpp tutorials directly to the existing memory; there will be no impact on performance.
• ✅ This makes std::span that would be useful in areas where performance is critical especially in the case of large datasets.

Understanding the std::span::subspan Function

It serves as a utility function for generating a std::span::subspan or a partial view of the current std::span. This utility empowers you to manipulate a specific segment of the data referenced by the span without directly interacting with, modifying, or moving the data content. Below is an elaborate explanation of the function, its parameters, and its functionality:

Definition and syntax of subspan

The subspan method retrieves a subspan from a pre-existing std::span, commencing from a designated offset and potentially extending for a specified number of elements.

Syntax:

It has the following syntax:

std::span<T, Extent>::subspan(std::size_t offset, std::size_t count = std::dynamic_extent) const;

• ✅ T: The type of elements in the span.
• ✅ Extent: The size of the span (either static or dynamic).

The function generates a fresh std::span instance that denotes a perspective beginning from the offset index and, if needed, for a specified number of elements.

Example:

std::span<int> original_span(arr, 6); // span over {1, 2, 3, 4, 5, 6}
auto sub = original_span.subspan(2, 3); // subspan {3, 4, 5}

Parameters of subspan: Offset and Count

• ✅ Data Type: std::size_t
• ✅ Explanation: The offset represents the position (matching the initial index in the original span, with the subspan's initial index set at 0). Elements preceding the offset will be excluded from the resulting subspan.

Count (optional):

• ✅ Type: std::sizet (optional; default is std::dynamicextent)
• ✅ Description: This is the count of elements to take into the subspan starting with the offset. If count is omitted, which might be a common practice as seen above, the subspan will start from the offset till the end of the span.
• ✅ Default Value: If the count is missed then the subspan will be from the offset to the final position of the span.

Example:

int arr[] = {1, 2, 3, 4, 5, 6};
std::span<int> span(arr, 6);  // span over {1, 2, 3, 4, 5, 6}

// Subspan from index 2, and for 3 elements: {3, 4, 5}
auto subspan_1 = span.subspan(2, 3);

// Subspan from index 4 to the end: {5, 6}
auto subspan_2 = span.subspan(4);

// Subspan from index 0, taking the first 4 elements: {1, 2, 3, 4}
auto subspan_3 = span.subspan(0, 4);

Return type and behaviour:

Return Type: std::span<T>

The function produces a fresh std::span instance that signifies a portion of the elements found in the initial span.

Behavior:

• ✅ Offset Behavior: The subspan is defined from the element indicated by the given offset. If the offset is greater than the size of the original span, this produces undefined behavior.
• ✅ Count Behavior: If the count is more than the elements available starting from the offset, it will return the span with the remaining elements from the original span only.
• ✅ Zero-cost Abstraction: Like std::span, the subspan is not considered to allocate any memory or copy elements between the views. It only offers a fresh perspective over a part of the initial data.
• ✅ Issues with Out-of-bounds Access: When it comes to the offset or count, causing access to elements outside the span's size, the behavior is unspecified. However, if the compiler is configured with certain debug flags, runtime bounds-checking may be implemented.
• ✅ Handling Empty Spans: In scenarios where the count equals 0 or the subspan goes beyond the data range, the resulting span will be empty.

Example of Out-of-bounds Behavior:

std::span<int> span(arr, 6);

// Undefined behavior: Offset is too large
auto invalid_subspan = span.subspan(10); 

// This will work fine: span from index 2 to the end
auto valid_subspan = span.subspan(2);  // {3, 4, 5, 6}

Examples of Using std::span::subspan

Here are some instances showcasing the application of the std::span::subspan method, encompassing fundamental utilization as well as specialized scenarios.

Example 1: Basic example of creating a subspan

This illustration demonstrates the creation of a std::span from an array, followed by the extraction of a subspan using both an offset and a count.

#include <span>
#include <iostream>

int main() {
    int arr[] = {10, 20, 30, 40, 50, 60};
    
    // Create a span over the entire array
    std::span<int> span(arr, 6);  // span over {10, 20, 30, 40, 50, 60}

    // Create a subspan starting at index 2, for 3 elements
    std::span<int> subspan = span.subspan(2, 3);  // subspan {30, 40, 50}

    // Print the elements of the subspan
    for (int element : subspan) {
        std::cout << element << " ";  // Outputs: 30 40 50
    }

    return 0;
}

Output:

30 40 50

Explanation:

• ✅ We create a std::span over an array of 6 elements.
• ✅ Using subspan(2, 3), we extract a subspan that starts at index 2 and includes 3 elements, giving us {30, 40, 50}.

Example 2: Subspan with an offset only

When you specify only an offset, the subspan function will generate a view starting from that offset and extending to the end of the original span.

#include <span>
#include <iostream>

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

    // Create a span over the entire array
    std::span<int> span(arr, 6);  // span over {1, 2, 3, 4, 5, 6}

    // Create a subspan starting at index 3 (subspan {4, 5, 6})
    std::span<int> subspan = span.subspan(3);

    // Print the elements of the subspan
    for (int element : subspan) {
        std::cout << element << " ";  // Outputs: 4 5 6
    }

    return 0;
}

Output:

Explanation:

• ✅ We create a span over the array {1, 2, 3, 4, 5, 6}.
• ✅ By using subspan(3), we create a subspan that starts at index 3 and includes all elements from there to the end, resulting in {4, 5, 6}.

Example 3: Subspan with both offset and count

This illustration showcases how to generate a subsequence by defining both an initial position and a length, restricting the quantity of elements in the resulting subsequence.

#include <span>
#include <iostream>

int main() {
    int arr[] = {5, 10, 15, 20, 25, 30, 35};

    // Create a span over the entire array
    std::span<int> span(arr, 7);  // span over {5, 10, 15, 20, 25, 30, 35}

    // Create a subspan starting at index 1, with 4 elements (subspan {10, 15, 20, 25})
    std::span<int> subspan = span.subspan(1, 4);

    // Print the elements of the subspan
    for (int element : subspan) {
        std::cout << element << " ";  // Outputs: 10 15 20 25
    }

    return 0;
}

Output:

10 15 20 25

Explanation:

• ✅ The original span covers all elements in the array {5, 10, 15, 20, 25, 30, 35}.
• ✅ Using subspan(1, 4), we start at index 1 and include 4 elements, resulting in the subspan {10, 15, 20, 25}.

Error Handling in std::span::subspan

1. Handling out-of-bound errors

By default, the std::span::subspan function does not conduct any validation on the offset or count concerning the data it references. Providing an incorrect offset or requesting more elements than allowed does not trigger an error; rather, it leads to unpredictable outcomes.

Examples of Out-of-Bounds Errors:

• ✅ Exceeding Offset: When the offset surpasses the span's size, it may result in accessing memory outside the bounds.
• ✅ Excessive Count: Similarly, if the count requested goes beyond the span's allocated space from the offset, it can result in unpredictable behavior.

Example:

#include <span>
#include <iostream>

int main() {
    int arr[] = {1, 2, 3, 4, 5};
    std::span<int> span(arr, 5);  // span over {1, 2, 3, 4, 5}

    // Potential undefined behavior: offset exceeds the span's size
    auto invalid_subspan = span.subspan(6);  // Offset out-of-bounds (UB)

    // This is safe and valid
    auto valid_subspan = span.subspan(2, 2);  // subspan {3, 4}

    return 0;
}

Explanation:

• ✅ In the first case, span.subspan(6) attempts to start a subspan from an index that doesn't exist, which can lead to undefined behavior (crashes or incorrect data).
• ✅ In the second case, span.subspan(2, 2) works safely since the offset and count fit within the span's bounds.

How to Avoid Out-of-Bounds Access:

Manually Verify Offsets and Counts: As subspan does not automatically validate bounds, it is important to manually confirm that both the offset and count fall within acceptable ranges.

if (offset <= span.size() && (offset + count) <= span.size()) {
    auto sub = span.subspan(offset, count);  // Safe
}

Utilize Compiler Flags or Debug Libraries: Certain compilers or development environments provide utilities to detect out-of-bounds access during debugging. These runtime verifications can be activated using options such as -DGLIBCXXDEBUG (in GCC) or -DLIBCPPDEBUG (in libc++), which trigger extra precautionary measures.

2. Understanding runtime checks (when subspan throws exceptions)

Despite not inherently throwing exceptions, std::span::subspan may be accompanied by exception generation in debug configurations by certain compilers or under specific flag settings. These runtime validations play a crucial role in averting out-of-range access, effectively eradicating any chances of encountering undefined behavior.

When Runtime Checks Take Place:

• ✅ During Debug Builds: Common libraries like libc++ or libstdc++, for example, include boundary checks in debug mode. If there is an attempt to form a subspan with an incorrect offset or count, the application will raise an exception, usually std::outofrange.
• ✅ Using Compiler Flags: Some compilers, when invoked with specific debug flags enabled, conduct boundary checks and trigger exceptions for access violations.

Example of Enabling Runtime Checks (GCC):

In GCC, you have the option to activate runtime checks by compiling with -DGLIBCXXDEBUG.

g++ -DGLIBCXXDEBUG myprogram.cpp -o myprogram

This will activate validations that trigger exceptions (like std::outofrange) in case of creating invalid spans.

Example with Runtime Checks:

#include <span>
#include <iostream>
#include <cassert>

int main() {
    int arr[] = {10, 20, 30, 40, 50};
    std::span<int> span(arr, 5);  // span over {10, 20, 30, 40, 50}

    // Manual bounds checking before calling subspan
    std::size_t offset = 3;
    std::size_t count = 3;

    if (offset <= span.size() && offset + count <= span.size()) {
        auto subspan = span.subspan(offset, count);  // Safe subspan
        for (int element : subspan) {
            std::cout << element << " ";  // Outputs: 40 50
        }
    } else {
        std::cerr << "Invalid subspan request (out of bounds)." << std::endl;
    }

    return 0;
}

Explanation:

• ✅ We first check that the requested offset and count are valid before creating the subspan.
• ✅ If they are out of bounds, we avoid calling subspan and handle the error instead of letting undefined behavior occur.

Runtime Check with Debug Flag Example:

If you are utilizing a compiler or development environment that offers bounds-checking (such as GCC with -DGLIBCXXDEBUG), this identical code will automatically raise an exception in case the boundaries are breached.

Conclusion:

In summary, the std::span class template in C++ provides a more secure and effective approach to handling multi-element objects by offering a lightweight, non-owning perspective of continuous memory. The std::span::subspan functionality allows users to generate sub-spans from a current span without requiring extra data duplication, thereby maintaining data integrity and readability.

Nevertheless, as std::span::subspan lacks inherent safeguards to prevent accessing data beyond its boundaries, caution is necessary when specifying an offset and count. Based on the provided parameters, developers can either verify all inputs or enable a runtime check (similar to activating debug flags in certain compilers) to enhance code safety and eradicate any undefined behavior.

Key Takeaways:

• ✅ Non-owning and lightweight: The std::span is perfect when it comes to data processing without creating copies of the input data.
• ✅ Improved safety: While it does not own a memory, the std::span wraps a pointer and size, thus preventing problems such as buffer overflows.
• ✅ Manual validation necessary: As a result, the offsets and counts should be manually constrained to not go out of range or use runtime assertions in debug configurations.