std::basic_string<CharT,Traits,Allocator>::basic_string

basic_string() : basic_string(Allocator()) {}

basic_string() noexcept(noexcept(Allocator()))
    : basic_string(Allocator()) {}

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

explicit basic_string( const Allocator& alloc );

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

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

template< container-compatible-range<CharT> R >
constexpr basic_string( std::from_range_t, R&& rg,
                        const Allocator& = Allocator());

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

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

basic_string( std::nullptr_t ) = delete;

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

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

basic_string( const basic_string& other );

basic_string( basic_string&& other ) noexcept;

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

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

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

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

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

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

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

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

Parámetros

Complejidad

Excepciones

Lanza std::length_error si la longitud de la cadena construida excediera max_size() (por ejemplo, si count > max_size ( ) para (3) ). Las llamadas a Allocator::allocate pueden lanzar excepciones.

Si se lanza una excepción por cualquier motivo, estas funciones no tienen efecto ( strong exception safety guarantee ).

Notas

Inicialización con un string literal que contiene caracteres ' \0 ' incrustados utiliza la sobrecarga (7) , que se detiene en el primer carácter nulo. Esto puede evitarse especificando un constructor diferente o utilizando 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

#include <cassert>
#include <cctype>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <string>
int main()
{
    std::cout << "1)  string(); ";
    std::string s1;
    assert(s1.empty() && (s1.length() == 0) && (s1.size() == 0));
    std::cout << "s1.capacity(): " << s1.capacity() << '\n'; // no especificado
    std::cout << "3)  string(size_type count, CharT ch): ";
    std::string s2(4, '=');
    std::cout << std::quoted(s2) << '\n'; // "===="
    std::cout << "4)  string(InputIt first, InputIt last): ";
    char mutable_c_str[] = "otra cadena de estilo C";
    std::string s4(std::begin(mutable_c_str) + 8, std::end(mutable_c_str) - 1);
    std::cout << std::quoted(s4) << '\n'; // "C-style string"
    std::cout << "6)  string(CharT const* s, size_type count): ";
    std::string s6("C-style string", 7);
    std::cout << std::quoted(s6) << '\n'; // "Estilo C", es decir, [0, 7)
    std::cout << "7)  string(CharT const* s): ";
    std::string s7("Cadena al estilo C\0");
    std::cout << std::quoted(s7) << '\n'; // "C-style"
    std::cout << "11) string(string&): ";
    std::string const other11("Ejemplar");
    std::string s11(other11);
    std::cout << std::quoted(s11) << '\n'; // "Exemplar"
    std::cout << "12) string(string&&): ";
    std::string s12(std::string("C++ por ") + std::string("ejemplo"));
    std::cout << std::quoted(s12) << '\n'; // "C++ by example"
    std::cout << "15) string(const string& other, size_type pos): ";
    std::string const other15("Mutatis Mutandis");
    std::string s15(other15, 8);
    std::cout << std::quoted(s15) << '\n'; // "Mutandis", es decir, [8, 16)
    std::cout << "17) string(const string& other, size_type pos, size_type count): ";
    std::string const other17("Ejemplar");
    std::string s17(other17, 0, other17.length() - 1);
    std::cout << std::quoted(s17) << '\n'; // "Exemplar"
    std::cout << "19) string(std::initializer_list<CharT>): ";
    std::string s19({'C', '-', 's', 't', 'y', 'l', 'e'});
    std::cout << std::quoted(s19) << '\n'; // "C-style"
}

1)  string(); s1.capacity(): 15
3)  string(size_type count, CharT ch): "===="
4)  string(InputIt first, InputIt last): "C-style string"
6)  string(CharT const* s, size_type count): "C-style"
7)  string(CharT const* s): "C-style"
11) string(string&): "Exemplar"
12) string(string&&): "C++ by example"
15) string(const string& other, size_type pos): "Mutandis"
17) string(const string& other, size_type pos, size_type count): "Exemplar"
19) string(std::initializer_list<CharT>): "C-style"

Informes de defectos

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

1. ↑ [ nullptr , nullptr + 0 ) es un rango vacío válido, porque sumar cero a un valor de puntero nulo también está bien definido (el resultado sigue siendo un valor de puntero nulo).

Véase también