Clase `basic_string_view`

Artículo
04/03/2023

La plantilla de clase basic_string_view<charT> se agregó en C++17 para actuar como una manera segura y eficaz de que una función acepte varios tipos de cadena no relacionados sin tener que crear plantillas en esos tipos. La clase contiene un puntero no propietario a una secuencia contigua de datos de caracteres y una longitud que especifica el número de caracteres de la secuencia. No se supone si la secuencia está terminada en null.

La biblioteca estándar define varias especializaciones basadas en el tipo de los elementos:

string_view
wstring_view
u16string_view
u32string_view

Un basic_string_view describe la interfaz común mínima necesaria para leer los datos de cadena. Proporciona acceso const a los datos subyacentes; no realiza copias (excepto para la función copy). Los datos pueden contener o no valores NULL (\0) en cualquier posición. Un objeto basic_string_view no tiene ningún control sobre la duración del objeto. Es responsabilidad del autor de la llamada asegurarse de que los datos de cadena subyacentes sean válidos.

Una función que acepta un parámetro de tipo string_view se puede hacer para trabajar con cualquier tipo similar a cadena, sin convertir la función en una plantilla ni restringir la función a un subconjunto determinado de tipos de cadena. El único requisito es que exista una conversión implícita del tipo de cadena a string_view. Todos los tipos de cadena estándar se pueden convertir implícitamente en string_view que contiene el mismo tipo de elemento. En otras palabras, un objeto std::string se puede convertir en string_view pero no en wstring_view.

En el ejemplo siguiente se muestra una función f que no es de plantilla que toma un parámetro de tipo wstring_view. Se puede llamar a con argumentos de tipo std::wstring, wchar_t* y 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);

Sintaxis

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

Parámetros

CharType
Tipo de caracteres que se almacenan en basic_string_view. La biblioteca estándar de C++ proporciona las siguientes definiciones de tipo para especializaciones de esta plantilla.

string_view para elementos de tipo char
wstring_view, para wchar_t
u16string_view para char16_t
u32string_view para char32_t .

Traits
Tiene como valor predeterminado char_traits<CharType>.

Constructores

Constructor	Descripción
`basic_string_view`	Construye un objeto `basic_string_view` que está vacío o que apunta a todos o a una parte de los datos de algún otro objeto de cadena, o a una matriz de caracteres de estilo C.

Typedefs

Nombre de tipo	Descripción
`const_iterator`	Iterador de acceso aleatorio que puede leer `const` elementos.
`const_pointer`	`using const_pointer = const value_type*;`
`const_reference`	`using const_reference = const value_type&;`
`const_reverse_iterator`	`using const_reverse_iterator = std::reverse_iterator<const_iterator>;`
`difference_type`	`using difference_type = ptrdiff_t;`
`iterator`	`using iterator = const_iterator;`
`npos`	`static constexpr size_type npos = size_type(-1);`
`pointer`	`using pointer = value_type*;`
`reference`	`using reference = value_type&;`
`reverse_iterator`	`using reverse_iterator = const_reverse_iterator;`
`size_type`	`using size_type = size_t;`
`traits_type`	`using traits_type = Traits;`
`value_type`	`using value_type = CharType;`

Operadores de miembro

Operator	Descripción
`operator=`	Asigna un objeto `basic_string_view` o un objeto de cadena convertible a otro `basic_string_view`.
`operator[]`	Devuelve el elemento que se encuentra en el índice especificado.

Funciones miembro

