std::basic_string::append

(1) string

Appends a copy of str.

(2) substring

Appends a copy of a substring of str. The substring is 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

Appends a copy of the string formed by the null-terminated character sequence (C-string) pointed by s.
The length of this character sequence is determined by calling traits_type::length(s).

(4) buffer

Appends a copy of the first n characters in the array of characters pointed by s.

(5) fill

Appends n consecutive copies of character c.

(6) range

Appends a copy of the sequence of characters in the range [first,last), in the same order.

(7) initializer list

Appends a copy of 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 appended.

subpos

Position of the first character in str that is copied to the object as a substring.
If this is greater than str's length, it throws out_of_range.
Note: The first character in str is denoted by a value of 0 (not 1).

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.
If InputIterator is an integral type, the arguments are casted to the proper types so that signature (5) is used instead.

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

// appending to string
#include <iostream>
#include <string>

int main ()
{
  std::string str;
  std::string str2="Writing ";
  std::string str3="print 10 and then 5 more";

  // used in the same order as described above:
  str.append(str2);                       // "Writing "
  str.append(str3,6,3);                   // "10 "
  str.append("dots are cool",5);          // "dots "
  str.append("here: ");                   // "here: "
  str.append(10u,'.');                    // ".........."
  str.append(str3.begin()+8,str3.end());  // " and then 5 more"
  str.append<int>(5,0x2E);                // "....."

  std::cout << str << '\n';
  return 0;
}

Writing 10 dots here: .......... and then 5 more.....

Complexity

Iterator validity

Data races

Exception safety

See also

basic_string::operator+=

Append to string (public member function )

basic_string::assign

Assign content to string (public member function )

basic_string::insert

Insert into string (public member function )

basic_string::replace

Replace portion of string (public member function )