Namespaces
Variants

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

From cppreference.net
C++
Strings library
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)
(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 mittels Traits :: length ( s ) bestimmt.
3) Fügt die Zeichen im Bereich [ s , s + count ) an der Position index ein. Der Bereich kann Nullzeichen enthalten.
4) Fügt den String str an der Position index ein.
5) Fügt einen String ein, erhalten durch str. substr ( s_index, count ) an der Position index ein.
6) Fügt das Zeichen ch vor dem durch pos gezeigten Zeichen ein.
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, wie durch insert ( pos - begin ( ) , basic_string ( first, last, get_allocator ( ) ) ) .

Diese Überladung nimmt nicht an der Überladungsauflösung teil, wenn InputIt nicht 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 implizit t zu einem String-View sv als ob durch std:: basic_string_view < CharT, Traits > sv = t ; , 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 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 implizit t zu einem String-View sv als ob durch std:: basic_string_view < CharT, Traits > sv = t ; , dann fügt, vor dem Element (falls vorhanden) auf das index zeigt, die Zeichen aus dem Subview [ t_index , t_index + count ) von sv ein.
  • Wenn der angeforderte Subview über das Ende von sv hinausreicht, oder wenn count == npos , ist der resultierende Subview [ t_index , sv. size ( ) ) .
  • Wenn t_index > sv. size ( ) , oder wenn index > size ( ) , wird std::out_of_range geworfen.
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 für * this ist, ist das Verhalten undefiniert.

Inhaltsverzeichnis

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)