| Home | Libraries | People | FAQ | More

## Class template basic_string

boost::container::basic_string

## Synopsis

    // In header: <boost/container/string.hpp>

    template<typename CharT, typename Traits = std::char_traits<CharT>,
             typename Allocator = void, typename Options = void>
    class basic_string :
      private dtl::basic_string_base< real_allocator< CharT, void >::type, void >
    {
    public:
      // types
      typedef Traits                                                                  traits_type;
      typedef CharT                                                                   value_type;
      typedef real_allocator< CharT, Allocator >::type                                allocator_type;
      typedef ::boost::container::allocator_traits< allocator_type >::pointer         pointer;
      typedef ::boost::container::allocator_traits< allocator_type >::const_pointer   const_pointer;
      typedef ::boost::container::allocator_traits< allocator_type >::reference       reference;
      typedef ::boost::container::allocator_traits< allocator_type >::const_reference const_reference;
      typedef ::boost::container::allocator_traits< allocator_type >::size_type       size_type;
      typedef ::boost::container::allocator_traits< allocator_type >::difference_type difference_type;
      typedef implementation_defined                                                  stored_allocator_type;
      typedef implementation_defined                                                  iterator;
      typedef implementation_defined                                                  const_iterator;
      typedef implementation_defined                                                  reverse_iterator;
      typedef implementation_defined                                                  const_reverse_iterator;

      // public member functions
      basic_string();
      explicit basic_string(const allocator_type &) noexcept;
      basic_string(const basic_string &);
      template<template< class, class > class BasicStringView>
        explicit basic_string(BasicStringView< CharT, Traits >,
                              const allocator_type & = allocator_type());
      basic_string(basic_string &&) noexcept;
      basic_string(const basic_string &, const allocator_type &);
      basic_string(basic_string &&, const allocator_type &);
      basic_string(const basic_string &, size_type, size_type = npos);
      basic_string(const basic_string &, size_type, size_type,
                   const allocator_type &);
      basic_string(const CharT *, size_type);
      basic_string(const CharT *, size_type, const allocator_type &);
      basic_string(const CharT *);
      basic_string(const CharT *, const allocator_type &);
      basic_string(size_type, CharT);
      basic_string(size_type, CharT, const allocator_type &);
      basic_string(size_type, default_init_t);
      basic_string(size_type, default_init_t, const allocator_type &);
      template<typename InputIterator> basic_string(InputIterator, InputIterator);
      template<typename InputIterator>
        basic_string(InputIterator, InputIterator, const allocator_type &);
      basic_string(std::initializer_list< value_type >,
                   const allocator_type & = allocator_type());
      ~basic_string() noexcept;
      basic_string & operator=(const basic_string &);
      basic_string & operator=(basic_string &&);
      basic_string & operator=(const CharT *);
      basic_string & operator=(CharT);
      template<template< class, class > class BasicStringView>
        basic_string & operator=(BasicStringView< CharT, Traits >);
      basic_string & operator=(std::initializer_list< CharT >);
      allocator_type get_allocator() const noexcept;
      stored_allocator_type & get_stored_allocator() noexcept;
      const stored_allocator_type & get_stored_allocator() const noexcept;
      iterator begin() noexcept;
      const_iterator begin() const noexcept;
      iterator end() noexcept;
      const_iterator end() const noexcept;
      reverse_iterator rbegin() noexcept;
      const_reverse_iterator rbegin() const noexcept;
      reverse_iterator rend() noexcept;
      const_reverse_iterator rend() const noexcept;
      const_iterator cbegin() const noexcept;
      const_iterator cend() const noexcept;
      const_reverse_iterator crbegin() const noexcept;
      const_reverse_iterator crend() const noexcept;
      bool empty() const noexcept;
      size_type size() const noexcept;
      size_type length() const noexcept;
      size_type max_size() const noexcept;
      void resize(size_type, CharT);
      void resize(size_type);
      void resize(size_type, default_init_t);
      size_type capacity() const noexcept;
      void reserve(size_type);
      void shrink_to_fit();
      reference front() noexcept;
      const_reference front() const noexcept;
      reference back() noexcept;
      const_reference back() const noexcept;
      reference operator[](size_type) noexcept;
      const_reference operator[](size_type) const noexcept;
      reference at(size_type);
      const_reference at(size_type) const;
      basic_string & operator+=(const basic_string &);
      template<template< class, class > class BasicStringView>
        basic_string & operator+=(BasicStringView< CharT, Traits >);
      basic_string & operator+=(const CharT *);
      basic_string & operator+=(CharT);
      basic_string & operator+=(std::initializer_list< CharT >);
      basic_string & append(const basic_string &);
      template<template< class, class > class BasicStringView>
        basic_string & append(BasicStringView< CharT, Traits >);
      basic_string & append(const basic_string &, size_type, size_type = npos);
      template<template< class, class > class BasicStringView>
        basic_string &
        append(BasicStringView< CharT, Traits >, size_type, size_type = npos);
      basic_string & append(const CharT *, size_type);
      basic_string & append(const CharT *);
      basic_string & append(size_type, CharT);
      template<typename InputIter> basic_string & append(InputIter, InputIter);
      basic_string & append(std::initializer_list< CharT >);
      void push_back(CharT);
      basic_string & assign(const basic_string &);
      basic_string & assign(basic_string &&) noexcept;
      template<template< class, class > class BasicStringView>
        basic_string & assign(BasicStringView< CharT, Traits >);
      template<template< class, class > class BasicStringView>
        basic_string &
        assign(BasicStringView< CharT, Traits >, size_type, size_type = npos);
      basic_string & assign(const basic_string &, size_type, size_type = npos);
      basic_string & assign(const CharT *, size_type);
      basic_string & assign(const CharT *);
      basic_string & assign(size_type, CharT);
      basic_string & assign(const CharT *, const CharT *);
      template<typename InputIter> basic_string & assign(InputIter, InputIter);
      basic_string & assign(std::initializer_list< CharT >);
      basic_string & insert(size_type, const basic_string &);
      basic_string &
      insert(size_type, const basic_string &, size_type, size_type = npos);
      basic_string & insert(size_type, const CharT *, size_type);
      basic_string & insert(size_type, const CharT *);
      basic_string & insert(size_type, size_type, CharT);
      template<template< class, class > class BasicStringView>
        basic_string & insert(size_type, BasicStringView< CharT, Traits >);
      template<template< class, class > class BasicStringView>
        basic_string &
        insert(size_type, BasicStringView< CharT, Traits >, size_type,
               size_type = npos);
      iterator insert(const_iterator, CharT);
      iterator insert(const_iterator, size_type, CharT);
      template<typename InputIter>
        iterator insert(const_iterator, InputIter, InputIter);
      iterator insert(const_iterator, std::initializer_list< CharT >);
      void pop_back() noexcept;
      basic_string & erase(size_type = 0, size_type = npos);
      iterator erase(const_iterator) noexcept;
      iterator erase(const_iterator, const_iterator) noexcept;
      void clear() noexcept;
      basic_string & replace(size_type, size_type, const basic_string &);
      template<template< class, class > class BasicStringView>
        basic_string &
        replace(size_type, size_type, BasicStringView< CharT, Traits >);
      basic_string &
      replace(size_type, size_type, const basic_string &, size_type,
              size_type = npos);
      template<template< class, class > class BasicStringView>
        basic_string &
        replace(size_type, size_type, BasicStringView< CharT, Traits >, size_type,
                size_type = npos);
      basic_string & replace(size_type, size_type, const CharT *, size_type);
      basic_string & replace(size_type, size_type, const CharT *);
      basic_string & replace(size_type, size_type, size_type, CharT);
      basic_string & replace(const_iterator, const_iterator, const basic_string &);
      basic_string &
      replace(const_iterator, const_iterator, const CharT *, size_type);
      basic_string & replace(const_iterator, const_iterator, const CharT *);
      basic_string & replace(const_iterator, const_iterator, size_type, CharT);
      template<typename InputIter>
        basic_string &
        replace(const_iterator, const_iterator, InputIter, InputIter);
      template<template< class, class > class BasicStringView>
        basic_string &
        replace(const_iterator, const_iterator, BasicStringView< CharT, Traits >);
      basic_string &
      replace(const_iterator, const_iterator, std::initializer_list< CharT >);
      size_type copy(CharT *, size_type, size_type = 0) const;
      void swap(basic_string &);
      const CharT * c_str() const noexcept;
      const CharT * data() const noexcept;
      CharT * data() noexcept;
      template<template< class, class > class BasicStringView>
        operator BasicStringView< CharT, Traits >() const noexcept;
      template<typename BasicStringView> BasicStringView to_view() const noexcept;
      size_type find(const basic_string &, size_type = 0) const;
      template<template< class, class > class BasicStringView>
        size_type find(BasicStringView< CharT, Traits >, size_type = 0) const;
      size_type find(const CharT *, size_type, size_type) const;
      size_type find(const CharT *, size_type = 0) const;
      size_type find(CharT, size_type = 0) const;
      size_type rfind(const basic_string &, size_type = npos) const;
      template<template< class, class > class BasicStringView>
        size_type rfind(BasicStringView< CharT, Traits >, size_type = npos) const;
      size_type rfind(const CharT *, size_type, size_type) const;
      size_type rfind(const CharT *, size_type = npos) const;
      size_type rfind(CharT, size_type = npos) const;
      size_type find_first_of(const basic_string &, size_type = 0) const;
      template<template< class, class > class BasicStringView>
        size_type find_first_of(BasicStringView< CharT, Traits >, size_type = 0) const;
      size_type find_first_of(const CharT *, size_type, size_type) const;
      size_type find_first_of(const CharT *, size_type = 0) const;
      size_type find_first_of(CharT, size_type = 0) const;
      size_type find_last_of(const basic_string &, size_type = npos) const;
      template<template< class, class > class BasicStringView>
        size_type find_last_of(BasicStringView< CharT, Traits >, size_type = npos) const;
      size_type find_last_of(const CharT *, size_type, size_type) const;
      size_type find_last_of(const CharT *, size_type = npos) const;
      size_type find_last_of(CharT, size_type = npos) const;
      size_type find_first_not_of(const basic_string &, size_type = 0) const;
      template<template< class, class > class BasicStringView>
        size_type find_first_not_of(BasicStringView< CharT, Traits >,
                                    size_type = 0) const;
      size_type find_first_not_of(const CharT *, size_type, size_type) const;
      size_type find_first_not_of(const CharT *, size_type = 0) const;
      size_type find_first_not_of(CharT, size_type = 0) const;
      size_type find_last_not_of(const basic_string &, size_type = npos) const;
      template<template< class, class > class BasicStringView>
        size_type find_last_not_of(BasicStringView< CharT, Traits >,
                                   size_type = npos) const;
      size_type find_last_not_of(const CharT *, size_type, size_type) const;
      size_type find_last_not_of(const CharT *, size_type = npos) const;
      size_type find_last_not_of(CharT, size_type = npos) const;
      basic_string substr(size_type = 0, size_type = npos) const;
      int compare(const basic_string &) const;
      template<template< class, class > class BasicStringView>
        int compare(BasicStringView< CharT, Traits >) const;
      int compare(size_type, size_type, const basic_string &) const;
      template<template< class, class > class BasicStringView>
        int compare(size_type, size_type, BasicStringView< CharT, Traits >) const;
      int compare(size_type, size_type, const basic_string &, size_type,
                  size_type = npos) const;
      template<template< class, class > class BasicStringView>
        int compare(size_type, size_type, BasicStringView< CharT, Traits >,
                    size_type, size_type = npos) const;
      int compare(const CharT *) const;
      int compare(size_type, size_type, const CharT *, size_type) const;
      int compare(size_type, size_type, const CharT *) const;
      template<template< class, class > class BasicStringView>
        bool contains(BasicStringView< CharT, Traits >) const noexcept;
      bool contains(CharT) const noexcept;
      bool contains(const CharT *) const noexcept;
      template<template< class, class > class BasicStringView>
        bool starts_with(BasicStringView< CharT, Traits >) const noexcept;
      bool starts_with(CharT) const noexcept;
      bool starts_with(const CharT *) const noexcept;
      template<template< class, class > class BasicStringView>
        bool ends_with(BasicStringView< CharT, Traits >) const noexcept;
      bool ends_with(CharT) const noexcept;
      bool ends_with(const CharT *) const noexcept;

      // public data members
      static const size_type npos;
    };