Función de miembro	Descripción
`at`	Devuelve un objeto `const_reference` al elemento situado en una ubicación especificada.
`back`	Devuelve un objeto `const_reference` al último elemento.
`begin`	Devuelve un iterador `const` que direcciona el primer elemento. (Los objetos `basic_string_view` son inmutables.)
`cbegin`	Igual que `begin`.
`cend`	Devuelve un iterador `const` que apunta a un elemento más allá del último elemento.
`copy`	Copia un número especificado de caracteres de una posición indexada de una cadena `basic_string_view` de origen a una matriz de caracteres de destino. (No se recomienda. Use `_Copy_s` en su lugar).
`_Copy_s`	Función de copia CRT segura.
`compare`	Compara una cadena `basic_string_view` con una cadena `basic_string_view` especificada para determinar si las dos cadenas son iguales o si una es lexicográficamente menor que la otra.
`crbegin`	Igual a `rbegin`.
`crend`	Igual a `rend`.
`data`	Devuelve un puntero no propietario sin formato a la secuencia de caracteres.
`empty`	Comprueba si la cadena `basic_string_view` contiene caracteres.
`end`	Igual que `cend`.
`ends_with`^C++20	Compruebe si una vista de cadena termina con un sufijo especificado.
`find`	Busca hacia delante la primera aparición de una subcadena que coincide con una secuencia especificada de caracteres.
`find_first_not_of`	Busca el primer carácter que no es un elemento de un objeto de cadena especificado `basic_string_view` o convertible.
`find_first_of`	Busca el primer carácter que coincide con cualquier elemento de un objeto de cadena especificado `basic_string_view` o convertible.
`find_last_not_of`	Busca el último carácter que no es un elemento de un objeto de cadena especificado `basic_string_view` o convertible.
`find_last_of`	Busca el último carácter que es un elemento de un objeto de cadena especificado `basic_string_view` o convertible.
`front`	Devuelve un objeto `const_reference` al primer elemento.
`length`	Devuelve el número actual de elementos.
`max_size`	Devuelve el número máximo de caracteres que puede contener una cadena `basic_string_view`.
`rbegin`	Devuelve un iterador `const` que direcciona el primer elemento del elemento `basic_string_view` invertido.
`remove_prefix`	Mueve el puntero hacia delante el número de elementos especificados.
`remove_suffix`	Reduce el tamaño de la vista en el número especificado de elementos a partir de la parte posterior.
`rend`	Devuelve un iterador `const` que apunta a un elemento más allá del último elemento en un elemento `basic_string_view` invertido.
`rfind`	Busca en `basic_string_view` hacia atrás la primera aparición de una subcadena que coincida con una secuencia especificada de caracteres.
`size`	Devuelve el número actual de elementos.
`starts_with`^C++20	Compruebe si una vista de cadena comienza con un prefijo determinado.
`substr`	Devuelve una subcadena de una longitud especificada a partir de un índice especificado.
`swap`	Intercambia el contenido de dos objetos `basic_string_view`.

Comentarios

Si se pide a una función que genere una secuencia de más de max_sizeelementos, la función notifica un error de longitud al iniciar un objeto de tipo length_error.

Requisitos

std:c++17 o una versión posterior

Encabezado: <string_view>

Espacio de nombres: std

`basic_string_view::at`

Devuelve un const_reference objeto al carácter en el índice de base cero especificado.

constexpr const_reference at(size_type offset) const;

Parámetros

offset
Índice del elemento al que se hará referencia.

Valor devuelto

const_reference al carácter en la posición especificada por el índice de parámetro.

Comentarios

El primer elemento tiene un índice de cero y los enteros positivos indizan de forma consecutiva los siguientes elementos para que una cadena basic_string_view de longitud n tenga un enésimo (nº) elemento indizado por el número n - 1. at produce una excepción para índices no válidos, a diferencia de operator[].

En general, se recomienda no usar nunca at para secuencias como std::vector y basic_string_view. Un índice no válido pasado a una secuencia es un error lógico que se debe detectar y corregir durante el desarrollo. Si un programa no está seguro de si sus índices son válidos, debe probarlos y no llamar a at() y confiar en las excepciones para defenderse de la programación negligente.

Para obtener más información, vea basic_string_view::operator[].

Ejemplo

// 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`

Devuelve un objeto const_reference al último elemento.

constexpr const_reference back() const;

Valor devuelto

const_reference al último elemento de basic_string_view.

Comentarios

Produce una excepción si basic_string_view está vacía.

Tenga en cuenta que, después de modificar una basic_string_view, por ejemplo, al llamar a remove_suffix, el elemento devuelto por esta función ya no es el último elemento de los datos subyacentes.

Ejemplo

Una string_view que se construye con un literal de cadena de C no incluye el valor NULL de terminación. En el ejemplo siguiente, back devuelve 'p', y no '\0'.

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

Los valores NULL incrustados se tratan como cualquier otro carácter:

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

`basic_string_view::basic_string_view`

Construye un objeto 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);

Parámetros

str
Puntero a los valores de caracteres.

len
Número de caracteres que se van a incluir en la vista.

Comentarios

Los constructores con un parámetro charT* asumen que la entrada termina en NULL, pero el valor NULL de terminación no se incluye en basic_string_view.

También puede construir un basic_string_view con un literal. Vea operator"" sv.

`basic_string_view::begin`

Igual que cbegin.

constexpr const_iterator begin() const noexcept;

Valor devuelto

Devuelve un const_iterator con direccionamiento al primer elemento.

