Partage via

fonctions<string>

  • Article

getline
stod
stof
stoi
stol
stold
stoll
stoul
stoull
swap
to_string
to_wstring

getline

Extrait des chaînes du flux d'entrée, ligne par ligne.

// (1) delimiter as parameter
template <class CharType, class Traits, class Allocator>
basic_istream<CharType, Traits>& getline(
    basic_istream<CharType, Traits>& in_stream,
    basic_string<CharType, Traits, Allocator>& str,
    CharType delimiter);

template <class CharType, class Traits, class Allocator>
basic_istream<CharType, Traits>& getline(
    basic_istream<CharType, Traits>&& in_stream,
    basic_string<CharType, Traits, Allocator>& str,
    const CharType delimiter);

// (2) default delimiter used
template <class CharType, class Traits, class Allocator>
basic_istream<CharType, Traits>& getline(
    basic_istream<CharType, Traits>& in_stream,
    basic_string<CharType, Traits, Allocator>& str);

template <class Allocator, class Traits, class Allocator>
basic_istream<Allocator, Traits>& getline(
    basic_istream<Allocator, Traits>&& in_stream,
    basic_string<Allocator, Traits, Allocator>& str);

Paramètres

in_stream
Flux d'entrée à partir duquel une chaîne doit être extraite.

str
Chaîne dans laquelle les caractères sont lus à partir du flux d'entrée.

delimiter
Délimiteur de ligne.

Valeur de retour

Flux d'entrée in_stream.

Notes

La paire de signatures de fonction marquée (1) extrait des caractères de in_stream jusqu'à ce que delimiter soit trouvé, en les stockant dans str.

La paire de signatures de fonction marquée (2) utiliser newline comme délimiteur de ligne par défaut et se comporte comme getline(in_stream, str, in_stream. widen('\n')).

La deuxième fonction de chaque paire est analogue au premier pour prendre en charge rvalue les références.

L'extraction s'arrête dans les situations suivantes :

  • À la fin du fichier, auquel cas l’indicateur d’état interne est in_stream défini sur ios_base::eofbit.

  • Une fois la fonction extraite un élément qui est égal à delimiter. L’élément n’est pas remis ou ajouté à la séquence contrôlée.

  • Une fois la fonction extraite des str.max_size éléments. L’indicateur d’état interne de in_stream est défini sur ios_base::failbit.

  • Une autre erreur que celles précédemment répertoriées ; l’indicateur d’état interne de in_stream est défini sur ios_base::badbit.

Pour plus d’informations sur les indicateurs d’état internes, consultez ios_base::iostate.

Si la fonction n'extrait aucun élément, l'indicateur d'état interne de in_stream a la valeur ios_base::failbit. Dans tous les cas, getline retourne in_stream.

Si une exception est levée, in_stream et str sont laissés dans un état valide.

Exemple

Le code suivant illustre getline() dans deux modes : d'abord avec le délimiteur par défaut (nouvelle ligne) et ensuite avec un espace blanc comme délimiteur. Le caractère de fin de fichier (Ctrl-Z sur le clavier) est utilisé pour contrôler la fin des boucles while. Cette valeur définit l’indicateur d’état interne de cin la eofbitvaleur , qui doit être effacé avant basic_ios::clear() que la deuxième boucle while fonctionne correctement.

// compile with: /EHsc /W4
#include <string>
#include <iostream>
#include <vector>

using namespace std;

int main()
{
    string str;
    vector<string> v1;
    cout << "Enter a sentence, press ENTER between sentences. (Ctrl-Z to stop): " << endl;
    // Loop until end-of-file (Ctrl-Z) is input, store each sentence in a vector.
    // Default delimiter is the newline character.
    while (getline(cin, str)) {
        v1.push_back(str);
    }

    cout << "The following input was stored with newline delimiter:" << endl;
    for (const auto& p : v1) {
        cout << p << endl;
    }

    cin.clear();

    vector<string> v2;
    // Now try it with a whitespace delimiter
    while (getline(cin, str, ' ')) {
        v2.push_back(str);
    }

    cout << "The following input was stored with whitespace as delimiter:" << endl;
    for (const auto& p : v2) {
        cout << p << endl;
    }
}

stod

Convertit une séquence de caractères en double.

double stod(
    const string& str,
    size_t* idx = 0);

