std::basic_string::basic_string

 

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

 

Biblioteca de cadenas

Cadenas terminadas en nulo

Cadenas de bytes

Cadenas multibyte

De caracteres anchos

Clases

basic_string

basic_string_view (C++17)

char_traits

 

std::basic_string

Funciones miembro basic_string::basic_string basic_string::operator= basic_string::assign basic_string::get_allocator Acceso a elementos basic_string::at basic_string::operator[] basic_string::front (C++11) basic_string::back (C++11) basic_string::data basic_string::c_str basic_string::operator basic_string_view (C++17) Iteradores basic_string::beginbasic_string::cbegin (C++11) basic_string::endbasic_string::cend (C++11) basic_string::rbeginbasic_string::crbegin (C++11) basic_string::rendbasic_string::crend (C++11) Capacidad basic_string::empty basic_string::sizebasic_string::length basic_string::max_size basic_string::reserve basic_string::capacity basic_string::shrink_to_fit (C++11)

Operaciones basic_string::clear basic_string::insert basic_string::erase basic_string::push_back basic_string::pop_back (C++11) basic_string::append basic_string::operator+= basic_string::compare basic_string::starts_with (C++20) basic_string::ends_with (C++20) basic_string::replace basic_string::substr basic_string::copy basic_string::resize basic_string::swap Búsqueda basic_string::find basic_string::rfind basic_string::find_first_of basic_string::find_first_not_of basic_string::find_last_of basic_string::find_last_not_of Constantes basic_string::npos

Funciones no miembro operator+ swap(std::basic_string) operator""s (C++14) erase(std::basic_string)erase_if(std::basic_string) (C++20)(C++20) E/S operator<<operator>> getline Comparación operator==operator!=operator<operator>operator<=operator>=operator<=> (hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(hasta C++20)(C++20) Conversión numérica (C++11) stoistolstoll stoulstoull stofstodstold to_string to_wstring Clases auxiliares hash<std::string>hash<std::wstring>hash<std::u32string>hash<std::u16string>hash<std::u8string> (C++11)(C++11)(C++11)(C++11)(C++20) hash<std::pmr::string>hash<std::pmr::wstring>hash<std::pmr::u32string>hash<std::pmr::u16string>hash<std::pmr::u8string> (C++20)(C++20)(C++20)(C++20)(C++20) Guías de deducción(C++17)

 

<tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody> <tbody class="t-dcl-rev t-dcl-rev-num "> </tbody><tbody> </tbody>

(1)

basic_string(); explicit basic_string( const Allocator& alloc );

(hasta C++17)

basic_string() noexcept(noexcept( Allocator() )) : basic_string( Allocator() ) {} explicit basic_string( const Allocator& alloc ) noexcept;

(desde C++17) (hasta C++20)

constexpr basic_string() noexcept(noexcept( Allocator() )) : basic_string( Allocator() ) {} explicit constexpr basic_string( const Allocator& alloc ) noexcept;

(desde C++20)

(2)

basic_string( size_type count, CharT ch, const Allocator& alloc = Allocator() );

(hasta C++20)

constexpr basic_string( size_type count, CharT ch, const Allocator& alloc = Allocator() );

(desde C++20)

(3)

basic_string( const basic_string& other, size_type pos, size_type count = std::basic_string::npos, const Allocator& alloc = Allocator() );

(hasta C++17)

basic_string( const basic_string& other, size_type pos, const Allocator& alloc = Allocator() );

(desde C++17) (hasta C++20)

constexpr basic_string( const basic_string& other, size_type pos, const Allocator& alloc = Allocator() );

(desde C++20)

(3)

basic_string( const basic_string& other, size_type pos, size_type count, const Allocator& alloc = Allocator() );

(desde C++17) (hasta C++20)

constexpr basic_string( const basic_string& other, size_type pos, size_type count, const Allocator& alloc = Allocator() );

(desde C++20)

(4)

basic_string( const CharT* s, size_type count, const Allocator& alloc = Allocator() );

(hasta C++20)

constexpr basic_string( const CharT* s, size_type count, const Allocator& alloc = Allocator() );

(desde C++20)

(5)

basic_string( const CharT* s, const Allocator& alloc = Allocator() );

(hasta C++20)

constexpr basic_string( const CharT* s, const Allocator& alloc = Allocator() );

(desde C++20)

(6)

template< class InputIt > basic_string( InputIt first, InputIt last, const Allocator& alloc = Allocator() );

(hasta C++20)

template< class InputIt > constexpr basic_string( InputIt first, InputIt last, const Allocator& alloc = Allocator() );

(desde C++20)

(7)

basic_string( const basic_string& other );

(hasta C++20)

constexpr basic_string( const basic_string& other );

(desde C++20)

(7)

basic_string( const basic_string& other, const Allocator& alloc );

(desde C++11) (hasta C++20)

constexpr basic_string( const basic_string& other, const Allocator& alloc );

(desde C++20)

(8)

basic_string( basic_string&& other ) noexcept;

(desde C++11) (hasta C++20)

constexpr basic_string( basic_string&& other ) noexcept;

(desde C++20)

(8)

basic_string( basic_string&& other, const Allocator& alloc );

(desde C++11) (hasta C++20)

constexpr basic_string( basic_string&& other, const Allocator& alloc );

(desde C++20)

(9)

basic_string( std::initializer_list<CharT> ilist, const Allocator& alloc = Allocator() );

(desde C++11) (hasta C++20)

constexpr basic_string( std::initializer_list<CharT> ilist, const Allocator& alloc = Allocator() );

(desde C++20)

(10)

template < class T > explicit basic_string( const T& t, const Allocator& alloc = Allocator() );

(desde C++17) (hasta C++20)

template < class T > explicit constexpr basic_string( const T& t, const Allocator& alloc = Allocator() );

(desde C++20)

(11)

template < class T > basic_string( const T& t, size_type pos, size_type n, const Allocator& alloc = Allocator() );

(desde C++17) (hasta C++20)

template < class T > constexpr basic_string( const T& t, size_type pos, size_type n, const Allocator& alloc = Allocator() );

(desde C++20)

See More

Construye nueva cadena a partir de una variedad de fuentes de datos y opcionalmente utilizando un asignador alloc proporcionado por el usuario.

1) Constructor por defecto. Construye una cadena vacía (de tamaño cero y capacidad no especificada). Si no se proporciona un asignador, el asignador se obtiene de una instancia construida por defecto.

