Espacios de nombres
Variantes
Acciones

Archivo de encabezado de la biblioteca estándar <string_view>

De cppreference.com
< cpp‎ | header
 
C++
Apoyo de compiladores
Implementaciones independientes y albergadas
Lenguaje
Biblioteca estándar
Encabezados de la biblioteca estándar
Requisitos denominados
Macros de prueba de característica (C++20)
Biblioteca de apoyo del lenguaje
Biblioteca de conceptos (C++20)
Biblioteca de diagnósticos
Biblioteca de gestión de memoria
Biblioteca de metaprogramación (C++11)
Biblioteca de servicios generales
Biblioteca de contenedores
Biblioteca de iteradores
Biblioteca de rangos (C++20)
Biblioteca de algoritmos
Biblioteca de cadenas
Biblioteca de procesamiento de texto
Biblioteca numérica
Biblioteca de fecha y hora
Biblioteca de entrada/salida
Biblioteca del sistema de archivos (C++17)
Biblioteca de apoyo de concurrencia (C++11)
Biblioteca de apoyo de ejecución (C++26)
Especificaciones técnicas
Índice de símbolos
Bibliotecas externas
 
Archivos de encabezado de la biblioteca estándar
Algoritmos
<algorithm>
<numeric>
Cadenas
<cctype>
<cstring>
<cuchar> (C++11)
<cwchar>
<cwctype>
<string_view> (C++17)
<string>
Procesamiento de texto
<clocale>
<codecvt> (C++11/17/26*)
<locale>
<regex> (C++11)
<text_encoding> (C++26)   
Numéricos
<cfenv> (C++11)
<cmath>
<complex>
<linalg> (C++26)
<numbers> (C++20)
<random> (C++11)
<simd> (C++26)
<valarray>
Tiempo
<chrono> (C++11)
<ctime>
Compatibilidad con C
<ccomplex> (C++11/17/20*)
<ciso646> (hasta C++20)
<cstdalign> (C++11/17/20*)
<cstdbool> (C++11/17/20*)
<ctgmath> (C++11/17/20*)
 

Este archivo de encabezado es parte de la biblioteca de cadenas.

Contenido

[editar] Clases

(C++17)
 Vista sobre cadena de solo lectura.
(plantilla de clase) [editar]
std::string_view std::basic_string_view<char>
std::u8string_view std::basic_string_view<char8_t> (C++20)
std::u16string_view std::basic_string_view<char16_t>
std::u32string_view std::basic_string_view<char32_t>
std::wstring_view std::basic_string_view<wchar_t>
(C++17)(C++17)(C++20)(C++17)(C++17)
 Apoyo de generación de dispersión para vistas sobre cadena
(especialización de plantilla de clase) [editar]

[editar] Funciones

(eliminado en C++20)(eliminado en C++20)(eliminado en C++20)(eliminado en C++20)(eliminado en C++20)(C++20)
 Compara dos vistas sobre cadena lexicográficamente.
(plantilla de función) [editar]
Realiza salida de flujo en vistas sobre cadena.
(plantilla de función) [editar]

[editar] Sinopsis

namespace std {
 
// plantilla de clase basic_string_view
template<typename charT, typename traits = char_traits<charT>>
class basic_string_view;
 
// funciones no miembro de comparación
template<typename charT, typename traits>
constexpr bool operator==(basic_string_view<charT, traits> x,
                          basic_string_view<charT, traits> y) noexcept;
template<typename charT, typename traits>
constexpr bool operator!=(basic_string_view<charT, traits> x,
                          basic_string_view<charT, traits> y) noexcept;
template<typename charT, typename traits>
constexpr bool operator< (basic_string_view<charT, traits> x,
                          basic_string_view<charT, traits> y) noexcept;
template<typename charT, typename traits>
constexpr bool operator> (basic_string_view<charT, traits> x,
                          basic_string_view<charT, traits> y) noexcept;
template<typename charT, typename traits>
constexpr bool operator<=(basic_string_view<charT, traits> x,
                          basic_string_view<charT, traits> y) noexcept;
template<typename charT, typename traits>
constexpr bool operator>=(basic_string_view<charT, traits> x,
                          basic_string_view<charT, traits> y) noexcept;
/* sobrecargas de funciones de comparación adicionales suficientes */
 
// insertadores y extractores
template<typename charT, typename traits>
basic_ostream<charT, traits>& 
operator<<(basic_ostream<charT, traits>& os, basic_string_view<charT, traits> str);
 
// nombres de tipos definidos (typedef) de basic_string_view
using string_view    = basic_string_view<char>;
using u8string_view  = basic_string_view<char8_t>;
using u16string_view = basic_string_view<char16_t>;
using u32string_view = basic_string_view<char32_t>;
using wstring_view   = basic_string_view<wchar_t>;
 
// soporte para hash (resumen)
template<typename T> struct hash;
template<> struct hash<string_view>;
template<> struct hash<u8string_view>;
template<> struct hash<u16string_view>;
template<> struct hash<u32string_view>;
template<> struct hash<wstring_view>;
 
inline namespace literals {
inline namespace string_view_literals {
// sufijo para los literales de basic_string_view
constexpr string_view operator "" sv(const char* str, size_t len) noexcept;
constexpr u8string_view operator "" sv(const char8_t* str, size_t len) noexcept;
constexpr u16string_view operator "" sv(const char16_t* str, size_t len) noexcept;
constexpr u32string_view operator "" sv(const char32_t* str, size_t len) noexcept;
constexpr wstring_view operator "" sv(const wchar_t* str, size_t len) noexcept;
}
}
} // namespace std

