[strings] (original) (raw)

27.4.1 General [string.classes.general]

The header <string> defines thebasic_string class template for manipulating varying-length sequences of char-like objects and fivetypedef-names, string,u8string,u16string,u32string, and wstring, that name the specializationsbasic_string<char>,basic_string<char8_t>,basic_string<char16_t>,basic_string<char32_t>, andbasic_string<​wchar_t>, respectively.

27.4.2 Header synopsis [string.syn]

#include <compare> #include <initializer_list> namespace std { template<class charT> struct char_traits; template<> struct char_traits<char>; template<> struct char_traits<char8_t>; template<> struct char_traits<char16_t>; template<> struct char_traits<char32_t>; template<> struct char_traits<wchar_t>; template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>> class basic_string;template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs,const basic_string<charT, traits, Allocator>& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs,const basic_string<charT, traits, Allocator>& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, basic_string<charT, traits, Allocator>&& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, basic_string<charT, traits, Allocator>&& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const charT* lhs,const basic_string<charT, traits, Allocator>& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(charT lhs,const basic_string<charT, traits, Allocator>& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(charT lhs, basic_string<charT, traits, Allocator>&& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs,const charT* rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs,const charT* rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, charT rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, type_identity_t<basic_string_view<charT, traits>> rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, type_identity_t<basic_string_view<charT, traits>> rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(type_identity_t<basic_string_view<charT, traits>> lhs,const basic_string<charT, traits, Allocator>& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(type_identity_t<basic_string_view<charT, traits>> lhs, basic_string<charT, traits, Allocator>&& rhs);template<class charT, class traits, class Allocator> constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,const basic_string<charT, traits, Allocator>& rhs) noexcept;template<class charT, class traits, class Allocator> constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,const charT* rhs);template<class charT, class traits, class Allocator> constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,const basic_string<charT, traits, Allocator>& rhs) noexcept;template<class charT, class traits, class Allocator> constexpr see below operator<=>(const basic_string<charT, traits, Allocator>& lhs,const charT* rhs);template<class charT, class traits, class Allocator> constexpr void swap(basic_string<charT, traits, Allocator>& lhs, basic_string<charT, traits, Allocator>& rhs) noexcept(noexcept(lhs.swap(rhs)));template<class charT, class traits, class Allocator> basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);template<class charT, class traits, class Allocator> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os,const basic_string<charT, traits, Allocator>& str);template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str, charT delim);template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>&& is, basic_string<charT, traits, Allocator>& str, charT delim);template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>&& is, basic_string<charT, traits, Allocator>& str);template<class charT, class traits, class Allocator, class U = charT> constexpr typename basic_string<charT, traits, Allocator>::size_type erase(basic_string<charT, traits, Allocator>& c, const U& value);template<class charT, class traits, class Allocator, class Predicate> constexpr typename basic_string<charT, traits, Allocator>::size_type erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);using string = basic_string<char>;using u8string = basic_string<char8_t>;using u16string = basic_string<char16_t>;using u32string = basic_string<char32_t>;using wstring = basic_string<wchar_t>;int stoi(const string& str, size_t* idx = nullptr, int base = 10);long stol(const string& str, size_t* idx = nullptr, int base = 10);unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);long long stoll(const string& str, size_t* idx = nullptr, int base = 10);unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);float stof(const string& str, size_t* idx = nullptr);double stod(const string& str, size_t* idx = nullptr);long double stold(const string& str, size_t* idx = nullptr); string to_string(int val); string to_string(unsigned val); string to_string(long val); string to_string(unsigned long val); string to_string(long long val); string to_string(unsigned long long val); string to_string(float val); string to_string(double val); string to_string(long double val);int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);long stol(const wstring& str, size_t* idx = nullptr, int base = 10);unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);float stof(const wstring& str, size_t* idx = nullptr);double stod(const wstring& str, size_t* idx = nullptr);long double stold(const wstring& str, size_t* idx = nullptr); wstring to_wstring(int val); wstring to_wstring(unsigned val); wstring to_wstring(long val); wstring to_wstring(unsigned long val); wstring to_wstring(long long val); wstring to_wstring(unsigned long long val); wstring to_wstring(float val); wstring to_wstring(double val); wstring to_wstring(long double val);namespace pmr { template<class charT, class traits = char_traits<charT>> using basic_string = std::basic_string<charT, traits, polymorphic_allocator<charT>>;using string = basic_string<char>;using u8string = basic_string<char8_t>;using u16string = basic_string<char16_t>;using u32string = basic_string<char32_t>;using wstring = basic_string<wchar_t>;} template<class T> struct hash;template<class A> struct hash<basic_string<char, char_traits<char>, A>>;template<class A> struct hash<basic_string<char8_t, char_traits<char8_t>, A>>;template<class A> struct hash<basic_string<char16_t, char_traits<char16_t>, A>>;template<class A> struct hash<basic_string<char32_t, char_traits<char32_t>, A>>;template<class A> struct hash<basic_string<wchar_t, char_traits<wchar_t>, A>>;inline namespace literals { inline namespace string_literals { constexpr string operator""s(const char* str, size_t len);constexpr u8string operator""s(const char8_t* str, size_t len);constexpr u16string operator""s(const char16_t* str, size_t len);constexpr u32string operator""s(const char32_t* str, size_t len);constexpr wstring operator""s(const wchar_t* str, size_t len);} } }

27.4.3 Class template basic_string [basic.string]

27.4.3.1 General [basic.string.general]

The class templatebasic_stringdescribes objects that can store a sequence consisting of a varying number of arbitrary char-like objects with the first element of the sequence at position zero.

Such a sequence is also called a “string” if the type of the char-like objects that it holds is clear from context.

In the rest of [basic.string], the type of the char-like objects held in a basic_string object is designated by charT.

In all cases, [data(), data() + size()] is a valid range,data() + size() points at an object with value charT()(a “null terminator”), and size() <= capacity() is true.

