Namespaces
Variants

std:: basic_string_view

From cppreference.net
C++
Strings library
Classes
basic_string_view
(C++17)
std::basic_string_view
Definido en el encabezado <string_view>
template <

class CharT,
class Traits = std:: char_traits < CharT >

> class basic_string_view ;
(desde C++17)

La plantilla de clase basic_string_view describe un objeto que puede hacer referencia a una secuencia contigua constante de CharT con el primer elemento de la secuencia en la posición cero.

Para un basic_string_view str , los punteros, iteradores y referencias a elementos de str se invalidan cuando una operación invalida un puntero en el rango [ str. data ( ) , str. data ( ) + str. size ( ) ) .

Cada especialización de std::basic_string_view es un tipo TriviallyCopyable .

(desde C++23)

Se proporcionan varios typedefs para tipos de caracteres comunes:

Definido en el encabezado <string_view>
Tipo Definición
std::string_view (C++17) std :: basic_string_view < char >
std::wstring_view (C++17) std :: basic_string_view < wchar_t >
std::u8string_view (C++20) std :: basic_string_view < char8_t >
std::u16string_view (C++17) std :: basic_string_view < char16_t >
std::u32string_view (C++17) std :: basic_string_view < char32_t >

Contenidos

Parámetros de plantilla

CharT - tipo de carácter
Traits - CharTraits clase que especifica las operaciones sobre el tipo de carácter. Al igual que para std::basic_string , Traits::char_type debe nombrar el mismo tipo que CharT o el programa estará mal formado.

Tipos anidados

Tipo Definición
traits_type Traits
value_type CharT
pointer CharT *
const_pointer const CharT *
reference CharT &
const_reference const CharT &
const_iterator iterador constante definido por la implementación LegacyRandomAccessIterator ,
y LegacyContiguousIterator (hasta C++20)
ConstexprIterator , y contiguous_iterator (desde C++20)

cuyo value_type es CharT

iterator const_iterator
const_reverse_iterator std:: reverse_iterator < const_iterator >
reverse_iterator const_reverse_iterator
size_type std::size_t
difference_type std::ptrdiff_t

Nota: iterator y const_iterator son el mismo tipo porque las vistas de cadena son vistas sobre secuencias de caracteres constantes.

Todos los requisitos sobre los tipos de iteradores de un Container se aplican también a los tipos iterator y const_iterator de basic_string_view .

Miembros de datos

Miembro Descripción
const_pointer data_ un puntero a la secuencia subyacente
( objeto miembro solo para exposición* )
size_type size_ el número de caracteres
( objeto miembro solo para exposición* )

Funciones miembro

Constructores y asignación
construye un basic_string_view
(función miembro pública)
asigna una vista
(función miembro pública)
Iteradores
devuelve un iterador al inicio
(función miembro pública)
devuelve un iterador al final
(función miembro pública)
devuelve un iterador inverso al principio
(función miembro pública)
devuelve un iterador inverso al final
(función miembro pública)
Acceso a elementos
accede al carácter especificado
(función miembro pública)
accede al carácter especificado con verificación de límites
(función miembro pública)
accede al primer carácter
(función miembro pública)
accede al último carácter
(función miembro pública)
devuelve un puntero al primer carácter de una vista
(función miembro pública)
Capacidad
devuelve el número de caracteres
(función miembro pública)
devuelve el número máximo de caracteres
(función miembro pública)
comprueba si la vista está vacía
(función miembro pública)
Modificadores
reduce la vista moviendo su inicio hacia adelante
(función miembro pública)
reduce la vista moviendo su final hacia atrás
(función miembro pública)
intercambia los contenidos
(función miembro pública)
Operaciones
copia caracteres
(función miembro pública)
devuelve una subcadena
(función miembro pública)
compara dos vistas
(función miembro pública)
(C++20)
comprueba si la vista de cadena comienza con el prefijo dado
(función miembro pública)
(C++20)
comprueba si la vista de cadena termina con el sufijo dado
(función miembro pública)
(C++23)
comprueba si la vista de cadena contiene la subcadena o carácter dado
(función miembro pública)
encontrar caracteres en la vista
(función miembro pública)
encontrar la última ocurrencia de una subcadena
(función miembro pública)
encontrar primera ocurrencia de caracteres
(función miembro pública)
encontrar última ocurrencia de caracteres
(función miembro pública)
encontrar primera ausencia de caracteres
(función miembro pública)
encontrar última ausencia de caracteres
(función miembro pública)

