Namespaces
Variants

    std::basic_string_view<CharT,Traits>::basic_string_view

    Von de.cppreference.net


     
    C++
     
    Zeichenketten-Bibliothek
     
    std::basic_string_view
    Elementfunktionen
      
    Iteratoren
    Kapazität
    Operationen
    (C++26)
    (C++20)
    (C++20)
    (C++23)
     
    constexpr basic_string_view() noexcept;
    		(1) (seit C++17) 
    constexpr basic_string_view( const basic_string_view& other ) noexcept = default;
    		(2) (seit C++17) 
    constexpr basic_string_view( const CharT* s, size_type count );
    		(3) (seit C++17) 
    constexpr basic_string_view( const CharT* s );
    		(4) (seit C++17) 
    template< class It, class End >
constexpr basic_string_view( It first, End last );
    		(5) (seit C++20) 
    template< class R >
constexpr explicit basic_string_view( R&& r );
    		(6) (seit C++23) 
    basic_string_view( std::nullptr_t ) = delete;
    		(7) (seit C++23)
    1) Standardkonstruktor. Erzeugt einen leeren std::basic_string_view. Nach der Konstruktion ist data() gleich nullptr, und size() ist gleich 0.
    2) Kopierkonstruktor. Erzeugt eine Ansicht mit demselben Inhalt wie other. Nach der Konstruktion ist data() gleich other.data(), und size() ist gleich other.size().
    3) Erzeugt eine Ansicht der ersten count Zeichen des Zeichenarrays, das mit dem Element beginnt, auf das s zeigt. s kann Nullzeichen enthalten. Das Verhalten ist undefiniert, wenn [s, s + count) kein gültiger Bereich ist (obwohl der Konstruktor möglicherweise nicht auf Elemente dieses Bereichs zugreift). Nach der Konstruktion ist data() gleich s, und size() ist gleich count.
    4) Erzeugt eine Ansicht der nullterminierten Zeichenkette, auf die s zeigt, ohne das abschließende Nullzeichen. Die Länge der Ansicht wird wie durch Traits::length(s) bestimmt. Das Verhalten ist undefiniert, wenn [s, s + Traits::length(s)) kein gültiger Bereich ist. Nach der Konstruktion ist data() gleich s, und size() ist gleich Traits::length(s).
    5) Erzeugt einen std::basic_string_view über den Bereich [first, last). Das Verhalten ist undefiniert, wenn [first, last) kein gültiger Bereich ist, wenn It tatsächlich kein contiguous_iterator modelliert, oder wenn End tatsächlich kein sized_sentinel_for für It modelliert. Nach der Konstruktion ist data() gleich std::to_address(first), und size() ist gleich last - first.

    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:

    6) Erzeugt einen std::basic_string_view über den Bereich r. Nach der Konstruktion ist data() gleich ranges::data(r), und size() ist gleich ranges::size(r).

    Diese Überladung nimmt nur an der Überladungsauflösung teil, wenn alle folgenden Bedingungen erfüllt sind:

    • std::remove_cvref_t<R> ist nicht der gleiche Typ wie std::basic_string_view,
    • R modelliert contiguous_range und sized_range,
    • ranges::range_value_t<R> und CharT sind vom gleichen Typ,
    • R ist nicht in const CharT* konvertierbar, und
    • Sei d ein L-Wert vom Typ std::remove_cvref_t<R>, d.operator ::std::basic_string_view<CharT, Traits>() ist kein gültiger Ausdruck.
    7) std::basic_string_view kann nicht aus nullptr konstruiert werden.

    Parameter

    other - eine andere Ansicht, mit der die Ansicht initialisiert werden soll
    s - Zeiger auf ein Zeichenarray oder einen C-String, mit dem die Ansicht initialisiert werden soll
    count - Anzahl der in die Ansicht einzubeziehenden Zeichen
    first - Iterator zum ersten Zeichen der Sequenz
    last - Iterator hinter dem letzten Zeichen der Sequenz oder eines anderen Sentinels
    r - ein zusammenhängender Bereich, der die Sequenz enthält

    Komplexität

    1-3,5,6) Konstante.
    4) Linear in der Länge von s .

    Beispiel

    Diesen Code ausführen 
    #include <array>
#include <iomanip>
#include <iostream>
#include <string>
#include <string_view>
int main()
{
    std::string cppstr = "Foo";
    std::string_view cppstr_v(cppstr); // Überladung (2), nach
                                       // std::string::operator string_view
    std::cout << "1) cppstr_v: " << std::quoted(cppstr_v) << '\n';
    char array[3] = {'B', 'a', 'r'};
    std::string_view array_v(array, std::size(array)); // Überladung (3)
    std::cout << "2) array_v: " << std::quoted(array_v) << '\n';
    const char* one_0_two = "One\0Two";
    std::string_view one_two_v{one_0_two, 7}; // Überladung (3)
    std::cout << "3) one_two_v: \"";
    for (char c : one_two_v)
        std::cout << (c != '\0' ? c : '?');
    std::cout << "\", one_two_v.size(): " << one_two_v.size() << '\n';
    std::string_view one_v{one_0_two}; // Überladung (4)
    std::cout << "4) one_v: " << std::quoted(one_v) << ", one_v.size(): " 
              << one_v.size() << '\n';
    constexpr std::wstring_view wcstr_v = L"xyzzy"; // Überladung (4)
    std::cout << "5) wcstr_v.size(): " << wcstr_v.size() << '\n';
    std::array ar = {'P', 'u', 'b'};
    std::string_view ar_v(ar.begin(), ar.end()); // Überladung (5), C++20
    std::cout << "6) ar_v: " << std::quoted(ar_v) << '\n';
//  std::string_view ar_v2{ar}; // Überladung (6), OK in C++23
//  std::cout << "ar_v2: " << std::quoted(ar_v2) << '\n'; // ar_v2: "Pub"
    [[maybe_unused]] auto zero = [] { /* ... */ return nullptr; };
//  std::string_view s{zero()}; // Überladung (7), kompiliert nicht ab C++23
}

    Ausgabe: 

    1) cppstr_v: "Foo"
2) array_v: "Bar"
3) one_two_v: "One?Two", one_two_v.size(): 7
4) one_v: "One", one_v.size(): 3
5) wcstr_v.size(): 5
6) ar_v: "Pub"

    Siehe auch

    		weist eine Ansicht zu
    (öffentliche Elementfunktion)
    		konstruiert einen basic_string
    (öffentliche Elementfunktion von std::basic_string<CharT,Traits,Allocator> )