## Description

The basic_string class represents a Sequence of characters. It contains all the usual operations of a Sequence, and, additionally, it contains standard string operations such as search and concatenation.

The basic_string class is parameterized by character type, and by that type's Character Traits.

This class has performance characteristics very much like vector<>, meaning, for example, that it does not perform reference-count or copy-on-write, and that concatenation of two strings is an O(N) operation.

Some of basic_string's member functions use an unusual method of specifying positions and ranges. In addition to the conventional method using iterators, many of basic_string's member functions use a single value pos of type size_type to represent a position (in which case the position is begin() + pos, and many of basic_string's member functions use two values, pos and n, to represent a range. In that case pos is the beginning of the range and n is its size. That is, the range is [begin() + pos, begin() + pos + n).

Note that the C++ standard does not specify the complexity of basic_string operations. In this implementation, basic_string has performance characteristics very similar to those of vector: access to a single character is O(1), while copy and concatenation are O(N).

In this implementation, begin(), end(), rbegin(), rend(), operator[], c_str(), and data() do not invalidate iterators. In this implementation, iterators are only invalidated by member functions that explicitly change the string's contents.

### Template Parameters

1.     typename CharT

   The type of character it contains.

2.     typename Traits = std::char_traits<CharT>

   The Character Traits type, which encapsulates basic character operations

3.     typename Allocator = void

   The allocator, used for internal memory management.

4.     typename Options = void

   A type produced from `boost::container::string_options`.

### `basic_string` public member functions

1.     basic_string();

   Effects: Default constructs a basic_string.

   Throws: If allocator_type's default constructor throws.

2.     explicit basic_string(const allocator_type & a) noexcept;

   Effects: Constructs a basic_string taking the allocator as parameter.

   Throws: Nothing

3.     basic_string(const basic_string & s);

   Effects: Copy constructs a basic_string.

   Postcondition: x == *this.

   Throws: If allocator_type's default constructor or allocation throws.

4.     template<template< class, class > class BasicStringView>
         explicit basic_string(BasicStringView< CharT, Traits > sv,
                               const allocator_type & a = allocator_type());

   Effects: Same as basic_string(sv.data(), sv.size(), a).

   Throws: If allocator_type's default constructor or allocation throws.

5.     basic_string(basic_string && s) noexcept;

   Effects: Move constructor. Moves s's resources to *this.

   Throws: Nothing.

   Complexity: Constant.

6.     basic_string(const basic_string & s, const allocator_type & a);

   Effects: Copy constructs a basic_string using the specified allocator.

   Postcondition: x == *this.

   Throws: If allocation throws.

7.     basic_string(basic_string && s, const allocator_type & a);

   Effects: Move constructor using the specified allocator. Moves s's resources to *this.

   Throws: If allocation throws.

   Complexity: Constant if a == s.get_allocator(), linear otherwise.

8.     basic_string(const basic_string & s, size_type pos, size_type n = npos);

   Effects: Constructs a basic_string with a default-constructed allocator, and is initialized by a specific number of characters of the s string.

9.     basic_string(const basic_string & s, size_type pos, size_type n,
                    const allocator_type & a);

   Effects: Constructs a basic_string taking the allocator as parameter, and is initialized by a specific number of characters of the s string.

10.     basic_string(const CharT * s, size_type n);

    Effects: Constructs a basic_string taking a default-constructed allocator, and is initialized by a specific number of characters of the s c-string.

11.     basic_string(const CharT * s, size_type n, const allocator_type & a);

    Effects: Constructs a basic_string taking the allocator as parameter, and is initialized by a specific number of characters of the s c-string.

12.     basic_string(const CharT * s);

    Effects: Constructs a basic_string with a default-constructed allocator, and is initialized by the null-terminated s c-string.

13.     basic_string(const CharT * s, const allocator_type & a);

    Effects: Constructs a basic_string taking the allocator as parameter, and is initialized by the null-terminated s c-string.

14.     basic_string(size_type n, CharT c);

    Effects: Constructs a basic_string with a default-constructed allocator, and is initialized by n copies of c.

15.     basic_string(size_type n, CharT c, const allocator_type & a);

    Effects: Constructs a basic_string taking the allocator as parameter, and is initialized by n copies of c.

16.     basic_string(size_type n, default_init_t);

    Effects: Constructs a basic_string with a default-constructed allocator, and is initialized by n default-initialized characters.

17.     basic_string(size_type n, default_init_t, const allocator_type & a);

    Effects: Constructs a basic_string taking the allocator as parameter, and is initialized by n default-initialized characters.

18.     template<typename InputIterator>
          basic_string(InputIterator f, InputIterator l);

    Effects: Constructs a basic_string with a default-constructed allocator, and a range of iterators.

19.     template<typename InputIterator>
          basic_string(InputIterator f, InputIterator l, const allocator_type & a);

    Effects: Constructs a basic_string taking the allocator as parameter, and a range of iterators.

20.     basic_string(std::initializer_list< value_type > il,
                     const allocator_type & a = allocator_type());

    Effects: Same as basic_string(il.begin(), il.end(), a).

21.     ~basic_string() noexcept;

    Effects: Destroys the basic_string. All used memory is deallocated.

    Throws: Nothing.

    Complexity: Constant.

22.     basic_string & operator=(const basic_string & x);

    Effects: Copy constructs a string.

    Postcondition: x == *this.

    Complexity: Linear to the elements x contains.

23.     basic_string & operator=(basic_string && x);

    Effects: Move constructor. Moves x's resources to *this.

    Throws: If allocator_traits_type::propagate_on_container_move_assignment is false and allocation throws

    Complexity: Constant if allocator_traits_type:: propagate_on_container_move_assignment is true or this->get>allocator() == x.get_allocator(). Linear otherwise.

24.     basic_string & operator=(const CharT * s);

    Effects: Assignment from a null-terminated c-string.

25.     basic_string & operator=(CharT c);

    Effects: Returns *this = basic_string(1, c).

26.     template<template< class, class > class BasicStringView>
          basic_string & operator=(BasicStringView< CharT, Traits > sv);

    Effects: Equivalent to return assign(sv).

27.     basic_string & operator=(std::initializer_list< CharT > il);

    Effects: Returns *this = basic_string(il);

28.     allocator_type get_allocator() const noexcept;

    Effects: Returns a copy of the internal allocator.

    Throws: If allocator's copy constructor throws.

    Complexity: Constant.

29.     stored_allocator_type & get_stored_allocator() noexcept;

    Effects: Returns a reference to the internal allocator.

    Throws: Nothing

    Complexity: Constant.

    Note: Non-standard extension.

30.     const stored_allocator_type & get_stored_allocator() const noexcept;

    Effects: Returns a reference to the internal allocator.

    Throws: Nothing

    Complexity: Constant.

    Note: Non-standard extension.

31.     iterator begin() noexcept;

    Effects: Returns an iterator to the first element contained in the vector.

    Throws: Nothing.

    Complexity: Constant.

32.     const_iterator begin() const noexcept;

    Effects: Returns a const_iterator to the first element contained in the vector.

    Throws: Nothing.

    Complexity: Constant.

33.     iterator end() noexcept;

    Effects: Returns an iterator to the end of the vector.

    Throws: Nothing.

    Complexity: Constant.

34.     const_iterator end() const noexcept;

    Effects: Returns a const_iterator to the end of the vector.

    Throws: Nothing.

    Complexity: Constant.

35.     reverse_iterator rbegin() noexcept;

    Effects: Returns a reverse_iterator pointing to the beginning of the reversed vector.

    Throws: Nothing.

    Complexity: Constant.

36.     const_reverse_iterator rbegin() const noexcept;

    Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed vector.

    Throws: Nothing.

    Complexity: Constant.

37.     reverse_iterator rend() noexcept;

    Effects: Returns a reverse_iterator pointing to the end of the reversed vector.

    Throws: Nothing.

    Complexity: Constant.

38.     const_reverse_iterator rend() const noexcept;

    Effects: Returns a const_reverse_iterator pointing to the end of the reversed vector.

    Throws: Nothing.

    Complexity: Constant.

39.     const_iterator cbegin() const noexcept;

    Effects: Returns a const_iterator to the first element contained in the vector.

    Throws: Nothing.

    Complexity: Constant.

40.     const_iterator cend() const noexcept;

    Effects: Returns a const_iterator to the end of the vector.

    Throws: Nothing.

    Complexity: Constant.

41.     const_reverse_iterator crbegin() const noexcept;

    Effects: Returns a const_reverse_iterator pointing to the beginning of the reversed vector.

    Throws: Nothing.

    Complexity: Constant.

42.     const_reverse_iterator crend() const noexcept;

    Effects: Returns a const_reverse_iterator pointing to the end of the reversed vector.

    Throws: Nothing.

    Complexity: Constant.

43.     bool empty() const noexcept;

    Effects: Returns true if the vector contains no elements.

    Throws: Nothing.

    Complexity: Constant.

44.     size_type size() const noexcept;

    Effects: Returns the number of the elements contained in the vector.

    Throws: Nothing.

    Complexity: Constant.

45.     size_type length() const noexcept;

    Effects: Returns the number of the elements contained in the vector.

    Throws: Nothing.

    Complexity: Constant.

46.     size_type max_size() const noexcept;

    Effects: Returns the largest possible size of the vector.

    Throws: Nothing.

    Complexity: Constant

47.     void resize(size_type n, CharT c);

    Effects: Inserts or erases elements at the end such that the size becomes n. New elements are copy constructed from x.

    Throws: If memory allocation throws

    Complexity: Linear to the difference between size() and new_size.

48.     void resize(size_type n);

    Effects: Inserts or erases elements at the end such that the size becomes n. New elements are value initialized.

    Throws: If memory allocation throws

    Complexity: Linear to the difference between size() and new_size.

49.     void resize(size_type n, default_init_t);

    Effects: Inserts or erases elements at the end such that the size becomes n. New elements are uninitialized.

    Throws: If memory allocation throws

    Complexity: Linear to the difference between size() and new_size.

    Note: Non-standard extension

50.     size_type capacity() const noexcept;

    Effects: Number of elements for which memory has been allocated. capacity() is always greater than or equal to size().

    Throws: Nothing.

    Complexity: Constant.

51.     void reserve(size_type res_arg);

    Effects: If n is less than or equal to capacity(), this call has no effect. Otherwise, it is a request for allocation of additional memory. If the request is successful, then capacity() is greater than or equal to n; otherwise, capacity() is unchanged. In either case, size() is unchanged.

    Throws: If memory allocation allocation throws

52.     void shrink_to_fit();

    Effects: Tries to deallocate the excess of memory created with previous allocations. The size of the string is unchanged

    Throws: Nothing

    Complexity: Linear to size().

53.     reference front() noexcept;

    Requires: !empty()

    Effects: Returns a reference to the first element of the container.

    Throws: Nothing.

    Complexity: Constant.

54.     const_reference front() const noexcept;

    Requires: !empty()

    Effects: Returns a const reference to the first element of the container.

    Throws: Nothing.

    Complexity: Constant.

55.     reference back() noexcept;

    Requires: !empty()

    Effects: Returns a reference to the last element of the container.

    Throws: Nothing.

    Complexity: Constant.

56.     const_reference back() const noexcept;

    Requires: !empty()

    Effects: Returns a const reference to the last element of the container.

    Throws: Nothing.

    Complexity: Constant.

57.     reference operator[](size_type n) noexcept;

    Requires: size() >= n.

    Effects: Returns a reference to the nth element from the beginning of the container.

    Throws: Nothing.

    Complexity: Constant.

58.     const_reference operator[](size_type n) const noexcept;

    Requires: size() >= n.

    Effects: Returns a const reference to the nth element from the beginning of the container.

    Throws: Nothing.

    Complexity: Constant.

59.     reference at(size_type n);

    Requires: size() > n.

    Effects: Returns a reference to the nth element from the beginning of the container.

    Throws: range_error if n >= size()

    Complexity: Constant.

60.     const_reference at(size_type n) const;

    Requires: size() > n.

    Effects: Returns a const reference to the nth element from the beginning of the container.

    Throws: range_error if n >= size()

    Complexity: Constant.

61.     basic_string & operator+=(const basic_string & s);

    Effects: Calls append(str.data, str.size()).

    Returns: *this

62.     template<template< class, class > class BasicStringView>
          basic_string & operator+=(BasicStringView< CharT, Traits > sv);

    Effects: Same as `return append(sv)`.

63.     basic_string & operator+=(const CharT * s);

    Effects: Calls append(s).

    Returns: *this

64.     basic_string & operator+=(CharT c);

    Effects: Calls append(1, c).

    Returns: *this

65.     basic_string & operator+=(std::initializer_list< CharT > il);

    Effects: Returns append(il)

66.     basic_string & append(const basic_string & s);

    Effects: Calls append(str.data(), str.size()).

    Returns: *this

67.     template<template< class, class > class BasicStringView>
          basic_string & append(BasicStringView< CharT, Traits > sv);

    Effects: Same as return append(sv.data(), sv.size()).

68.     basic_string &
        append(const basic_string & s, size_type pos, size_type n = npos);

    Requires: pos <= str.size()

    Effects: Determines the effective length rlen of the string to append as the smaller of n and str.size() - pos and calls append(str.data() + pos, rlen).

    Throws: If memory allocation throws and out_of_range if pos > str.size()

    Returns: *this

69.     template<template< class, class > class BasicStringView>
          basic_string &
          append(BasicStringView< CharT, Traits > sv, size_type pos,
                 size_type n = npos);

    Requires: pos <= sv.size()

    Effects: Determines the effective length rlen of the string to append as the smaller of n and sv.size() - pos and calls append(sv.data() + pos, rlen).

    Throws: If memory allocation throws and out_of_range if pos > sv.size()

    Returns: *this

70.     basic_string & append(const CharT * s, size_type n);

    Requires: s points to an array of at least n elements of CharT.

    Effects: The function replaces the string controlled by *this with a string of length size() + n whose irst size() elements are a copy of the original string controlled by *this and whose remaining elements are a copy of the initial n elements of s.

    Throws: If memory allocation throws length_error if size() + n > max_size().

    Returns: *this

71.     basic_string & append(const CharT * s);

    Requires: s points to an array of at least traits::length(s) + 1 elements of CharT.

    Effects: Calls append(s, traits::length(s)).

    Returns: *this

72.     basic_string & append(size_type n, CharT c);

    Effects: Equivalent to append(basic_string(n, c)).

    Returns: *this

73.     template<typename InputIter>
          basic_string & append(InputIter first, InputIter last);

    Requires: [first,last) is a valid range.

    Effects: Equivalent to append(basic_string(first, last)).

    Returns: *this

74.     basic_string & append(std::initializer_list< CharT > il);

    Effects: Returns append(il.begin(), il.end()).

75.     void push_back(CharT c);

    Effects: Equivalent to append(static_cast<size_type>(1), c).

76.     basic_string & assign(const basic_string & s);

    Effects: return *this = s;

    Returns: *this

77.     basic_string & assign(basic_string && s) noexcept;

    Effects: return *this = move(s);

    Returns: *this

78.     template<template< class, class > class BasicStringView>
          basic_string & assign(BasicStringView< CharT, Traits > sv);

    Effects: Equivalent to return assign(sv.data(), sv.size()).

    Returns: *this

79.     template<template< class, class > class BasicStringView>
          basic_string &
          assign(BasicStringView< CharT, Traits > sv, size_type pos,
                 size_type n = npos);

    Requires: pos <= sv.size()

    Effects: Determines the effective length rlen of the string to assign as the smaller of n and sv.size() - pos and calls assign(sv.data() + pos rlen).

    Throws: If memory allocation throws or out_of_range if pos > sv.size().

    Returns: *this

80.     basic_string &
        assign(const basic_string & s, size_type pos, size_type n = npos);

    Requires: pos <= str.size()

    Effects: Determines the effective length rlen of the string to assign as the smaller of n and str.size() - pos and calls assign(str.data() + pos rlen).

    Throws: If memory allocation throws or out_of_range if pos > str.size().

    Returns: *this

81.     basic_string & assign(const CharT * s, size_type n);

    Requires: s points to an array of at least n elements of CharT.

    Effects: Replaces the string controlled by *this with a string of length n whose elements are a copy of those pointed to by s.

    Throws: If memory allocation throws or length_error if n > max_size().

    Returns: *this

82.     basic_string & assign(const CharT * s);

    Requires: s points to an array of at least traits::length(s) + 1 elements of CharT.

    Effects: Calls assign(s, traits::length(s)).

    Returns: *this

83.     basic_string & assign(size_type n, CharT c);

    Effects: Equivalent to assign(basic_string(n, c)).

    Returns: *this

84.     basic_string & assign(const CharT * first, const CharT * last);

    Effects: Equivalent to assign(basic_string(first, last)).

    Returns: *this

85.     template<typename InputIter>
          basic_string & assign(InputIter first, InputIter last);

    Effects: Equivalent to assign(basic_string(first, last)).

    Returns: *this

86.     basic_string & assign(std::initializer_list< CharT > il);

    Effects: Returns assign(il.begin(), il.end()).

87.     basic_string & insert(size_type pos, const basic_string & s);

    Requires: pos <= size().

    Effects: Calls insert(pos, str.data(), str.size()).

    Throws: If memory allocation throws or out_of_range if pos > size().

    Returns: *this

88.     basic_string &
        insert(size_type pos1, const basic_string & s, size_type pos2,
               size_type n = npos);

    Requires: pos1 <= size() and pos2 <= str.size()

    Effects: Determines the effective length rlen of the string to insert as the smaller of n and str.size() - pos2 and calls insert(pos1, str.data() + pos2, rlen).

    Throws: If memory allocation throws or out_of_range if pos1 > size() or pos2 > str.size().

    Returns: *this

89.     basic_string & insert(size_type pos, const CharT * s, size_type n);

    Requires: s points to an array of at least n elements of CharT and pos <= size().

    Effects: Replaces the string controlled by *this with a string of length size() + n whose first pos elements are a copy of the initial elements of the original string controlled by *this and whose next n elements are a copy of the elements in s and whose remaining elements are a copy of the remaining elements of the original string controlled by *this.

    Throws: If memory allocation throws, out_of_range if pos > size() or length_error if size() + n > max_size().

    Returns: *this

90.     basic_string & insert(size_type pos, const CharT * s);

    Requires: pos <= size() and s points to an array of at least traits::length(s) + 1 elements of CharT

    Effects: Calls insert(pos, s, traits::length(s)).

    Throws: If memory allocation throws, out_of_range if pos > size() length_error if size() > max_size() - Traits::length(s)

    Returns: *this

91.     basic_string & insert(size_type pos, size_type n, CharT c);

    Effects: Equivalent to insert(pos, basic_string(n, c)).

    Throws: If memory allocation throws, out_of_range if pos > size() length_error if size() > max_size() - n

    Returns: *this

92.     template<template< class, class > class BasicStringView>
          basic_string & insert(size_type pos, BasicStringView< CharT, Traits > sv);

    Effects: Same as `return insert(pos, sv.data(), sv.size())`.

93.     template<template< class, class > class BasicStringView>
          basic_string &
          insert(size_type pos1, BasicStringView< CharT, Traits > sv, size_type pos2,
                 size_type n = npos);

    Requires: pos1 <= size() and pos2 <= sv.size()

    Effects: Determines the effective length rlen of the string to insert as the smaller of n and sv.size() - pos2 and calls insert(pos1, sv.data() + pos2, rlen).

    Throws: If memory allocation throws or out_of_range if pos1 > size() or pos2 > sv.size().

    Returns: *this

94.     iterator insert(const_iterator p, CharT c);

    Requires: p is a valid iterator on *this.

    Effects: inserts a copy of c before the character referred to by p.

    Returns: An iterator which refers to the copy of the inserted character.

95.     iterator insert(const_iterator p, size_type n, CharT c);

    Requires: p is a valid iterator on *this.

    Effects: Inserts n copies of c before the character referred to by p.

    Returns: an iterator to the first inserted element or p if n is 0.

96.     template<typename InputIter>
          iterator insert(const_iterator p, InputIter first, InputIter last);

    Requires: p is a valid iterator on *this. [first,last) is a valid range.

    Effects: Equivalent to insert(p - begin(), basic_string(first, last)).

    Returns: an iterator to the first inserted element or p if first == last.

97.     iterator insert(const_iterator p, std::initializer_list< CharT > il);

    Effects: As if by insert(p, il.begin(), il.end()).

    Returns: An iterator which refers to the copy of the first inserted character, or p if i1 is empty.

98.     void pop_back() noexcept;

    Effects: Removes the last element from the container.

    Throws: Nothing.

    Complexity: Constant time.

99.     basic_string & erase(size_type pos = 0, size_type n = npos);

    Requires: pos <= size()

    Effects: Determines the effective length xlen of the string to be removed as the smaller of n and size() - pos. The function then replaces the string controlled by *this with a string of length size() - xlen whose first pos elements are a copy of the initial elements of the original string controlled by *this, and whose remaining elements are a copy of the elements of the original string controlled by *this beginning at position pos + xlen.

    Throws: out_of_range if pos > size().

    Returns: *this

100.     iterator erase(const_iterator p) noexcept;

     Effects: Removes the character referred to by p.

     Throws: Nothing

     Returns: An iterator which points to the element immediately following p prior to the element being erased. If no such element exists, end() is returned.

101.     iterator erase(const_iterator first, const_iterator last) noexcept;

     Requires: first and last are valid iterators on *this, defining a range [first,last).

     Effects: Removes the characters in the range [first,last).

     Throws: Nothing

     Returns: An iterator which points to the element pointed to by last prior to the other elements being erased. If no such element exists, end() is returned.

102.     void clear() noexcept;

     Effects: Erases all the elements of the vector.

     Throws: Nothing.

     Complexity: Linear to the number of elements in the vector.

103.     basic_string & replace(size_type pos1, size_type n1, const basic_string & str);

     Requires: pos1 <= size().

     Effects: Calls replace(pos1, n1, str.data(), str.size()).

     Throws: if memory allocation throws or out_of_range if pos1 > size().

     Returns: *this

104.     template<template< class, class > class BasicStringView>
           basic_string &
           replace(size_type pos1, size_type n1, BasicStringView< CharT, Traits > sv);

     Effects: Calls `return replace(pos1, n1, sv.data(), sv.size());`.

105.     basic_string &
         replace(size_type pos1, size_type n1, const basic_string & str,
                 size_type pos2, size_type n2 = npos);

     Requires: pos1 <= size() and pos2 <= str.size().

     Effects: Determines the effective length rlen of the string to be inserted as the smaller of n2 and str.size() - pos2 and calls replace(pos1, n1, str.data() + pos2, rlen).

     Throws: if memory allocation throws, out_of_range if pos1 > size() or pos2 > str.size().

     Returns: *this

106.     template<template< class, class > class BasicStringView>
           basic_string &
           replace(size_type pos1, size_type n1, BasicStringView< CharT, Traits > sv,
                   size_type pos2, size_type n2 = npos);

     Throws: out_of_range if pos1 > size() or pos2 > sv.size().

     Effects: Determines the effective length rlen of the string to be inserted as the smaller of n2 and sv.size() - pos2 and calls `replace(pos1, n1, sv.data() + pos2, rlen)`.

     Returns: *this.

107.     basic_string &
         replace(size_type pos1, size_type n1, const CharT * s, size_type n2);

     Requires: pos1 <= size() and s points to an array of at least n2 elements of CharT.

     Effects: Determines the effective length xlen of the string to be removed as the smaller of n1 and size() - pos1. If size() - xlen >= max_size() - n2 throws length_error. Otherwise, the function replaces the string controlled by *this with a string of length size() - xlen + n2 whose first pos1 elements are a copy of the initial elements of the original string controlled by *this, whose next n2 elements are a copy of the initial n2 elements of s, and whose remaining elements are a copy of the elements of the original string controlled by *this beginning at position pos + xlen.

     Throws: if memory allocation throws, out_of_range if pos1 > size() or length_error if the length of the resulting string would exceed max_size()

     Returns: *this

108.     basic_string & replace(size_type pos, size_type n1, const CharT * s);

     Requires: pos1 <= size() and s points to an array of at least n2 elements of CharT.

     Effects: Determines the effective length xlen of the string to be removed as the smaller of n1 and size() - pos1. If size() - xlen >= max_size() - n2 throws length_error. Otherwise, the function replaces the string controlled by *this with a string of length size() - xlen + n2 whose first pos1 elements are a copy of the initial elements of the original string controlled by *this, whose next n2 elements are a copy of the initial n2 elements of s, and whose remaining elements are a copy of the elements of the original string controlled by *this beginning at position pos + xlen.

     Throws: if memory allocation throws, out_of_range if pos1 > size() or length_error if the length of the resulting string would exceed max_size()

     Returns: *this

109.     basic_string & replace(size_type pos1, size_type n1, size_type n2, CharT c);

     Requires: pos1 <= size().

     Effects: Equivalent to replace(pos1, n1, basic_string(n2, c)).

     Throws: if memory allocation throws, out_of_range if pos1 > size() or length_error if the length of the resulting string would exceed max_size()

     Returns: *this

110.     basic_string &
         replace(const_iterator i1, const_iterator i2, const basic_string & str);

     Requires: [begin(),i1) and [i1,i2) are valid ranges.

     Effects: Calls replace(i1 - begin(), i2 - i1, str).

     Throws: if memory allocation throws

     Returns: *this

111.     basic_string &
         replace(const_iterator i1, const_iterator i2, const CharT * s, size_type n);

     Requires: [begin(),i1) and [i1,i2) are valid ranges and s points to an array of at least n elements

     Effects: Calls replace(i1 - begin(), i2 - i1, s, n).

     Throws: if memory allocation throws

     Returns: *this

112.     basic_string & replace(const_iterator i1, const_iterator i2, const CharT * s);

     Requires: [begin(),i1) and [i1,i2) are valid ranges and s points to an array of at least traits::length(s) + 1 elements of CharT.

     Effects: Calls replace(i1 - begin(), i2 - i1, s, traits::length(s)).

     Throws: if memory allocation throws

     Returns: *this

113.     basic_string &
         replace(const_iterator i1, const_iterator i2, size_type n, CharT c);

     Requires: [begin(),i1) and [i1,i2) are valid ranges.

     Effects: Calls replace(i1 - begin(), i2 - i1, basic_string(n, c)).

     Throws: if memory allocation throws

     Returns: *this

114.     template<typename InputIter>
           basic_string &
           replace(const_iterator i1, const_iterator i2, InputIter j1, InputIter j2);

     Requires: [begin(),i1), [i1,i2) and [j1,j2) are valid ranges.

     Effects: Calls replace(i1 - begin(), i2 - i1, basic_string(j1, j2)).

     Throws: if memory allocation throws

     Returns: *this

115.     template<template< class, class > class BasicStringView>
           basic_string &
           replace(const_iterator i1, const_iterator i2,
                   BasicStringView< CharT, Traits > sv);

     Requires: [begin(), i1) and [i1, i2) are valid ranges.

     Effects: Calls `replace(i1 - begin(), i2 - i1, sv).`.

     Returns: *this.

116.     basic_string &
         replace(const_iterator i1, const_iterator i2,
                 std::initializer_list< CharT > il);

     Requires: [begin(), i1) and [i1, i2) are valid ranges.

     Effects: Calls replace(i1, i2, il.begin(), il.end()).

     Returns: *this.

117.     size_type copy(CharT * s, size_type n, size_type pos = 0) const;

     Requires: pos <= size()

     Effects: Determines the effective length rlen of the string to copy as the smaller of n and size() - pos. s shall designate an array of at least rlen elements. The function then replaces the string designated by s with a string of length rlen whose elements are a copy of the string controlled by *this beginning at position pos. The function does not append a null object to the string designated by s.

     Throws: if memory allocation throws, out_of_range if pos > size().

     Returns: rlen

118.     void swap(basic_string & x);

     Effects: *this contains the same sequence of characters that was in s, s contains the same sequence of characters that was in *this.

     Throws: Nothing

119.     const CharT * c_str() const noexcept;

     Requires: The program shall not alter any of the values stored in the character array.

     Returns: A pointer p such that p + i == &operator[](i) for each i in [0,size()].

     Complexity: constant time.

120.     const CharT * data() const noexcept;

     Requires: The program shall not alter any of the values stored in the character array.

     Returns: A pointer p such that p + i == &operator[](i) for each i in [0,size()].

     Complexity: constant time.

121.     CharT * data() noexcept;

     Returns: A pointer p such that p + i == &operator[](i) for each i in [0,size()].

     Complexity: constant time.

122.     template<template< class, class > class BasicStringView>
           operator BasicStringView< CharT, Traits >() const noexcept;

     Returns: a string_view to the characters in the string.

     Complexity: constant time.

123.     template<typename BasicStringView> BasicStringView to_view() const noexcept;

     Returns: a string_view to the characters in the string.

     Complexity: constant time.

     Note: This function is available to write portable code for compilers that don't support templated conversion operators.

124.     size_type find(const basic_string & s, size_type pos = 0) const;

     Effects: Determines the lowest position xpos, if possible, such that both of the following conditions hold: 1) pos <= xpos and xpos + str.size() <= size(); 2) traits::eq(at(xpos+I), str.at(I)) for all elements I of the string controlled by str.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

