# span

***

**1. String Slicing and Manipulation:**

```cpp
std::string str = "Hello world";
std::span<char> substr = str.substr(6, 5); // "world"
```

**2. Array Subsetting:**

```cpp
int arr[] = {1, 2, 3, 4, 5};
std::span<int> subarr = std::span(arr + 1, 3); // {2, 3, 4}
```

**3. Efficient Buffer Passing to Functions:**

```cpp
void write_bytes(std::span<const char> buffer);
char buffer[1024];
write_bytes(std::span(buffer));
```

**4. Memory Management with RAII (Resource Acquisition Is Initialization):**

```cpp
class MyResource {
public:
  MyResource(std::span<char> data) : data_(data) {}
  ~MyResource() { data_.clear(); }

private:
  std::span<char> data_;
};
```

**5. Iterating over a Sequence:**

```cpp
std::string str = "Hello world";
for (auto& c : std::span(str)) {
  std::cout << c; // prints "Hello world"
}
```

**6. Sorting:**

```cpp
std::vector<int> vec = {3, 1, 4, 2, 5};
std::span<int> vec_span = vec;
std::sort(vec_span.begin(), vec_span.end()); // vec is now {1, 2, 3, 4, 5}
```

**7. Searching:**

```cpp
std::string str = "Hello world";
std::span<char> substr = "world";
auto pos = str.find(substr); // pos = 6
```

**8. String Comparison:**

```cpp
std::string str1 = "Hello";
std::string str2 = "World";
bool equal = std::equal(str1.begin(), str1.end(), str2.begin(), str2.end()); // equal = false
```

**9. Container Conversion:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> vec_span = std::span(vec);
```

**10. Copying Data:**

```cpp
std::vector<int> vec1 = {1, 2, 3, 4, 5};
std::vector<int> vec2(vec1.size());
std::copy(vec1.begin(), vec1.end(), vec2.begin());
```

**11. Filling a Span:**

```cpp
std::span<int> span(5);
std::fill(span.begin(), span.end(), 42); // span = {42, 42, 42, 42, 42}
```

**12. Byte Manipulation:**

```cpp
std::span<const std::byte> bytes = {0x12, 0x34, 0x56, 0x78};
std::cout << std::hex << *bytes.begin() << std::endl; // prints "12"
```

**13. Bitwise Operations:**

```cpp
std::span<std::uint8_t> bits = {0b11111111, 0b10101010};
bits[0] &= 0b11110000; // bits[0] = 0b11110000
```

**14. Transposing a Matrix:**

```cpp
std::vector<std::vector<int>> matrix = {
  {1, 2, 3},
  {4, 5, 6},
  {7, 8, 9}
};
std::span<int> matrix_transposed(matrix.size() * matrix[0].size());
for (size_t i = 0; i < matrix.size(); ++i) {
  for (size_t j = 0; j < matrix[i].size(); ++j) {
    matrix_transposed[i * matrix[i].size() + j] = matrix[j][i];
  }
}
```

**15. Creating a Custom View:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> evens = std::views::filter(vec, [](int i) { return i % 2 == 0; }); // evens = {2, 4}
```

**16. View Transformation:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> doubled = std::views::transform(vec, [](int i) { return i * 2; }); // doubled = {2, 4, 6, 8, 10}
```

**17. Combining Views:**

```cpp
std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2 = {4, 5, 6};
std::span<int> combined = std::views::concat(vec1, vec2); // combined = {1, 2, 3, 4, 5, 6}
```

**18. Zip Ranges:**

```cpp
std::vector<int> vec1 = {1, 2, 3};
std::vector<char> vec2 = {'a', 'b', 'c'};
std::span<std::tuple<int, char>> zipped = std::views::zip(vec1, vec2); // zipped = {(1, 'a'), (2, 'b'), (3, 'c')}
```

**19. Partitioning a Span:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::pair<std::span<int>, std::span<int>> partitioned = std::views::partition(vec, [](int i) { return i % 2 == 0; }); // partitioned = {evens, odds}
```

**20. Stripping Delimiters:**

```cpp
std::string str = "1,2,3,4,5";
std::span<char> stripped = std::views::strip(str, ','); // stripped = "12345"
```

**21. Read-Only View:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<const int> readonly = std::views::all(vec);
for (int i : readonly) {
  std::cout << i << ' '; // prints "1 2 3 4 5"
}
```

**22. Splitting a String:**

```cpp
std::string str = "Hello world";
std::span<std::string> parts = std::views::split(str, ' '); // parts = {"Hello", "world"}
```

**23. Joining a String:**

```cpp
std::vector<std::string> parts = {"Hello", "world"};
std::string joined = std::views::join(parts, ','); // joined = "Hello, world"
```

**24. Filtering Elements:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> filtered = std::views::filter(vec, [](int i) { return i % 2 == 0; }); // filtered = {2, 4}
```