`basic_string_view::cbegin`

Devuelve un const_iterator que direcciona el primer elemento del intervalo.

constexpr const_iterator cbegin() const noexcept;

Valor devuelto

Iterador const de acceso aleatorio que apunta al primer elemento del intervalo o la ubicación situada más allá del final de un intervalo vacío (para un intervalo vacío, cbegin() == cend()).

`basic_string_view::cend`

Devuelve un iterador const_iterator que direcciona la ubicación situada más allá del último elemento de un intervalo.

constexpr const_iterator cend() const noexcept;

Valor devuelto

Iterador const de acceso aleatorio que apunta justo después del final del intervalo.

Comentarios

El valor devuelto por cend no se debe desreferenciar.

`basic_string_view::compare`

Realiza una comparación que distingue entre mayúsculas y minúsculas con una basic_string_view (o un tipo de cadena convertible) para determinar si las dos cadenas son iguales o si una es lexicográficamente menor que la otra. Los <string_view>operadores usan esta función miembro para realizar comparaciones.

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;

Parámetros

strv
basic_string_view que se va a comparar con este basic_string_view.

pos
Índice de esta cadena basic_string_view en la que comienza la comparación.

num
Número máximo de caracteres de esta cadena basic_string_view que se va a comparar.

num2
Número máximo de caracteres de strv que se va a comparar.

offset
Índice de strv en la que comienza la comparación.

ptr
Cadena de C que se va a comparar a esta basic_string_view.

Valor devuelto

Valor negativo si basic_string_view es menor que strv o ptr
Cero si las dos secuencias de caracteres son iguales
Valor positivo si basic_string_view es mayor que strv o ptr

Comentarios

Las funciones de miembro compare realizan una comparación con distinción entre mayúsculas y minúsculas de la totalidad o de una parte de cada secuencia de caracteres.

Ejemplo

// 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`

Copia un número especificado de caracteres de una posición indexada de una cadena basic_string_view de origen a una matriz de caracteres de destino. Se recomienda usar la función segura basic_string_view::_Copy_s en su lugar.

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

Parámetros

ptr
Matriz de caracteres de destino en la que van a copiarse los elementos.

count
Número de caracteres que se van a copiar desde la basic_string_view de origen.

offset
Posición inicial de la cadena de origen a partir de la basic_string_view de origen desde la que se van a realizar las copias.

Valor devuelto

Número de caracteres copiados.

Comentarios

Un carácter nulo no se anexa al final de la copia.

`basic_string_view::_Copy_s`

Función de copia de CRT segura que se va a usar en lugar de copy.

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

Parámetros

dest
Matriz de caracteres de destino en la que van a copiarse los elementos.

dest_size
Tamaño de dest.

count Número de caracteres que se van a copiar, como máximo, desde la cadena de origen.

_Off
Posición inicial de la cadena de origen a partir de la que se van a realizar las copias.

Valor devuelto

Número de caracteres copiados.

Comentarios

Un carácter nulo no se anexa al final de la copia.

Para obtener más información, vea c-runtime-library/security-features-in-the-crt.

`basic_string_view::crbegin`

Devuelve un const_reverse_iterator que direcciona el primer elemento en un basic_string_view invertido.

constexpr const_reverse_iterator crbegin() const noexcept;

Valor devuelto

const_reverse_iterator que direcciona el primer elemento en un basic_string_view invertido.

`basic_string_view::crend`

Igual que rend.

constexpr const_reverse_iterator crend() const noexcept;

Valor devuelto

Devuelve un objeto const_reverse_iterator que direcciona un elemento pasado el final de un basic_string_view invertido.

`basic_string_view::data`

Devuelve un puntero no propietario sin formato a la secuencia de caracteres const del objeto que se usó para construir basic_string_view.

constexpr value_type *data() const noexcept;

Valor devuelto

Puntero a const al primer elemento de la secuencia de caracteres.

Comentarios

El puntero no puede modificar los caracteres.

Una secuencia de basic_string_view caracteres no termina necesariamente en null. El tipo devuelto para data no es una cadena de C válida porque no se anexa ningún carácter nulo. El carácter nulo \0 no tienen ningún significado especial en un objeto del tipo basic_string_view y puede ser parte del objeto basic_string_view al igual que cualquier otro carácter.

`basic_string_view::empty`

Comprueba si basic_string_view contiene caracteres o no.

constexpr bool empty() const noexcept;

Valor devuelto

true si el objeto basic_string_view no contiene caracteres; false si tiene al menos un carácter.