125.     template<template< class, class > class BasicStringView>
           size_type find(BasicStringView< CharT, Traits > sv, size_type pos = 0) const;

     Effects: Determines the lowest position xpos, if possible, such that both of the following conditions hold: 1) pos <= xpos and xpos + sv.size() <= size(); 2) traits::eq(at(xpos+I), sv.at(I)) for all elements I of the string controlled by sv.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

126.     size_type find(const CharT * s, size_type pos, size_type n) const;

     Requires: s points to an array of at least n elements of CharT.

     Throws: Nothing

     Returns: find(basic_string<CharT,traits,allocator_type>(s,n),pos).

127.     size_type find(const CharT * s, size_type pos = 0) const;

     Requires: s points to an array of at least traits::length(s) + 1 elements of CharT.

     Throws: Nothing

     Returns: find(basic_string(s), pos).

128.     size_type find(CharT c, size_type pos = 0) const;

     Throws: Nothing

     Returns: find(basic_string<CharT,traits,allocator_type>(1,c), pos).

129.     size_type rfind(const basic_string & str, size_type pos = npos) const;

     Effects: Determines the highest position xpos, if possible, such that both of the following conditions obtain: a) xpos <= pos and xpos + str.size() <= size(); b) traits::eq(at(xpos+I), str.at(I)) for all elements I of the string controlled by str.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

