C++ Primer Plus

string st4 = 't' + st2;    // st4 is "train"

string st5 = st1 + st2;    // st5 is "redrain"

More Assignment Methods

In addition to the basic assignment operator, the string class provides assign() methods, which allow you to assign a whole string or a part of a string or a sequence of identical characters to a string object. Here are the prototypes for the various assign() methods:

basic_string& assign(const basic_string& str);

basic string& assign(basic_string&& str) noexcept;   // C++11

basic_string& assign(const basic_string& str, size_type pos,

                     size_type n);

basic_string& assign(const charT* s, size_type n);

basic_string& assign(const charT* s);

basic_string& assign(size_type n, charT c); // assign n copies of c

template

  basic_string& assign(InputIterator first, InputIterator last);

basic_string& assign(initializer_list);  // C++11

Here are a couple examples:

string test;

string stuff("set tubs clones ducks");

test.assign(stuff, 1, 5);   // test is "et tu"

test.assign(6, '#");        // test is "######"

The assign() method with an rvalue reference (added by C++11) allows for move semantics, and the second new assign() method allows one to assign an initializer_list to a string object.

Insertion Methods

The insert() methods let you insert a string object, a string array, a character, or several characters into a string object. The methods are similar to the append() methods, except that they take an additional argument, indicating where to insert the new material. This argument may be a position or an iterator. The material is inserted before the insertion point. Several of the methods return a reference to the resulting string. If pos1 is beyond the end of the target string or if pos2 is beyond the end of the string to be inserted, a method throws an out_of_range exception. If the resulting string will be larger than the maximum size, a method throws a length_error exception. Here are the prototypes for the various insert() methods:

basic_string& insert(size_type pos1, const basic_string& str);

basic_string& insert(size_type pos1, const basic_string& str,

                     size_type pos2, size_type n);

basic_string& insert(size_type pos, const charT* s, size_type n);

basic_string& insert(size_type pos, const charT* s);

basic_string& insert(size_type pos, size_type n, charT c);

iterator insert(const_iterator p, charT c);

iterator insert(const_iterator p, size_type n, charT c);

template

  void insert(iterator p, InputIterator first, InputIterator last);

iterator insert(const_iterator p, initializer_list); // C++11

For example, the following code inserts the string "former " before the b in "The banker.":

string st3("The banker.");

st3.insert(4, "former ");

Then the following code inserts the string " waltzed" (not including the !, which would be the ninth character) just before the period at the end of "The former banker.":

st3.insert(st3.size() - 1, " waltzed!", 8);

Erase Methods

The erase() methods remove characters from a string. Here are their prototypes:

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

iterator erase(const_iterator position);

iterator erase(const_iterator first, iterator last);

void pop_back();

The first form removes the character from position pos to n characters later or the end of the string, whichever comes first. The second removes the single character referenced by the iterator position and returns an iterator to the next element or if there are no more elements, returns end(). The third removes the characters in the range [first, last); that is, including first and up to but not including last. The method returns an iterator to the element following the last element erased. Finally, the pop_back() method removes the last character in the string.

Replacement Methods

The various replace() methods identify part of a string to be replaced and identify the replacement. The part to be replaced can be identified by an initial position and a character count or by an iterator range. The replacement can be a string object, a string array, or a particular character duplicated several times. Replacement string objects and arrays can further be modified by indicating a particular portion, using a position and a count, just a count, or an iterator range. Here are the prototypes for the various replace() methods:

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

basic_string& replace(size_type pos1, size_type n1, const basic_string& str,

                      size_type pos2, size_type n2);

basic_string& replace(size_type pos, size_type n1, const charT* s,

                      size_type n2);

basic_string& replace(size_type pos, size_type n1, const charT* s);

basic_string& replace(size_type pos, size_type n1, size_type n2, charT c);

basic_string& replace(const_iterator i1, const_iterator i2,

                      const basic_string& str);

basic_string& replace(const_iterator i1, const_iterator i2,

                      const charT* s, size_type n);

basic_string& replace(const_iterator i1, const_iterator i2,

                      const charT* s);