namespace std { template<class charT, class traits = char_traits<charT>,class Allocator = allocator<charT>> class basic_string { public: using traits_type = traits;using value_type = charT;using allocator_type = Allocator;using size_type = typename allocator_traits<Allocator>::size_type;using difference_type = typename allocator_traits<Allocator>::difference_type;using pointer = typename allocator_traits<Allocator>::pointer;using const_pointer = typename allocator_traits<Allocator>::const_pointer;using reference = value_type&;using const_reference = const value_type&;using iterator = implementation-defined; using const_iterator = implementation-defined; using reverse_iterator = std::reverse_iterator<iterator>;using const_reverse_iterator = std::reverse_iterator<const_iterator>;static constexpr size_type npos = size_type(-1);constexpr basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { } constexpr explicit basic_string(const Allocator& a) noexcept;constexpr basic_string(const basic_string& str);constexpr basic_string(basic_string&& str) noexcept;constexpr basic_string(const basic_string& str, size_type pos,const Allocator& a = Allocator());constexpr basic_string(const basic_string& str, size_type pos, size_type n,const Allocator& a = Allocator());constexpr basic_string(basic_string&& str, size_type pos,const Allocator& a = Allocator());constexpr basic_string(basic_string&& str, size_type pos, size_type n,const Allocator& a = Allocator());template<class T> constexpr basic_string(const T& t, size_type pos, size_type n,const Allocator& a = Allocator());template<class T> constexpr explicit basic_string(const T& t, const Allocator& a = Allocator());constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());constexpr basic_string(const charT* s, const Allocator& a = Allocator()); basic_string(nullptr_t) = delete;constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());template<class InputIterator> constexpr basic_string(InputIterator begin, InputIterator end,const Allocator& a = Allocator());template<container-compatible-range<charT> R> constexpr basic_string(from_range_t, R&& rg, const Allocator& a = Allocator());constexpr basic_string(initializer_list<charT>, const Allocator& = Allocator());constexpr basic_string(const basic_string&, const Allocator&);constexpr basic_string(basic_string&&, const Allocator&);constexpr ~basic_string();constexpr basic_string& operator=(const basic_string& str);constexpr basic_string& operator=(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value || allocator_traits<Allocator>::is_always_equal::value);template<class T> constexpr basic_string& operator=(const T& t);constexpr basic_string& operator=(const charT* s); basic_string& operator=(nullptr_t) = delete;constexpr basic_string& operator=(charT c);constexpr basic_string& operator=(initializer_list<charT>);constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr reverse_iterator rbegin() noexcept;constexpr const_reverse_iterator rbegin() const noexcept;constexpr reverse_iterator rend() noexcept;constexpr const_reverse_iterator rend() const noexcept;constexpr const_iterator cbegin() const noexcept;constexpr const_iterator cend() const noexcept;constexpr const_reverse_iterator crbegin() const noexcept;constexpr const_reverse_iterator crend() const noexcept;constexpr size_type size() const noexcept;constexpr size_type length() const noexcept;constexpr size_type max_size() const noexcept;constexpr void resize(size_type n, charT c);constexpr void resize(size_type n);template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);constexpr size_type capacity() const noexcept;constexpr void reserve(size_type res_arg);constexpr void shrink_to_fit();constexpr void clear() noexcept;constexpr bool empty() const noexcept;constexpr const_reference operator[](size_type pos) const;constexpr reference operator[](size_type pos);constexpr const_reference at(size_type n) const;constexpr reference at(size_type n);constexpr const charT& front() const;constexpr charT& front();constexpr const charT& back() const;constexpr charT& back();constexpr basic_string& operator+=(const basic_string& str);template<class T> constexpr basic_string& operator+=(const T& t);constexpr basic_string& operator+=(const charT* s);constexpr basic_string& operator+=(charT c);constexpr basic_string& operator+=(initializer_list<charT>);constexpr basic_string& append(const basic_string& str);constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);template<class T> constexpr basic_string& append(const T& t);template<class T> constexpr basic_string& append(const T& t, size_type pos, size_type n = npos);constexpr basic_string& append(const charT* s, size_type n);constexpr basic_string& append(const charT* s);constexpr basic_string& append(size_type n, charT c);template<class InputIterator> constexpr basic_string& append(InputIterator first, InputIterator last);template<container-compatible-range<charT> R> constexpr basic_string& append_range(R&& rg);constexpr basic_string& append(initializer_list<charT>);constexpr void push_back(charT c);constexpr basic_string& assign(const basic_string& str);constexpr basic_string& assign(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value || allocator_traits<Allocator>::is_always_equal::value);constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);template<class T> constexpr basic_string& assign(const T& t);template<class T> constexpr basic_string& assign(const T& t, size_type pos, size_type n = npos);constexpr basic_string& assign(const charT* s, size_type n);constexpr basic_string& assign(const charT* s);constexpr basic_string& assign(size_type n, charT c);template<class InputIterator> constexpr basic_string& assign(InputIterator first, InputIterator last);template<container-compatible-range<charT> R> constexpr basic_string& assign_range(R&& rg);constexpr basic_string& assign(initializer_list<charT>);constexpr basic_string& insert(size_type pos, const basic_string& str);constexpr basic_string& insert(size_type pos1, const basic_string& str, size_type pos2, size_type n = npos);template<class T> constexpr basic_string& insert(size_type pos, const T& t);template<class T> constexpr basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n = npos);constexpr basic_string& insert(size_type pos, const charT* s, size_type n);constexpr basic_string& insert(size_type pos, const charT* s);constexpr basic_string& insert(size_type pos, size_type n, charT c);constexpr iterator insert(const_iterator p, charT c);constexpr iterator insert(const_iterator p, size_type n, charT c);template<class InputIterator> constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);template<container-compatible-range<charT> R> constexpr iterator insert_range(const_iterator p, R&& rg);constexpr iterator insert(const_iterator p, initializer_list<charT>);constexpr basic_string& erase(size_type pos = 0, size_type n = npos);constexpr iterator erase(const_iterator p);constexpr iterator erase(const_iterator first, const_iterator last);constexpr void pop_back();constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos);template<class T> constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);template<class T> constexpr basic_string& replace(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos);constexpr basic_string& replace(size_type pos, size_type n1, const charT* s, size_type n2);constexpr basic_string& replace(size_type pos, size_type n1, const charT* s);constexpr basic_string& replace(size_type pos, size_type n1, size_type n2, charT c);constexpr basic_string& replace(const_iterator i1, const_iterator i2,const basic_string& str);template<class T> constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);template<class InputIterator> constexpr basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);template<container-compatible-range<charT> R> constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);constexpr basic_string& replace(const_iterator, const_iterator, initializer_list<charT>);constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;constexpr void swap(basic_string& str) noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value || allocator_traits<Allocator>::is_always_equal::value);constexpr const charT* c_str() const noexcept;constexpr const charT* data() const noexcept;constexpr charT* data() noexcept;constexpr operator basic_string_view<charT, traits>() const noexcept;constexpr allocator_type get_allocator() const noexcept;template<class T> constexpr size_type find(const T& t, size_type pos = 0) const noexcept(see below);constexpr size_type find(const basic_string& str, 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 find(charT c, size_type pos = 0) const noexcept;template<class T> constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(see below);constexpr size_type rfind(const basic_string& str, 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 rfind(charT c, size_type pos = npos) const noexcept;template<class T> constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(see below);constexpr size_type find_first_of(const basic_string& str, 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_first_of(charT c, size_type pos = 0) const noexcept;template<class T> constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(see below);constexpr size_type find_last_of(const basic_string& str, 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_last_of(charT c, size_type pos = npos) const noexcept;template<class T> constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(see below);constexpr size_type find_first_not_of(const basic_string& str, 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_first_not_of(charT c, size_type pos = 0) const noexcept;template<class T> constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(see below);constexpr size_type find_last_not_of(const basic_string& str, 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;constexpr size_type find_last_not_of(charT c, size_type pos = npos) const noexcept;constexpr basic_string substr(size_type pos = 0, size_type n = npos) const &;constexpr basic_string substr(size_type pos = 0, size_type n = npos) &&;template<class T> constexpr int compare(const T& t) const noexcept(see below);template<class T> constexpr int compare(size_type pos1, size_type n1, const T& t) const;template<class T> constexpr int compare(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos) const;constexpr int compare(const basic_string& str) const noexcept;constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;constexpr int compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos) 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<charT, traits> 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<charT, traits> x) const noexcept;constexpr bool ends_with(charT x) const noexcept;constexpr bool ends_with(const charT* x) const;constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;constexpr bool contains(charT x) const noexcept;constexpr bool contains(const charT* x) const;};template<class InputIterator,class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> basic_string(InputIterator, InputIterator, Allocator = Allocator()) -> basic_string<typename iterator_traits<InputIterator>::value_type, char_traits<typename iterator_traits<InputIterator>::value_type>, Allocator>;template<ranges::input_range R,class Allocator = allocator<ranges::range_value_t<R>>> basic_string(from_range_t, R&&, Allocator = Allocator()) -> basic_string<ranges::range_value_t<R>, char_traits<ranges::range_value_t<R>>, Allocator>;template<class charT,class traits,class Allocator = allocator<charT>> explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator()) -> basic_string<charT, traits, Allocator>;template<class charT,class traits,class Allocator = allocator<charT>> basic_string(basic_string_view<charT, traits>,typename see below::size_type, typename see below::size_type,const Allocator& = Allocator()) -> basic_string<charT, traits, Allocator>;}

A size_type parameter type in a basic_string deduction guide refers to the size_type member type of the type deduced by the deduction guide.

27.4.3.2 General requirements [string.require]

If any operation would cause size() to exceed max_size(), that operation throws an exception object of type length_error.

If any member function or operator of basic_string throws an exception, that function or operator has no other effect on the basic_string object.

Every object of typebasic_string<charT, traits, Allocator> uses an object of typeAllocator to allocate and free storage for the contained charTobjects as needed.

In every specialization basic_string<charT, traits, Allocator>, the type traits shall meet the character traits requirements ([char.traits]).

[Note 1:

Every specialization basic_string<charT, traits, Allocator> is an allocator-aware container ([container.alloc.reqmts]), but does not use the allocator's construct and destroymember functions ([container.requirements.pre]).

The program is ill-formed ifAllocator​::​value_type is not the same type as charT.

— _end note_]

[Note 2:

The program is ill-formed if traits​::​char_typeis not the same type as charT.

— _end note_]

References, pointers, and iterators referring to the elements of abasic_string sequence may be invalidated by the following uses of that basic_string object:

27.4.3.3 Constructors and assignment operators [string.cons]

constexpr explicit basic_string(const Allocator& a) noexcept;

Postconditions: size() is equal to 0.

constexpr basic_string(const basic_string& str);constexpr basic_string(basic_string&& str) noexcept;

Effects: Constructs an object whose value is that of str prior to this call.

Remarks: In the second form, str is left in a valid but unspecified state.

constexpr basic_string(const basic_string& str, size_type pos,const Allocator& a = Allocator());constexpr basic_string(const basic_string& str, size_type pos, size_type n,const Allocator& a = Allocator());constexpr basic_string(basic_string&& str, size_type pos,const Allocator& a = Allocator());constexpr basic_string(basic_string&& str, size_type pos, size_type n,const Allocator& a = Allocator());

Let

Effects: Constructs an object whose initial value is the range [s.data() + pos, s.data() + rlen).

Throws: out_of_range if pos > s.size().

Remarks: For the overloads with a basic_string&& parameter,str is left in a valid but unspecified state.

Recommended practice: For the overloads with a basic_string&& parameter, implementations should avoid allocation if s.get_allocator() == a is true.

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

Constraints: is_convertible_v<const T&, basic_string_view<charT, traits>>is true.

Effects: Creates a variable, sv, as if by basic_string_view<charT, traits> sv = t;and then behaves the same as:basic_string(sv.substr(pos, n), a);

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

Constraints:

Effects: Creates a variable, sv, as if bybasic_string_view<charT, traits> sv = t; and then behaves the same as basic_string(sv.data(), sv.size(), a).

constexpr basic_string(const charT* s, size_type n, const Allocator& a = Allocator());

Preconditions: [s, s + n) is a valid range.

Effects: Constructs an object whose initial value is the range [s, s + n).

Postconditions: size() is equal to n, andtraits​::​compare(data(), s, n) is equal to 0.

constexpr basic_string(const charT* s, const Allocator& a = Allocator());

Constraints: Allocator is a type that qualifies as an allocator ([container.reqmts]).

[Note 1:

This affects class template argument deduction.

— _end note_]

Effects: Equivalent to: basic_string(s, traits​::​length(s), a).

constexpr basic_string(size_type n, charT c, const Allocator& a = Allocator());

Constraints: Allocator is a type that qualifies as an allocator ([container.reqmts]).

[Note 2:

This affects class template argument deduction.

— _end note_]

Effects: Constructs an object whose value consists of n copies of c.

template<class InputIterator> constexpr basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator());