[editar] Plantilla de clase std::basic_string_view

namespace std {
template<typename charT, typename traits = char_traits<charT>>
class basic_string_view {
public:
// tipos
typedef traits traits_type;
typedef charT value_type;
typedef charT* pointer;
typedef const charT* const_pointer;
typedef charT& reference;
typedef const charT& const_reference;
typedef /*definido por la implementación*/ const_iterator;
typedef const_iterator iterator;
typedef reverse_iterator<const_iterator> const_reverse_iterator;
typedef const_reverse_iterator reverse_iterator;
typedef size_t size_type;
typedef ptrdiff_t difference_type;
static constexpr size_type npos = size_type(-1);
 
// construcción y asignación
constexpr basic_string_view() noexcept;
constexpr basic_string_view(const basic_string_view&) noexcept = default;
basic_string_view &operator=(const basic_string_view&) noexcept = default;
constexpr basic_string_view(const charT* str);
constexpr basic_string_view(const charT* str, size_type len);
 
// soporte de iteradores
constexpr const_iterator begin() const noexcept;
constexpr const_iterator end() const noexcept;
constexpr const_iterator cbegin() const noexcept;
constexpr const_iterator cend() const noexcept;
constexpr const_reverse_iterator rbegin() const noexcept;
constexpr const_reverse_iterator rend() const noexcept;
constexpr const_reverse_iterator crbegin() const noexcept;
constexpr const_reverse_iterator crend() const noexcept;
 
// capacidad
constexpr size_type size() const noexcept;
constexpr size_type length() const noexcept;
constexpr size_type max_size() const noexcept;
[[nodiscard]] constexpr bool empty() const noexcept;
 
// acceso a elementos
constexpr const_reference operator[](size_type pos) const;
constexpr const_reference at(size_type pos) const;
constexpr const_reference front() const;
constexpr const_reference back() const;
constexpr const_pointer data() const noexcept;
 
// modificadores
constexpr void remove_prefix(size_type n);
constexpr void remove_suffix(size_type n);
constexpr void swap(basic_string_view& s) noexcept;
 
constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;
constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
constexpr int compare(basic_string_view s) const noexcept;
constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
constexpr int compare(size_type pos1, size_type n1, basic_string_view s,
                      size_type pos2, size_type n2) const;
constexpr int compare(const charT* s) const;
constexpr int compare(size_type pos1, size_type n1, const charT* s) const;
constexpr int compare(size_type pos1, size_type n1, const charT* s, size_type n2) const;
constexpr bool starts_with(basic_string_view x) const noexcept;
constexpr bool starts_with(charT x) const noexcept;
constexpr bool starts_with(const charT* x) const;
constexpr bool ends_with(basic_string_view x) const noexcept;
constexpr bool ends_with(charT x) const noexcept;
constexpr bool ends_with(const charT* x) const;
constexpr size_type find(basic_string_view s, size_type pos = 0) const noexcept;
constexpr size_type find(charT c, size_type pos = 0) const noexcept;
constexpr size_type find(const charT* s, size_type pos, size_type n) const;
constexpr size_type find(const charT* s, size_type pos = 0) const;
constexpr size_type rfind(basic_string_view s, size_type pos = npos) const noexcept;
constexpr size_type rfind(charT c, size_type pos = npos) const noexcept;
constexpr size_type rfind(const charT* s, size_type pos, size_type n) const;
constexpr size_type rfind(const charT* s, size_type pos = npos) const;
constexpr size_type find_first_of(basic_string_view s, size_type pos = 0) const noexcept;
constexpr size_type find_first_of(charT c, size_type pos = 0) const noexcept;
constexpr size_type find_first_of(const charT* s, size_type pos, size_type n) const;
constexpr size_type find_first_of(const charT* s, size_type pos = 0) const;
constexpr size_type find_last_of(basic_string_view s, size_type pos = npos) const noexcept;
constexpr size_type find_last_of(charT c, size_type pos = npos) const noexcept;
constexpr size_type find_last_of(const charT* s, size_type pos, size_type n) const;
constexpr size_type find_last_of(const charT* s, size_type pos = npos) const;
constexpr size_type find_first_not_of(basic_string_view s, size_type pos = 0) const noexcept;
constexpr size_type find_first_not_of(charT c, size_type pos = 0) const noexcept;
constexpr size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
constexpr size_type find_first_not_of(const charT* s, size_type pos = 0) const;
constexpr size_type find_last_not_of(basic_string_view s,size_type pos = npos) const noexcept;
constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;
constexpr size_type find_last_not_of(const charT* s, size_type pos, size_type n) const;
constexpr size_type find_last_not_of(const charT* s, size_type pos = npos) const;
private:
const_pointer data_; // solo exposición
size_type size_; // solo exposición
};
 
}
Obtenido de «https://es.cppreference.com/mwiki/index.php?title=cpp/header/string_view&oldid=34171»