DOCUMENT NUMBER? Adding string-slicing to C++

1. Table of Contents

• Changelog

  • R5

  • R4

  • R3

  • R2

  • R1

• Motivation and Scope

• Impact on the Standard

• Design Decisions

• Technical Specifications

• Proposed Wording

  • std::basic_string::operator

  • Addition to string

  • std::basic_string::slice

  • std::basic_string::first

  • std::basic_string::last

• Acknowledgements

2. Changelog

2.1. R5

• Added multi-indexed operator[] for unsafe variant of std::string::slice(size_t start, size_t end)

• Adjust proposed wording

2.2. R4

• Removed std::basic_string::slice(size_t start, size_t end, size_t step) since with the addition of std::stride_view it will no longer be necessary.
  

• Added proposed wording

• Made functions constexpr, const and noexcept (where applicable)

2.3. R3

• Added unit tests to a GitHub project.
  

2.4. R2

• std::basic_string::slice() now throws std::out_of_range when start >= size().
  

2.5. R1

• Removed default parameter from std::basic_string::slice(size_t start, size_t end, size_t step).
  

3. Motivation and Scope

namespace std
{
  /* 1. */ constexpr basic_string_view  basic_string::operator[](size_t start, size_t end) const;
  /* 2. */ constexpr basic_string_view  basic_string::slice(size_t start, size_t end) const;
  /* 3. */ constexpr basic_string_view  basic_string::first(size_t count) const noexcept;
  /* 4. */ constexpr basic_string_view  basic_string::last(size_t count) const noexcept;
}

4. Impact on the Standard

5. Design Decisions

1. These functions will most often be used to find something in a string, often not requiring a new dynamic allocation to be made.

2. std::basic_string::contains(), std::basic_string::starts_with() and std::basic_string::ends_with() all take a std::basic_string_view as a parameter. Therefore, the return value of the proposed functions matching up with these is a benefit.

3. If the user wants a std::basic_string instead of a std::basic_string_view, they can always construct a std::basic_string.
   

C++23 introduced operator[] with any number of subscripts cppreference here.
Using this technique, we can very closely mimic what Python does with their string slicing. This does raise the question if std::basic_string::slice() is still useful, but in my opinion it can serve as a the safe variant of the unsafe operator[](size_t start, size_t end) like .at(size_t pos) is the safe variant of the unsafe operator[](size_t pos).

6. Technical Specifications

1. std::basic_string::operator[] takes 2 parameters: size_t start and size_t end and returns a std::basic_string_view.

   • start is the starting index (inclusive) of where to start the slice.

     • There is no guarantee of safety when start >= size().

   • end is the ending index (exclusive) of where to end the slice.

     • There is no guarantee of safety when end > size()

     • There is no guarantee of safety when end < start

2. std::basic_string::slice() takes 2 parameters: size_t start and size_t end and returns a std::basic_string_view.

   • start is the starting index (inclusive) of where to start the slice.

     • std::out_of_range is thrown when start >= size().

   • end is the ending index (exclusive) of where to end the slice.

     • if end > size() then end will be set to size()

     • if end < start then end will be set to start

3. std::basic_string::first() takes 1 parameter: size_t count and returns a std::basic_string_view.

   • count is the amount of characters to be included (counting from index 0) in the slice.

     • if count >= size() then count will be set to size().

4. std::basic_string::last() takes 1 parameter: size_t count and returns a std::basic_string_view.

   • count is the amount of characters to be included (counting from the last index) in the slice.

     • if count >= size() then count will be set to size().

These are easily implemented functions and depend on specific vendor-implementation of std::basic_string, but I have provided unit tests and sample implementations here.

7. Proposed Wording

7.1. Addition to <string>

// [...]
namespace std {
  // [...]
	
  // [string.ops], string operations
  // [...]
  constexpr bool contains(const charT* x) const;
	
  constexpr basic_string_view<charT, traits> operator[](size_t start, size_t end) const noexcept;
  constexpr basic_string_view<charT, traits> slice(size_t start, size_t end) const;
  constexpr basic_string_view<charT, traits> first(size_t count) const noexcept;
  constexpr basic_string_view<charT, traits> last(size_t count) const noexcept;
}

7.2. std::basic_string::operator[]

• 23.4.3.?: basic_string::operator[] [string.slice]

  • constexpr basic_string_view<charT, traits> operator[](size_t start, size_t end) const noexcept;

    1. Effects: Equivalent to:
       return basic_string_view<charT, traits>(data() + start, end);

7.3. std::basic_string::slice

• 23.4.3.?: basic_string::slice [string.slice]

  • constexpr basic_string_view<charT, traits> slice(size_t start, size_t end) const;

    1. Effects: Determines the effective length xlen of the string to be returned as std::max(std::min(end, size()), start).
       Returns the characters in the range [data() + start, data() + xlen);

    2. Returns: basic_string_view<charT, traits>(data() + start, end)

    3. Throws: out_of_range if start >= size()

7.4. std::basic_string::first

• 23.4.3.?: basic_string::first [string.first]

  • constexpr basic_string_view<charT, traits> first(size_t count) const noexcept;

    1. Effects: Equivalent to:
       return basic_string_view<charT, traits>(data(), count);

7.5. std::basic_string::last

• 23.4.3.?: basic_string::last [string.last]

  • constexpr basic_string_view<charT, traits> last(size_t count) const noexcept;

    1. Effects: Equivalent to:
       return basic_string_view<charT, traits>(data() + (size() - count), count);

8. Acknowledgements