Constraints: InputIterator is a type that qualifies as an input iterator ([container.reqmts]).

Effects: Constructs a string from the values in the range [begin, end), as specified in [sequence.reqmts].

Effects: Constructs a string from the values in the range rg, as specified in [sequence.reqmts].

constexpr basic_string(initializer_list<charT> il, const Allocator& a = Allocator());

Effects: Equivalent to basic_string(il.begin(), il.end(), a).

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

Effects: Constructs an object whose value is that of str prior to this call.

The stored allocator is constructed from alloc.

In the second form, str is left in a valid but unspecified state.

Throws: The second form throws nothing if alloc == str.get_allocator().

template<class InputIterator,class Allocator = allocator<typename iterator_traits<InputIterator>::value_type>> basic_string(InputIterator, InputIterator, Allocator = Allocator()) -> basic_string<typename iterator_traits<InputIterator>::value_type, char_traits<typename iterator_traits<InputIterator>::value_type>, Allocator>;

Constraints: InputIterator is a type that qualifies as an input iterator, and Allocator is a type that qualifies as an allocator ([container.reqmts]).

template<class charT,class traits,class Allocator = allocator<charT>> explicit basic_string(basic_string_view<charT, traits>, const Allocator& = Allocator()) -> basic_string<charT, traits, Allocator>;template<class charT,class traits,class Allocator = allocator<charT>> basic_string(basic_string_view<charT, traits>,typename _see below_::size_type, typename _see below_::size_type,const Allocator& = Allocator()) -> basic_string<charT, traits, Allocator>;

