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

basic_string() : basic_string(Allocator()) {}

basic_string() noexcept(noexcept(Allocator()))
    : basic_string(Allocator()) {}

explicit basic_string( const Allocator& alloc = Allocator() );

explicit basic_string( const Allocator& alloc );

basic_string( size_type count, CharT ch,
              const Allocator& alloc = Allocator() );

template< class InputIt >
basic_string( InputIt first, InputIt last,
              const Allocator& alloc = Allocator() );

template< container-compatible-range<CharT> R >
constexpr basic_string( std::from_range_t, R&& rg,
                        const Allocator& = Allocator());

basic_string( const CharT* s, size_type count,
              const Allocator& alloc = Allocator() );

basic_string( const CharT* s, const Allocator& alloc = Allocator() );

basic_string( std::nullptr_t ) = delete;

template< class StringViewLike >
explicit basic_string( const StringViewLike& t,
                       const Allocator& alloc = Allocator() );

template< class StringViewLike >
basic_string( const StringViewLike& t,
              size_type pos, size_type count,
              const Allocator& alloc = Allocator() );

basic_string( const basic_string& other );

basic_string( basic_string&& other ) noexcept;

basic_string( const basic_string& other, const Allocator& alloc );

basic_string( basic_string&& other, const Allocator& alloc );

basic_string( const basic_string& other, size_type pos,
              const Allocator& alloc = Allocator() );

constexpr basic_string( basic_string&& other, size_type pos,
                        const Allocator& alloc = Allocator() );

basic_string( const basic_string& other,
              size_type pos, size_type count,
              const Allocator& alloc = Allocator() );

constexpr basic_string( basic_string&& other,
                        size_type pos, size_type count,
                        const Allocator& alloc = Allocator() );

basic_string( std::initializer_list<CharT> ilist,
              const Allocator& alloc = Allocator() );

Erstellt einen neuen String aus verschiedenen Datenquellen und optional unter Verwendung eines benutzerbereitgestellten Allokatorsalloc.

Parameter

Komplexität

Ausnahmen

Wirft std::length_error , wenn die Länge der konstruierten Zeichenkette max_size() überschreiten würde (zum Beispiel, wenn count > max_size ( ) für (3) ). Aufrufe von Allocator::allocate können Ausnahmen werfen.

Wenn aus irgendeinem Grund eine Exception ausgelöst wird, haben diese Funktionen keine Wirkung ( strong exception safety guarantee ).

Hinweise

Initialisierung mit einem string literal , das eingebettete ' \0 ' -Zeichen enthält, verwendet die Überladung (7) , die beim ersten Nullzeichen stoppt. Dies kann vermieden werden, indem ein anderer Konstruktor angegeben oder operator""s verwendet wird:

std::string s1 = "ab\0\0cd";   // s1 enthält "ab"
std::string s2{"ab\0\0cd", 6}; // s2 enthält "ab\0\0cd"
std::string s3 = "ab\0\0cd"s;  // s3 enthält "ab\0\0cd"

Beispiel

#include <cassert>
#include <cctype>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string>
int main()
{
    std::cout << "1)  string(); ";
    std::string s1;
    assert(s1.empty() && (s1.length() == 0) && (s1.size() == 0));
    std::cout << "s1.capacity(): " << s1.capacity() << '\n'; // nicht spezifiziert
    std::cout << "3)  string(size_type count, CharT ch): ";
    std::string s2(4, '=');
    std::cout << std::quoted(s2) << '\n'; // "===="
    std::cout << "4)  string(InputIt first, InputIt last): ";
    char mutable_c_str[] = "ein weiterer C-String";
    std::string s4(std::begin(mutable_c_str) + 8, std::end(mutable_c_str) - 1);
    std::cout << std::quoted(s4) << '\n'; // "C-style string"
    std::cout << "6)  string(CharT const* s, size_type count): ";
    std::string s6("C-style string", 7);
    std::cout << std::quoted(s6) << '\n'; // "C-style", d.h. [0, 7)
    std::cout << "7)  string(CharT const* s): ";
    std::string s7("C-style\0string");
    std::cout << std::quoted(s7) << '\n'; // "C-style"
    std::cout << "11) string(string&): ";
    std::string const other11("Exemplar");
    std::string s11(other11);
    std::cout << std::quoted(s11) << '\n'; // "Exemplar"
    std::cout << "12) string(string&&): ";
    std::string s12(std::string("C++ von ") + std::string("Beispiel"));
    std::cout << std::quoted(s12) << '\n'; // "C++ by example"
    std::cout << "15) string(const string& other, size_type pos): ";
    std::string const other15("Mutatis Mutandis");
    std::string s15(other15, 8);
    std::cout << std::quoted(s15) << '\n'; // "Mutandis", d.h. [8, 16)
    std::cout << "17) string(const string& other, size_type pos, size_type count): ";
    std::string const other17("Exemplarisch");
    std::string s17(other17, 0, other17.length() - 1);
    std::cout << std::quoted(s17) << '\n'; // "Exemplar"
    std::cout << "19) string(std::initializer_list<CharT>): ";
    std::string s19({'C', '-', 's', 't', 'y', 'l', 'e'});
    std::cout << std::quoted(s19) << '\n'; // "C-Style"
}

1)  string(); s1.capacity(): 15
3)  string(size_type count, CharT ch): "===="
4)  string(InputIt first, InputIt last): "C-style string"
6)  string(CharT const* s, size_type count): "C-style"
7)  string(CharT const* s): "C-style"
11) string(string&): "Exemplar"
12) string(string&&): "C++ by example"
15) string(const string& other, size_type pos): "Mutandis"
17) string(const string& other, size_type pos, size_type count): "Exemplar"
19) string(std::initializer_list<CharT>): "C-style"

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

1. ↑ [ nullptr , nullptr + 0 ) ist ein gültiger leerer Bereich, da das Addieren von Null zu einem Nullzeigerwert ebenfalls wohldefiniert ist (das Ergebnis bleibt ein Nullzeigerwert).

Siehe auch