130.     template<template< class, class > class BasicStringView>
           size_type rfind(BasicStringView< CharT, Traits > sv, size_type pos = npos) const;

     Effects: Determines the highest position xpos, if possible, such that both of the following conditions obtain: a) xpos <= pos and xpos + sv.size() <= size(); b) traits::eq(at(xpos+I), sv.at(I)) for all elements I of the string controlled by sv.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

131.     size_type rfind(const CharT * s, size_type pos, size_type n) const;

     Requires: s points to an array of at least n elements of CharT.

     Throws: Nothing

     Returns: rfind(basic_string(s, n), pos).

132.     size_type rfind(const CharT * s, size_type pos = npos) const;

     Requires: pos <= size() and s points to an array of at least traits::length(s) + 1 elements of CharT.

     Throws: Nothing

     Returns: rfind(basic_string(s), pos).

133.     size_type rfind(CharT c, size_type pos = npos) const;

     Throws: Nothing

     Returns: rfind(basic_string<CharT,traits,allocator_type>(1,c),pos).

134.     size_type find_first_of(const basic_string & str, size_type pos = 0) const;

     Effects: Determines the lowest position xpos, if possible, such that both of the following conditions obtain: a) pos <= xpos and xpos < size(); b) traits::eq(at(xpos), str.at(I)) for some element I of the string controlled by str.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

