Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Zeichenkettenbibliothek
     
    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) 
    basic_string& append( const basic_string& str,
                      size_type pos, size_type count );
    		(7) (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)

    Hängt zusätzliche Zeichen an die Zeichenkette an.

    1) Hängt count Kopien des Zeichens ch an.
    2) Hängt Zeichen im Bereich [s, s + count) an.
    Wenn [s, s + count) kein gültiger Bereich ist, ist das Verhalten undefiniert.
    3) Entspricht return append(s, Traits::length(s));.
    4,5) Hängt Zeichen in einer Zeichenkettenansicht (string_view) sv an, die aus t erstellt wurde.
    • Wenn nur t angegeben ist, werden alle Zeichen in sv angehängt.
    • Wenn auch pos angegeben ist:
      • Wenn count gleich npos ist, werden alle Zeichen in sv ab pos angehängt.
      • Andernfalls werden die std::min(count, sv.size() - pos) Zeichen in sv ab pos angehängt.
    Diese Überladungen nehmen nur an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:
    • std::is_convertible_v<const SV&, std::basic_string_view<CharT, Traits>> ist true.
    • std::is_convertible_v<const SV&, const CharT*> ist false.
    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) Hängt Zeichen aus einer anderen Zeichenkette str an.
    • Wenn nur str angegeben ist, werden alle darin enthaltenen Zeichen angehängt.
    • Wenn auch pos angegeben ist:
      • Wenn count gleich npos ist, werden alle Zeichen in str ab pos angehängt.
      • Andernfalls werden die std::min(count, str.size() - pos) Zeichen in str ab 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 ganzzahliger 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());.

    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)