Namespaces
Variants

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

From cppreference.net
C++
Strings library
std::basic_string
basic_string & assign ( const basic_string & str ) ;
(1) (constexpr seit C++20)
basic_string & assign ( basic_string && str ) noexcept ( /* siehe unten */ ) ;
(2) (seit C++11)
(constexpr seit C++20)
basic_string & assign ( size_type count, CharT ch ) ;
(3) (constexpr seit C++20)
basic_string & assign ( const CharT * s, size_type count ) ;
(4) (constexpr seit C++20)
basic_string & assign ( const CharT * s ) ;
(5) (constexpr seit C++20)
template < class SV >
basic_string & assign ( const SV & t ) ;
(6) (seit C++17)
(constexpr seit C++20)
template < class SV >

basic_string & assign ( const SV & t,

size_type pos, size_type count = npos ) ;
(7) (seit C++17)
(constexpr seit C++20)
(8)
basic_string & assign ( const basic_string & str,
size_type pos, size_type count ) ;
(bis C++14)
basic_string & assign ( const basic_string & str,
size_type pos, size_type count = npos ) ;
(seit C++14)
(constexpr seit C++20)
template < class InputIt >
basic_string & assign ( InputIt first, InputIt last ) ;
(9) (constexpr seit C++20)
basic_string & assign ( std:: initializer_list < CharT > ilist ) ;
(10) (seit C++11)
(constexpr seit C++20)

Ersetzt den Inhalt der Zeichenkette.

1) Entspricht return * this = str ; .
2) Entspricht return * this = std :: move ( str ) ; .
3) Ersetzt den Inhalt durch count Kopien des Zeichens ch .
Entspricht clear ( ) ; resize ( n, c ) ; return * this ; .
4) Ersetzt den Inhalt durch Kopien der Zeichen im Bereich [ s , s + count ) .
Falls [ s , s + count ) kein gültiger Bereich ist, ist das Verhalten undefiniert.
5) Entspricht return assign ( s, Traits :: length ( s ) ) ; .
6,7) Ersetzt den Inhalt durch Zeichen in einem String-View sv , der aus t konstruiert wird.
  • Wenn nur t angegeben ist, ersetzt den Inhalt durch alle Zeichen in sv .
  • Wenn pos ebenfalls angegeben ist:
    • Wenn count gleich npos ist, ersetzt den Inhalt durch alle Zeichen in sv ab Position pos .
    • Andernfalls ersetzt den Inhalt durch std:: min ( count, sv. size ( ) - pos ) Zeichen in sv ab Position pos .
Diese Überladungen nehmen an der Überladungsauflösung nur teil, wenn alle folgenden Bedingungen erfüllt sind:
6) Entspricht std:: basic_string_view < CharT, Traits > sv = t ;
return assign ( sv. data ( ) , sv. size ( ) ) ; .
7) Entspricht std:: basic_string_view < CharT, Traits > sv = t ;
return assign ( sv. substr ( pos, count ) ) ; .
8) Ersetzt den Inhalt durch die Zeichen in str .
  • Wenn count gleich npos ist, ersetzt den Inhalt durch alle Zeichen in str ab Position pos .
  • Andernfalls ersetzt den Inhalt durch die std:: min ( count, str. size ( ) - pos ) Zeichen in str ab Position pos .
Entspricht return assign ( std:: basic_string_view < CharT, Traits >
( str ) . substr ( pos, count ) ) ; .
(seit C++20)
9) Entspricht return assign ( basic_string ( first, last, get_allocator ( ) ) ) ; .

Diese Überladung nimmt nur dann an der Überlagerungsauflösung teil, wenn InputIt die Anforderungen von LegacyInputIterator erfüllt.

(seit C++11)
10) Entspricht return assign ( ilist. begin ( ) , ilist. size ( ) ) ; .

Inhaltsverzeichnis

Parameter

str - Zeichenkette, die als Quelle zur Initialisierung der Zeichen verwendet werden soll
count - Größe der resultierenden Zeichenkette
ch - Wert zur Initialisierung der Zeichen der Zeichenkette
s - Zeiger auf eine Zeichenkette, die als Quelle zur Initialisierung der Zeichenkette verwendet werden soll
t - Objekt (konvertierbar zu std::basic_string_view ) zur Initialisierung der Zeichen der Zeichenkette
pos - Index des ersten zu übernehmenden Zeichens
first, last - Bereich, aus dem die Zeichen kopiert werden sollen
ilist - std::initializer_list zur Initialisierung der Zeichen der Zeichenkette

Rückgabewert

* this

Ausnahmen

2)
noexcept Spezifikation:
noexcept ( std:: allocator_traits < Allocator > ::

propagate_on_container_move_assignment :: value ||

std:: allocator_traits < Allocator > :: is_always_equal :: value )

Falls die Operation dazu führen würde, dass size() die max_size() überschreitet, wird std::length_error ausgelöst.

7) Wenn pos > sv. size ( ) true ist, wird std::out_of_range ausgelöst.
8) 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 <iostream>
#include <iterator>
#include <string>
int main()
{
    std::string s;
    // assign(size_type count, CharT ch)
    s.assign(4, '=');
    std::cout << s << '\n'; // "===="
    std::string const c("Exemplary");
    // assign(const basic_string& str)
    s.assign(c);
    std::cout << c << " == " << s << '\n'; // "Exemplary == Exemplary"
    // assign(const basic_string& str, size_type pos, size_type count)
    s.assign(c, 0, c.length() - 1);
    std::cout << s << '\n'; // "Exemplar";
    // assign(basic_string&& str)
    s.assign(std::string("C++ by ") + "example");
    std::cout << s << '\n'; // "C++ by example"
    // assign(const CharT* s, size_type count)
    s.assign("C-style string", 7);
    std::cout << s << '\n'; // "C-style"
    // assign(const CharT* s)
    s.assign("C-style\0string");
    std::cout << s << '\n'; // "C-style"
    char mutable_c_str[] = "C-style string";
    // assign(InputIt first, InputIt last)
    s.assign(std::begin(mutable_c_str), std::end(mutable_c_str) - 1);
    std::cout << s << '\n'; // "C-style string"
    // assign(std::initializer_list<CharT> ilist)
    s.assign({'C', '-', 's', 't', 'y', 'l', 'e'});
    std::cout << s << '\n'; // "C-style"
}

Ausgabe: 

====
Exemplary == Exemplary
Exemplar
C++ by example
C-style
C-style
C-style string
C-style

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 847 C++98 es gab keine Exception-Sicherheitsgarantie starke Exception-Sicherheitsgarantie hinzugefügt
LWG 2063 C++11 nicht-normative Anmerkung stellte fest, dass Überladung ( 2 )
durch Swapping implementiert werden kann 		korrigiert, um Move-Zuweisung zu erfordern
LWG 2250 C++98 das Verhalten der Überladung ( 8 ) war
undefiniert wenn pos > str. size ( ) ist true 		wirft in diesem Fall immer eine Exception
LWG 2579 C++98 Überladung ( 1 ) und der Kopierzuweisungs-
operator hatten unterschiedliche Effekte 		sie haben denselben Effekt
LWG 2946 C++17 Überladung ( 6 ) verursachte in manchen Fällen Mehrdeutigkeit vermieden durch Template-Implementierung

Siehe auch

(C++23)
weist einen Zeichenbereich einer Zeichenkette zu
(öffentliche Elementfunktion)
konstruiert einen basic_string
(öffentliche Elementfunktion)
weist der Zeichenkette Werte zu
(öffentliche Elementfunktion)