135.     template<template< class, class > class BasicStringView>
           size_type find_first_of(BasicStringView< CharT, Traits > sv,
                                   size_type pos = 0) const;

     Effects: Determines the lowest position xpos, if possible, such that both of the following conditions obtain: a) pos <= xpos and xpos < size(); b) traits::eq(at(xpos), sv.at(I)) for some element I of the string controlled by sv.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

136.     size_type find_first_of(const CharT * s, size_type pos, size_type n) const;

     Requires: s points to an array of at least n elements of CharT.

     Throws: Nothing

     Returns: find_first_of(basic_string(s, n), pos).

137.     size_type find_first_of(const CharT * s, size_type pos = 0) const;

     Requires: s points to an array of at least traits::length(s) + 1 elements of CharT.

     Throws: Nothing

     Returns: find_first_of(basic_string(s), pos).

138.     size_type find_first_of(CharT c, size_type pos = 0) const;

     Requires: s points to an array of at least traits::length(s) + 1 elements of CharT.

     Throws: Nothing

     Returns: find_first_of(basic_string<CharT,traits,allocator_type>(1,c), pos).

139.     size_type find_last_of(const basic_string & str, size_type pos = npos) const;

     Effects: Determines the highest position xpos, if possible, such that both of the following conditions obtain: a) xpos <= pos and xpos < size(); b) traits::eq(at(xpos), str.at(I)) for some element I of the string controlled by str.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

