##### 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
stoi stol stoll (C++11)(C++11)(C++11) | converts a string to a signed integer (function) [edit]
stoul stoull (C++11)(C++11) | converts a string to an unsigned integer (function) [edit]
stof stod stold (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) 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);
        }
      }
    }

#### [edit] Class template 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;
      };
    }

#### [edit] Class template 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>;
    }

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