**25. Transforming Elements:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> transformed = std::views::transform(vec, [](int i) { return i * 2; }); // transformed = {2, 4, 6, 8, 10}
```

**26. Combining Ranges:**

```cpp
std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2 = {4, 5, 6};
std::span<int> combined = std::views::concat(vec1, vec2); // combined = {1, 2, 3, 4, 5, 6}
```

**27. Zipping Ranges:**

```cpp
std::vector<int> vec1 = {1, 2, 3};
std::vector<char> vec2 = {'a', 'b', 'c'};
std::span<std::tuple<int, char>> zipped = std::views::zip(vec1, vec2); // zipped = {(1, 'a'), (2, 'b'), (3, 'c')}
```

**28. Partitioning a Span:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::pair<std::span<int>, std::span<int>> partitioned = std::views::partition(vec, [](int i) { return i % 2 == 0; }); // partitioned = {evens, odds}
```

**29. Stripping Delimiters:**

```cpp
std::string str = "1,2,3,4,5";
std::span<char> stripped = std::views::strip(str, ','); // stripped = "12345"
```

**30. Read-Only View:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<const int> readonly = std::views::all(vec);
for (int i : readonly) {
  std::cout << i << ' '; // prints "1 2 3 4 5"
}
```

**31. Splitting a String:**

```cpp
std::string str = "Hello world";
std::span<std::string> parts = std::views::split(str, ' '); // parts = {"Hello", "world"}
```

**32. Joining a String:**

```cpp
std::vector<std::string> parts = {"Hello", "world"};
std::string joined = std::views::join(parts, ','); // joined = "Hello, world"
```

**33. Filtering Elements:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> filtered = std::views::filter(vec, [](int i) { return i % 2 == 0; }); // filtered = {2, 4}
```

**34. Transforming Elements:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> transformed = std::views::transform(vec, [](int i) { return i * 2; }); // transformed = {2, 4, 6, 8, 10}
```

**35. Combining Ranges:**

```cpp
std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2 = {4, 5, 6};
std::span<int> combined = std::views::concat(vec1, vec2); // combined = {1, 2, 3, 4, 5, 6}
```

**36. Zipping Ranges:**

```cpp
std::vector<int> vec1 = {1, 2, 3};
std::vector<char> vec2 = {'a', 'b', 'c'};
std::span<std::tuple<int, char>> zipped = std::views::zip(vec1, vec2); // zipped = {(1, 'a'), (2, 'b'), (3, 'c')}
```

**37. Partitioning a Span:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::pair<std::span<int>, std::span<int>> partitioned = std::views::partition(vec, [](int i) { return i % 2 == 0; }); // partitioned = {evens, odds}
```

**38. Stripping Delimiters:**

```cpp
std::string str = "1,2,3,4,5";
std::span<char> stripped = std::views::strip(str, ','); // stripped = "12345"
```

**39. Read-Only View:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<const int> readonly = std::views::all(vec);
for (int i : readonly) {
  std::cout << i << ' '; // prints "1 2 3 4 5"
}
```

**40. Splitting a String:**

```cpp
std::string str = "Hello world";
std::span<std::string> parts = std::views::split(str, ' '); // parts = {"Hello", "world"}
```

**41. Joining a String:**

```cpp
std::vector<std::string> parts = {"Hello", "world"};
std::string joined = std::views::join(parts, ','); // joined = "Hello, world"
```

**42. Filtering Elements:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> filtered = std::views::filter(vec, [](int i) { return i % 2 == 0; }); // filtered = {2, 4}
```

**43. Transforming Elements:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<int> transformed = std::views::transform(vec, [](int i) { return i * 2; }); // transformed = {2, 4, 6, 8, 10}
```

**44. Combining Ranges:**

```cpp
std::vector<int> vec1 = {1, 2, 3};
std::vector<int> vec2 = {4, 5, 6};
std::span<int> combined = std::views::concat(vec1, vec2); // combined = {1, 2, 3, 4, 5, 6}
```

**45. Zipping Ranges:**

```cpp
std::vector<int> vec1 = {1, 2, 3};
std::vector<char> vec2 = {'a', 'b', 'c'};
std::span<std::tuple<int, char>> zipped = std::views::zip(vec1, vec2); // zipped = {(1, 'a'), (2, 'b'), (3, 'c')}
```

**46. Partitioning a Span:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::pair<std::span<int>, std::span<int>> partitioned = std::views::partition(vec, [](int i) { return i % 2 == 0; }); // partitioned = {evens, odds}
```

**47. Stripping Delimiters:**

```cpp
std::string str = "1,2,3,4,5";
std::span<char> stripped = std::views::strip(str, ','); // stripped = "12345"
```

**48. Read-Only View:**

```cpp
std::vector<int> vec = {1, 2, 3, 4, 5};
std::span<const int> readonly = std::views::all(vec);
for (int i : readonly) {
  std::cout << i << ' '; // prints "1 2 3 4 5"
}
```

**49. Splitting a String:**

```cpp
std::string str = "Hello world";
std::span<std::string> parts = std::views::split(str, ' '); // parts = {"Hello", "world"}
```

**50. Joining a String:**

```cpp
std::vector<std::string> parts = {"Hello", "world"};
std::string joined = std::views::join(parts, ','); // joined = "Hello, world"
```