140.     template<template< class, class > class BasicStringView>
           size_type find_last_of(BasicStringView< CharT, Traits > sv,
                                  size_type pos = npos) const;

     Effects: Determines the highest position xpos, if possible, such that both of the following conditions obtain: a) xpos <= pos and xpos < size(); b) traits::eq(at(xpos), str.at(I)) for some element I of the string controlled by str.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

141.     size_type find_last_of(const CharT * s, size_type pos, size_type n) const;

     Requires: s points to an array of at least n elements of CharT.

     Throws: Nothing

     Returns: find_last_of(basic_string(s, n), pos).

142.     size_type find_last_of(const CharT * s, size_type pos = npos) const;

     Requires: s points to an array of at least traits::length(s) + 1 elements of CharT.

     Throws: Nothing

     Returns: find_last_of(basic_string<CharT,traits,allocator_type>(1,c),pos).

143.     size_type find_last_of(CharT c, size_type pos = npos) const;

     Throws: Nothing

     Returns: find_last_of(basic_string(s), pos).

144.     size_type find_first_not_of(const basic_string & str, size_type pos = 0) const;

     Effects: Determines the lowest position xpos, if possible, such that both of the following conditions obtain: a) pos <= xpos and xpos < size(); b) traits::eq(at(xpos), str.at(I)) for no element I of the string controlled by str.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

