basic_string_view klass

Klassmallen basic_string_view<charT> lades till i C++17 för att fungera som ett säkert och effektivt sätt för en funktion att acceptera olika orelaterade strängtyper utan att funktionen behöver vara templaterad för dessa typer. Klassen innehåller en pekare som inte äger en sammanhängande sekvens med teckendata och en längd som anger antalet tecken i sekvensen. Inget antagande görs om huruvida sekvensen är null-avslutad.

Standardbiblioteket definierar flera specialiseringar baserat på typen av element:

• string_view
• wstring_view
• u16string_view
• u32string_view

A basic_string_view beskriver det minsta vanliga gränssnitt som krävs för att läsa strängdata. Det ger åtkomst till underliggande data. den gör inga kopior (förutom copy funktionen). Data kan innehålla null-värden (\0) på valfri plats. A basic_string_view har ingen kontroll över objektets livslängd. Det är anroparens ansvar att se till att de underliggande strängdata är giltiga.

En funktion som accepterar en parameter av typen string_view kan göras för att fungera med valfri strängliknande typ, utan att göra funktionen till en mall eller begränsa funktionen till en viss delmängd av strängtyper. Det enda kravet är att det finns en implicit konvertering från strängtypen till string_view. Alla standardsträngstyper kan implicit konverteras till en string_view som innehåller samma elementtyp. Med andra ord är en std::string konvertibel till en string_view men inte till en wstring_view.

I följande exempel visas en icke-mallfunktion f som tar en parameter av typen wstring_view. Den kan anropas med argument av typen std::wstring, wchar_t*och winrt::hstring.

// compile with: /std:c++17
// string_view that uses elements of wchar_t
void f(wstring_view);

// pass a std::wstring:
const std::wstring& s { L"Hello" };
f(s);

// pass a C-style null-terminated string (string_view is not null-terminated):
const wchar_t* ns = L"Hello";
f(ns);

// pass a C-style character array of len characters (excluding null terminator):
const wchar_t* cs { L"Hello" };
size_t len { 5 };
f({cs,len});

// pass a WinRT string
winrt::hstring hs { L"Hello" };
f(hs);

Syntax

template <class CharType, class Traits = char_traits<CharType>>
class basic_string_view;

Parameters

CharType
Typen av tecken som lagras i basic_string_view. C++-standardbiblioteket innehåller följande typedefs för specialiseringar av den här mallen.

• string_view för element av typen char
• wstring_viewför wchar_t
• u16string_view för char16_t
• u32string_view för char32_t.

Traits
Standardvärdet är char_traits<CharType>.

Constructors

Typedefs

Member operators

Member functions

Remarks

Om en funktion uppmanas att generera en sekvens som är längre än max_size element rapporterar funktionen ett längdfel genom att generera ett objekt av typen length_error.

Requirements

/std:c++17 eller senare.

Header:<string_view>

Namespace:std

basic_string_view::at

Returnerar ett const_reference till tecknet vid det angivna nollbaserade indexet.

constexpr const_reference at(size_type offset) const;

Parameters

offset
Indexet för det element som ska refereras till.

Return value

A const_reference till tecknet på den position som anges av parameterindexet.

Remarks

Det första elementet har ett index på noll och följande element indexeras i följd av de positiva heltalen, så att en basic_string_view längd n har ett *n*th element indexerat med talet n - 1. at genererar ett undantag för ogiltiga index, till skillnad från operator[].

I allmänhet rekommenderar vi att at för sekvenser som std::vector och basic_string_view aldrig ska användas. Ett ogiltigt index som skickas till en sekvens är ett logikfel som ska identifieras och åtgärdas under utvecklingen. Om ett program inte är säkert på att dess index är giltiga bör det testa dem, inte anropa at() och förlita sig på undantag för att försvara mot vårdslös programmering.

Mer information finns i basic_string_view::operator[].

Example

// basic_string_view_at.cpp
// compile with: /EHsc
#include <string_view>
#include <iostream>

