<string>

Artigo
03/14/2013

Define a classe basic_string do modelo de recipiente e diversos modelos de suporte.

Para obter mais informações sobre basic_string, consulte basic_string Class

namespace std {
    template<class CharType>
        class char_traits;
    template<>
        class char_traits<char>;
    template<>
        class char_traits<wchar_t>;
    template<>
        class char_traits<char16_t>; 
    template<>
        class char_traits<char32_t>;

    template<
        class CharType,
        class Traits = char_traits<CharType>,
        class Allocator = allocator<CharType> 
    > class basic_string;

    typedef basic_string<char> string;
    typedef basic_string<wchar_t> wstring;
    typedef basic_string<char16_t> u16string;
    typedef basic_string<char32_t> u32string;

        // NARROW FUNCTIONS
    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 (long long _Val); 
    string to_string (unsigned long long _Val); 
    string to_string (long double _Val);

        // WIDE FUNCTIONS
    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 (long long _Val); 
    wstring to_wstring (unsigned long long _Val); 
    wstring to_wstring (long double _Val);

       // TEMPLATE FUNCTIONS
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator> operator+ (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator> operator+ (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const CharType *_Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator> operator+ (
            const basic_string<CharType, Traits, Allocator>& _Left,
            CharType _Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator> operator+ (
            const CharType *_Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator> operator+ (
            CharType _Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );

    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator>&& operator+ (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const basic_string<CharType, Traits, Allocator>&& _Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator>&& operator+ (
            const basic_string<CharType, Traits, Allocator>&& _Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator>&& operator+ (
            const basic_string<CharType, Traits, Allocator>&& _Left,
            const basic_string<CharType, Traits, Allocator>&& _Right
        );
    template<class CharType, class Traits, class Allocator> 
        basic_string<CharType, Traits, Allocator>&& operator+ (
            const basic_string<CharType, Traits, Allocator>&& _Left,
            const CharType *_Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator>&& operator+ (
            const basic_string<CharType, Traits, Allocator>&& _Left,
            CharType _Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator>&& operator+ (
            const CharType *_Left,
            const basic_string<CharType, Traits, Allocator>&& _Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_string<CharType, Traits, Allocator>&& operator+ (
            CharType _Left,
            const basic_string<CharType, Traits, Allocator>&& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator== (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator== (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const CharType *_Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator== (
            const CharType *_Left, 
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator!= (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator!= (
            const basic_string<CharType, Traits, Allocator>& left,
            const CharType *_Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator!= (
            const CharType *_Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator< (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator< (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const CharType *_Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator< (
            const CharType *_Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator>= (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator>= (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const CharType *_Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator>= (
            const CharType *_Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator> (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator> (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const CharType *_Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator> (
            const CharType *_Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator<= (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator<= (
            const basic_string<CharType, Traits, Allocator>& _Left,
            const CharType *_Right
        );
    template<class CharType, class Traits, class Allocator>
        bool operator<= (
            const CharType *_Left,
            const basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        void swap (
            basic_string<CharType, Traits, Allocator>& _Left,
            basic_string<CharType, Traits, Allocator>& _Right
        );
    template<class CharType, class Traits, class Allocator>
        basic_ostream<CharType>& operator<< (
            basic_ostream<CharType>& _OStream,
            const basic_string<CharType, Traits, Allocator>& _Str
        );
    template<class CharType, class Traits, class Allocator>
        basic_istream<CharType>& operator>> (
            basic_istream<CharType>& _IStream,
            basic_string<CharType, Traits, Allocator>& _Str
        );
    template<class CharType, class Traits, class Allocator>
        basic_istream<CharType, Traits>& getline (
            basic_istream<CharType, Traits>& _IStream,
            basic_string<CharType, Traits, Allocator>& _Str
        );
     template<class CharType, class Traits, class Allocator>
        basic_istream<CharType, Traits>& getline (
            basic_istream<CharType, Traits>& _IStream,
            basic_string<CharType, Traits, Allocator>& _Str,
            CharType _Delimiter
        );
     template<class CharType, class Traits, class Allocator>
        basic_istream<CharType, Traits>& getline (
            basic_istream<CharType, Traits>&& _IStream,
            basic_string<CharType, Traits, Allocator>& _Str
        ); 
     template<class CharType, class Traits, class Allocator>
        basic_istream<CharType, Traits>& getline (
            basic_istream<CharType, Traits>&& _IStream,
            basic_string<CharType, Traits, Allocator>& _Str,
            CharType _Delimiter
        );
}  // namespace std

Parâmetros

CharType
O parâmetro do modelo que descreve o tipo de dados de caracteres.
Sublinha
O parâmetro do modelo que descreve todas as propriedades de dados de caractere de CharType .
Distribuidor
O parâmetro do modelo que descreve o objeto armazenado do distribuidor de memória.
_Str
basic_string que suporta dados de caractere de CharType .
_Val
o valor a ser convertido.
_Idx
O valor de índice do primeiro caractere unconverted.
_Base
A base de número a ser usada.
_IStream
o fluxo de entrada que suporta dados de caractere de CharType .
_OStream
o fluxo de saída que suporta dados de caractere de CharType .
_Delimiter
a linha delimitador.
_Left
O primeiro deixados () comparam o parâmetro, basic_string ou dados de caractere.
_Right
O segundo direito () compara o parâmetro, basic_string ou dados de caractere.

Comentários

O idioma C++ e os tipos de suporte dois biblioteca de C++ padrão de cadeias de caracteres:

Matrizes de caracteres NULL- terminadas referenciavam geralmente como cadeias de caracteres de C.
A classe de modelo, objetos do tipo basic_string, que trata qualquer char- como argumentos de modelo.

Typedefs

cadeia de caracteres	Um tipo que descreve uma especialização da classe basic_string de modelo com elementos do tipo char como string.
wstring	Um tipo que descreve uma especialização da classe basic_string de modelo com elementos do tipo wchar_t como wstring.
u16string	Um tipo que descrevesse uma especialização da classe basic_string de modelo com base nos elementos de tipo char16_t.
u32string	Um tipo que descrevesse uma especialização da classe basic_string de modelo com base nos elementos de tipo char32_t.

Operadores

operator+	Concatena dois objetos de cadeia de caracteres.
operador! =	Teste se o objeto de cadeia de caracteres no lado esquerdo do operador não é igual ao objeto de cadeia de caracteres no lado direito.
operator==	Teste se o objeto de cadeia de caracteres no lado esquerdo do operador é igual ao objeto de cadeia de caracteres no lado direito.
operator<	Teste se o objeto de cadeia de caracteres no lado esquerdo do operador é menor que o objeto de cadeia de caracteres no lado direito.
operator<=	Teste se o objeto de cadeia de caracteres no lado esquerdo do operador é menor ou igual ao objeto de cadeia de caracteres no lado direito.
operator<<	Uma função do modelo que insere uma cadeia de caracteres no fluxo de saída.
operator>	Teste se o objeto de cadeia de caracteres no lado esquerdo do operador é maior do que o objeto de cadeia de caracteres no lado direito.
operator>=	Teste se o objeto de cadeia de caracteres no lado esquerdo do operador é maior ou igual ao objeto de cadeia de caracteres no lado direito.
operador >>	Uma função do modelo que extrai uma cadeia de caracteres de fluxo de entrada.

Funções do modelo especializadas

troca	Troca matrizes de caracteres de duas cadeias de caracteres.
stod	Converte uma seqüência de caracteres a double.
stof	Converte uma seqüência de caracteres a float.
stoi	Converte uma seqüência de caracteres em um número inteiro.
stold	Converte uma seqüência de caracteres a long double.
stoll	Converte uma seqüência de caracteres a long long.
stoul	Converte uma seqüência de caracteres a unsigned long.
stoull	Converte uma seqüência de caracteres a unsigned long long.
to_string	Converter um valor a string.
to_wstring	Converter um valor a stringamplo.

Funções

getline

Extrair cadeias de caracteres de linha de fluxo de entrada por linha.

Classes

basic_string Class	Uma classe de modelo que descreve os objetos que podem armazenar uma sequência de arbitrário caractere- como objetos.
char_traits Struct	Uma classe de modelo que descreve os atributos associados com um caractere de tipo CharType

Especializações

char_traits<char> Struct	Uma estrutura que é uma especialização de estrutura char_traits<CharType> de modelo a um elemento de tipo char.
char_traits<wchar_t> Struct	Uma estrutura que é uma especialização de estrutura char_traits<CharType> de modelo a um elemento de tipo wchar_t.
char_traits<char16_t> Struct	Uma estrutura que é uma especialização de estrutura char_traits<CharType> de modelo a um elemento de tipo char16_t.
char_traits<char32_t> Struct	Uma estrutura que é uma especialização de estrutura char_traits<CharType> de modelo a um elemento de tipo char32_t.

Requisitos

Cabeçalho: <string>
namespace: STD

Consulte também

Referência

Segurança do thread na biblioteca C++ padrão

Outros recursos

Arquivos de cabeçalho

Compartilhar via