Constantes

[static]
valor especial. El significado exacto depende del contexto
(constante de miembro público estático)

Funciones no miembro

(C++17) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (eliminado en C++20) (C++20)
compara lexicográficamente dos vistas de cadena
(plantilla de función)
Entrada/Salida
(C++17)
realiza salida de flujo en vistas de cadena
(plantilla de función)

Literales

Definido en el espacio de nombres en línea std::literals::string_view_literals
(C++17)
crea una vista de cadena de un literal de arreglo de caracteres
(función)

Clases auxiliares

(C++17) (C++17) (C++20) (C++17) (C++17)
soporte de hash para vistas de cadena
(especialización de plantilla de clase)

Plantillas auxiliares

template < class CharT, class Traits >

inline constexpr bool

ranges:: enable_borrowed_range < std :: basic_string_view < CharT, Traits >> = true ;
(desde C++20)

Esta especialización de ranges::enable_borrowed_range hace que basic_string_view satisfaga borrowed_range .

template < class CharT, class Traits >

inline constexpr bool

ranges:: enable_view < std :: basic_string_view < CharT, Traits >> = true ;
(desde C++20)

Esta especialización de ranges::enable_view hace que basic_string_view satisfaga view .

Guías de deducción

(desde C++20)

Notas

Es responsabilidad del programador garantizar que std::string_view no sobreviva al array de caracteres al que apunta: 

std::string_view good{"a string literal"};
    // Caso "bueno": `good` apunta a un array estático.
    // Los literales de cadena residen en almacenamiento de datos persistente.
std::string_view bad{"a temporary string"s};
    // Caso "malo": `bad` contiene un puntero colgante ya que el temporal std::string,
    // creado por std::operator""s, será destruido al final de la sentencia.

Las especializaciones de std::basic_string_view ya son tipos trivialmente copiables en todas las implementaciones existentes, incluso antes del requisito formal introducido en C++23.

Macro de prueba de características Valor Std Característica
__cpp_lib_string_view 201606L (C++17) std::string_view
201803L (C++20) ConstexprIterator
__cpp_lib_string_contains 202011L (C++23) contains

Ejemplo

Ejecutar este código 
#include <iostream>
#include <string_view>
int main()
{
    #define A "▀"
    #define B "▄"
    #define C "─"
    constexpr std::string_view blocks[]{A B C, B A C, A C B, B C A};
    for (int y{}, p{}; y != 8; ++y, p = ((p + 1) % 4))
    {
        for (char x{}; x != 29; ++x)
            std::cout << blocks[p];
        std::cout << '\n';
    }
}

Salida: 

▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─
▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─
▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄
▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀
▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─
▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─
▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄▀─▄
▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀▄─▀

Informes de defectos

Los siguientes informes de defectos que modifican el comportamiento se aplicaron retroactivamente a los estándares de C++ publicados anteriormente.

DR Aplicado a Comportamiento publicado Comportamiento correcto
LWG 3203 C++17 solo los punteros, iteradores y referencias
devueltos por las funciones miembro de
basic_string_view podrían invalidarse 		todos los punteros, iteradores y referencias
a elementos de basic_string_view
pueden invalidarse

Véase también

almacena y manipula secuencias de caracteres
(plantilla de clase)
concatena dos strings, un string y un char , o un string y un string_view
(plantilla de función)
(C++20)
una vista no propietaria sobre una secuencia contigua de objetos
(plantilla de clase)
(C++11)
referencia un array temporal creado en inicialización de lista
(plantilla de clase)