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

 

C++

Compiler-Unterstützung

Freestanding und gehostet

Sprache

Standardbibliothek

Header der Standardbibliothek

Benannte Anforderungen

Feature-Test-Makros (C++20)

Bibliothek für Sprachunterstützung

Konzepte-Bibliothek (C++20)

Diagnostik-Bibliothek

Speicherverwaltungsbibliothek

Metaprogrammierungsbibliothek (C++11)

Allgemeine Dienstprogramme-Bibliothek

Container-Bibliothek

Iterator-Bibliothek

Ranges-Bibliothek (C++20)

Algorithmen-Bibliothek

Bibliothek für Zeichenketten

Textverarbeitungsbibliothek

Numerik-Bibliothek

Datums- und Zeitbibliothek

Ein-/Ausgabe-Bibliothek

Dateisystembibliothek (C++17)

Unterstützung für nebenläufige Programmierung (C++11)

Ausführungssteuerungsbibliothek (C++26)

Technische Spezifikationen

Symbolverzeichnis

Externe Bibliotheken

 

Bibliothek für Zeichenketten

Klassen

basic_string

basic_string_view (C++17)

char_traits

 

std::basic_string

Memberfunktionen basic_string::basic_string basic_string::~basic_string basic_string::operator= basic_string::assign basic_string::assign_range (C++23)   basic_string::get_allocator Elementzugriff basic_string::at basic_string::operator[] basic_string::front (DR*) basic_string::back (DR*) basic_string::data basic_string::c_str basic_string::operator  basic_string_view (C++17) Iteratoren basic_string::beginbasic_string::cbegin (C++11) basic_string::endbasic_string::cend (C++11) basic_string::rbeginbasic_string::crbegin (C++11) basic_string::rendbasic_string::crend (C++11) Suche 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

Modifizierer basic_string::clear basic_string::insert basic_string::insert_range (C++23) basic_string::erase basic_string::push_back basic_string::pop_back (DR*) basic_string::append basic_string::append_range (C++23) basic_string::operator+= basic_string::replace basic_string::replace_with_range (C++23) basic_string::copy basic_string::resize basic_string::resize_and_overwrite (C++23)  basic_string::swap Kapazität basic_string::empty basic_string::sizebasic_string::length basic_string::max_size basic_string::reserve basic_string::capacity basic_string::shrink_to_fit (DR*) Operationen basic_string::compare basic_string::starts_with (C++20) basic_string::ends_with (C++20) basic_string::contains (C++23) basic_string::substr

Konstanten basic_string::npos Nicht-Member-Funktionen operator+ swap(std::basic_string) erase(std::basic_string)erase_if(std::basic_string) (C++20)(C++20) I/O operator<<operator>> getline Vergleich operator==operator!=operator<operator>operator<=operator>=operator<=> (bis C++20)(bis C++20)(bis C++20)(bis C++20)(bis C++20)(C++20) Numerische Konvertierungen stoistolstoll (C++11)(C++11)(C++11) stoulstoull (C++11)(C++11)  stofstodstold (C++11)(C++11)(C++11) to_string (C++11) to_wstring (C++11) Literale operator""s (C++14) Hilfsklassen hash<std::basic_string> (C++11) Deduction guides (C++17)

 

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)

Hängt zusätzliche Zeichen an den String 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 String-Ansicht sv an, die aus t konstruiert wurde.

• Wenn nur t angegeben ist, werden alle Zeichen in sv angehängt.
• Wenn pos ebenfalls 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 an der Auflösungsauflösung teil, nur 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 einem anderen String str an.

• Wenn nur str angegeben ist, werden alle Zeichen darin angehängt.
• Wenn pos ebenfalls 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 eines LegacyInputIterator erfüllt.	(seit C++11)

9) Entspricht return append(ilist.begin(), ilist.size());.

Parameter

zählt	-	Anzahl der anzuhängenden Zeichen
ch	-	anzuhängender Zeichenwert
s	-	Zeiger auf den anzuhängenden Zeichenstring
t	-	Objekt, das in std::basic_string_view konvertierbar ist, mit den anzuhängenden Zeichen
pos	-	Der Index des ersten anzuhängenden Zeichens
str	-	anzuhängender String
first, last	-	Bereich von 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

Wenn die Operation dazu führen würde, dass size() 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 Ausnahme ausgelöst wird, hat diese Funktion keine Auswirkungen (starkes Ausnahmesicherheitsgarantie).

Beispiel

Führen Sie diesen Code aus

#include <cassert>
#include <string>
 
int main()
{
    std::string str = "std::string";
    const char* cptr = "C-string";
    const char carr[] = "range";
 
    std::string result;
 
    // 1) Append a char 3 times.
    // Note: This is the only overload accepting “CharT”s.
    result.append(3, '*');
    assert(result == "***");
 
    // 2) Append a fixed-length C-string
    result.append(cptr, 5);
    assert(result == "***C-str");
 
    // 3) Append a null-terminated C-string
    // Note: Because “append” returns *this, we can chain calls together.
    result.append(1, ' ').append(cptr);
    assert(result == "***C-str C-string");
 
    // 6) Append a whole string
    result.append(1, ' ').append(str);
    assert(result == "***C-str C-string std::string");
 
    // 7) Append part of a string
    result.append(str, 3, 2);
    assert(result == "***C-str C-string std::string::");
 
    // 8) Append range
    result.append(&carr[2], &carr[3]);
    assert(result == "***C-str C-string std::string::n");
 
    // 9) Append initializer list
    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 von Überladung (7) war undefiniert, wenn pos > str.size() true ist	wirft in diesem Fall immer eine Ausnahme
LWG 2788	C++98	Überladung (8) verwendete einen standardkonstruierten Allocator zum Konstruieren des temporären Strings	holt den Allocator von get_allocator()
LWG 2946	C++17	Überladung (4) verursacht in einigen Fällen Mehrdeutigkeit	vermieden durch die Erstellung als Template

Siehe auch

append_range (C++23)	hängt einen Zeichenbereich am Ende an (public member function)
operator+=	hängt Zeichen am Ende an (public member function)
strcat	verbindet zwei Strings (Funktion)
strncat	verbindet eine bestimmte Anzahl von Zeichen von zwei Strings (Funktion)
wcscat	hängt eine Kopie einer breiten Zeichenkette an eine andere an (Funktion)
wcsncat	hängt eine bestimmte Anzahl breiter Zeichen von einer breiten Zeichenkette an eine andere an (Funktion)