constexpr basic_string& operator=(const basic_string& str);

Effects: If *this and str are the same object, has no effect.

Otherwise, replaces the value of *this with a copy of str.

constexpr basic_string& operator=(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value || allocator_traits<Allocator>::is_always_equal::value);

Effects: Move assigns as a sequence container ([sequence.reqmts]), except that iterators, pointers and references may be invalidated.

template<class T> constexpr basic_string& operator=(const T& t);

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return assign(sv);

constexpr basic_string& operator=(const charT* s);

Effects: Equivalent to:return *this = basic_string_view<charT, traits>(s);

constexpr basic_string& operator=(charT c);

Effects: Equivalent to:return *this = basic_string_view<charT, traits>(addressof(c), 1);

constexpr basic_string& operator=(initializer_list<charT> il);

Effects: Equivalent to:return *this = basic_string_view<charT, traits>(il.begin(), il.size());

27.4.3.4 Iterator support [string.iterators]

constexpr iterator begin() noexcept;constexpr const_iterator begin() const noexcept;constexpr const_iterator cbegin() const noexcept;

Returns: An iterator referring to the first character in the string.

constexpr iterator end() noexcept;constexpr const_iterator end() const noexcept;constexpr const_iterator cend() const noexcept;

Returns: An iterator which is the past-the-end value.

constexpr reverse_iterator rbegin() noexcept;constexpr const_reverse_iterator rbegin() const noexcept;constexpr const_reverse_iterator crbegin() const noexcept;

Returns: An iterator which is semantically equivalent toreverse_iterator(end()).

constexpr reverse_iterator rend() noexcept;constexpr const_reverse_iterator rend() const noexcept;constexpr const_reverse_iterator crend() const noexcept;

Returns: An iterator which is semantically equivalent toreverse_iterator(begin()).

27.4.3.5 Capacity [string.capacity]

constexpr size_type size() const noexcept;constexpr size_type length() const noexcept;

Returns: A count of the number of char-like objects currently in the string.

Complexity: Constant time.

constexpr size_type max_size() const noexcept;

Returns: The largest possible number of char-like objects that can be stored in abasic_string.

Complexity: Constant time.

constexpr void resize(size_type n, charT c);

Effects: Alters the value of*thisas follows:

constexpr void resize(size_type n);

Effects: Equivalent to resize(n, charT()).

template<class Operation> constexpr void resize_and_overwrite(size_type n, Operation op);

Let

Preconditions:

Effects: Evaluates OP, replaces the contents of *this with [p, p + r), and invalidates all pointers and references to the range [p, p + n].

Recommended practice: Implementations should avoid unnecessary copies and allocations by, for example, making p a pointer into internal storage and by restoring *(p + r) to charT() after evaluating OP.

constexpr size_type capacity() const noexcept;

Returns: The size of the allocated storage in the string.

Complexity: Constant time.

constexpr void reserve(size_type res_arg);

Effects: A directive that informs a basic_string of a planned change in size, so that the storage allocation can be managed accordingly.

Following a call toreserve,capacity()is greater or equal to the argument ofreserveif reallocation happens; and equal to the previous value ofcapacity()otherwise.

Reallocation happens at this point if and only if the current capacity is less than the argument of reserve.

Throws: length_errorifres_arg > max_size() or any exceptions thrown byallocator_traits <Allocator>​::​allocate.

constexpr void shrink_to_fit();

Effects: shrink_to_fit is a non-binding request to reducecapacity() to size().

[Note 1:

The request is non-binding to allow latitude for implementation-specific optimizations.

— _end note_]

It does not increase capacity(), but may reduce capacity()by causing reallocation.

Complexity: If the size is not equal to the old capacity, linear in the size of the sequence; otherwise constant.

Remarks: Reallocation invalidates all the references, pointers, and iterators referring to the elements in the sequence, as well as the past-the-end iterator.

[Note 2:

If no reallocation happens, they remain valid.

— _end note_]

constexpr void clear() noexcept;

Effects: Equivalent to: erase(begin(), end());

constexpr bool empty() const noexcept;

Effects: Equivalent to:return size() == 0;

27.4.3.6 Element access [string.access]

constexpr const_reference operator[](size_type pos) const;constexpr reference operator[](size_type pos);

Hardened preconditions: pos <= size() is true.

Returns: *(begin() + pos) if pos < size().

Otherwise, returns a reference to an object of type charT with valuecharT(), where modifying the object to any value other thancharT() leads to undefined behavior.

Complexity: Constant time.

constexpr const_reference at(size_type pos) const;constexpr reference at(size_type pos);

Returns: operator[](pos).

Throws: out_of_rangeifpos >= size().

constexpr const charT& front() const;constexpr charT& front();

Hardened preconditions: empty() is false.

Effects: Equivalent to: return operator[](0);

constexpr const charT& back() const;constexpr charT& back();

Hardened preconditions: empty() is false.

Effects: Equivalent to: return operator[](size() - 1);

27.4.3.7 Modifiers [string.modifiers]

27.4.3.7.1 basic_string​::​operator+= [string.op.append]

constexpr basic_string& operator+=(const basic_string& str);

Effects: Equivalent to: return append(str);

template<class T> constexpr basic_string& operator+=(const T& t);

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return append(sv);

constexpr basic_string& operator+=(const charT* s);

Effects: Equivalent to: return append(s);

constexpr basic_string& operator+=(charT c);

Effects: Equivalent to: return append(size_type{1}, c);

constexpr basic_string& operator+=(initializer_list<charT> il);

Effects: Equivalent to: return append(il);

27.4.3.7.2 basic_string​::​append [string.append]

constexpr basic_string& append(const basic_string& str);

Effects: Equivalent to: return append(str.data(), str.size());

constexpr basic_string& append(const basic_string& str, size_type pos, size_type n = npos);

Effects: Equivalent to:return append(basic_string_view<charT, traits>(str).substr(pos, n));

template<class T> constexpr basic_string& append(const T& t);

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return append(sv.data(), sv.size());

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

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return append(sv.substr(pos, n));

constexpr basic_string& append(const charT* s, size_type n);

Preconditions: [s, s + n) is a valid range.

Effects: Appends a copy of the range [s, s + n) to the string.

constexpr basic_string& append(const charT* s);

Effects: Equivalent to: return append(s, traits​::​length(s));