145.     template<template< class, class > class BasicStringView>
           size_type find_first_not_of(BasicStringView< CharT, Traits > sv,
                                       size_type pos = 0) const;

     Effects: Determines the lowest position xpos, if possible, such that both of the following conditions obtain: a) pos <= xpos and xpos < size(); b) traits::eq(at(xpos), sv.at(I)) for no element I of the string controlled by sv.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

146.     size_type find_first_not_of(const CharT * s, size_type pos, size_type n) const;

     Requires: s points to an array of at least traits::length(s) + 1 elements of CharT.

     Throws: Nothing

     Returns: find_first_not_of(basic_string(s, n), pos).

147.     size_type find_first_not_of(const CharT * s, size_type pos = 0) const;

     Requires: s points to an array of at least traits::length(s) + 1 elements of CharT.

     Throws: Nothing

     Returns: find_first_not_of(basic_string(s), pos).

148.     size_type find_first_not_of(CharT c, size_type pos = 0) const;

     Throws: Nothing

     Returns: find_first_not_of(basic_string(1, c), pos).

149.     size_type find_last_not_of(const basic_string & str, size_type pos = npos) const;

     Effects: Determines the highest position xpos, if possible, such that both of the following conditions obtain: a) xpos <= pos and xpos < size(); b) traits::eq(at(xpos), str.at(I)) for no element I of the string controlled by str.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

