string

This header is part of the strings library.

Includes

<initializer_list> (since C++11)

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)

Functions

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)
Input/output
operator<<operator>>	performs stream input and output on strings (function template)
getline	read data from an I/O stream into a string (function template)
Numeric conversions
stoistolstoll (C++11)(C++11)(C++11)	converts a string to a signed integer (function)
stoulstoull (C++11)(C++11)	converts a string to an unsigned integer (function)
stofstodstold (C++11)(C++11)(C++11)	converts a string to a floating point value (function)
to_string (C++11)	converts an integral or floating point value to `string` (function)
to_wstring (C++11)	converts an integral or floating point value to `wstring` (function)

Literals

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

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

Links:

http://en.cppreference.com/w/cpp/header/string

doc_CPP

2025-01-10 15:47:30

Comments

string

Includes

Classes

Functions

Input/output

Numeric conversions

Literals

Synopsis