double stod(
    const wstring& str,
    size_t* idx = 0
;

Paramètres

str
Séquence de caractères à convertir.

idx
Valeur d'index du premier caractère non converti.

Valeur de retour

valeur double.

Notes

La fonction convertit la séquence d’éléments dans str une valeur de type double comme si elle appelait strtod( str.c_str(), _Eptr), où _Eptr est un objet interne à la fonction. Si str.c_str() == *_Eptr, il lève un objet de type invalid_argument. Si cet appel définit errno, elle lève un objet de type out_of_range. Sinon, si idx ce n’est pas un pointeur Null, la fonction stocke *_Eptr - str.c_str() *idx et retourne la valeur.

stof

Convertit une séquence de caractères en type flottant.

float stof(
    const string& str,
    size_t* idx = 0);

float stof(
    const wstring& str,
    size_t* idx = 0);

Paramètres

str
Séquence de caractères à convertir.

idx
Valeur d'index du premier caractère non converti.

Valeur de retour

valeur float.

Notes

La fonction convertit la séquence d’éléments dans str une valeur de type float comme si elle appelait strtof( str.c_str(), _Eptr), où _Eptr est un objet interne à la fonction. Si str.c_str() == *_Eptr, il lève un objet de type invalid_argument. Si cet appel définit errno, elle lève un objet de type out_of_range. Sinon, si idx ce n’est pas un pointeur Null, la fonction stocke *_Eptr - str.c_str() *idx et retourne la valeur.

stoi

Convertit une séquence de caractères en entier.

int stoi(
    const string& str,
    size_t* idx = 0,
    int base = 10);

int stoi(
    const wstring& str,
    size_t* idx = 0,
    int base = 10);

Valeur de retour

Valeur entière.

Paramètres

str
Séquence de caractères à convertir.

idx
Valeur d'index du premier caractère non converti.

base
Base numérique à utiliser.

Notes

La fonction stoi convertit la séquence de caractères en str en valeur de type int et retourne la valeur. Par exemple, quand la séquence de caractères « 10 » est passée, la valeur retournée par stoi est l'entier 10.

stoi se comporte de la même façon que la fonction strtol pour les caractères d’un octet lorsqu’elle est appelée de la manière strtol( str.c_str(), _Eptr, idx), où _Eptr est un objet interne à la fonction ; ou wcstol pour des caractères larges, lorsqu’il est appelé de la même manière, wcstol(Str.c_str(), _Eptr, idx). Pour plus d’informations, consultez , , _strtol_lwcstol, _wcstol_l.strtol

Si str.c_str() == *_Eptr, stoi lève un objet de type invalid_argument. Si un tel appel définit errno, ou si la valeur retournée ne peut pas être représentée en tant qu’objet de type int, elle lève un objet de type out_of_range. Sinon, si idx n’est pas un pointeur Null, la fonction stocke *_Eptr - str.c_str() dans *idx.

stol

Convertit une séquence de caractères en long.

long stol(
    const string& str,
    size_t* idx = 0,
    int base = 10);

long stol(
    const wstring& str,
    size_t* idx = 0,
    int base = 10);

Paramètres

str
Séquence de caractères à convertir.

idx
Valeur d'index du premier caractère non converti.

base
Base numérique à utiliser.

Valeur de retour

Valeur entière de type long.

Notes

La fonction convertit la séquence d’éléments en str en valeur de type long comme si elle appelait strtol( str.c_str(), _Eptr, idx), où _Eptr est un objet interne à la fonction. Si str.c_str() == *_Eptr, il lève un objet de type invalid_argument. Si cet appel définit errno, elle lève un objet de type out_of_range. Sinon, si idx ce n’est pas un pointeur Null, la fonction stocke *_Eptr - str.c_str() *idx et retourne la valeur.

stold

Convertit une séquence de caractères en long double.

double stold(
    const string& str,
    size_t* idx = 0);

double stold(
    const wstring& str,
    size_t* idx = 0);

Paramètres

str
Séquence de caractères à convertir.

idx
Valeur d'index du premier caractère non converti.

Valeur de retour

valeur long double.

Notes

La fonction convertit la séquence d’éléments en str en valeur de type long double comme si elle appelait strtold( str.c_str(), _Eptr), où _Eptr est un objet interne à la fonction. Si str.c_str() == *_Eptr, il lève un objet de type invalid_argument. Si cet appel définit errno, elle lève un objet de type out_of_range. Sinon, si idx ce n’est pas un pointeur Null, la fonction stocke *_Eptr - str.c_str() *idx et retourne la valeur.

stoll

Convertit une séquence de caractères en long long.

long long stoll(
    const string& str,
    size_t* idx = 0,
    int base = 10);

long long stoll(
    const wstring& str,
    size_t* idx = 0,
    int base = 10);

Paramètres

str
Séquence de caractères à convertir.

idx
Valeur d'index du premier caractère non converti.

base
Base numérique à utiliser.

Valeur de retour

valeur long long.

Notes

La fonction convertit la séquence d’éléments en str en valeur de type long long comme si elle appelait strtoll( str.c_str(), _Eptr, idx), où _Eptr est un objet interne à la fonction. Si str.c_str() == *_Eptr, il lève un objet de type invalid_argument. Si cet appel définit errno, elle lève un objet de type out_of_range. Sinon, si idx n’est pas un pointeur Null, la fonction stocke *idx *_Eptr - str.c_str() et retourne la valeur.

stoul

Convertit une séquence de caractères en type long non signé.

unsigned long stoul(
    const string& str,
    size_t* idx = 0,
    int base = 10);

unsigned long stoul(
    const wstring& str,
    size_t* idx = 0,
    int base = 10);

Paramètres

str
Séquence de caractères à convertir.

idx
Valeur d'index du premier caractère non converti.

base
Base numérique à utiliser.

Valeur de retour

Valeur entière de type long non signé.

Notes

La fonction convertit la séquence d’éléments en str en valeur de type unsigned long comme si elle appelait strtoul( str.c_str(), _Eptr, idx), où _Eptr est un objet interne à la fonction. Si str.c_str() == *_Eptr, il lève un objet de type invalid_argument. Si cet appel définit errno, elle lève un objet de type out_of_range. Sinon, si idx n’est pas un pointeur Null, la fonction stocke *idx *_Eptr - str.c_str() et retourne la valeur.

stoull

Convertit une séquence de caractères en unsigned long long.

unsigned long long stoull(
    const string& str,
    size_t* idx = 0,
    int base = 10);

unsigned long long stoull(
    const wstring& str,
    size_t* idx = 0,
    int base = 10);

Paramètres

str
Séquence de caractères à convertir.

idx
Valeur d'index du premier caractère non converti.

base
Base numérique à utiliser.

Valeur de retour

valeur unsigned long long.

Notes

La fonction convertit la séquence d’éléments en str en valeur de type unsigned long long comme si elle appelait strtoull( str.c_str(), _Eptr, idx), où _Eptr est un objet interne à la fonction. Si str.c_str() == *_Eptr, il lève un objet de type invalid_argument. Si cet appel définit errno, elle lève un objet de type out_of_range. Sinon, si idx ce n’est pas un pointeur Null, la fonction stocke *_Eptr - str.c_str() *idx et retourne la valeur.

swap

Échange les tableaux de caractères de deux chaînes.

template <class Traits, class Allocator>
void swap(basic_string<CharType, Traits, Allocator>& left, basic_string<CharType, Traits, Allocator>& right);

Paramètres

left
Chaîne dont les éléments doivent être échangés avec les éléments d’une autre chaîne.

right
Autre chaîne dont les éléments doivent être échangés avec la première chaîne.

Notes

La fonction de modèle exécute la fonction left.swapmembre spécialisée (right) pour les chaînes, ce qui garantit une complexité constante.

Exemple

// string_swap.cpp
// compile with: /EHsc
#include <string>
#include <iostream>

int main( )
{
   using namespace std;
   // Declaring an object of type basic_string<char>
   string s1 ( "Tweedledee" );
   string s2 ( "Tweedledum" );
   cout << "Before swapping string s1 and s2:" << endl;
   cout << "The basic_string s1 = " << s1 << "." << endl;
   cout << "The basic_string s2 = " << s2 << "." << endl;

   swap ( s1 , s2 );
   cout << "\nAfter swapping string s1 and s2:" << endl;
   cout << "The basic_string s1 = " << s1 << "." << endl;
   cout << "The basic_string s2 = " << s2 << "." << endl;
}

Before swapping string s1 and s2:
The basic_string s1 = Tweedledee.
The basic_string s2 = Tweedledum.

After swapping string s1 and s2:
The basic_string s1 = Tweedledum.
The basic_string s2 = Tweedledee.

to_string

Convertit une valeur en string.

string to_string(int value);
string to_string(unsigned int value);
string to_string(long value);
string to_string(unsigned long value);
string to_string(long long value);
string to_string(unsigned long long value);
string to_string(float value);
string to_string(double value);
string to_string(long double value);

Paramètres

value
Valeur à convertir.

Valeur de retour

Objet string qui représente la valeur.

Notes

La fonction convertit la valeur en une séquence d’éléments stockés dans un objet Buf tableau interne à la fonction comme si elle appelait sprintf(Buf, Fmt, value), où Fmt est

  • "%d" s’il value est de type int

  • "%u" s’il value est de type unsigned int

  • "%ld" s’il value est de type long

  • "%lu" s’il value est de type unsigned long

  • "%lld" s’il value est de type long long

  • "%llu" s’il value est de type unsigned long long

  • "%f" s’il value est de type float ou double

  • "%Lf" s’il value est de type long double

La fonction retourne string(Buf).

to_wstring

Convertit une valeur en une chaîne étendue.

wstring to_wstring(int value);
wstring to_wstring(unsigned int value);
wstring to_wstring(long value);
wstring to_wstring(unsigned long value);
wstring to_wstring(long long value);
wstring to_wstring(unsigned long long value);
wstring to_wstring(float value);
wstring to_wstring(double value);
wstring to_wstring(long double value);

Paramètres

value
Valeur à convertir.

Valeur de retour

Chaîne étendue qui représente la valeur.

Notes

La fonction convertit value en une séquence d'éléments stockés dans un objet tableau Buf interne à la fonction, comme dans un appel de swprintf(Buf, Len, Fmt, value), où Fmt est

  • L"%d" s’il value est de type int

  • L"%u" s’il value est de type unsigned int

  • L"%ld" s’il value est de type long

  • L"%lu" s’il value est de type unsigned long

  • L"%lld" s’il value est de type long long

  • L"%llu" s’il value est de type unsigned long long

  • L"%f" s’il value est de type float ou double

  • L"%Lf" s’il value est de type long double

La fonction retourne wstring(Buf).

Voir aussi

<string>