span

---

1. String Slicing and Manipulation:

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

2. Array Subsetting:

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:

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):

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

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

5. Iterating over a Sequence:

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

6. Sorting:

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:

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

8. String Comparison:

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:

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

10. Copying Data:

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:

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

12. Byte Manipulation:

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

13. Bitwise Operations:

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

14. Transposing a Matrix:

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:

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:

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:

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:

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:

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:

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

21. Read-Only View:

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:

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

23. Joining a String:

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

24. Filtering Elements:

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:

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:

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:

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:

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:

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

30. Read-Only View:

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:

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

32. Joining a String:

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

33. Filtering Elements:

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:

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:

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:

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:

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:

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

39. Read-Only View:

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:

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

41. Joining a String:

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

42. Filtering Elements:

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:

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:

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:

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:

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:

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

48. Read-Only View:

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:

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

50. Joining a String:

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