Boost C++ Libraries

...one of the most highly regarded and expertly designed C++ library projects in the world. Herb Sutter and Andrei Alexandrescu, C++ Coding Standards

PrevUpHomeNext

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 = std::allocator<CharT> > 
class basic_string {
public:
  // types
  typedef Traits                                                             traits_type;           
  typedef CharT                                                              value_type;            
  typedef ::boost::container::allocator_traits< Allocator >::pointer         pointer;               
  typedef ::boost::container::allocator_traits< Allocator >::const_pointer   const_pointer;         
  typedef ::boost::container::allocator_traits< Allocator >::reference       reference;             
  typedef ::boost::container::allocator_traits< Allocator >::const_reference const_reference;       
  typedef ::boost::container::allocator_traits< Allocator >::size_type       size_type;             
  typedef ::boost::container::allocator_traits< Allocator >::difference_type difference_type;       
  typedef Allocator                                                          allocator_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;

  // construct/copy/destruct
  basic_string();
  explicit basic_string(const allocator_type &) noexcept;
  basic_string(const basic_string &);
  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, 
               const allocator_type & = allocator_type());
  basic_string(const CharT *, size_type, 
               const allocator_type & = allocator_type());
  basic_string(const CharT *, const allocator_type & = allocator_type());
  basic_string(size_type, CharT, const allocator_type & = allocator_type());
  basic_string(size_type, default_init_t, 
               const allocator_type & = allocator_type());
  template<typename InputIterator> 
    basic_string(InputIterator, InputIterator, 
                 const allocator_type & = allocator_type());
  basic_string & operator=(const basic_string &);
  basic_string & 
  operator=(basic_string &&) noexcept(allocator_traits_type::propagate_on_container_move_assignment::value));
  basic_string & operator=(const CharT *);
  basic_string & operator=(CharT);
  ~basic_string();

  // public member functions
  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 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 &);
  basic_string & operator+=(const CharT *);
  basic_string & operator+=(CharT);
  basic_string & append(const basic_string &);
  basic_string & append(const basic_string &, size_type, size_type);
  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);
  void push_back(CharT);
  basic_string & assign(const basic_string &);
  basic_string & assign(basic_string &&) noexcept;
  basic_string & assign(const basic_string &, size_type, size_type);
  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 & insert(size_type, const basic_string &);
  basic_string & insert(size_type, const basic_string &, size_type, size_type);
  basic_string & insert(size_type, const CharT *, size_type);
  basic_string & insert(size_type, const CharT *);
  basic_string & insert(size_type, size_type, CharT);
  iterator insert(const_iterator, CharT);
  iterator insert(const_iterator, size_type, CharT);
  template<typename InputIter> 
    iterator insert(const_iterator, InputIter, InputIter);
  basic_string & erase(size_type = 0, size_type = npos);
  iterator erase(const_iterator) noexcept;
  iterator erase(const_iterator, const_iterator) noexcept;
  void pop_back() noexcept;
  void clear() noexcept;
  basic_string & replace(size_type, size_type, const basic_string &);
  basic_string & 
  replace(size_type, size_type, const basic_string &, size_type, size_type);
  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);
  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;
  size_type find(const basic_string &, 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;
  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;
  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;
  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;
  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;
  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;
  int compare(size_type, size_type, const basic_string &) const;
  int compare(size_type, size_type, const basic_string &, size_type, 
              size_type) 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;

  // 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 = std::allocator<CharT>

    The allocator, used for internal memory management.

basic_string public construct/copy/destruct

  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. basic_string(basic_string && s) noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  5. 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.

  6. 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.

  7. basic_string(const basic_string & s, size_type pos, size_type n = npos, 
                 const allocator_type & a = allocator_type());

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

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

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

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

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

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

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

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

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

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

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

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

    Effects: Copy constructs a string.

    Postcondition: x == *this.

    Complexity: Linear to the elements x contains.

  14. basic_string & 
    operator=(basic_string && x) noexcept(allocator_traits_type::propagate_on_container_move_assignment::value));

    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.

  15. basic_string & operator=(const CharT * s);
    Effects: Assignment from a null-terminated c-string.
  16. basic_string & operator=(CharT c);
    Effects: Assignment from character.
  17. ~basic_string();

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

    Throws: Nothing.

    Complexity: Constant.

