Boost C++ Libraries Home Libraries People FAQ More

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 A = std::allocator<CharT> > 
class basic_string {
public:
  // types
  typedef A                                       allocator_type;        
  typedef allocator_type                          stored_allocator_type;   // The stored allocator type. 
  typedef CharT                                   value_type;              // The type of object, CharT, stored in the string. 
  typedef Traits                                  traits_type;             // The second template parameter Traits. 
  typedef allocator_traits_type::pointer          pointer;                 // Pointer to CharT. 
  typedef allocator_traits_type::const_pointer    const_pointer;           // Const pointer to CharT. 
  typedef allocator_traits_type::reference        reference;               // Reference to CharT. 
  typedef allocator_traits_type::const_reference  const_reference;         // Const reference to CharT. 
  typedef allocator_traits_type::size_type        size_type;               // An unsigned integral type. 
  typedef allocator_traits_type::difference_type  difference_type;         // A signed integral type. 
  typedef pointer                                 iterator;                // Iterator used to iterate through a string. It's a Random Access Iterator. 
  typedef const_pointer                           const_iterator;          // Const iterator used to iterate through a string. It's a Random Access Iterator. 
  typedef std::reverse_iterator< iterator >       reverse_iterator;        // Iterator used to iterate backwards through a string. 
  typedef std::reverse_iterator< const_iterator > const_reverse_iterator;  // Const iterator used to iterate backwards through a string. 

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

  // public member functions
  iterator begin();
  const_iterator begin() const;
  const_iterator cbegin() const;
  iterator end();
  const_iterator end() const;
  const_iterator cend() const;
  reverse_iterator rbegin();
  const_reverse_iterator rbegin() const;
  const_reverse_iterator crbegin() const;
  reverse_iterator rend();
  const_reverse_iterator rend() const;
  const_reverse_iterator crend() const;
  allocator_type get_allocator() const;
  const stored_allocator_type & get_stored_allocator() const;
  stored_allocator_type & get_stored_allocator();
  size_type size() const;
  size_type length() const;
  size_type max_size() const;
  void resize(size_type, CharT);
  void resize(size_type);
  void reserve(size_type);
  size_type capacity() const;
  void clear();
  void shrink_to_fit();
  bool empty() const;
  reference operator[](size_type);
  const_reference operator[](size_type) const;
  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 &&);
  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);
  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);
  void insert(const_iterator, size_type, CharT);
  template<typename InputIter> 
    void insert(const_iterator, InputIter, InputIter);
  basic_string & erase(size_type = 0, size_type = npos);
  iterator erase(const_iterator);
  iterator erase(const_iterator, const_iterator);
  void pop_back();
  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;
  const CharT * data() const;
  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;  // The largest possible value of type size_type. That is, size_type(-1). 
};

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.

basic_string public types

  1. typedef A allocator_type;

    The allocator type

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

    Effects: Constructs a basic_string taking the allocator as parameter.

    Throws: If allocator_type's copy constructor throws.

  3. basic_string(const basic_string & s);

    Effects: Copy constructs a basic_string.

    Postcondition: x == *this.

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

  4. basic_string(basic_string && s);

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

    Throws: If allocator_type's copy constructor throws.

    Complexity: Constant.

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

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

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

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

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

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

    Effects: Copy constructs a string.

    Postcondition: x == *this.

    Complexity: Linear to the elements x contains.

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

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

    Throws: If allocator_type's copy constructor throws.

    Complexity: Constant.

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

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

    Throws: Nothing.

    Complexity: Constant.

basic_string public member functions

  1. iterator begin();

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

    Throws: Nothing.

    Complexity: Constant.

  2. const_iterator begin() const;

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

    Throws: Nothing.

    Complexity: Constant.

  3. const_iterator cbegin() const;

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

    Throws: Nothing.

    Complexity: Constant.

  4. iterator end();

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

    Throws: Nothing.

    Complexity: Constant.

  5. const_iterator end() const;

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

    Throws: Nothing.

    Complexity: Constant.

  6. const_iterator cend() const;

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

    Throws: Nothing.

    Complexity: Constant.

  7. reverse_iterator rbegin();

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

    Throws: Nothing.

    Complexity: Constant.

  8. const_reverse_iterator rbegin() const;

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

    Throws: Nothing.

    Complexity: Constant.

  9. const_reverse_iterator crbegin() const;

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

    Throws: Nothing.

    Complexity: Constant.

  10. reverse_iterator rend();

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

    Throws: Nothing.

    Complexity: Constant.

  11. const_reverse_iterator rend() const;

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

    Throws: Nothing.

    Complexity: Constant.

  12. const_reverse_iterator crend() const;

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

    Throws: Nothing.

    Complexity: Constant.

  13. allocator_type get_allocator() const;

    Effects: Returns a copy of the internal allocator.

    Throws: If allocator's copy constructor throws.

    Complexity: Constant.

  14. const stored_allocator_type & get_stored_allocator() const;

    Effects: Returns a reference to the internal allocator.

    Throws: Nothing

    Complexity: Constant.

    Note: Non-standard extension.

  15. stored_allocator_type & get_stored_allocator();

    Effects: Returns a reference to the internal allocator.

    Throws: Nothing

    Complexity: Constant.

    Note: Non-standard extension.

  16. size_type size() const;

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

    Throws: Nothing.

    Complexity: Constant.

  17. size_type length() const;

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

    Throws: Nothing.

    Complexity: Constant.

  18. size_type max_size() const;

    Effects: Returns the largest possible size of the vector.

    Throws: Nothing.

    Complexity: Constant.

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

  20. void resize(size_type n);

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

    Throws: If memory allocation throws

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

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

  22. size_type capacity() const;

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

    Throws: Nothing.

    Complexity: Constant.

  23. void clear();

    Effects: Erases all the elements of the vector.

    Throws: Nothing.

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

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

  25. bool empty() const;

    Effects: Returns true if the vector contains no elements.

    Throws: Nothing.

    Complexity: Constant.

  26. reference operator[](size_type n);

    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;

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

    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. template<typename InputIter> 
      basic_string & assign(InputIter first, InputIter last);

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

    Returns: *this

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

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

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

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

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

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

  53. void 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 which refers to the copy of the first inserted character, or p if n == 0.

  54. template<typename InputIter> 
      void 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 which refers to the copy of the first inserted character, or p if first == last.

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

  56. iterator erase(const_iterator p);

    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.

  57. iterator erase(const_iterator first, const_iterator last);

    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.

  58. void pop_back();

    Requires: !empty()

    Throws: Nothing

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

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

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

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

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

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

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

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

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

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

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

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

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

  71. const CharT * c_str() const;

    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.

  72. const CharT * data() const;

    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.

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

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

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

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

    Throws: Nothing

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

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

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

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

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

    Throws: Nothing

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

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

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

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

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

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

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

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

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

    Throws: Nothing

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Throws: Nothing

    Returns: compare(basic_string(s)).

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

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