std::basic_string::append

From cppreference.com
 
 
 
std::basic_string
Member functions
basic_string::basic_string
basic_string::operator=
basic_string::assign
basic_string::get_allocator
Element access
basic_string::at
basic_string::operator[]
basic_string::front (C++11)
basic_string::back (C++11)
basic_string::data
basic_string::c_str
Iterators
basic_string::begin
basic_string::cbegin

(C++11)
basic_string::end
basic_string::cend

(C++11)
basic_string::rbegin
basic_string::crbegin

(C++11)
basic_string::rend
basic_string::crend

(C++11)
Capacity
basic_string::empty
basic_string::size
basic_string::length
basic_string::max_size
basic_string::reserve
basic_string::capacity
basic_string::shrink_to_fit (C++11)
Operations
basic_string::clear
basic_string::insert
basic_string::erase
basic_string::push_back
basic_string::pop_back (C++11)
basic_string::append
basic_string::operator+=
basic_string::compare
basic_string::replace
basic_string::substr
basic_string::copy
basic_string::resize
basic_string::swap
Search
basic_string::find
basic_string::rfind
basic_string::find_first_of
basic_string::find_first_not_of
basic_string::find_last_of
basic_string::find_last_not_of
Constants
basic_string::npos
Non-member functions
operator+
operator==
operator!=
operator<
operator>
operator<=
operator>=
swap(std::basic_string)
operator<<
operator>>
getline
stoi
stol
stoll
(C++11)
(C++11)
(C++11)
stoul
stoull
(C++11)
(C++11)
stof
stod
stold
(C++11)
(C++11)
(C++11)
to_string (C++11)
to_wstring (C++11)
Helper classes
hash<std::string>
hash<std::wstring>
hash<std::u32string>
hash<std::u16string>
(C++11)
 
basic_string& append( size_type count, const CharT& ch );
(1)
basic_string& append( const basic_string& str );
(2)
basic_string& append( const basic_string& str,

                      size_type pos,

                      size_type count );
(3)
basic_string& append( const CharT* s,
                      size_type count );
(4)
basic_string& append( const CharT* s );
(5)
template< class InputIt >
basic_string& append( InputIt first, InputIt last );
(6)
basic_string& append( std::initializer_list<CharT> ilist );
(7) (since C++11)

Appends additional characters to the string.

1) Appends count copies of character ch

2) Appends string str

3) Appends a substring [pos, pos+count) of str. If the requested substring lasts past the end of the string, or if count == npos, the appended substring is [pos, size()). If pos >= str.size(), std::out_of_range is thrown.

4) Appends the first count characters of character string pointed to by s. s can contain null characters.

5) Appends the null-terminated character string pointed to by s. The length of the string is determined by the first null character.

6) Appends characters in the range [first, last)

7) Appends characters in the initializer list ilist.

Contents

[edit] Parameters

count - number of characters to append
ch - character value to append
first, last - range of characters to append
str - string to append
s - pointer to the character string to append
init - initializer list with the characters to append
Type requirements
-
InputIt must meet the requirements of InputIterator.

[edit] Return value

*this

[edit] Complexity

1) linear in count

2) linear in size of str

3-4) linear in count

5) linear in size of s

6) linear in distance between first and last

7) linear in size of init

[edit] Example

#include <string>
#include <iostream>
 
int main() {
    std::basic_string<char> str = "string";
    const char* cptr = "C-string";
    const char carr[] = "Two and one";
 
    std::string output;
 
    // 1) Repeat a char
    output.append(3, '*');
    std::cout << "1) " << output << "\n";
 
    //  2) Append a whole string
    output.append(str);
    std::cout << "2) " << output << "\n";
 
    // 3) Append part of a string (last 3 letters, in this case)
    output.append(str, 3, 3);
    std::cout << "3) " << output << "\n";
 
    // 4) Append part of a C-string
    // Notice, because `append` returns *this, we can chain calls together
    output.append(1, ' ').append(carr, 4);
    std::cout << "4) " << output << "\n";
 
    // 5) Append a whole C-string
    output.append(cptr);
    std::cout << "5) " << output << "\n";
 
    // 6) Append range
    output.append(&carr[3], std::end(carr));
    std::cout << "6) " << output << "\n";
 
    // 7) Append initializer list
    output.append({ ' ', 'l', 'i', 's', 't' });
    std::cout << "7) " << output << "\n";
}

Output:

1) ***
2) ***string
3) ***stringing
4) ***stringing Two 
5) ***stringing Two C-string
6) ***stringing Two C-string and one
7) ***stringing Two C-string and one list

[edit] See also

appends characters to the end
(public member function)