Comentarios

La función miembro es equivalente a size() == 0.

`basic_string_view::end`

Devuelve un const_iterator de acceso aleatorio que apunta a un elemento más allá del último elemento.

constexpr const_iterator end() const noexcept;

Valor devuelto

Devuelve un const_iterator de acceso aleatorio que apunta a un elemento más allá del último elemento.

Comentarios

end se usa para comprobar si un const_iterator ha llegado al final de su basic_string_view. El valor devuelto por end no se debe desreferenciar.

`basic_string_view::ends_with`

Compruebe si la vista de cadena termina con el sufijo especificado.

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;

Parámetros

c
Sufijo de carácter único que se va a buscar.

sv
Vista de cadena que contiene el sufijo que se va a buscar.
Puede pasar un std::basic_string, que se convierte en basic_string_view.

x
Cadena de caracteres terminada en NULL que contiene el sufijo que se va a buscar.

Valor devuelto

true si la vista de cadena termina con el sufijo especificado; de lo contrario false.

Comentarios

ends_with() es nuevo en C++20. Para usarlo, especifique /std:c++20 o una opción de compilador posterior.

Vea starts_with para comprobar si una vista de cadena comienza con el prefijo especificado.

Ejemplo

// Requires /std:c++20 or /std:c++latest
#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`

Busca en basic_string_view hacia delante la primera aparición de una subcadena que coincide con una secuencia especificada de caracteres.

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;

Parámetros

str
basic_string_view para la que se va a buscar la función miembro.

chVal
Valor de carácter que va a buscar la función miembro.

offset
Índice en el que se va a comenzar la búsqueda.

ptr
Cadena de C para que va a buscar la función miembro.

count
Número de caracteres en ptr, a contar hacia adelante desde el primer carácter.

Valor devuelto

Índice del primer carácter de la subcadena buscada cuando la operación se realiza correctamente; de lo contrario, npos.

`basic_string_view::find_first_not_of`

Busca el primer carácter que no es un elemento de un objeto de cadena especificado basic_string_view o convertible.

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;

Parámetros

str
basic_string_view para la que se va a buscar la función miembro.

chVal
Valor de carácter que va a buscar la función miembro.

offset
Índice en el que se va a comenzar la búsqueda.

ptr
Cadena de C para que va a buscar la función miembro.

count
Número de caracteres, contando hacia delante desde el primer carácter, de la cadena de C que va a buscar la función miembro.

Valor devuelto

Índice del primer carácter de la subcadena buscada cuando la operación se realiza correctamente; de lo contrario, npos.

`basic_string_view::find_first_of`

Busca el primer carácter que coincide con algún elemento de una basic_string_view especificada.

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;

Parámetros

chVal
Valor de carácter que va a buscar la función miembro.

offset
Índice en el que se va a comenzar la búsqueda.

ptr
Cadena de C para que va a buscar la función miembro.

count
Número de caracteres, contando hacia delante desde el primer carácter, de la cadena de C que va a buscar la función miembro.

str
basic_string_view para la que se va a buscar la función miembro.

Valor devuelto

Índice del primer carácter de la subcadena buscada cuando la operación se realiza correctamente; de lo contrario, npos.

`basic_string_view::find_last_not_of`

Busca el primer carácter que no sea un elemento de una basic_string_view especificada.

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;

Parámetros

str
basic_string_view para la que se va a buscar la función miembro.

chVal
Valor de carácter que va a buscar la función miembro.

offset
Índice en el que va a finalizar la búsqueda.

ptr
Cadena de C para que va a buscar la función miembro.

count
Número de caracteres en, a contar hacia adelante desde el primer carácter en ptr.

Valor devuelto

Índice del primer carácter de la subcadena buscada cuando la operación se realiza correctamente; de lo contrario, string_view::npos.

`basic_string_view::find_last_of`

Busca el último carácter que coincide con algún elemento de una basic_string_view especificada.

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;

Parámetros

str
basic_string_view para la que se va a buscar la función miembro.

chVal
Valor de carácter que va a buscar la función miembro.

offset
Índice en el que va a finalizar la búsqueda.

ptr
Cadena de C para que va a buscar la función miembro.

count
Número de caracteres, contando hacia delante desde el primer carácter, de la cadena de C que va a buscar la función miembro.

Valor devuelto

Índice del último carácter de la subcadena buscada cuando la operación se realiza correctamente; de lo contrario, npos.

`basic_string_view::front`

Devuelve un objeto const_reference al primer elemento.

