当前头文件是字符串库(Strings library)的部分内容。

​字符串库(参考手册) ​字符串库(标准)

  • std::char_traits 字符特性类模板,该类模板为描述字符属性及操作字符提供了统一的接口。
    std::char_traits<char> std::char_traits 类模板对 char 类型的特例化
    std::char_traits<wchar_t> std::char_traits 类模板对 wchar_t 类型的特例化
    std::char_traits<char16_t> std::char_traits 类模板对 char16_t 类型的特例化
    std::char_traits<char32_t> std::char_traits 类模板对 char32_t 类型的特例化
    std::basic_string 该类模板归纳了一个字符序列是如何被存储及操作的。
    std::string std::basic_string<char>typedef
    std::wstring std::basic_string<wchar_t> (typedef
    std::u16string std::basic_string<char16_t> (typedef
    std::u32string std::basic_string<char32_t> (typedef
  • std::operator+(std::basic_string) 连接两个字符串或一个字符串和一个字符
    operator==
    operator!=
    operator<
    operator>
    operator<=
    operator>=
    按字典序比较两个字符串
    std::swap(std::basic_string) 特例化 std::swap 函数模板
    operator<<
    operator>>
    对字符串进行流输入或输出操作
    std::getline(std::basic_string) 从流中读取一行字符

    输入/输出 

    operator<<
    operator>>
    对字符串进行流输入或输出操作
    std::getline(std::basic_string) 从流中读取一行字符

    数值转换(Numeric conversion)

    std::stoi C++11 将字符串转化成带符号(Signed)整数
    std::stol C++11 将字符串转化成带符号整数
    std::stoll C++11 将字符串转化成带符号整数
    std::stoul C++11 将字符串转化成无符号(Unsigned)整数
    std::stoull C++11 将字符串转化成无符号整数
    std::stof C++11 将字符串转化成浮点数
    std::stod C++11 将字符串转化成浮点数
    std::stold C++11 将字符串转化成浮点数
    std::to_string C++11 将一个整数或浮点数转化成字符串
    std::to_wstring C++11 将一个整数或浮点数转化成宽字符串
    std::hash<std::string> C++11 字符串的啥希(Hash)支持
    std::hash<std::u16string> C++11
    std::hash<std::u32string> C++11
    std::hash<std::wstring> C++11
  • #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);
        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);
        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);
        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);
        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);
        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);
        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);
     
        // 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
        typedef basic_string<char> string;
        typedef basic_string<char16_t> u16string;
        typedef basic_string<char32_t> u32string;
        typedef basic_string<wchar_t> wstring;
     
        // 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 std