150.     template<template< class, class > class BasicStringView>
           size_type find_last_not_of(BasicStringView< CharT, Traits > sv,
                                      size_type pos = npos) const;

     Effects: Determines the highest position xpos, if possible, such that both of the following conditions obtain: a) xpos <= pos and xpos < size(); b) traits::eq(at(xpos), sv.at(I)) for no element I of the string controlled by sv.

     Throws: Nothing

     Returns: xpos if the function can determine such a value for xpos. Otherwise, returns npos.

151.     size_type find_last_not_of(const CharT * s, size_type pos, size_type n) const;

     Requires: s points to an array of at least n elements of CharT.

     Throws: Nothing

     Returns: find_last_not_of(basic_string(s, n), pos).

152.     size_type find_last_not_of(const CharT * s, size_type pos = npos) const;

     Requires: s points to an array of at least traits::length(s) + 1 elements of CharT.

     Throws: Nothing

     Returns: find_last_not_of(basic_string(s), pos).

153.     size_type find_last_not_of(CharT c, size_type pos = npos) const;

     Throws: Nothing

     Returns: find_last_not_of(basic_string(1, c), pos).

154.     basic_string substr(size_type pos = 0, size_type n = npos) const;

     Requires: Requires: pos <= size()

     Effects: Determines the effective length rlen of the string to copy as the smaller of n and size() - pos.

     Throws: If memory allocation throws or out_of_range if pos > size().

     Returns: basic_string<CharT,traits,allocator_type>(data()+pos,rlen).

155.     int compare(const basic_string & str) const;

     Effects: Determines the effective length rlen of the string to compare as the smaller of size() and str.size(). The function then compares the two strings by calling traits::compare(data(), str.data(), rlen).

     Throws: Nothing

     Returns: The nonzero result if the result of the comparison is nonzero. Otherwise, returns a value < 0 if size() < str.size(), a 0 value if size() == str.size(), and value > 0 if size() > str.size()

156.     template<template< class, class > class BasicStringView>
           int compare(BasicStringView< CharT, Traits > sv) const;

     Throws: Nothing

     Returns: compare(basic_string(sv)).

157.     int compare(size_type pos1, size_type n1, const basic_string & str) const;

     Requires: pos1 <= size()

     Effects: Determines the effective length rlen of the string to compare as the smaller of (this->size() - pos1), n1 and str.size(). The function then compares the two strings by calling traits::compare(data()+pos1, str.data(), rlen).

     Throws: out_of_range if pos1 > size()

     Returns:basic_string(*this,pos1,n1).compare(str).

158.     template<template< class, class > class BasicStringView>
           int compare(size_type pos1, size_type n1,
                       BasicStringView< CharT, Traits > sv) const;

     Requires: pos1 <= size()

     Throws: out_of_range if pos1 > size()

     Returns:basic_string(*this,pos1,n1).compare(sv).

159.     int compare(size_type pos1, size_type n1, const basic_string & str,
                     size_type pos2, size_type n2 = npos) const;

     Requires: pos1 <= size() and pos2 <= str.size()

     Effects: Determines the effective length rlen of the string to copy as the smaller of

     Throws: out_of_range if pos1 > size() or pos2 > str.size()

     Returns: basic_string(*this, pos1, n1).compare(basic_string(str, pos2, n2)).

160.     template<template< class, class > class BasicStringView>
           int compare(size_type pos1, size_type n1,
                       BasicStringView< CharT, Traits > sv, size_type pos2,
                       size_type n2 = npos) const;

     Requires: pos1 <= size() and pos2 <= str.size()

     Effects: Determines the effective length rlen of the string to copy as the smaller of

     Throws: out_of_range if pos1 > size() or pos2 > sv.size()

     Returns: basic_string(*this, pos1, n1).compare(BasicStringView<CharT, Traits>(sv, pos2, n2)).

161.     int compare(const CharT * s) const;

     Throws: Nothing

     Returns: compare(basic_string(s)).

162.     int compare(size_type pos1, size_type n1, const CharT * s, size_type n2) const;

     Requires: pos1 > size() and s points to an array of at least n2 elements of CharT.

     Throws: out_of_range if pos1 > size()

     Returns: basic_string(*this, pos, n1).compare(basic_string(s, n2)).

163.     int compare(size_type pos1, size_type n1, const CharT * s) const;

     Requires: pos1 > size() and s points to an array of at least traits::length(s) + 1 elements of CharT.

     Throws: out_of_range if pos1 > size()

     Returns: basic_string(*this, pos, n1).compare(basic_string(s, n2)).

164.     template<template< class, class > class BasicStringView>
           bool contains(BasicStringView< CharT, Traits > sv) const noexcept;

     Effects: Equivalent to find(sv) != npos

     Throws: Nothing

     Returns: true if the string contains the provided substring, false otherwise.

165.     bool contains(CharT c) const noexcept;

     Effects: Equivalent to find(c) != npos

     Throws: Nothing

     Returns: true if the string contains the provided substring, false otherwise.

166.     bool contains(const CharT * s) const noexcept;

     Effects: Equivalent to find(c) != npos

     Throws: Nothing

     Returns: true if the string contains the provided substring, false otherwise.

167.     template<template< class, class > class BasicStringView>
           bool starts_with(BasicStringView< CharT, Traits > sv) const noexcept;

     Effects: Checks if the string begins with the given prefix

     Throws: Nothing

     Returns: true if the string begins with the provided prefix, false otherwise.

168.     bool starts_with(CharT c) const noexcept;

     Effects: Checks if the string begins with the given prefix

     Throws: Nothing

     Returns: true if the string begins with the provided prefix, false otherwise.

169.     bool starts_with(const CharT * s) const noexcept;

     Effects: Checks if the string begins with the given prefix

     Throws: Nothing

     Returns: true if the string begins with the provided prefix, false otherwise.

170.     template<template< class, class > class BasicStringView>
           bool ends_with(BasicStringView< CharT, Traits > sv) const noexcept;

     Effects: Checks if the string begins with the given suffix

     Throws: Nothing

     Returns: true if the string begins with the provided suffix, false otherwise.

171.     bool ends_with(CharT c) const noexcept;

     Effects: Checks if the string begins with the given suffix

     Throws: Nothing

     Returns: true if the string begins with the provided suffix, false otherwise.

172.     bool ends_with(const CharT * s) const noexcept;

     Effects: Checks if the string begins with the given suffix

     Throws: Nothing

     Returns: true if the string begins with the provided suffix, false otherwise.