basic_string public member functions

  1. allocator_type get_allocator() const noexcept;

    Effects: Returns a copy of the internal allocator.

    Throws: If allocator's copy constructor throws.

    Complexity: Constant.

  2. stored_allocator_type & get_stored_allocator() noexcept;

    Effects: Returns a reference to the internal allocator.

    Throws: Nothing

    Complexity: Constant.

    Note: Non-standard extension.

  3. 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.

  4. iterator begin() noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  5. const_iterator begin() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  6. iterator end() noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  7. const_iterator end() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  8. reverse_iterator rbegin() noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  9. const_reverse_iterator rbegin() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  10. reverse_iterator rend() noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  11. const_reverse_iterator rend() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  12. const_iterator cbegin() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  13. const_iterator cend() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  14. const_reverse_iterator crbegin() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  15. const_reverse_iterator crend() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  16. bool empty() const noexcept;

    Effects: Returns true if the vector contains no elements.

    Throws: Nothing.

    Complexity: Constant.

  17. size_type size() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  18. size_type length() const noexcept;

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

    Throws: Nothing.

    Complexity: Constant.

  19. size_type max_size() const noexcept;

    Effects: Returns the largest possible size of the vector.

    Throws: Nothing.

    Complexity: Constant.

  20. 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.

  21. 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.

  22. 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

  23. 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.

  24. 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

  25. 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().

  26. 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.

  27. 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.

  28. reference at(size_type n);

    Requires: size() > n.

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

    Throws: std::range_error if n >= size()

    Complexity: Constant.

  29. 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: std::range_error if n >= size()

    Complexity: Constant.

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

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

    Returns: *this

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

    Effects: Calls append(s).

    Returns: *this

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

    Effects: Calls append(1, c).

    Returns: *this

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

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

    Returns: *this

  34. basic_string & append(const basic_string & s, size_type pos, size_type n);

    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

  35. 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

  36. 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

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

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

    Returns: *this

  38. 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

  39. void push_back(CharT c);
    Effects: Equivalent to append(static_cast<size_type>(1), c).
  40. basic_string & assign(const basic_string & s);

    Effects: Equivalent to assign(str, 0, npos).

    Returns: *this

  41. basic_string & assign(basic_string && ms) noexcept;

    Effects: The function replaces the string controlled by *this with a string of length str.size() whose elements are a copy of the string controlled by str. Leaves str in a valid but unspecified state.

    Throws: Nothing

    Returns: *this

  42. basic_string & assign(const basic_string & s, size_type pos, size_type n);

    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

  43. 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

  44. 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

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

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

    Returns: *this

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

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

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

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

    Returns: *this

  48. 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

  49. basic_string & 
    insert(size_type pos1, const basic_string & s, size_type pos2, size_type n);

    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

  50. 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

  51. 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

  52. 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

  53. 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.

  54. 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.

  55. 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.

  56. 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

  57. 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.

  58. 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.

  59. void pop_back() noexcept;

    Requires: !empty()

    Throws: Nothing

    Effects: Equivalent to erase(size() - 1, 1).

  60. void clear() noexcept;

    Effects: Erases all the elements of the vector.

    Throws: Nothing.

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

  61. 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

  62. basic_string & 
    replace(size_type pos1, size_type n1, const basic_string & str, 
            size_type pos2, size_type n2);

    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

  63. 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

  64. 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

  65. 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

  66. 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

  67. 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

  68. 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

  69. 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

  70. 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

  71. 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

  72. 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

  73. const CharT * c_str() const noexcept;

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

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

    Complexity: constant time.

  74. const CharT * data() const noexcept;

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

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

    Complexity: constant time.

  75. 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 obtain: 19 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.

  76. 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>(s,n),pos).

  77. 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).

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

    Throws: Nothing

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

  79. 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.

  80. 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).

  81. 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).

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

    Throws: Nothing

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

  83. size_type find_first_of(const basic_string & s, 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.

  84. 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).

  85. 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).

  86. 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>(1,c), pos).

  87. 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.

  88. 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).

  89. 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>(1,c),pos).

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

    Throws: Nothing

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

  91. 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.

  92. 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).

  93. 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).

  94. 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).

  95. 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.

  96. 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).

  97. 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).

  98. 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).

  99. 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>(data()+pos,rlen).

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

    Effects: Determines the effective length rlen of the string to copy 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()

  101. 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 copy as the smaller of

    Throws: out_of_range if pos1 > size()

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

  102. int compare(size_type pos1, size_type n1, const basic_string & str, 
                size_type pos2, size_type n2) 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)).

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

    Throws: Nothing

    Returns: compare(basic_string(s)).

  104. 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)).

  105. 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)).


PrevUpHomeNext