constexpr basic_string& append(size_type n, charT c);

Effects: Appends n copies of c to the string.

template<class InputIterator> constexpr basic_string& append(InputIterator first, InputIterator last);

Constraints: InputIterator is a type that qualifies as an input iterator ([container.reqmts]).

Effects: Equivalent to: return append(basic_string(first, last, get_allocator()));

Effects: Equivalent to: return append(basic_string(from_range, std​::​forward<R>(rg), get_allocator()));

constexpr basic_string& append(initializer_list<charT> il);

Effects: Equivalent to: return append(il.begin(), il.size());

constexpr void push_back(charT c);

Effects: Equivalent toappend(size_type{1}, c).

27.4.3.7.3 basic_string​::​assign [string.assign]

constexpr basic_string& assign(const basic_string& str);

Effects: Equivalent to: return *this = str;

constexpr basic_string& assign(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value || allocator_traits<Allocator>::is_always_equal::value);

Effects: Equivalent to: return *this = std​::​move(str);

constexpr basic_string& assign(const basic_string& str, size_type pos, size_type n = npos);

Effects: Equivalent to:return assign(basic_string_view<charT, traits>(str).substr(pos, n));

template<class T> constexpr basic_string& assign(const T& t);

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return assign(sv.data(), sv.size());

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

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return assign(sv.substr(pos, n));

constexpr basic_string& assign(const charT* s, size_type n);

Preconditions: [s, s + n) is a valid range.

Effects: Replaces the string controlled by *this with a copy of the range [s, s + n).

constexpr basic_string& assign(const charT* s);

Effects: Equivalent to: return assign(s, traits​::​length(s));

constexpr basic_string& assign(initializer_list<charT> il);

Effects: Equivalent to: return assign(il.begin(), il.size());

constexpr basic_string& assign(size_type n, charT c);

Effects: Equivalent to:clear(); resize(n, c);return *this;

template<class InputIterator> constexpr basic_string& assign(InputIterator first, InputIterator last);

Constraints: InputIterator is a type that qualifies as an input iterator ([container.reqmts]).

Effects: Equivalent to: return assign(basic_string(first, last, get_allocator()));

Effects: Equivalent to: return assign(basic_string(from_range, std​::​forward<R>(rg), get_allocator()));

27.4.3.7.4 basic_string​::​insert [string.insert]

constexpr basic_string& insert(size_type pos, const basic_string& str);

Effects: Equivalent to: return insert(pos, str.data(), str.size());

constexpr basic_string& insert(size_type pos1, const basic_string& str, size_type pos2, size_type n = npos);

Effects: Equivalent to:return insert(pos1, basic_string_view<charT, traits>(str), pos2, n);

template<class T> constexpr basic_string& insert(size_type pos, const T& t);

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return insert(pos, sv.data(), sv.size());

template<class T> constexpr basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n = npos);

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return insert(pos1, sv.substr(pos2, n));

constexpr basic_string& insert(size_type pos, const charT* s, size_type n);

Preconditions: [s, s + n) is a valid range.

Effects: Inserts a copy of the range [s, s + n) immediately before the character at position pos if pos < size(), or otherwise at the end of the string.

Throws:

constexpr basic_string& insert(size_type pos, const charT* s);

Effects: Equivalent to: return insert(pos, s, traits​::​length(s));

constexpr basic_string& insert(size_type pos, size_type n, charT c);

Effects: Inserts n copies of c before the character at position posif pos < size(), or otherwise at the end of the string.

Throws:

constexpr iterator insert(const_iterator p, charT c);

Preconditions: p is a valid iterator on*this.

Effects: Inserts a copy of c at the position p.

Returns: An iterator which refers to the inserted character.

constexpr iterator insert(const_iterator p, size_type n, charT c);

Preconditions: p is a valid iterator on*this.

Effects: Inserts n copies of c at the position p.

Returns: An iterator which refers to the first inserted character, orp if n == 0.

template<class InputIterator> constexpr iterator insert(const_iterator p, InputIterator first, InputIterator last);

Constraints: InputIterator is a type that qualifies as an input iterator ([container.reqmts]).

Preconditions: p is a valid iterator on*this.

Effects: Equivalent toinsert(p - begin(), basic_string(first, last, get_allocator())).

Returns: An iterator which refers to the first inserted character, orp if first == last.

Preconditions: p is a valid iterator on *this.

Effects: Equivalent toinsert(p - begin(), basic_string(from_range, std​::​forward<R>(rg), get_allocator())).

Returns: An iterator which refers to the first inserted character, orp if rg is empty.

constexpr iterator insert(const_iterator p, initializer_list<charT> il);

Effects: Equivalent to: return insert(p, il.begin(), il.end());

27.4.3.7.5 basic_string​::​erase [string.erase]

constexpr basic_string& erase(size_type pos = 0, size_type n = npos);

Effects: Determines the effective length xlenof the string to be removed as the smaller of n andsize() - pos.

Removes the characters in the range [begin() + pos, begin() + pos + xlen).

Throws: out_of_rangeif pos > size().

constexpr iterator erase(const_iterator p);

Preconditions: p is a valid dereferenceable iterator on *this.

Effects: Removes the character referred to by p.

Returns: An iterator which points to the element immediately following p prior to the element being erased.

If no such element exists,end()is returned.

constexpr iterator erase(const_iterator first, const_iterator last);

Preconditions: first and last are valid iterators on*this.

[first, last) is a valid range.

Effects: Removes the characters in the range [first, last).

Returns: An iterator which points to the element pointed to by last prior to the other elements being erased.

If no such element exists,end()is returned.

constexpr void pop_back();

Hardened preconditions: empty() is false.

Effects: Equivalent to erase(end() - 1).

27.4.3.7.6 basic_string​::​replace [string.replace]

constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str);

Effects: Equivalent to: return replace(pos1, n1, str.data(), str.size());

constexpr basic_string& replace(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos);

Effects: Equivalent to:return replace(pos1, n1, basic_string_view<charT, traits>(str).substr(pos2, n2));

template<class T> constexpr basic_string& replace(size_type pos1, size_type n1, const T& t);

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return replace(pos1, n1, sv.data(), sv.size());

template<class T> constexpr basic_string& replace(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos);

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return replace(pos1, n1, sv.substr(pos2, n2));

constexpr basic_string& replace(size_type pos1, size_type n1, const charT* s, size_type n2);

Preconditions: [s, s + n2) is a valid range.

Effects: Determines the effective length xlen of the string to be removed as the smaller of n1 and size() - pos1.

Ifsize() - xlen >= max_size() - n2 throws length_error.

Otherwise, the function replaces the characters in the range [begin() + pos1, begin() + pos1 + xlen) with a copy of the range [s, s + n2).

Throws:

constexpr basic_string& replace(size_type pos, size_type n, const charT* s);

Effects: Equivalent to: return replace(pos, n, s, traits​::​length(s));

constexpr basic_string& replace(size_type pos1, size_type n1, size_type n2, charT c);

Effects: Determines the effective length xlen of the string to be removed as the smaller of n1 and size() - pos1.

Ifsize() - xlen >= max_size() - n2 throws length_error.

Otherwise, the function replaces the characters in the range [begin() + pos1, begin() + pos1 + xlen) with n2 copies of c.

Throws:

constexpr basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);

Effects: Equivalent to: return replace(i1, i2, basic_string_view<charT, traits>(str));

template<class T> constexpr basic_string& replace(const_iterator i1, const_iterator i2, const T& t);

Constraints:

Preconditions: [begin(), i1) and [i1, i2) are valid ranges.

Effects: Equivalent to:basic_string_view<charT, traits> sv = t;return replace(i1 - begin(), i2 - i1, sv.data(), sv.size());

constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n);

Effects: Equivalent to: return replace(i1, i2, basic_string_view<charT, traits>(s, n));

constexpr basic_string& replace(const_iterator i1, const_iterator i2, const charT* s);

Effects: Equivalent to: return replace(i1, i2, basic_string_view<charT, traits>(s));

constexpr basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c);

Preconditions: [begin(), i1) and [i1, i2) are valid ranges.

Effects: Equivalent to: return replace(i1 - begin(), i2 - i1, n, c);

template<class InputIterator> constexpr basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);

Constraints: InputIterator is a type that qualifies as an input iterator ([container.reqmts]).

Effects: Equivalent to: return replace(i1, i2, basic_string(j1, j2, get_allocator()));

template<[_container-compatible-range_](container.intro.reqmts#concept:container-compatible-range "23.2.2.1 Introduction [container.intro.reqmts]")<charT> R> constexpr basic_string& replace_with_range(const_iterator i1, const_iterator i2, R&& rg);

Effects: Equivalent to:return replace(i1, i2, basic_string(from_range, std::forward<R>(rg), get_allocator()));

constexpr basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<charT> il);

Effects: Equivalent to: return replace(i1, i2, il.begin(), il.size());

27.4.3.7.7 basic_string​::​copy [string.copy]

constexpr size_type copy(charT* s, size_type n, size_type pos = 0) const;

Effects: Equivalent to:return basic_string_view<charT, traits>(*this).copy(s, n, pos);

[Note 1:

This does not terminate s with a null object.

— _end note_]

27.4.3.7.8 basic_string​::​swap [string.swap]

constexpr void swap(basic_string& s) noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value || allocator_traits<Allocator>::is_always_equal::value);

Preconditions: allocator_traits<Allocator>​::​propagate_on_container_swap​::​value is trueorget_allocator() == s.get_allocator().

Postconditions: *thiscontains the same sequence of characters that was in s,s contains the same sequence of characters that was in*this.

Complexity: Constant time.

27.4.3.8 String operations [string.ops]

27.4.3.8.1 Accessors [string.accessors]

constexpr const charT* c_str() const noexcept;constexpr const charT* data() const noexcept;

Returns: A pointer p such that p + i == addressof(operator[](i)) for eachi in [0, size()].

Complexity: Constant time.

Remarks: The program shall not modify any of the values stored in the character array; otherwise, the behavior is undefined.

constexpr charT* data() noexcept;

Returns: A pointer p such that p + i == addressof(operator[](i)) for eachi in [0, size()].

Complexity: Constant time.

Remarks: The program shall not modify the value stored at p + size()to any value other than charT(); otherwise, the behavior is undefined.

constexpr operator basic_string_view<charT, traits>() const noexcept;

Effects: Equivalent to:return basic_string_view<charT, traits>(data(), size());

constexpr allocator_type get_allocator() const noexcept;

Returns: A copy of theAllocatorobject used to construct the string or, if that allocator has been replaced, a copy of the most recent replacement.

27.4.3.8.2 Searching [string.find]

Let F be one offind, rfind, find_first_of, find_last_of,find_first_not_of, and find_last_not_of.

template<class T> constexpr size_type find(const T& t, size_type pos = 0) const noexcept(_see below_);template<class T> constexpr size_type rfind(const T& t, size_type pos = npos) const noexcept(_see below_);template<class T> constexpr size_type find_first_of(const T& t, size_type pos = 0) const noexcept(_see below_);template<class T> constexpr size_type find_last_of(const T& t, size_type pos = npos) const noexcept(_see below_);template<class T> constexpr size_type find_first_not_of(const T& t, size_type pos = 0) const noexcept(_see below_);template<class T> constexpr size_type find_last_not_of(const T& t, size_type pos = npos) const noexcept(_see below_);

Constraints:

Effects: Let G be the name of the function.

Equivalent to:basic_string_view<charT, traits> s = *this, sv = t;return s.G(sv, pos);

Remarks: The exception specification is equivalent tois_nothrow_convertible_v<const T&, basic_string_view<charT, traits>>.

27.4.3.8.3 basic_string​::​substr [string.substr]

constexpr basic_string substr(size_type pos = 0, size_type n = npos) const &;

Effects: Equivalent to: return basic_string(*this, pos, n);

constexpr basic_string substr(size_type pos = 0, size_type n = npos) &&;

Effects: Equivalent to: return basic_string(std​::​move(*this), pos, n);

27.4.3.8.4 basic_string​::​compare [string.compare]

template<class T> constexpr int compare(const T& t) const noexcept(_see below_);

Constraints:

Effects: Equivalent to: return basic_string_view<charT, traits>(*this).compare(t);

Remarks: The exception specification is equivalent tois_nothrow_convertible_v<const T&, basic_string_view<charT, traits>>.

template<class T> constexpr int compare(size_type pos1, size_type n1, const T& t) const;

Constraints:

Effects: Equivalent to:return basic_string_view<charT, traits>(*this).substr(pos1, n1).compare(t);

template<class T> constexpr int compare(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos) const;

Constraints:

Effects: Equivalent to:basic_string_view<charT, traits> s = *this, sv = t;return s.substr(pos1, n1).compare(sv.substr(pos2, n2));

constexpr int compare(const basic_string& str) const noexcept;

Effects: Equivalent to:return compare(basic_string_view<charT, traits>(str));

constexpr int compare(size_type pos1, size_type n1, const basic_string& str) const;

Effects: Equivalent to:return compare(pos1, n1, basic_string_view<charT, traits>(str));

constexpr int compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos) const;

Effects: Equivalent to:return compare(pos1, n1, basic_string_view<charT, traits>(str), pos2, n2);

constexpr int compare(const charT* s) const;

Effects: Equivalent to:return compare(basic_string_view<charT, traits>(s));

