std::basic_string

template<
    class CharT,
    class Traits = std::char_traits<CharT>,
    class Allocator = std::allocator<CharT>
> class basic_string;

namespace pmr {
template<
    class CharT,
    class Traits = std::char_traits<CharT>
> using basic_string =
    std::basic_string<CharT, Traits, std::pmr::polymorphic_allocator<CharT>>;
}

La plantilla de clase basic_string almacena y manipula secuencias de objetos tipo carácter, que son objetos que no son arreglos de TrivialType y StandardLayoutType. La clase no depende ni del tipo de carácter ni de la naturaleza de las operaciones sobre ese tipo. Las definiciones de las operaciones se proporcionan a través del parámetro de plantilla Traits: una especialización de std::char_traits o una clase de rasgos compatible.

Los elementos de un basic_string se almacenan de forma contigua, es decir, para un basic_string s, &*(s.begin() + n) == &*s.begin() + n para cualquier n en [0, s.size()), y *(s.begin() + s.size()) tiene el valor CharT() (un terminador nulo)(desde C++11); o, de manera equivalente, un puntero a s[0] se puede pasar a funciones que esperan un puntero al primer elemento de un arreglo(hasta C++11)un arreglo terminado en nulo(desde C++11) de CharT.

std::basic_string satisface los requisitos de AllocatorAwareContainer (excepto que las construct/destroy personalizadas no se utilizan para la construcción/destrucción de elementos), SequenceContainer y ContiguousContainer(desde C++17).

Si alguno de Traits::char_type y Allocator::char_type es diferente de CharT, el programa está mal formado.

Se proporcionan varias definiciones de tipos (typedefs) para tipos de caracteres comunes:

Parámetros de plantilla

Tipos anidados

Miembros de datos

Funciones miembro

Funciones no miembro

Literales

Clases auxiliares

Guías de deducción (desde C++17)

Invalidación de iteradores

Las referencias, punteros e iteradores que hacen referencia a los elementos de un basic_string pueden ser invalidados por cualquier función de la biblioteca estándar que tome una referencia a un basic_string no constante como argumento, como std::getline , std::swap , o operator>> , y al llamar a funciones miembro no constantes, excepto operator[] , at , data , front , back , begin , rbegin , end , y rend .

Notas

Aunque se requería que se utilizaran construct o destroy personalizados al construir o destruir elementos de std::basic_string hasta C++23, todas las implementaciones solo utilizaron el mecanismo predeterminado. El requisito se corrigió mediante P1072R10 para ajustarse a la práctica existente.

Ejemplo

#include <iostream>
#include <string>
int main()
{
    using namespace std::literals;
    // Creando un string desde const char*
    std::string str1 = "hello";
    // Creando un string usando literal de cadena
    auto str2 = "world"s;
    // Concatenando strings
    std::string str3 = str1 + " " + str2;
    // Imprimir el resultado
    std::cout << str3 << '\n';
    std::string::size_type pos = str3.find(" ");
    str1 = str3.substr(pos + 1); // la parte después del espacio
    str2 = str3.substr(0, pos);  // la parte hasta el espacio
    std::cout << str1 << ' ' << str2 << '\n';
    // Accediendo a un elemento usando el operador subíndice[]
    std::cout << str1[0] << '\n';
    str1[0] = 'W';
    std::cout << str1 << '\n';
}

hello world
world hello
w
World

Informes de defectos

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

1. ↑ El caso de Traits::char_type está corregido en P1148R0 .

Véase también

Enlaces externos