constexpr const_reference front() const;

Valor devuelto

const_reference al primer elemento.

Comentarios

Produce una excepción si basic_string_view está vacía.

`basic_string_view::length`

Devuelve el número actual de elementos.

constexpr size_type length() const noexcept;

Comentarios

La función miembro es igual que size.

`basic_string_view::max_size`

Devuelve el número máximo de caracteres que basic_string_view puede contener.

constexpr size_type max_size() const noexcept;

Valor devuelto

Número máximo de caracteres que basic_string_view puede contener.

Comentarios

Se genera una excepción del tipo length_error cuando una operación produce una basic_string_view con una longitud superior a max_size().

`basic_string_view::operator=`

Asigna un objeto basic_string_view o un objeto de cadena convertible a otro basic_string_view.

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

Ejemplo

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

`basic_string_view::operator[]`

Proporciona una referencia const_reference al carácter de una cadena que tiene el índice especificado.

constexpr const_reference operator[](size_type offset) const;

Parámetros

offset
Índice del elemento al que se hará referencia.

Valor devuelto

const_reference al carácter en la posición especificada por el índice de parámetro.

Comentarios

operator[] es más rápido que la función miembro at a la hora de proporcionar acceso de lectura a los elementos de una basic_string_view.

operator[] no comprueba si el índice pasado como argumento es válido. Un índice no válido pasado a operator[] da como resultado un comportamiento indefinido.

La referencia devuelta se puede invalidar si el objeto propietario modifica o elimina los datos de cadena subyacentes.

Al compilar con _ITERATOR_DEBUG_LEVEL establecido en 1 o 2, se producirá un error en tiempo de ejecución si intenta acceder a un elemento fuera de los límites de la cadena basic_string_view. Para más información, vea Iteradores activados.

`basic_string_view::rbegin`

Devuelve un iterador const al primer elemento en un basic_string_view invertido.

constexpr const_reverse_iterator rbegin() const noexcept;

Valor devuelto

Devuelve un iterador de acceso aleatorio al primer elemento de una basic_string_view invertida que se direcciona a lo que sería el último elemento de la basic_string_view no invertida correspondiente.

Comentarios

rbegin se usa con un basic_string_view invertido igual que begin se usa con un basic_string_view. rbegin puede usarse para inicializar una iteración hacia atrás.

`basic_string_view::remove_prefix`

Mueve el puntero hacia delante el número de elementos especificados.

constexpr void remove_prefix(size_type n);

Comentarios

Deja los datos subyacentes sin cambios. Mueve el puntero basic_string_view hacia adelante n elementos y establece el miembro de datos privado size en size - n.

`basic_string_view::remove_suffix`

Reduce el tamaño de la vista en el número especificado de elementos a partir de la parte posterior.

constexpr void remove_suffix(size_type n);

Comentarios

Deja los datos subyacentes y el puntero a ellos sin cambios. Establece el miembro de datos privado size en size - n.

`basic_string_view::rend`

Devuelve un iterador const que apunta a un elemento más allá del último elemento en un elemento basic_string_view invertido.

constexpr reverse_iterator rend() const noexcept;

Valor devuelto

Iterador const invertido de acceso aleatorio que apunta a un elemento más allá del último elemento de un basic_string_view invertido.

Comentarios

rend se usa con un basic_string_view invertido igual que end se usa con un basic_string_view. rend se puede usar para comprobar si un iterador inverso ha llegado al final de basic_string_view. El valor devuelto por rend no se debe desreferenciar.

`basic_string_view::rfind`

Busca en basic_string_view hacia atrás una subcadena que coincida con una secuencia especificada de caracteres.

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;

Parámetros

chVal
Valor de carácter que va a buscar la función miembro.

offset
Índice en el que se va a comenzar la búsqueda.

ptr
Cadena de C para que va a buscar la función miembro.

count
Número de caracteres, contando hacia delante desde el primer carácter, de la cadena de C que va a buscar la función miembro.

str
basic_string_view para la que se va a buscar la función miembro.

Valor devuelto

Índice del primer carácter de la subcadena cuando la operación se realiza correctamente; de lo contrario, npos.

`basic_string_view::size`

Devuelve el número de elementos de basic_string_view.

constexpr size_type size() const noexcept;

Valor devuelto

Longitud de basic_string_view.

Comentarios

Un basic_string_view puede modificar su longitud, por ejemplo, por remove_prefix y remove_suffix. Dado que esto no modifica los datos de cadena subyacentes, el tamaño de un basic_string_view no es necesariamente el tamaño de los datos subyacentes.