constexpr int compare(size_type pos, size_type n1, const charT* s) const;

Effects: Equivalent to: return compare(pos, n1, basic_string_view<charT, traits>(s));

constexpr int compare(size_type pos, size_type n1, const charT* s, size_type n2) const;

Effects: Equivalent to: return compare(pos, n1, basic_string_view<charT, traits>(s, n2));

27.4.3.8.5 basic_string​::​starts_with [string.starts.with]

constexpr bool starts_with(basic_string_view<charT, traits> x) const noexcept;constexpr bool starts_with(charT x) const noexcept;constexpr bool starts_with(const charT* x) const;

Effects: Equivalent to:return basic_string_view<charT, traits>(data(), size()).starts_with(x);

27.4.3.8.6 basic_string​::​ends_with [string.ends.with]

constexpr bool ends_with(basic_string_view<charT, traits> x) const noexcept;constexpr bool ends_with(charT x) const noexcept;constexpr bool ends_with(const charT* x) const;

Effects: Equivalent to:return basic_string_view<charT, traits>(data(), size()).ends_with(x);

27.4.3.8.7 basic_string​::​contains [string.contains]

constexpr bool contains(basic_string_view<charT, traits> x) const noexcept;constexpr bool contains(charT x) const noexcept;constexpr bool contains(const charT* x) const;

Effects: Equivalent to:return basic_string_view<charT, traits>(data(), size()).contains(x);

27.4.4 Non-member functions [string.nonmembers]

27.4.4.1 operator+ [string.op.plus]

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs,const basic_string<charT, traits, Allocator>& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs);

Effects: Equivalent to:basic_string<charT, traits, Allocator> r = lhs; r.append(rhs);return r;

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs,const basic_string<charT, traits, Allocator>& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, const charT* rhs);

Effects: Equivalent to:lhs.append(rhs);return std::move(lhs);

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, basic_string<charT, traits, Allocator>&& rhs);

Effects: Equivalent to:lhs.append(rhs);return std::move(lhs);except that both lhs and rhsare left in valid but unspecified states.

[Note 1:

If lhs and rhs have equal allocators, the implementation can move from either.

— _end note_]

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, basic_string<charT, traits, Allocator>&& rhs);template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs);

Effects: Equivalent to:rhs.insert(0, lhs);return std::move(rhs);

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs);

Effects: Equivalent to:basic_string<charT, traits, Allocator> r = rhs; r.insert(0, lhs);return r;

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(charT lhs, const basic_string<charT, traits, Allocator>& rhs);

Effects: Equivalent to:basic_string<charT, traits, Allocator> r = rhs; r.insert(r.begin(), lhs);return r;

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(charT lhs, basic_string<charT, traits, Allocator>&& rhs);

Effects: Equivalent to:rhs.insert(rhs.begin(), lhs);return std::move(rhs);

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs);

Effects: Equivalent to:basic_string<charT, traits, Allocator> r = lhs; r.push_back(rhs);return r;

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, charT rhs);

Effects: Equivalent to:lhs.push_back(rhs);return std::move(lhs);

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, type_identity_t<basic_string_view<charT, traits>> rhs);

Equivalent to:basic_string<charT, traits, Allocator> r = lhs; r.append(rhs);return r;

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, type_identity_t<basic_string_view<charT, traits>> rhs);

Equivalent to:lhs.append(rhs);return std::move(lhs);

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(type_identity_t<basic_string_view<charT, traits>> lhs,const basic_string<charT, traits, Allocator>& rhs);

Equivalent to:basic_string<charT, traits, Allocator> r = rhs; r.insert(0, lhs);return r;

template<class charT, class traits, class Allocator> constexpr basic_string<charT, traits, Allocator> operator+(type_identity_t<basic_string_view<charT, traits>> lhs, basic_string<charT, traits, Allocator>&& rhs);

Equivalent to:rhs.insert(0, lhs);return std::move(rhs);

[Note 2:

Using a specialization of type_identity_t as a parameter type ensures that an object of type basic_string<charT, traits, Allocator>can be concatenated with an object of a type Thaving an implicit conversion tobasic_string_view<charT, traits> ([over.match.oper]).

— _end note_]

27.4.4.2 Non-member comparison operator functions [string.cmp]

template<class charT, class traits, class Allocator> constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,const basic_string<charT, traits, Allocator>& rhs) noexcept;template<class charT, class traits, class Allocator> constexpr bool operator==(const basic_string<charT, traits, Allocator>& lhs,const charT* rhs);template<class charT, class traits, class Allocator> constexpr _see below_ operator<=>(const basic_string<charT, traits, Allocator>& lhs,const basic_string<charT, traits, Allocator>& rhs) noexcept;template<class charT, class traits, class Allocator> constexpr _see below_ operator<=>(const basic_string<charT, traits, Allocator>& lhs,const charT* rhs);

Effects: Let op be the operator.

Equivalent to:return basic_string_view<charT, traits>(lhs) op basic_string_view<charT, traits>(rhs);

27.4.4.3 swap [string.special]

template<class charT, class traits, class Allocator> constexpr void swap(basic_string<charT, traits, Allocator>& lhs, basic_string<charT, traits, Allocator>& rhs) noexcept(noexcept(lhs.swap(rhs)));

Effects: Equivalent to lhs.swap(rhs).

27.4.4.4 Inserters and extractors [string.io]

template<class charT, class traits, class Allocator> basic_istream<charT, traits>& operator>>(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);

After constructing a sentry object, if the sentry object returns truewhen converted to a value of type bool, calls str.erase()and then extracts characters from is and appends them to str as if by callingstr.append(1, c).

Ifis.width()is greater than zero, the maximum number n of characters appended isis.width(); otherwise n isstr.max_size().

Characters are extracted and appended until any of the following occurs:

After the last character (if any) is extracted,is.width(0)is called and thesentryobject is destroyed.

If the function extracts no characters,ios_base​::​failbit is set in the input function's local error state before setstate is called.

template<class charT, class traits, class Allocator> basic_ostream<charT, traits>& operator<<(basic_ostream<charT, traits>& os,const basic_string<charT, traits, Allocator>& str);

Effects: Equivalent to: return os << basic_string_view<charT, traits>(str);

template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str, charT delim);template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>&& is, basic_string<charT, traits, Allocator>& str, charT delim);

Effects: Behaves as an unformatted input function ([istream.unformatted]), except that it does not affect the value returned by subsequent calls tobasic_istream<>​::​gcount().

After constructing a sentry object, if the sentry object returns truewhen converted to a value of type bool, calls str.erase()and then extracts characters from is and appends them to str as if by callingstr.append(1, c)until any of the following occurs:

The conditions are tested in the order shown.