int main()
{
    using namespace std;

    const string_view  str1("Hello world");
    string_view::const_reference refStr2 = str1.at(8); // 'r'
}

basic_string_view::back

Returnerar ett const_reference till det sista elementet.

constexpr const_reference back() const;

Return value

A const_reference till det sista elementet basic_string_viewi .

Remarks

Utlöser ett undantag om är basic_string_view tomt.

Tänk på att när en basic_string_view har ändrats, till exempel genom att anropa remove_suffix, är elementet som returneras av den här funktionen inte längre det sista elementet i underliggande data.

Example

En string_view som är konstruerad med en C-strängliteral innehåller inte avslutande null. Så i följande exempel back returnerar 'p' och inte '\0'.

char c[] = "Help"; // char[5]
string_view sv{ c };
cout << sv.size(); // size() == 4
cout << sv.back() << endl; // p

Inbäddade null-värden behandlas som andra tecken:

string_view e = "embedded\0nulls"sv;
cout << boolalpha << (e.back() == 's'); // true

basic_string_view::basic_string_view

Konstruerar en basic_string_view.

constexpr basic_string_view() noexcept;
constexpr basic_string_view(const basic_string_view&) noexcept = default;
constexpr basic_string_view(const charT* str);
constexpr basic_string_view(const charT* str, size_type len);

Parameters

str
Pekaren till teckenvärdena.

len
Antalet tecken som ska inkluderas i vyn.

Remarks

Konstruktorerna med en charT* parameter förutsätter att indata är null-avslutade, men den avslutande null-värdet ingår inte i basic_string_view.

Du kan också skapa en basic_string_view med en literal. Se även operator"" sv.

basic_string_view::begin

Samma som cbegin.

constexpr const_iterator begin() const noexcept;

Return value

Returnerar en const_iterator adressering av det första elementet.

basic_string_view::cbegin

Returnerar ett const_iterator som adresserar det första elementet i intervallet.

constexpr const_iterator cbegin() const noexcept;

Return value

En const iterator för slumpmässig åtkomst som pekar på det första elementet i intervallet eller platsen precis utanför slutet av ett tomt intervall (för ett tomt intervall cbegin() == cend()).

basic_string_view::cend

Returnerar en const_iterator som adresserar platsen precis utanför det sista elementet i ett intervall.

constexpr const_iterator cend() const noexcept;

Return value

En const iterator med slumpmässig åtkomst som pekar precis utanför intervallets slut.

Remarks

Värdet som returneras av cend ska inte derefereras.

basic_string_view::compare

Gör en skiftlägeskänslig jämförelse med en angiven basic_string_view (eller en konvertibel strängtyp) för att avgöra om de två objekten är lika med eller om det ena är lexicographically mindre än det andra. Operatorerna<string_view> använder den här medlemsfunktionen för att göra jämförelser.

constexpr int compare(basic_string_view strv) const noexcept;
constexpr int compare(size_type pos, size_type num, basic_string_view strv) const;
constexpr int compare(size_type pos, size_type num, basic_string_view strv, size_type offset, size_type num2) const;
constexpr int compare(const charT* ptr) const;
constexpr int compare(size_type pos, size_type num, const charT* ptr) const;
constexpr int compare(size_type pos, size_type num, const charT* ptr, size_type num2) const;

Parameters

strv
Det basic_string_view som ska jämföras med detta basic_string_view.

pos
Indexet för detta basic_string_view där jämförelsen börjar.

num
Det maximala antalet tecken från detta basic_string_view som ska jämföras.

num2
Det maximala antalet tecken som strv ska jämföras.

offset
Indexet strv där jämförelsen börjar.

ptr
C-strängen som ska jämföras med den här basic_string_view.

Return value

• Ett negativt värde om detta basic_string_view är mindre än strv eller ptr
• Noll om de två teckensekvenserna är lika med
• Ett positivt värde om detta basic_string_view är större än strv eller ptr

Remarks

Medlemsfunktionerna compare gör en skiftlägeskänslig jämförelse av alla eller delar av varje teckensekvens.