`basic_string_view::starts_with`

Compruebe si una vista de cadena comienza con el prefijo especificado.

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;

Parámetros

c
Prefijo de carácter único que se va a buscar.

sv
Vista de cadena que contiene el prefijo que se va a buscar.
Puede pasar un std::basic_string, que se convierte en una vista de cadena.

x
Cadena de caracteres terminada en NULL que contiene el prefijo que se va a buscar.

Valor devuelto

true si la cadena empieza con el prefijo especificado; en caso contrario, false.

Comentarios

starts_with() es nuevo en C++20. Para usarlo, especifique std:c++20 o una opción de compilador posterior.

Vea ends_with para verificar si una cadena termina con un sufijo.

Ejemplo

// Requires /std:c++20 or /std:c++latest
#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`

Devuelve un objeto basic_string_view que representa (como máximo) el número especificado de caracteres de una posición especificada.

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

Parámetros

offset
Índice que localiza el elemento en la posición a partir de la que se realiza la copia, con un valor predeterminado de 0.

count
Número de caracteres que se van a incluir en la subcadena, si están presentes.

Valor devuelto

Objeto basic_string_view que representa la subsecuencia especificada de elementos.

`basic_string_view::swap`

Intercambia dos basic_string_view, es decir, los punteros a los datos de cadena subyacentes y los valores de tamaño.

constexpr void swap(basic_string_view& sv) noexcept;

Parámetros

sv
basic_string_view de origen cuyo puntero y valores de tamaño se van a intercambiar con el basic_string_view de destino.

Consulte también

<string_view>
Seguridad para subprocesos en la biblioteca estándar de C++

Compartir a través de

Clase basic_string_view

Sintaxis

Parámetros

Constructores

Typedefs

Operadores de miembro

Funciones miembro

Comentarios

Requisitos

basic_string_view::at

Parámetros

Valor devuelto

Comentarios

Ejemplo

basic_string_view::back

Valor devuelto

Comentarios

Ejemplo

basic_string_view::basic_string_view

Parámetros

Comentarios

basic_string_view::begin

Valor devuelto

basic_string_view::cbegin

Valor devuelto

basic_string_view::cend

Valor devuelto

Comentarios

basic_string_view::compare

Parámetros

Valor devuelto

Comentarios

Ejemplo

basic_string_view::copy

Parámetros

Valor devuelto

Comentarios

basic_string_view::_Copy_s

Parámetros

Valor devuelto

Comentarios

basic_string_view::crbegin

Valor devuelto

basic_string_view::crend

Valor devuelto

basic_string_view::data

Valor devuelto

Comentarios

basic_string_view::empty

Valor devuelto

Comentarios

basic_string_view::end

Valor devuelto

Comentarios

basic_string_view::ends_with

Parámetros

Valor devuelto

Comentarios

Ejemplo

basic_string_view::find

Parámetros

Valor devuelto

basic_string_view::find_first_not_of

Parámetros

Valor devuelto

basic_string_view::find_first_of

Parámetros

Valor devuelto

basic_string_view::find_last_not_of

Parámetros

Valor devuelto

basic_string_view::find_last_of

Parámetros

Valor devuelto

basic_string_view::front

Valor devuelto

Comentarios

basic_string_view::length

Comentarios

Clase `basic_string_view`

`basic_string_view::at`

`basic_string_view::back`

`basic_string_view::basic_string_view`

`basic_string_view::begin`

`basic_string_view::cbegin`

`basic_string_view::cend`

`basic_string_view::compare`

`basic_string_view::copy`

`basic_string_view::_Copy_s`

`basic_string_view::crbegin`

`basic_string_view::crend`

`basic_string_view::data`

`basic_string_view::empty`

`basic_string_view::end`

`basic_string_view::ends_with`

`basic_string_view::find`

`basic_string_view::find_first_not_of`

`basic_string_view::find_first_of`

`basic_string_view::find_last_not_of`

`basic_string_view::find_last_of`

`basic_string_view::front`

`basic_string_view::length`

`basic_string_view::max_size`

`basic_string_view::operator=`

`basic_string_view::operator[]`

`basic_string_view::rbegin`

`basic_string_view::remove_prefix`

`basic_string_view::remove_suffix`

`basic_string_view::rend`

`basic_string_view::rfind`

`basic_string_view::size`

`basic_string_view::starts_with`

`basic_string_view::substr`

`basic_string_view::swap`