std::basic_string::replace

(1) string

Copies str.

(2) substring

Copies the portion of str that begins at the character position subpos and spans sublen characters (or until the end of str, if either str is too short or if sublen is basic_string::npos).

(3) c-string

Copies the null-terminated character sequence (C-string) pointed by s.
The length is determined by calling traits.length(s).

(4) buffer

Copies the first n characters from the array of characters pointed by s.

(5) fill

Replaces the portion of the string by n consecutive copies of character c.

(6) range

Copies the sequence of characters in the range [first,last), in the same order.

(7) initializer list

Copies each of the characters in il, in the same order.

Parameters

str

Another basic_string object of the same type (with the same class template arguments charT, traits and Alloc), whose value is copied.

pos

Position of the first character to be replaced.
If this is greater than the string length, it throws out_of_range.

len

Number of characters to replace (if the string is shorter, as many characters as possible are replaced).
A value of basic_string::npos indicates all characters until the end of the string.

subpos

Position of the first character in str that is copied to the object as replacement.
If this is greater than str's length, it throws out_of_range.

sublen

Length of the substring to be copied (if the string is shorter, as many characters as possible are copied).
A value of basic_string::npos indicates all characters until the end of str.

s

Pointer to an array of characters (such as a c-string).

n

Number of characters to copy.

c

Character value, repeated n times.

first, last

Input iterators to the initial and final positions in a range. The range used is [first,last), which includes all the characters between first and last, including the character pointed by first but not the character pointed by last.
The function template argument InputIterator shall be an input iterator type that points to elements of a type convertible to charT.

il

An initializer_list object.
These objects are automatically constructed from initializer list declarators.

Return Value

Example

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

// replacing in a string
#include <iostream>
#include <string>

int main ()
{
  std::string base="this is a test string.";
  std::string str2="n example";
  std::string str3="sample phrase";
  std::string str4="useful.";

  // replace signatures used in the same order as described above:

  // Using positions:                 0123456789*123456789*12345
  std::string str=base;           // "this is a test string."
  str.replace(9,5,str2);          // "this is an example string." (1)
  str.replace(19,6,str3,7,6);     // "this is an example phrase." (2)
  str.replace(8,10,"just a");     // "this is just a phrase."     (3)
  str.replace(8,6,"a shorty",7);  // "this is a short phrase."    (4)
  str.replace(22,1,3,'!');        // "this is a short phrase!!!"  (5)

  // Using iterators:                                               0123456789*123456789*
  str.replace(str.begin(),str.end()-3,str3);                    // "sample phrase!!!"      (1)
  str.replace(str.begin(),str.begin()+6,"replace");             // "replace phrase!!!"     (3)
  str.replace(str.begin()+8,str.begin()+14,"is coolness",7);    // "replace is cool!!!"    (4)
  str.replace(str.begin()+12,str.end()-4,4,'o');                // "replace is cooool!!!"  (5)
  str.replace(str.begin()+11,str.end(),str4.begin(),str4.end());// "replace is useful."    (6)
  std::cout << str << '\n';
  return 0;
}

replace is useful.

Complexity

Iterator validity

Data races

Exception safety

See also

basic_string::insert

Insert into string (public member function)

basic_string::append

Append to string (public member function)

basic_string::substr

Generate substring (public member function)

basic_string::erase

Erase characters from string (public member function)

basic_string::assign

Assign content to string (public member function)