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() );

Construit une nouvelle chaîne à partir d'une variété de sources de données et éventuellement en utilisant un allocateur fourni par l'utilisateur alloc.

Paramètres

Complexité

Exceptions

Lance std::length_error si la longueur de la chaîne construite dépasse max_size() (par exemple, si count > max_size ( ) pour (3) ). Les appels à Allocator::allocate peuvent lancer des exceptions.

Si une exception est levée pour quelque raison que ce soit, ces fonctions n'ont aucun effet ( strong exception safety guarantee ).

Notes

Initialisation avec un littéral de chaîne qui contient des caractères ' \0 ' intégrés utilise la surcharge (7) , qui s'arrête au premier caractère nul. Ceci peut être évité en spécifiant un constructeur différent ou en utilisant operator""s :

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

Exemple

#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'; // non spécifié
    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[] = "another C-style string";
    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("Chaîne de style C", 7);
    std::cout << std::quoted(s6) << '\n'; // Style C, c'est-à-dire [0, 7)
    std::cout << "7)  string(CharT const* s): ";
    std::string s7("Chaîne de style C\0");
    std::cout << std::quoted(s7) << '\n'; // "Style C"
    std::cout << "11) string(string&): ";
    std::string const other11("Exemplaire");
    std::string s11(other11);
    std::cout << std::quoted(s11) << '\n'; // "Exemplaire"
    std::cout << "12) string(string&&): ";
    std::string s12(std::string("C++ par ") + std::string("exemple"));
    std::cout << std::quoted(s12) << '\n'; // "C++ par l'exemple"
    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", c'est-à-dire [8, 16)
    std::cout << "17) string(const string& other, size_type pos, size_type count): ";
    std::string const other17("Exemplaire");
    std::string s17(other17, 0, other17.length() - 1);
    std::cout << std::quoted(s17) << '\n'; // "Exemplaire"
    std::cout << "19) string(std::initializer_list<CharT>): ";
    std::string s19({'C', '-', 's', 't', 'y', 'l', 'e'});
    std::cout << std::quoted(s19) << '\n'; // "Style C"
}

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"

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

1. ↑ [ nullptr , nullptr + 0 ) constitue une plage vide valide, car l'ajout de zéro à une valeur de pointeur nul est également bien défini (le résultat reste une valeur de pointeur nul).

Voir aussi