2) Construye la cadena con count copias del carácter ch. Este constructor no se usa para la deducción de argumentos de plantillas de clase si el tipo de Allocator que se deduciría no califica como un asignador. (desde C++17)

3) Construye la cadena con una subcadena [pos, pos+count) de other. Si count == npos, y count no se especifica, o si la subcadena solicitada va más allá del final de la cadena, la subcadena resultante es {tt|[pos, other.size())}}.

4) Construye la cadena con los primeros count caracteres de la cadena de caracteres apuntada por s. s puede contener caracteres nulos. La longitud de la cadena es count. El comportamiento es indefinido si [s, s + count) no es un rango válido.

5) Construye la cadena con el contenido inicializado con una copia de la cadena de caracteres terminada en nulo señalada por s. La longitud de la cadena está determinada por el primer carácter nulo. El comportamiento no está definido si [s, s + Traits::length(s)) no es un rango válido (por ejemplo, si s es un puntero nulo). Este constructor no se usa para la deducción de argumentos de plantillas de clase si el tipo Allocator que se deduciría no califica como un asignador. (desde C++17)

6) Construye la cadena con el contenido del rango [first, last).

Si InputIt es un tipo entero, equivalente a la sobrecarga (2), como si fuera por basic_string(static_cast<size_type>(first), static_cast<value_type>(last), alloc)	(hasta C++11)
Este constructor participa en la resolución de sobrecarga si InputIt satisface a InputIterator.	(desde C++11)

7) Constructor de copia. Construye la cadena con una copia del contenido de other.

8) Constructor de movimiento. Construye la cadena con el contenido de other utilizando semántica de movimiento. other se deja en un estado válido pero no especificado.

9) Construye la cadena con el contenido de la lista de inicializadores ilist.

10) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces inicializa la cadena con el contenido de sv, como si fuera mediante basic_string(sv.data(), sv.size(), alloc). Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_convertible_v<const T&, std::basic_string_view<CharT, Traits>> es true y std::is_convertible_v<const T&, const CharT*> es false..

11) Implícitamente convierte t a una vista sobre cadena sv como si fuera mediante std::basic_string_view<CharT, Traits> sv = t;, entonces inicializa la cadena con el subrango [pos, pos + n) de sv como si fuera mediante basic_string(sv.substr(pos, n), alloc). Esta sobrecarga solo participa en la resolución de sobrecargas si std::is_convertible_v<const T&, std::basic_string_view<CharT, Traits>> es true .

Parámetros