Example

// basic_string_view_compare.cpp
// compile with: /EHsc
#include <string_view>
#include <iostream>
#include <string>

using namespace std;

string to_alpha(int result)
{
   if (result < 0) return " less than ";
   else if (result == 0) return " equal to ";
   else return " greater than ";
}

int main()
{
   // The first member function compares
   // two string_views
   string_view sv_A("CAB");
   string_view sv_B("CAB");
   cout << "sv_A is " << sv_A << endl;
   cout << "sv_B is " << sv_B << endl;
   int comp1 = sv_A.compare(sv_B);
   cout << "sv_A is" << to_alpha(comp1) << "sv_B.\n";

   // The second member function compares part of
   // an operand string_view to another string_view
   string_view sv_C("AACAB");
   string_view sv_D("CAB");
   cout << "sv_C is: " << sv_C << endl;
   cout << "sv_D is: " << sv_D << endl;
   int comp2a = sv_C.compare(2, 3, sv_D);
   cout << "The last three characters of sv_C are"
       << to_alpha(comp2a) << "sv_D.\n";

   int comp2b = sv_C.compare(0, 3, sv_D);
   cout << "The first three characters of sv_C are"
       << to_alpha(comp2b) << "sv_D.\n";

   // The third member function compares part of
   // an operand string_view to part of another string_view
   string_view sv_E("AACAB");
   string_view sv_F("DCABD");
   cout << "sv_E: " << sv_E << endl;
   cout << "sv_F is: " << sv_F << endl;
   int comp3a = sv_E.compare(2, 3, sv_F, 1, 3);
   cout << "The three characters from position 2 of sv_E are"
       << to_alpha(comp3a)
       << "the 3 characters of sv_F from position 1.\n";

   // The fourth member function compares
   // an operand string_view to a C string
   string_view sv_G("ABC");
   const char* cs_A = "DEF";
   cout << "sv_G is: " << sv_G << endl;
   cout << "cs_A is: " << cs_A << endl;
   int comp4a = sv_G.compare(cs_A);
   cout << "sv_G is" << to_alpha(comp4a) << "cs_A.\n";

   // The fifth member function compares part of
   // an operand string_view to a C string
   string_view sv_H("AACAB");
   const char* cs_B = "CAB";
   cout << "sv_H is: " << sv_H << endl;
   cout << "cs_B is: " << cs_B << endl;
   int comp5a = sv_H.compare(2, 3, cs_B);
   cout << "The last three characters of sv_H are"
      << to_alpha(comp5a) << "cs_B.\n";

   // The sixth member function compares part of
   // an operand string_view to part of an equal length of
   // a C string
   string_view sv_I("AACAB");
   const char* cs_C = "ACAB";
   cout << "sv_I is: " << sv_I << endl;
   cout << "cs_C: " << cs_C << endl;
   int comp6a = sv_I.compare(1, 3, cs_C, 3);
   cout << "The 3 characters from position 1 of sv_I are"
      << to_alpha(comp6a) << "the first 3 characters of cs_C.\n";
}

sv_A is CAB
sv_B is CAB
sv_A is equal to sv_B.
sv_C is: AACAB
sv_D is: CAB
The last three characters of sv_C are equal to sv_D.
The first three characters of sv_C are less than sv_D.
sv_E: AACAB
sv_F is: DCABD
The three characters from position 2 of sv_E are equal to the 3 characters of sv_F from position 1.
sv_G is: ABC
cs_A is: DEF
sv_G is less than cs_A.
sv_H is: AACAB
cs_B is: CAB
The last three characters of sv_H are equal to cs_B.
sv_I is: AACAB
cs_C: ACAB
The 3 characters from position 1 of sv_I are equal to the first 3 characters of cs_C.

basic_string_view::copy

Kopierar högst ett angivet antal tecken från en indexerad position i en källa basic_string_view till en målteckenmatris. Vi rekommenderar att du använder den säkra funktionen basic_string_view::_Copy_s i stället.