In any case, after the last character is extracted, thesentryobject is destroyed.

If the function extracts no characters,ios_base​::​failbit is set in the input function's local error state before setstate is called.

template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>& is, basic_string<charT, traits, Allocator>& str);template<class charT, class traits, class Allocator> basic_istream<charT, traits>& getline(basic_istream<charT, traits>&& is, basic_string<charT, traits, Allocator>& str);

Returns: getline(is, str, is.widen('\n')).

27.4.4.5 Erasure [string.erasure]

template<class charT, class traits, class Allocator, class U = charT> constexpr typename basic_string<charT, traits, Allocator>::size_type erase(basic_string<charT, traits, Allocator>& c, const U& value);

Effects: Equivalent to:auto it = remove(c.begin(), c.end(), value);auto r = distance(it, c.end()); c.erase(it, c.end());return r;

template<class charT, class traits, class Allocator, class Predicate> constexpr typename basic_string<charT, traits, Allocator>::size_type erase_if(basic_string<charT, traits, Allocator>& c, Predicate pred);

Effects: Equivalent to:auto it = remove_if(c.begin(), c.end(), pred);auto r = distance(it, c.end()); c.erase(it, c.end());return r;

27.4.5 Numeric conversions [string.conversions]

int stoi(const string& str, size_t* idx = nullptr, int base = 10);long stol(const string& str, size_t* idx = nullptr, int base = 10);unsigned long stoul(const string& str, size_t* idx = nullptr, int base = 10);long long stoll(const string& str, size_t* idx = nullptr, int base = 10);unsigned long long stoull(const string& str, size_t* idx = nullptr, int base = 10);

Effects: The first two functions call strtol(str.c_str(), ptr, base), and the last three functions call strtoul(str.c_str(), ptr, base),strtoll(str.c_str(), ptr, base), and strtoull(​str.c_str(), ptr, base), respectively.

Each function returns the converted result, if any.

The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx.

If the function does not throw an exception and idx != nullptr, the function stores in *idxthe index of the first unconverted element of str.

Returns: The converted result.

Throws: invalid_argument if strtol, strtoul,strtoll, or strtoull reports that no conversion can be performed.

Throws out_of_range if strtol, strtoul,strtoll or strtoull sets errno to ERANGE, or if the converted value is outside the range of representable values for the return type.

float stof(const string& str, size_t* idx = nullptr);double stod(const string& str, size_t* idx = nullptr);long double stold(const string& str, size_t* idx = nullptr);

Effects: These functions callstrtof(str.c_str(), ptr), strtod(str.c_str(), ptr), andstrtold(​str.c_str(), ptr), respectively.

Each function returns the converted result, if any.

The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at*idx.

If the function does not throw an exception and idx != nullptr, the function stores in *idx the index of the first unconverted element of str.

Returns: The converted result.

Throws: invalid_argument if strtof, strtod, orstrtold reports that no conversion can be performed.

Throwsout_of_range if strtof, strtod, orstrtold sets errno to ERANGEor if the converted value is outside the range of representable values for the return type.

string to_string(int val); string to_string(unsigned val); string to_string(long val); string to_string(unsigned long val); string to_string(long long val); string to_string(unsigned long long val); string to_string(float val); string to_string(double val); string to_string(long double val);

Returns: format("{}", val).

int stoi(const wstring& str, size_t* idx = nullptr, int base = 10);long stol(const wstring& str, size_t* idx = nullptr, int base = 10);unsigned long stoul(const wstring& str, size_t* idx = nullptr, int base = 10);long long stoll(const wstring& str, size_t* idx = nullptr, int base = 10);unsigned long long stoull(const wstring& str, size_t* idx = nullptr, int base = 10);

Effects: The first two functions call wcstol(str.c_str(), ptr, base), and the last three functions call wcstoul(str.c_str(), ptr, base),wcstoll(str.c_str(), ptr, base), and wcstoull(​str.c_str(), ptr, base), respectively.

Each function returns the converted result, if any.

The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx.

If the function does not throw an exception and idx != nullptr, the function stores in *idxthe index of the first unconverted element of str.

Returns: The converted result.

Throws: invalid_argument if wcstol, wcstoul, wcstoll, orwcstoull reports that no conversion can be performed.

Throwsout_of_range if the converted value is outside the range of representable values for the return type.

float stof(const wstring& str, size_t* idx = nullptr);double stod(const wstring& str, size_t* idx = nullptr);long double stold(const wstring& str, size_t* idx = nullptr);

Effects: These functions call wcstof(str.c_str(), ptr),wcstod(str.c_str(), ptr), and wcstold(​str.c_str(), ptr), respectively.

Each function returns the converted result, if any.

The argument ptr designates a pointer to an object internal to the function that is used to determine what to store at *idx.

If the function does not throw an exception and idx != nullptr, the function stores in *idxthe index of the first unconverted element of str.

Returns: The converted result.

Throws: invalid_argument if wcstof, wcstod, or wcstold reports that no conversion can be performed.

Throws out_of_range if wcstof, wcstod, orwcstold sets errno to ERANGE.

wstring to_wstring(int val); wstring to_wstring(unsigned val); wstring to_wstring(long val); wstring to_wstring(unsigned long val); wstring to_wstring(long long val); wstring to_wstring(unsigned long long val); wstring to_wstring(float val); wstring to_wstring(double val); wstring to_wstring(long double val);

Returns: format(L"{}", val).

27.4.6 Hash support [basic.string.hash]

template<class A> struct hash<basic_string<char, char_traits<char>, A>>;template<class A> struct hash<basic_string<char8_t, char_traits<char8_t>, A>>;template<class A> struct hash<basic_string<char16_t, char_traits<char16_t>, A>>;template<class A> struct hash<basic_string<char32_t, char_traits<char32_t>, A>>;template<class A> struct hash<basic_string<wchar_t, char_traits<wchar_t>, A>>;

If S is one of these string types,SV is the corresponding string view type, ands is an object of type S, then hash<S>()(s) == hash<SV>()(SV(s)).

27.4.7 Suffix for basic_string literals [basic.string.literals]

constexpr string operator""s(const char* str, size_t len);

Returns: string{str, len}.

constexpr u8string operator""s(const char8_t* str, size_t len);

Returns: u8string{str, len}.

constexpr u16string operator""s(const char16_t* str, size_t len);

Returns: u16string{str, len}.

constexpr u32string operator""s(const char32_t* str, size_t len);

Returns: u32string{str, len}.

constexpr wstring operator""s(const wchar_t* str, size_t len);

Returns: wstring{str, len}.

[Note 1:

The same suffix s is used for chrono​::​duration literals denoting seconds but there is no conflict, since duration suffixes apply to numbers and string literal suffixes apply to character array literals.

— _end note_]