alloc	-	Asignador a usar para todas las asignaciones de memoria de esta cadena.
count	-	Tamaño de la cadena resultante.
ch	-	Valor con el cual inicializar la cadena.
first, last	-	Rango del cual copiar los caracteres.
s	-	Puntero a una cadena de caracteres a usar como fuente para inicializar la cadena.
other	-	Otra cadena que se utiliza como fuente para inicializar la cadena.
ilist	-	std::initializer_list con la cual inicializar la cadena.
t	-	Objeto (convertible a std::basic_string_view) con el cual inicializar la cadena.

Complejidad

1) Constante

2-4) Lineal en count

5) Lineal en la longitud de s

6) Lineal en la distancia entre first y last

7) Lineal en el tamaño de other

8) constant. Si se da alloc y alloc != other.get_allocator(), entonces lineal

9) Lineal en el tamaño de ilist

Excepciones

3) std::out_of_range si pos > other.size()

8) No lanza nada si alloc == str.get_allocator()

11) std::out_of_range si pos está fuera de rango

Lanza std::length_error si la longitud de la cadena construida excediera max_size() (p. ej., si count > max_size() para (2)). Llamadas a Allocator::allocate pueden lanzar.

Notas

La inicialización con un literal de cadena que contiene caracteres '\0' incrustados utilizan la sobrecarga (5), que se detiene en el primer carácter nulo. Esto se puede evitar especificando un constructor diferente o usando el operador de literal operator""s:

std::string s1 = "ab\0\0cd";   // s1 contiene "ab"
std::string s2{"ab\0\0cd", 6}; // s2 contiene "ab\0\0cd"
std::string s3 = "ab\0\0cd"s;  // s3 contiene "ab\0\0cd"

Ejemplo

Ejecuta este código

#include <iostream>
#include <cassert>
#include <iterator>
#include <string>
#include <cctype>

int main()
{
  {
    // string::string()
    std::string s;
    assert(s.empty() && (s.length() == 0) && (s.size() == 0));
  }

  {
    // string::string(size_type count, charT ch)
    std::string s(4, '=');
    std::cout << s << '\n'; // "===="
  }

  {
    std::string const other("Exemplary");
    // string::string(string const& other, size_type pos, size_type count)
    std::string s(other, 0, other.length()-1);
    std::cout << s << '\n'; // "Exemplar"
  }

  {
    // string::string(charT const* s, size_type count)
    std::string s("C-style string", 7);
    std::cout << s << '\n'; // "C-style"
  }

  {
    // string::string(charT const* s)
    std::string s("C-style\0string");
    std::cout << s << '\n'; // "C-style"
  }

  {
    char mutable_c_str[] = "another C-style string";
    // string::string(InputIt first, InputIt last)
    std::string s(std::begin(mutable_c_str)+8, std::end(mutable_c_str)-1);
    std::cout << s << '\n'; // "C-style string"
  }

  {
    std::string const other("Exemplar");
    std::string s(other);
    std::cout << s << '\n'; // "Exemplar"
  }

  {
    // string::string(string&& str)
    std::string s(std::string("C++ by ") + std::string("example"));
    std::cout << s << '\n'; // "C++ by example"
  }

  {
    // string(std::initializer_list<charT> ilist)
    std::string s({ 'C', '-', 's', 't', 'y', 'l', 'e' });
    std::cout << s << '\n'; // "C-style"
  }

  {
    // la resolución de sobrecarga selecciona
    // string(InputIt first, InputIt last) [con InputIt = int]
    // que se comporta como si se llamara a string(size_type count, charT ch)
    std::string s(3, std::toupper('a'));
    std::cout << s << '\n'; // "AAA"
  }
}

Salida:

====
Exemplar
C-style
C-style
C-style string
Exemplar
C++ by example
C-style
AAA

Informes de defectos

Los siguientes informes de defectos de cambio de comportamiento se aplicaron de manera retroactiva a los estándares de C++ publicados anteriormente.

ID	Aplicado a	Comportamiento según lo publicado	Comportamiento correcto
LWG 2193	C++11	El constructor por defecto es explicit.	Se hizo no explicit.
LWG 2946	C++17	La sobrecarga para string_view causa ambigüedad en algunos casos.	Se evitó haciéndola una plantilla.
LWG 3076	C++17	Dos constructores pueden causar ambigüedad en la deducción de argumentos de plantillas de clase.	Restringido.

Véase también

assign	Asigna caracteres a una cadena (función miembro pública)
operator=	Asigna valores a la cadena (función miembro pública)
to_string (C++11)	Convierte un valor de punto flotante o entero a una cadena string. (función)
to_wstring (C++11)	Convierte un valor de punto flotante o entero a una cadena wstring. (función)