size_type copy(charT* ptr, size_type count, size_type offset = 0) const;

Parameters

ptr
Målteckenmatrisen som elementen ska kopieras till.

count
Det antal tecken som ska kopieras, högst från källan basic_string_view.

offset
Begynnelsepositionen i källan basic_string_view som kopior ska göras från.

Return value

Antalet tecken som kopieras.

Remarks

Ett null-tecken läggs inte till i slutet av kopian.

basic_string_view::_Copy_s

Säker CRT-kopieringsfunktion som ska användas i stället copyför .

size_type _Copy_s(
    value_type* dest,
    size_type dest_size,
    size_type count,
    size_type _Off = 0) const;

Parameters

dest
Målteckenmatrisen som elementen ska kopieras till.

dest_size
Storleken på dest.

count Det antal tecken som ska kopieras, högst från källsträngen.

_Off
Startpositionen i källsträngen som kopior ska göras från.

Return value

Antalet tecken som kopieras.

Remarks

Ett null-tecken läggs inte till i slutet av kopian.

For more information, see c-runtime-library/security-features-in-the-crt.

basic_string_view::crbegin

Returnerar ett const_reverse_iterator som adresserar det första elementet i en omvänd basic_string_view.

constexpr const_reverse_iterator crbegin() const noexcept;

Return value

En const_reverse_iterator som adresserar det första elementet i en omvänd basic_string_view.

basic_string_view::crend

Samma som rend.

constexpr const_reverse_iterator crend() const noexcept;

Return value

Returnerar en const_reverse_iterator som adresserar en efter slutet av en omvänd basic_string_view.

basic_string_view::data

Returnerar en rå pekare som inte äger till const-teckensekvensen för objektet som användes för att konstruera basic_string_view.

constexpr value_type *data() const noexcept;

Return value

En pekare-till-const till det första elementet i teckensekvensen.

Remarks

Pekaren kan inte ändra tecknen.

En sekvens med basic_string_view tecken är inte nödvändigtvis null-avslutad. Returtypen för data är inte en giltig C-sträng eftersom inget null-tecken läggs till. Null-tecknet \0 har ingen särskild betydelse i ett objekt av typen basic_string_view och kan vara en del av basic_string_view objektet precis som andra tecken.

basic_string_view::empty

Testar om innehåller basic_string_view tecken eller inte.

constexpr bool empty() const noexcept;

Return value

true om objektet basic_string_view inte innehåller några tecken, false om det har minst ett tecken.

Remarks

Medlemsfunktionen motsvarar size() == 0.

basic_string_view::end

Returnerar en slumpmässig åtkomst const_iterator som pekar på ett förbi det sista elementet.

constexpr const_iterator end() const noexcept;

Return value

Returnerar en slumpmässig åtkomst const_iterator som pekar på ett förbi det sista elementet.

Remarks

end används för att testa om en const_iterator har nått slutet av sin basic_string_view. Värdet som returneras av end ska inte derefereras.

basic_string_view::ends_with

Kontrollera om strängvyn slutar med det angivna suffixet.

bool ends_with(const CharType c) const noexcept;
bool ends_with(const CharType* const x) const noexcept;
bool ends_with(const basic_string_view sv) const noexcept;

Parameters

c
Suffixet med ett tecken att leta efter.

sv
En strängvy som innehåller suffixet att söka efter.
Du kan skicka en std::basic_string, som konverteras till en basic_string_view.

x
Null-avslutad teckensträng som innehåller suffixet som ska sökas efter.

Return value

true om strängvyn slutar med det angivna suffixet; false annars.

Remarks

ends_with() är nytt i C++20. Om du vill använda den anger du alternativet /std:c++20 eller senare kompilator.

Kontrollera starts_with om en strängvy börjar med det angivna prefixet.

Example

// Requires /std:c++20 or later
#include <string>
#include <iostream>

