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

 

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& insert( size_type index, size_type count, CharT ch );	(1)	(constexpr seit C++20)
basic_string& insert( size_type index, const CharT* s );	(2)	(constexpr seit C++20)
basic_string& insert( size_type index, const CharT* s, size_type count );	(3)	(constexpr seit C++20)
basic_string& insert( size_type index, const basic_string& str );	(4)	(constexpr seit C++20)
	(5)
basic_string& insert( size_type index, const basic_string& str,                       size_type s_index, size_type count );			(bis C++14)
basic_string& insert( size_type index, const basic_string& str,                       size_type s_index, size_type count = npos );			(seit C++14) (constexpr seit C++20)
		(6)
iterator insert( iterator pos, CharT ch );				(bis C++11)
iterator insert( const_iterator pos, CharT ch );				(seit C++11) (constexpr seit C++20)
			(7)
void insert( iterator pos, size_type count, CharT ch );					(bis C++11)
iterator insert( const_iterator pos, size_type count, CharT ch );					(seit C++11) (constexpr seit C++20)
				(8)
template< class InputIt > void insert( iterator pos, InputIt first, InputIt last );						(bis C++11)
template< class InputIt > iterator insert( const_iterator pos, InputIt first, InputIt last );						(seit C++11) (constexpr seit C++20)
iterator insert( const_iterator pos, std::initializer_list<CharT> ilist );					(9)	(seit C++11) (constexpr seit C++20)
template< class StringViewLike > basic_string& insert( size_type index, const StringViewLike& t );					(10)	(seit C++17) (constexpr seit C++20)
template< class StringViewLike > basic_string& insert( size_type index, const StringViewLike& t,                       size_type t_index, size_type count = npos );					(11)	(seit C++17) (constexpr seit C++20)

Fügt Zeichen in die Zeichenkette ein.

1) Fügt count Kopien des Zeichens ch an der Position index ein.

2) Fügt die nullterminierte Zeichenkette, auf die s zeigt, an der Position index ein. Die Länge der Zeichenkette wird durch das erste Nullzeichen bestimmt, mittels Traits::length(s).

3) Fügt die Zeichen im Bereich [s, s + count) an der Position index ein. Der Bereich kann Nullzeichen enthalten.

4) Fügt die Zeichenkette str an der Position index ein.

5) Fügt eine Zeichenkette ein, die durch str.substr(s_index, count) gebildet wird, an der Position index ein.

6) Fügt das Zeichen ch vor dem Zeichen ein, auf das pos zeigt.

7) Fügt count Kopien des Zeichens ch vor dem Element (falls vorhanden) ein, auf das pos zeigt.

8) Fügt Zeichen aus dem Bereich [first, last) vor dem Element (falls vorhanden) ein, auf das pos zeigt, als ob durch insert(pos - begin(), basic_string(first, last, get_allocator())).

Diese Überladung nimmt nicht an der Überladungsauflösung teil, wenn InputIt LegacyInputIterator erfüllt.

(seit C++11)

9) Fügt Elemente aus der Initialisierungsliste ilist vor dem Element (falls vorhanden) ein, auf das pos zeigt.

10) Konvertiert t implizit in eine Zeichenkettenansicht (string view) sv, als ob durch std::basic_string_view<CharT, Traits> sv = t;, und fügt dann die Elemente aus sv vor dem Element (falls vorhanden) ein, auf das index zeigt, als ob durch insert(index, sv.data(), sv.size()).

Diese Überladung nimmt an der Überladungsauflösung teil, nur wenn std::is_convertible_v<const StringViewLike&,
                      std::basic_string_view<CharT, Traits>> true ist und std::is_convertible_v<const StringViewLike&, const CharT*> false ist.

11) Konvertiert t implizit in eine Zeichenkettenansicht (string view) sv, als ob durch std::basic_string_view<CharT, Traits> sv = t;, und fügt dann vor dem Element (falls vorhanden) ein, auf das index zeigt, die Zeichen aus der Teilansicht (subview) [t_index, t_index + count) von sv.

• Wenn die angeforderte Teilansicht über das Ende von sv hinausgeht oder wenn count == npos, ist die resultierende Teilansicht [t_index, sv.size()).
• Wenn t_index > sv.size() oder wenn index > size(), wird std::out_of_range ausgelöst.

