string
标准库标头<string>
此标头是弦图书馆。
包括
| (since C++11) |
|---|
班
| Name | Description |
|---|---|
| std::char_traits | Class Template which describes properties of a character type (class template) |
| std::char_traits<char> | (class template specialization) |
| std::char_traits<wchar_t> | (class template specialization) |
| std::char_traits<char16_t> (C++11) | (class template specialization) |
| std::char_traits<char32_t> (C++11) | (class template specialization) |
| std::basic_string | Class template representing a text string object (class template) |
| std::string | std::basic_string<char> (typedef) |
| std::wstring | std::basic_string<wchar_t> (typedef) |
| std::u16string (C++11) | std::basic_string<char16_t> (typedef) |
| std::u32string (C++11) | std::basic_string<char32_t> (typedef) |
| std::hash<std::string> (C++11) | (class template specialization) |
| std::hash<std::u16string> (C++11) | (class template specialization) |
| std::hash<std::u32string> (C++11) | (class template specialization) |
| std::hash<std::wstring> (C++11) | (class template specialization) |
功能
| operator+ | concatenates two strings or a string and a char (function template) |
|---|---|
| operator==operator!=operator<operator>operator<=operator>= | lexicographically compares two strings (function template) |
| std::swap(std::basic_string) | specializes the std::swap algorithm (function template) |
输入/输出
运算符<<operator>>对字符串%28函数模板%29执行流输入和输出
将I/O流中的数据读取到字符串%28函数模板%29中
数值转换
斯托斯特洛斯托尔%28C++11%29%28C++11%29%28C+11%29将字符串转换为有符号整数%28函数%29
stoulstoull%28C++11%29%28C++11%29将字符串转换为无符号整数%28函数%29
stofstodstold%28C++11%29%28C++11%29%28C+11%29将字符串转换为浮点值%28函数%29
到[医]字符串%28C++11%29将整数或浮点值转换为字符串%28函数%29
到[医]wstring%28C++11%29将整数或浮点值转换为wstring%28函数%29。
文字
定义在内联命名空间std：：alals：：string中[医]文字
*。
运算符“s%28C++14%29将字符数组文字转换为Basic[医]字符串%28功能%29
简介
二次
#include <initializer_list>
namespace std {
// character traits
template<class charT> struct char_traits;
template<> struct char_traits<char>;
template<> struct char_traits<char16_t>;
template<> struct char_traits<char32_t>;
template<> struct char_traits<wchar_t>;
// basic_string
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
class basic_string;
template<class charT, class traits, class Allocator>
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>
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>
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>
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>
basic_string<charT, traits, Allocator> operator+(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator> operator+(const charT* lhs, basic_string<charT, traits, Allocator>&& rhs
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator> operator+(charT lhs, const basic_string<charT, traits, Allocator>& rhs
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator> operator+(charT lhs, basic_string<charT, traits, Allocator>&& rhs
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs,
const charT* rhs
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator> operator+(const basic_string<charT, traits, Allocator>& lhs, charT rhs
template<class charT, class traits, class Allocator>
basic_string<charT, traits, Allocator> operator+(basic_string<charT, traits, Allocator>&& lhs, charT rhs
template<class charT, class traits, class Allocator>
bool operator==(const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator==(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs
template<class charT, class traits, class Allocator>
bool operator==(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs
template<class charT, class traits, class Allocator>
bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator!=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs
template<class charT, class traits, class Allocator>
bool operator!=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs
template<class charT, class traits, class Allocator>
bool operator< (const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator< (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs
template<class charT, class traits, class Allocator>
bool operator< (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs
template<class charT, class traits, class Allocator>
bool operator> (const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator> (const basic_string<charT, traits, Allocator>& lhs, const charT* rhs
template<class charT, class traits, class Allocator>
bool operator> (const charT* lhs, const basic_string<charT, traits, Allocator>& rhs
template<class charT, class traits, class Allocator>
bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator<=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs
template<class charT, class traits, class Allocator>
bool operator<=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs
template<class charT, class traits, class Allocator>
bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const basic_string<charT, traits, Allocator>& rhs) noexcept;
template<class charT, class traits, class Allocator>
bool operator>=(const basic_string<charT, traits, Allocator>& lhs, const charT* rhs
template<class charT, class traits, class Allocator>
bool operator>=(const charT* lhs, const basic_string<charT, traits, Allocator>& rhs
// swap
template<class charT, class traits, class Allocator>
void swap(basic_string<charT, traits, Allocator>& lhs, basic_string<charT, traits, Allocator>& rhs) noexcept(noexcept(lhs.swap(rhs))
// inserters and extractors
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
// basic_string typedef names
using string = basic_string<char>;
using u16string = basic_string<char16_t>;
using u32string = basic_string<char32_t>;
using wstring = basic_string<wchar_t>;
// numeric conversions
int stoi(const string& str, size_t* idx = 0, int base = 10
long stol(const string& str, size_t* idx = 0, int base = 10
unsigned long stoul(const string& str, size_t* idx = 0, int base = 10
long long stoll(const string& str, size_t* idx = 0, int base = 10
unsigned long long stoull(const string& str, size_t* idx = 0, int base = 10
float stof(const string& str, size_t* idx = 0
double stod(const string& str, size_t* idx = 0
long double stold(const string& str, size_t* idx = 0
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 = 0, int base = 10
long stol(const wstring& str, size_t* idx = 0, int base = 10
unsigned long stoul(const wstring& str, size_t* idx = 0, int base = 10
long long stoll(const wstring& str, size_t* idx = 0, int base = 10
unsigned long long stoull(const wstring& str, size_t* idx = 0, int base = 10
float stof(const wstring& str, size_t* idx = 0
double stod(const wstring& str, size_t* idx = 0
long double stold(const wstring& str, size_t* idx = 0
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
// hash support
template<class T> struct hash;
template<> struct hash<string>;
template<> struct hash<u16string>;
template<> struct hash<u32string>;
template<> struct hash<wstring>;
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 u16string = basic_string<char16_t>;
using u32string = basic_string<char32_t>;
using wstring = basic_string<wchar_t>;
}
inline namespace literals {
inline namespace string_literals {
// suffix for basic_string literals
string operator""s(const char* str, size_t len
u16string operator""s(const char16_t* str, size_t len
u32string operator""s(const char32_t* str, size_t len
wstring operator""s(const wchar_t* str, size_t len
}
}
}
二次
类模板std::char_traits
二次
namespace std {
template<> struct char_traits<char> {
using char_type = char;
using int_type = int;
using off_type = streamoff;
using pos_type = streampos;
using state_type = mbstate_t;
static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
static constexpr bool eq(char_type c1, char_type c2) noexcept;
static constexpr bool lt(char_type c1, char_type c2) noexcept;
static constexpr int compare(const char_type* s1, const char_type* s2, size_t n
static constexpr size_t length(const char_type* s
static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a
static char_type* move(char_type* s1, const char_type* s2, size_t n
static char_type* copy(char_type* s1, const char_type* s2, size_t n
static char_type* assign(char_type* s, size_t n, char_type a
static constexpr int_type not_eof(int_type c) noexcept;
static constexpr char_type to_char_type(int_type c) noexcept;
static constexpr int_type to_int_type(char_type c) noexcept;
static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
static constexpr int_type eof() noexcept;
};
template<> struct char_traits<char16_t> {
using char_type = char16_t;
using int_type = uint_least16_t;
using off_type = streamoff;
using pos_type = u16streampos;
using state_type = mbstate_t;
static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
static constexpr bool eq(char_type c1, char_type c2) noexcept;
static constexpr bool lt(char_type c1, char_type c2) noexcept;
static constexpr int compare(const char_type* s1, const char_type* s2, size_t n
static constexpr size_t length(const char_type* s
static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a
static char_type* move(char_type* s1, const char_type* s2, size_t n
static char_type* copy(char_type* s1, const char_type* s2, size_t n
static char_type* assign(char_type* s, size_t n, char_type a
static constexpr int_type not_eof(int_type c) noexcept;
static constexpr char_type to_char_type(int_type c) noexcept;
static constexpr int_type to_int_type(char_type c) noexcept;
static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
static constexpr int_type eof() noexcept;
};
template<> struct char_traits<char32_t> {
using char_type = char32_t;
using int_type = uint_least32_t;
using off_type = streamoff;
using pos_type = u32streampos;
using state_type = mbstate_t;
static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
static constexpr bool eq(char_type c1, char_type c2) noexcept;
static constexpr bool lt(char_type c1, char_type c2) noexcept;
static constexpr int compare(const char_type* s1, const char_type* s2, size_t n
static constexpr size_t length(const char_type* s
static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a
static char_type* move(char_type* s1, const char_type* s2, size_t n
static char_type* copy(char_type* s1, const char_type* s2, size_t n
static char_type* assign(char_type* s, size_t n, char_type a
static constexpr int_type not_eof(int_type c) noexcept;
static constexpr char_type to_char_type(int_type c) noexcept;
static constexpr int_type to_int_type(char_type c) noexcept;
static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
static constexpr int_type eof() noexcept;
};
template<> struct char_traits<wchar_t> {
using char_type = wchar_t;
using int_type = wint_t;
using off_type = streamoff;
using pos_type = wstreampos;
using state_type = mbstate_t;
static constexpr void assign(char_type& c1, const char_type& c2) noexcept;
static constexpr bool eq(char_type c1, char_type c2) noexcept;
static constexpr bool lt(char_type c1, char_type c2) noexcept;
static constexpr int compare(const char_type* s1, const char_type* s2, size_t n
static constexpr size_t length(const char_type* s
static constexpr const char_type* find(const char_type* s, size_t n, const char_type& a
static char_type* move(char_type* s1, const char_type* s2, size_t n
static char_type* copy(char_type* s1, const char_type* s2, size_t n
static char_type* assign(char_type* s, size_t n, char_type a
static constexpr int_type not_eof(int_type c) noexcept;
static constexpr char_type to_char_type(int_type c) noexcept;
static constexpr int_type to_int_type(char_type c) noexcept;
static constexpr bool eq_int_type(int_type c1, int_type c2) noexcept;
static constexpr int_type eof() noexcept;
};
}
二次
类模板std::basic_string
二次
namespace std {
template<class charT, class traits = char_traits<charT>, class Allocator = allocator<charT>>
class basic_string {
public:
// types:
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 = /* see definition */ ;
using const_iterator = /* see definition */ ;
using reverse_iterator = std::reverse_iterator<iterator>;
using const_reverse_iterator = std::reverse_iterator<const_iterator>;
static const size_type npos = -1;
// construct/copy/destroy
basic_string() noexcept(noexcept(Allocator())) : basic_string(Allocator()) { }
explicit basic_string(const Allocator& a) noexcept;
basic_string(const basic_string& str
basic_string(basic_string&& str) noexcept;
basic_string(const basic_string& str, size_type pos, const Allocator& a = Allocator()
basic_string(const basic_string& str, size_type pos, size_type n, const Allocator& a = Allocator()
template<class T>
basic_string(const T& t, size_type pos, size_type n, const Allocator& a = Allocator()
explicit basic_string(basic_string_view<charT, traits> sv, const Allocator& a = Allocator()
basic_string(const charT* s, size_type n, const Allocator& a = Allocator()
basic_string(const charT* s, const Allocator& a = Allocator()
basic_string(size_type n, charT c, const Allocator& a = Allocator()
template<class InputIterator>
basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator()
basic_string(initializer_list<charT>, const Allocator& = Allocator()
basic_string(const basic_string&, const Allocator&
basic_string(basic_string&&, const Allocator&
~basic_string(
basic_string& operator=(const basic_string& str
basic_string& operator=(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
allocator_traits<Allocator>::is_always_equal::value
basic_string& operator=(basic_string_view<charT, traits> sv
basic_string& operator=(const charT* s
basic_string& operator=(charT c
basic_string& operator=(initializer_list<charT>
// iterators
iterator begin() noexcept;
const_iterator begin() const noexcept;
iterator end() noexcept;
const_iterator end() const noexcept;
reverse_iterator rbegin() noexcept;
const_reverse_iterator rbegin() const noexcept;
reverse_iterator rend() noexcept;
const_reverse_iterator rend() const noexcept;
const_iterator cbegin() const noexcept;
const_iterator cend() const noexcept;
const_reverse_iterator crbegin() const noexcept;
const_reverse_iterator crend() const noexcept;
// capacity
size_type size() const noexcept;
size_type length() const noexcept;
size_type max_size() const noexcept;
void resize(size_type n, charT c
void resize(size_type n
size_type capacity() const noexcept;
void reserve(size_type res_arg = 0
void shrink_to_fit(
void clear() noexcept;
bool empty() const noexcept;
// element access
const_reference operator[](size_type pos) const;
reference operator[](size_type pos
const_reference at(size_type n) const;
reference at(size_type n
const charT& front() const;
charT& front(
const charT& back() const;
charT& back(
// modifiers
basic_string& operator+=(const basic_string& str
basic_string& operator+=(basic_string_view<charT, traits> sv
basic_string& operator+=(const charT* s
basic_string& operator+=(charT c
basic_string& operator+=(initializer_list<charT>
basic_string& append(const basic_string& str
basic_string& append(const basic_string& str, size_type pos, size_type n = npos
basic_string& append(basic_string_view<charT, traits> sv
template<class T>
basic_string& append(const T& t, size_type pos, size_type n = npos
basic_string& append(const charT* s, size_type n
basic_string& append(const charT* s
basic_string& append(size_type n, charT c
template<class InputIterator>
basic_string& append(InputIterator first, InputIterator last
basic_string& append(initializer_list<charT>
void push_back(charT c
basic_string& assign(const basic_string& str
basic_string& assign(basic_string&& str) noexcept(allocator_traits<Allocator>::propagate_on_container_move_assignment::value ||
allocator_traits<Allocator>::is_always_equal::value
basic_string& assign(const basic_string& str, size_type pos, size_type n = npos
basic_string& assign(basic_string_view<charT, traits> sv
template<class T>
basic_string& assign(const T& t, size_type pos, size_type n = npos
basic_string& assign(const charT* s, size_type n
basic_string& assign(const charT* s
basic_string& assign(size_type n, charT c
template<class InputIterator>
basic_string& assign(InputIterator first, InputIterator last
basic_string& assign(initializer_list<charT>
basic_string& insert(size_type pos, const basic_string& str
basic_string& insert(size_type pos1, const basic_string& str, size_type pos2, size_type n = npos
basic_string& insert(size_type pos, basic_string_view<charT, traits> sv
template<class T>
basic_string& insert(size_type pos1, const T& t, size_type pos2, size_type n = npos
basic_string& insert(size_type pos, const charT* s, size_type n
basic_string& insert(size_type pos, const charT* s
basic_string& insert(size_type pos, size_type n, charT c
iterator insert(const_iterator p, charT c
iterator insert(const_iterator p, size_type n, charT c
template<class InputIterator>
iterator insert(const_iterator p, InputIterator first, InputIterator last
iterator insert(const_iterator p, initializer_list<charT>
basic_string& erase(size_type pos = 0, size_type n = npos
iterator erase(const_iterator p
iterator erase(const_iterator first, const_iterator last
void pop_back(
basic_string& replace(size_type pos1, size_type n1, const basic_string& str
basic_string& replace(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos
basic_string& replace(size_type pos1, size_type n1, basic_string_view<charT, traits> sv
template<class T>
basic_string& replace(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos
basic_string& replace(size_type pos, size_type n1, const charT* s, size_type n2
basic_string& replace(size_type pos, size_type n1, const charT* s
basic_string& replace(size_type pos, size_type n1, size_type n2, charT c
basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str
basic_string& replace(const_iterator i1, const_iterator i2, basic_string_view<charT, traits> sv
basic_string& replace(const_iterator i1, const_iterator i2, const charT* s, size_type n
basic_string& replace(const_iterator i1, const_iterator i2, const charT* s
basic_string& replace(const_iterator i1, const_iterator i2, size_type n, charT c
template<class InputIterator>
basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2
basic_string& replace(const_iterator, const_iterator, initializer_list<charT>
size_type copy(charT* s, size_type n, size_type pos = 0) const;
void swap(basic_string& str) noexcept(allocator_traits<Allocator>::propagate_on_container_swap::value ||
allocator_traits<Allocator>::is_always_equal::value
// string operations
const charT* c_str() const noexcept;
const charT* data() const noexcept;
charT* data() noexcept;
operator basic_string_view<charT, traits>() const noexcept;
allocator_type get_allocator() const noexcept;
size_type find (basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
size_type find (const basic_string& str, size_type pos = 0) const noexcept;
size_type find (const charT* s, size_type pos, size_type n) const;
size_type find (const charT* s, size_type pos = 0) const;
size_type find (charT c, size_type pos = 0) const;
size_type rfind(basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
size_type rfind(const basic_string& str, size_type pos = npos) const noexcept;
size_type rfind(const charT* s, size_type pos, size_type n) const;
size_type rfind(const charT* s, size_type pos = npos) const;
size_type rfind(charT c, size_type pos = npos) const;
size_type find_first_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
size_type find_first_of(const basic_string& str, size_type pos = 0) const noexcept;
size_type find_first_of(const charT* s, size_type pos, size_type n) const;
size_type find_first_of(const charT* s, size_type pos = 0) const;
size_type find_first_of(charT c, size_type pos = 0) const;
size_type find_last_of (basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
size_type find_last_of (const basic_string& str, size_type pos = npos) const noexcept;
size_type find_last_of (const charT* s, size_type pos, size_type n) const;
size_type find_last_of (const charT* s, size_type pos = npos) const;
size_type find_last_of (charT c, size_type pos = npos) const;
size_type find_first_not_of(basic_string_view<charT, traits> sv, size_type pos = 0) const noexcept;
size_type find_first_not_of(const basic_string& str, size_type pos = 0) const noexcept;
size_type find_first_not_of(const charT* s, size_type pos, size_type n) const;
size_type find_first_not_of(const charT* s, size_type pos = 0) const;
size_type find_first_not_of(charT c, size_type pos = 0) const;
size_type find_last_not_of (basic_string_view<charT, traits> sv, size_type pos = npos) const noexcept;
size_type find_last_not_of (const basic_string& str, size_type pos = npos) const noexcept;
size_type find_last_not_of (const charT* s, size_type pos, size_type n) const;
size_type find_last_not_of (const charT* s, size_type pos = npos) const;
size_type find_last_not_of (charT c, size_type pos = npos) const;
basic_string substr(size_type pos = 0, size_type n = npos) const;
int compare(basic_string_view<charT, traits> sv) const noexcept;
int compare(size_type pos1, size_type n1,
basic_string_view<charT, traits> sv) const;
template<class T>
int compare(size_type pos1, size_type n1, const T& t, size_type pos2, size_type n2 = npos) const;
int compare(const basic_string& str) const noexcept;
int compare(size_type pos1, size_type n1, const basic_string& str) const;
int compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2 = npos) const;
int compare(const charT* s) const;
int compare(size_type pos1, size_type n1, const charT* s) const;
int compare(size_type pos1, size_type n1, const charT* s, size_type n2) 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>;
}
二次
© cppreference.com
在CreativeCommonsAttribution下授权-ShareAlike未移植许可v3.0。
