Namespaces
Variants

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

    Von de.cppreference.net
     
    C++
     
    Zeichenketten-Bibliothek
     
    std::basic_string
     
    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) 
    basic_string& insert( size_type index, const basic_string& str,
                      size_type s_index, size_type count );
    		(5) (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)    		 
    iterator insert( iterator pos, CharT ch );
    		(6) (bis C++11) 
    iterator insert( const_iterator pos, CharT ch );
    		(seit C++11)
    (constexpr seit C++20)    		 
    void insert( iterator pos, size_type count, CharT ch );
    		(7) (bis C++11) 
    iterator insert( const_iterator pos, size_type count, CharT ch );
    		(seit C++11)
    (constexpr seit C++20)    		 
    template< class InputIt >
void insert( iterator pos, InputIt first, InputIt last );
    		(8) (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 durch s beendete Zeichenkette, auf die index zeigt, an der Position Traits::length(s) ein. Die Länge der Zeichenkette wird mit
    durch das erste Nullzeichen bestimmt. 3)[s, s + count) Fügt die Zeichen im Bereich index an der Position
    ein. Der Bereich kann Nullzeichen enthalten.4)str Fügt die Zeichenkette index an der Position
    ein.5)str.substr(s_index, count) Fügt eine Zeichenkette, erhalten durch index, an der Position
    ein.6)ch Fügt das Zeichen pos vor dem Zeichen ein, auf das
    zeigt.7)count Fügt ch Kopien des Zeichens pos vor dem (falls vorhandenen) Element ein, auf das
    zeigt.8)[first, last) Fügt Zeichen aus dem Bereich pos vor dem (falls vorhandenen) Element ein, auf das insert(pos - begin(), basic_string(first, last, get_allocator())) zeigt, als ob durch

    . InputItDiese Überladung nimmt nicht an der Überladungsauflösung teil, wenn nicht LegacyInputIterator

    		 erfüllt.
    (seit C++11)9)ilist Fügt Elemente aus der Initialisierungsliste pos vor dem (falls vorhandenen) Element ein, auf das
    zeigt.10)t Konvertiert sv implizit in eine String-Ansicht std::basic_string_view<CharT, Traits> sv = t; als ob durch sv und fügt dann die Elemente aus index vor dem (falls vorhandenen) Element ein, auf das insert(index, sv.data(), sv.size()) zeigt, als ob durch
    . Diese Überladung nimmt nur dann an der Überladungsauflösung teil, 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 String-Ansicht sv als ob durch std::basic_string_view<CharT, Traits> sv = t; und fügt dann, vor dem (falls vorhandenen) Element, auf das index zeigt, die Zeichen aus der Unteransicht [t_index, t_index + count) von sv ein.
    • Wenn die angeforderte Unteransicht über das Ende von sv hinausreicht oder wenn count == npos, ist die resultierende Unteransicht [t_index, sv.size()).
    • Wenn t_index > sv.size() oder wenn index > size(), wird std::out_of_range ausgelöst.
    Diese Überladung nimmt nur dann an der Überladungsauflösung teil, 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 auf *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
    count - 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 zum Einfügen
    ilist - std::initializer_list zum Einfügen der Zeichen daraus
    t - Objekt (konvertierbar zu std::basic_string_view ) zum Einfügen der Zeichen daraus
    t_index - Position des ersten Zeichens in t zum Einfügen
    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 falls keine Zeichen eingefügt wurden ( count == 0 oder first == last oder ilist. size ( ) == 0 )
    10,11) * this

    Ausnahmen

    1-4,10) Wirft std::out_of_range falls index > size ( ) .
    5) Wirft std::out_of_range falls index > size ( ) oder falls s_index > str. size ( ) .
    11) Wirft std::out_of_range falls index > size ( ) oder falls t_index > sv. size ( ) .

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

    In allen Fällen, wenn std:: allocator_traits < Allocator > :: allocate eine Exception wirft, wird diese erneut geworfen.

    		(seit C++20)

    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 <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 Korrektes 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 Exception-Sicherheitsgarantie starke Exception-Sicherheitsgarantie hinzugefügt
    LWG 2946 C++17 Überladung (10) verursachte in einigen Fällen Mehrdeutigkeit vermieden durch Template-Implementierung

    Siehe auch

    (C++23)
    		fügt eine Reihe von Zeichen ein
    (öffentliche Elementfunktion)
    		hängt Zeichen am Ende an
    (öffentliche Elementfunktion)
    		hängt ein Zeichen am Ende an
    (öffentliche Elementfunktion)