Diese Überladung nimmt an der Überladungsauflösung teil, nur wenn std::is_convertible_v<const StringViewLike&,
                      std::basic_string_view<CharT, Traits>> true ist und std::is_convertible_v<const StringViewLike&, const CharT*> false ist.

Wenn pos kein gültiger Iterator für *this ist, ist das Verhalten undefiniert.

Parameter

index	-	Position, an der der Inhalt eingefügt wird
pos	-	Iterator, vor dem die Zeichen eingefügt werden
ch	-	einzufügendes Zeichen
zählt	-	Anzahl der einzufügenden Zeichen
s	-	Zeiger auf die einzufügende Zeichenkette
str	-	einzufügende Zeichenkette
first, last	-	Bereich, der die einzufügenden Zeichen definiert
s_index	-	Position des ersten Zeichens in str, das eingefügt werden soll
ilist	-	std::initializer_list, aus der die Zeichen eingefügt werden sollen
t	-	Objekt (konvertierbar zu std::basic_string_view), aus dem die Zeichen eingefügt werden sollen
t_index	-	Position des ersten Zeichens in t, das eingefügt werden soll
Typanforderungen
- InputIt muss die Anforderungen von LegacyInputIterator erfüllen.

Rückgabewert

1-5) *this

6-9) Ein Iterator, der auf die Kopie des ersten eingefügten Zeichens verweist, oder pos, wenn keine Zeichen eingefügt wurden (count == 0 oder first == last oder ilist.size() == 0)

10,11) *this

Ausnahmen

1-4,10) Löst std::out_of_range aus, wenn index > size().

5) Löst std::out_of_range aus, wenn index > size() oder wenn s_index > str.size().

11) Löst std::out_of_range aus, wenn index > size() oder wenn t_index > sv.size().

In allen Fällen wird std::length_error ausgelöst, wenn size() + ins_count > max_size(), wobei ins_count die Anzahl der einzufügenden Zeichen ist.

In allen Fällen wird eine Ausnahme ausgelöst, wenn std::allocator_traits<Allocator>::allocate eine Ausnahme auslöst, wird diese erneut ausgelöst.

(seit C++20)

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 <iterator>
#include <string>
 
using namespace std::string_literals;
 
int main()
{
    std::string s = "xmplr";
 
    // insert(size_type index, size_type count, char ch)
    s.insert(0, 1, 'E');
    assert("Exmplr" == s);
 
    // insert(size_type index, const char* s)
    s.insert(2, "e");
    assert("Exemplr" == s);
 
    // insert(size_type index, string const& str)
    s.insert(6, "a"s);
    assert("Exemplar" == s);
 
    // insert(size_type index, string const& str,
    //        size_type s_index, size_type count)
    s.insert(8, " is an example string."s, 0, 14);
    assert("Exemplar is an example" == s);
 
    // insert(const_iterator pos, char ch)
    s.insert(s.cbegin() + s.find_first_of('n') + 1, ':');
    assert("Exemplar is an: example" == s);
 
    // insert(const_iterator pos, size_type count, char ch)
    s.insert(s.cbegin() + s.find_first_of(':') + 1, 2, '=');
    assert("Exemplar is an:== example" == s);
 
    // insert(const_iterator pos, InputIt first, InputIt last)
    {
        std::string seq = " string";
        s.insert(s.begin() + s.find_last_of('e') + 1,
            std::begin(seq), std::end(seq));
        assert("Exemplar is an:== example string" == s);
    }
 
    // insert(const_iterator pos, std::initializer_list<char>)
    s.insert(s.cbegin() + s.find_first_of('g') + 1, {'.'});
    assert("Exemplar is an:== example string." == s);
}

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 7	C++98	Überladung (8) verwies auf eine nicht existierende Überladung	verweist korrekt auf Überladung (4)
LWG 847	C++98	Es gab keine Ausnahmesicherheitsgarantie	starke Ausnahmesicherheitsgarantie hinzugefügt
LWG 2946	C++17	Überladung (10) verursachte in einigen Fällen Mehrdeutigkeit	vermieden durch die Erstellung als Template

Siehe auch

insert_range (C++23)	fügt einen Bereich von Zeichen ein (public member function)
append	hängt Zeichen am Ende an (public member function)
push_back	hängt ein Zeichen am Ende an (public member function)