int main()
{
    std::cout << std::boolalpha; // so booleans show as 'true'/'false'  
    std::cout << std::string_view("abcdefg").ends_with('g') << '\n';
    std::cout << std::string_view("abcdefg").ends_with("eFg") << '\n';

    std::basic_string<char> str2 = "efg";
    std::cout << std::string_view("abcdefg").ends_with(str2);

    return 0;
}

true
false
true

basic_string_view::find

Söker i en basic_string_view framåtriktad riktning efter den första förekomsten av ett tecken eller en delsträng som matchar en angiven sekvens med tecken.

constexpr size_type find(basic_string_view str, size_type offset = 0) const noexcept;
constexpr size_type find(charT chVal, size_type offset = 0) const noexcept;
constexpr size_type find(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find(const charT* ptr, size_type offset = 0) const;

Parameters

str
Den basic_string_view som medlemsfunktionen ska söka efter.

chVal
Det teckenvärde som medlemsfunktionen ska söka efter.

offset
Index där sökningen ska börja.

ptr
C-strängen som medlemsfunktionen ska söka efter.

count
Antalet tecken i ptr, räknar framåt från det första tecknet.

Return value

Indexet för det första tecknet i understrängen som söktes efter när det lyckades. annars npos.

basic_string_view::find_first_not_of

Söker efter det första tecknet som inte är ett element i ett angivet basic_string_view eller konvertibelt strängobjekt.

constexpr size_type find_first_not_of(basic_string_view str, size_type offset = 0) const noexcept;
constexpr size_type find_first_not_of(charT chVal, size_type offset = 0) const noexcept;
constexpr size_type find_first_not_of(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find_first_not_of(const charT* ptr, size_type offset = 0) const;

Parameters

str
Den basic_string_view som medlemsfunktionen ska söka efter.

chVal
Det teckenvärde som medlemsfunktionen ska söka efter.

offset
Index där sökningen ska börja.

ptr
C-strängen som medlemsfunktionen ska söka efter.

count
Antalet tecken, som räknas framåt från det första tecknet, i den C-sträng som medlemsfunktionen ska söka efter.

Return value

Indexet för det första tecknet i understrängen som söktes efter när det lyckades. annars npos.

basic_string_view::find_first_of

Söker efter det första tecknet som matchar ett element i ett angivet basic_string_view.

constexpr size_type find_first_of(basic_string_view str, size_type offset = 0) const noexcept;
constexpr size_type find_first_of(charT chVal, size_type offset = 0) const noexcept;
constexpr size_type find_first_of(const charT* str, size_type offset, size_type count) const;
constexpr size_type find_first_of(const charT* str, size_type offset = 0) const;

Parameters

chVal
Det teckenvärde som medlemsfunktionen ska söka efter.

offset
Index där sökningen ska börja.

ptr
C-strängen som medlemsfunktionen ska söka efter.

count
Antalet tecken, som räknas framåt från det första tecknet, i den C-sträng som medlemsfunktionen ska söka efter.

str
Den basic_string_view som medlemsfunktionen ska söka efter.

Return value

Indexet för det första tecknet i understrängen som söktes efter när det lyckades. annars npos.

basic_string_view::find_last_not_of

Söker efter det sista tecknet som inte är något element i ett angivet basic_string_view.

constexpr size_type find_last_not_of(basic_string_view str, size_type offset = npos) const noexcept;
constexpr size_type find_last_not_of(charT chVal, size_type offset = npos) const noexcept;
constexpr size_type find_last_not_of(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find_last_not_of(const charT* ptr, size_type offset = npos) const;

Parameters

str
Den basic_string_view som medlemsfunktionen ska söka efter.

chVal
Det teckenvärde som medlemsfunktionen ska söka efter.

offset
Index där sökningen ska slutföras.

ptr
C-strängen som medlemsfunktionen ska söka efter.

count
Antalet tecken, som räknas framåt från det första tecknet, i ptr.

Return value

Indexet för det första tecknet i understrängen som söktes efter när det lyckades. annars string_view::npos.

basic_string_view::find_last_of

Söker efter det sista tecknet som matchar ett element i en angiven basic_string_view.

constexpr size_type find_last_of(basic_string_view str, size_type offset = npos) const noexcept;
constexpr size_type find_last_of(charT chVal, size_type offset = npos) const noexcept;
constexpr size_type find_last_of(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type find_last_of(const charT* ptr, size_type offset = npos) const;

Parameters

str
Den basic_string_view som medlemsfunktionen ska söka efter.

chVal
Det teckenvärde som medlemsfunktionen ska söka efter.

offset
Index där sökningen ska slutföras.

ptr
C-strängen som medlemsfunktionen ska söka efter.

count
Antalet tecken, som räknas framåt från det första tecknet, i den C-sträng som medlemsfunktionen ska söka efter.

Return value

Indexet för det sista tecknet i understrängen som söktes efter när det lyckades. annars npos.

basic_string_view::front

Returnerar ett const_reference till det första elementet.

constexpr const_reference front() const;

Return value

A const_reference till det första elementet.

Remarks

Utlöser ett undantag om är basic_string_view tomt.

basic_string_view::length

Returnerar det aktuella antalet element.

constexpr size_type length() const noexcept;

Remarks

Medlemsfunktionen är samma som size.

basic_string_view::max_size

Returnerar det maximala antalet tecken som en basic_string_view kan innehålla.

constexpr size_type max_size() const noexcept;

Return value

Det maximala antalet tecken som en basic_string_view kan innehålla.

Remarks

Ett undantag av typen length_error utlöses när en åtgärd genererar en basic_string_view med en längd som är större än max_size().

basic_string_view::operator=

Tilldelar ett eller ett konvertibelt strängobjekt till ett basic_string_view annat basic_string_view.

constexpr basic_string_view& operator=(const basic_string_view&) noexcept = default;

Example

   string_view s = "Hello";
   string_view s2 = s;

basic_string_view::operator[]

Ger ett const_reference till tecknet med ett angivet index.

constexpr const_reference operator[](size_type offset) const;

Parameters

offset
Indexet för det element som ska refereras till.

Return value

A const_reference till tecknet på den position som anges av parameterindexet.

Remarks

Det första elementet har ett index på noll och följande element indexeras i följd av de positiva heltalen, så att en basic_string_view längd n har ett *n*th-element indexerat med talet n-1.

operator[] är snabbare än medlemsfunktionen at för att ge läsåtkomst till elementen i en basic_string_view.

operator[] kontrollerar inte om indexet som skickades som ett argument är giltigt. Ett ogiltigt index som skickas till operator[] resulterar i odefinierat beteende.

Referensen som returneras kan ogiltigförklaras om underliggande strängdata ändras eller tas bort av det ägande objektet.

När du kompilerar med _ITERATOR_DEBUG_LEVEL värdet 1 eller 2 uppstår ett körningsfel om du försöker komma åt ett element utanför gränserna för basic_string_view. For more information, see Checked Iterators.

basic_string_view::rbegin

Returnerar en const iterator till det första elementet i en omvänd basic_string_view.

constexpr const_reverse_iterator rbegin() const noexcept;

Return value

Returnerar en iterator med slumpmässig åtkomst till det första elementet i en omvänd basic_string_view, som behandlar vad som skulle vara det sista elementet i motsvarande oreverserade basic_string_view.

Remarks

rbegin används med omvända basic_string_view precis som begin används med en basic_string_view. rbegin kan användas för att initiera en iteration bakåt.

basic_string_view::remove_prefix

Flyttar pekaren framåt med det angivna antalet element.

constexpr void remove_prefix(size_type n);

Remarks

Lämnar underliggande data oförändrade. Flyttar pekaren basic_string_view framåt efter n element och anger den privata size datamedlemmen till size - n.

basic_string_view::remove_suffix

Minskar storleken på vyn med det angivna antalet element från baksidan.

constexpr void remove_suffix(size_type n);

Remarks

Lämnar underliggande data och pekaren oförändrade. Anger den privata size datamedlemmen till size - n.

basic_string_view::rend

Returnerar en const iterator som pekar på ett förbi det sista elementet i en omvänd basic_string_view.

constexpr reverse_iterator rend() const noexcept;

Return value

En const omvänd iterator för slumpmässig åtkomst som pekar på ett förbi det sista elementet i en omvänd basic_string_view.

Remarks

rend används med omvända basic_string_view precis som end används med en basic_string_view. rend kan användas för att testa om en omvänd iterator har nått slutet av sin basic_string_view. Värdet som returneras av rend ska inte derefereras.

basic_string_view::rfind

Söker i omvänd basic_string_view ordning efter en delsträng som matchar en angiven sekvens med tecken.

constexpr size_type rfind(basic_string_view str, size_type offset = npos) const noexcept;
constexpr size_type rfind(charT chVal, size_type offset = npos) const noexcept;
constexpr size_type rfind(const charT* ptr, size_type offset, size_type count) const;
constexpr size_type rfind(const charT* ptr, size_type offset = npos) const;

Parameters

chVal
Det teckenvärde som medlemsfunktionen ska söka efter.

offset
Index där sökningen ska börja.

ptr
C-strängen som medlemsfunktionen ska söka efter.

count
Antalet tecken, som räknas framåt från det första tecknet, i den C-sträng som medlemsfunktionen ska söka efter.

str
Den basic_string_view som medlemsfunktionen ska söka efter.

Return value

Indexet för delsträngens första tecken när det lyckades. annars npos.

basic_string_view::size

Returnerar antalet element i basic_string_view.

constexpr size_type size() const noexcept;

Return value

Längden på basic_string_view.

Remarks

A basic_string_view kan ändra dess längd, till exempel av remove_prefix och remove_suffix. Eftersom detta inte ändrar underliggande strängdata är storleken på en basic_string_view inte nödvändigtvis storleken på underliggande data.

basic_string_view::starts_with

Kontrollera om strängvyn börjar med det angivna prefixet.

bool starts_with(const CharType c) const noexcept;
bool starts_with(const CharType* const x) const noexcept;
bool starts_with(const basic_string_view sv) const noexcept;

Parameters

c
Prefixet med ett tecken som ska sökas efter.

sv
En strängvy som innehåller prefixet som ska sökas efter.
Du kan skicka en std::basic_string, som konverteras till en strängvy.

x
Null-avslutad teckensträng som innehåller prefixet som ska sökas efter.

Return value

true om strängen börjar med det angivna prefixet; false annars.

Remarks

starts_with() är nytt i C++20. Om du vill använda den anger du alternativet /std:c++20 eller senare kompilator.

Se ends_with om en sträng slutar med ett suffix.

Example

// Requires /std:c++20 or later
#include <string>
#include <iostream>

int main()
{
    std::cout << std::boolalpha; // so booleans show as 'true'/'false'  
    std::cout << std::string_view("abcdefg").starts_with('b') << '\n';
    std::cout << std::string_view("abcdefg").starts_with("aBc") << '\n';

    std::basic_string<char> str2 = "abc";
    std::cout << std::string_view("abcdefg").starts_with(str2);

    return 0;
}

false
false
true

basic_string_view::substr

Returnerar ett basic_string_view som representerar (högst) det angivna antalet tecken från en angiven position.

constexpr basic_string_view substr(size_type offset = 0, size_type count = npos) const;

Parameters

offset
Ett index som lokaliserar elementet på den position som kopian görs från, med standardvärdet 0.

count
Antalet tecken som ska inkluderas i understrängen, om de finns.

Return value

Ett basic_string_view objekt som representerar den angivna delmängden av element.

basic_string_view::swap

Utbyter två basic_string_views, med andra ord pekarna till underliggande strängdata och storleksvärdena.

constexpr void swap(basic_string_view& sv) noexcept;

Parameters

sv
basic_string_view Källan vars pekare och storleksvärden ska bytas ut mot målvärdet basic_string_view.

See also

<string_view>
Trådsäkerhet i C++ Standard Library