Namespaces
Variants

std::basic_string<CharT,Traits,Allocator>:: append

From cppreference.net
C++
Strings library
std::basic_string
basic_string & append ( size_type count, CharT ch ) ;
(1) (constexpr seit C++20)
basic_string & append ( const CharT * s, size_type count ) ;
(2) (constexpr seit C++20)
basic_string & append ( const CharT * s ) ;
(3) (constexpr seit C++20)
template < class SV >
basic_string & append ( const SV & t ) ;
(4) (seit C++17)
(constexpr seit C++20)
template < class SV >

basic_string & append ( const SV & t, size_type pos,

size_type count = npos ) ;
(5) (seit C++17)
(constexpr seit C++20)
basic_string & append ( const basic_string & str ) ;
(6) (constexpr seit C++20)
(7)
basic_string & append ( const basic_string & str,
size_type pos, size_type count ) ;
(bis C++14)
basic_string & append ( const basic_string & str,
size_type pos, size_type count = npos ) ;
(seit C++14)
(constexpr seit C++20)
template < class InputIt >
basic_string & append ( InputIt first, InputIt last ) ;
(8) (constexpr seit C++20)
basic_string & append ( std:: initializer_list < CharT > ilist ) ;
(9) (seit C++11)
(constexpr seit C++20)

Fügt zusätzliche Zeichen an die Zeichenkette an.

1) Hängt count Kopien des Zeichens ch an.
2) Fügt Zeichen im Bereich [ s , s + count ) hinzu.
Falls [ s , s + count ) kein gültiger Bereich ist, ist das Verhalten undefiniert.
3) Entspricht return append ( s, Traits :: length ( s ) ) ; .
4,5) Fügt Zeichen aus einem String-View sv an, der aus t konstruiert wird.
  • Wenn nur t angegeben ist, werden alle Zeichen in sv angefügt.
  • Wenn pos ebenfalls angegeben ist:
    • Wenn count gleich npos ist, werden alle Zeichen in sv ab Position pos angefügt.
    • Andernfalls werden die std:: min ( count, sv. size ( ) - pos ) Zeichen in sv ab Position pos angefügt.
Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:
4) Entspricht std:: basic_string_view < CharT, Traits > sv = t ;
return append ( sv. data ( ) , sv. size ( ) ) ; .
5) Entspricht std:: basic_string_view < CharT, Traits > sv = t ;
return append ( sv. substr ( pos, count ) ) ; .
6,7) Fügt Zeichen aus einer anderen Zeichenkette str an.
  • Wenn nur str angegeben ist, werden alle darin enthaltenen Zeichen angehängt.
  • Wenn zusätzlich pos angegeben ist:
    • Wenn count gleich npos ist, werden alle Zeichen in str ab Position pos angehängt.
    • Andernfalls werden die std:: min ( count, str. size ( ) - pos ) Zeichen in str ab Position pos angehängt.
6) Entspricht return append ( str. data ( ) , str. size ( ) ) ; .
7) Entspricht return append ( std:: basic_string_view < CharT, Traits >
( str ) . substr ( pos, count ) ) ; .
(seit C++20)
8) Entspricht return append ( basic_string ( first, last, get_allocator ( ) ) ) ; .

Diese Überladung hat denselben Effekt wie Überladung (1) , wenn InputIt ein integraler Typ ist.

(bis C++11)

Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn InputIt die Anforderungen von LegacyInputIterator erfüllt.

(seit C++11)
9) Entspricht return append ( ilist. begin ( ) , ilist. size ( ) ) ; .

Inhaltsverzeichnis

Parameter

count - Anzahl der anzuhängenden Zeichen
ch - anzuhängender Zeichenwert
s - Zeiger auf die anzuhängende Zeichenkette
t - in std::basic_string_view konvertierbares Objekt mit den anzuhängenden Zeichen
pos - Index des ersten anzuhängenden Zeichens
str - anzuhängende Zeichenkette
first, last - Bereich der anzuhängenden Zeichen
ilist - Initialisierungsliste mit den anzuhängenden Zeichen

Rückgabewert

* this

Komplexität

Es gibt keine standardmäßigen Komplexitätsgarantien, typische Implementierungen verhalten sich ähnlich wie std::vector::insert() .

Ausnahmen

Falls die Operation dazu führen würde, dass size() die max_size() überschreitet, wird std::length_error ausgelöst.

5) Wenn pos > sv. size ( ) true ist, wird std::out_of_range ausgelöst.
7) Wenn pos > str. size ( ) true ist, wird std::out_of_range ausgelöst.

Wenn aus irgendeinem Grund eine Exception ausgelöst wird, hat diese Funktion keine Wirkung ( strong exception safety guarantee ).

Beispiel

Diesen Code ausführen 
#include <cassert>
#include <string>
int main()
{
    std::string str = "std::string";
    const char* cptr = "C-string";
    const char carr[] = "range";
    std::string result;
    // 1) Ein Zeichen 3-mal anhängen.
    // Hinweis: Dies ist die einzige Überladung, die "CharT" akzeptiert.
    result.append(3, '*');
    assert(result == "***");
    // 2) Einen festlangen C-String anhängen
    result.append(cptr, 5);
    assert(result == "***C-str");
    // 3) Einen nullterminierten C-String anhängen
    // Hinweis: Da "append" *this zurückgibt, können wir Aufrufe verketten.
    result.append(1, ' ').append(cptr);
    assert(result == "***C-str C-string");
    // 6) Einen gesamten String anhängen
    result.append(1, ' ').append(str);
    assert(result == "***C-str C-string std::string");
    // 7) Einen Teil eines Strings anhängen
    result.append(str, 3, 2);
    assert(result == "***C-str C-string std::string::");
    // 8) Einen Bereich anhängen
    result.append(&carr[2], &carr[3]);
    assert(result == "***C-str C-string std::string::n");
    // 9) Eine Initialisierungsliste anhängen
    result.append({'p', 'o', 's'});
    assert(result == "***C-str C-string std::string::npos");
}

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 847 C++98 es gab keine Ausnahmesicherheitsgarantie starke Ausnahmesicherheitsgarantie hinzugefügt
LWG 2250 C++98 das Verhalten der Überladung (7) war
undefiniert wenn pos > str. size ( ) ist true 		wirft in diesem Fall immer eine Ausnahme
LWG 2788 C++98 Überladung (8) verwendete einen standardkonstruierten
Allokator für die temporäre Zeichenkette 		bezieht den Allokator
von get_allocator()
LWG 2946 C++17 Überladung (4) verursacht in manchen Fällen Mehrdeutigkeit vermieden durch Template-Implementierung

Siehe auch

(C++23)
hängt einen Bereich von Zeichen an das Ende an
(öffentliche Elementfunktion)
hängt Zeichen an das Ende an
(öffentliche Elementfunktion)
verkettet zwei Zeichenketten
(Funktion)
verkettet eine bestimmte Anzahl von Zeichen zweier Zeichenketten
(Funktion)
hängt eine Kopie einer Breitzeichenkette an eine andere an
(Funktion)
hängt eine bestimmte Anzahl von Breitzeichen von einer Breitzeichenkette an eine andere an
(Funktion)