Standard library header <string> - cppreference.com

##### cppreference.com

##### Search

Create account

##### Namespaces

- Page
- Discussion

##### Variants

##### Views

- View
- Edit
- History

##### Actions

# Standard library header <string>

From cppreference.com
< cpp‎ | header

This header is part of the strings library.

### [edit] Includes

`<initializer_list>` | (since C++11)

### [edit] Classes

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)

### [edit] Functions

operator+ | concatenates two strings or a string and a char (function template) [edit]
operator==operator!=operator<operator>operator<=operator>= | lexicographically compares two strings (function template) [edit]
std::swap(std::basic_string) | specializes the std::swap algorithm (function template) [edit]
##### Input/output
operator<<operator>> | performs stream input and output on strings (function template) [edit]
getline | read data from an I/O stream into a string (function template) [edit]
##### Numeric conversions
stoistolstoll (C++11)(C++11)(C++11) | converts a string to a signed integer (function) [edit]
stoulstoull (C++11)(C++11) | converts a string to an unsigned integer (function) [edit]
stofstodstold (C++11)(C++11)(C++11) | converts a string to a floating point value (function) [edit]
to_string (C++11) | converts an integral or floating point value to `string` (function) [edit]
to_wstring (C++11) | converts an integral or floating point value to `wstring` (function) [edit]

### [edit] Literals

Defined in inline namespace `std::literals::string_literals`
operator""s (C++14) | Converts a character array literal to `basic_string` (function) [edit]

### [edit] Synopsis

    #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>;

        inline namespace literals {
        inline namespace 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);

       } // inline namespace string_literals
       } // inline namespace literals
    } // namespace std

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/string&oldid=72738"