La classe `ios_base`

Article
10/12/2023

La classe décrit les fonctions de stockage et de membre communes aux flux d’entrée et de sortie qui ne dépendent pas des paramètres du modèle. (Le modèle basic_ios de classe décrit ce qui est courant et dépend des paramètres du modèle.)

Un objet de classe ios_base stocke les informations de mise en forme, qui se composent des éléments suivants :

Mettre en forme des indicateurs dans un objet de type fmtflags.
Masque d’exception dans un objet de type iostate.
Largeur de champ dans un objet de type int.
Une précision d'affichage dans un objet de type int.
Objet locale d’un objet de type locale.
Deux tableaux extensibles, avec des éléments de type long et void de pointeur.

Un objet de classe ios_base stocke également les informations d’état de flux, dans un objet de type iostateet une pile de rappels.

Membres

Constructeurs

Nom	Description
`ios_base`	Construit des objets `ios_base`.

Typedefs

Nom	Description
`event_callback`	Décrit une fonction passée à `register_call`.
`fmtflags`	Constantes pour spécifier l'apparence de la sortie.
`iostate`	Définit des constantes décrivant l'état d'un flux.
`openmode`	Décrit comment interagir avec un flux.
`seekdir`	Spécifie le point de départ pour les opérations de décalage.

Énumérations

Nom	Description
`event`	Spécifie des types d'événements.

Constantes

Nom	Description
`adjustfield`	Masque de bits défini en tant que `internalright` \| `left` \| .
`app`	Spécifie qu'une recherche doit être effectuée jusqu'à la fin d'un flux avant chaque insertion.
`ate`	Spécifie qu'une recherche doit être effectuée jusqu'à la fin d'un flux quand son objet de contrôle est créé en premier.
`badbit`	Enregistre une perte d'intégrité de la mémoire tampon du flux.
`basefield`	Masque de bits défini en tant que `decoct` \| `hex` \| .
`beg`	Spécifie qu'une recherche doit être effectuée relativement au début d'une séquence.
`binary`	Spécifie qu'un fichier doit être lu comme un flux binaire, et non pas comme un flux de texte.
`boolalpha`	Spécifie l'insertion ou l'extraction d'objets de type `bool` en tant que noms (comme `true` et `false`) et non pas en tant que valeurs numériques.
`cur`	Spécifie qu'une recherche doit être effectuée relativement à la position actuelle dans une séquence.
`dec`	Spécifie l'insertion ou l'extraction de valeurs entières au format décimal.
`end`	Spécifie qu'une recherche doit être effectuée relativement à la fin d'une séquence.
`eofbit`	Enregistre la fin de fichier lors de l'extraction à partir d'un flux.
`failbit`	Enregistre un échec de l'extraction d'un champ valide dans un flux.
`fixed`	Spécifie l'insertion de valeurs à virgule flottante dans un format à virgule fixe (sans champ d'exposant).
`floatfield`	Masque de bits défini comme `fixed` \| `scientific`
`goodbit`	Tous les bits d'état sont effacés.
`hex`	Spécifie l'insertion ou l'extraction de valeurs entières au format hexadécimal.
`in`	Spécifie l'extraction à partir d'un flux.
`internal`	Complète jusqu'à une largeur de champ en insérant des caractères de remplissage à un point interne dans un champ numérique généré.
`left`	Spécifie la justification à gauche.
`oct`	Spécifie l'insertion ou l'extraction de valeurs entières au format octal.
`out`	Spécifie l'insertion dans un flux.
`right`	Spécifie la justification à droite.
`scientific`	Spécifie l'insertion de valeurs à virgule flottante au format scientifique (sans champ d'exposant).
`showbase`	Spécifie l'insertion d'un préfixe qui indique la base d'un champ d'entier généré.
`showpoint`	Spécifie l'insertion inconditionnelle de la virgule décimale dans un champ à virgule flottante généré.
`showpos`	Spécifie l'insertion d'un signe plus dans un champ numérique généré non négatif.
`skipws`	Spécifie qu'il faut ignorer l'espace blanc du début avant certaines extractions.
`trunc`	Spécifie la suppression du contenu d'un fichier existant lors de la création de son objet de contrôle.
`unitbuf`	Provoque le vidage de la sortie après chaque insertion.
`uppercase`	Spécifie l'insertion d'équivalents majuscules des lettres minuscules dans certaines insertions.

Functions

Nom	Description
`failure`	La classe membre sert de classe de base pour toutes les exceptions levées par la fonction membre effacée dans le modèle `basic_ios`de classe.
`flags`	Définit ou retourne les valeurs de l'indicateur actuel.
`getloc`	Retourne l’objet stocké `locale` .
`imbue`	Change les paramètres régionaux.
`Init`	Crée les objets standard `iostream` lors de la construction.
`iword`	Affecte une valeur à stocker comme `iword`.
`precision`	Spécifie le nombre de chiffres à afficher dans un nombre à virgule flottante.
`pword`	Affecte une valeur à stocker comme `pword`.
`register_callback`	Spécifie une fonction de rappel.
`setf`	Définit les indicateurs spécifiés.
`sync_with_stdio`	Garantit que `iostream` les opérations de bibliothèque runtime C et C se produisent dans l’ordre dans lequel elles apparaissent dans le code source.
`unsetf`	Désactive les indicateurs spécifiés.
`width`	Définit la longueur du flux de sortie.
`xalloc`	Spécifie qu'une variable fera partie du flux.

Opérateurs

Nom	Description
`operator=`	Opérateur d'affectation pour les objets `ios_base`.

Spécifications

En-tête : <ios>

Espace de noms : std

`event`

Spécifie des types d'événements.

enum event {
    erase_event,
    imbue_event,
    copyfmt_event};

Notes

Le type est un type énuméré qui décrit un objet qui peut stocker l’événement de rappel utilisé comme argument pour une fonction inscrite avec register_callback. Les valeurs d’événements distinctes sont les suivantes :

copyfmt_event, pour identifier un rappel qui se produit près de la fin d’un appel , copyfmtjuste avant la copie du masque d’exception.
erase_event, pour identifier un rappel qui se produit au début d’un appel à copyfmt, ou au début d’un appel au destructeur pour *this.
imbue_event, pour identifier un rappel qui se produit à la fin d’un appel à imbue, juste avant le retour de la fonction.

Exemple

Pour obtenir un exemple, consultez register_callback.

`event_callback`

Décrit une fonction passée à register_call.

typedef void (__cdecl *event_callback)(
    event _E,
    ios_base& _Base,
    int _I);

Paramètres

_E
Le event.

_Base
Flux dans lequel l’événement a été appelé.

_I
Nombre défini par l’utilisateur.

Notes

Le type décrit un pointeur vers une fonction qui peut être inscrite avec register_callback. Ce type de fonction ne doit pas lever d’exception.

Exemple

Consultez register_call un exemple qui utilise event_callback.

`failure`

La classe failure définit la classe de base pour les types de tous les objets levés comme exceptions, par des fonctions de la bibliothèque iostreams, pour signaler les erreurs détectées pendant les opérations de mise en mémoire tampon de flux.

namespace std {
    class failure : public system_error {
    public:
        explicit failure(
            const string& _Message,
            const error_code& _Code = io_errc::stream);

        explicit failure(
            const char* str,
            const error_code& _Code = io_errc::stream);
    };
}

Notes

La valeur retournée par what() est une copie de _Message, éventuellement augmentée avec un test basé sur _Code. Si _Code n’est pas spécifié, la valeur par défaut est make_error_code(io_errc::stream).

Exemple

// ios_base_failure.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>

int main ( )
{
    using namespace std;
    fstream file;
    file.exceptions(ios::failbit);
    try
    {
        file.open( "rm.txt", ios_base::in );
        // Opens nonexistent file for reading
    }
    catch( ios_base::failure f )
    {
        cout << "Caught an exception: " << f.what() << endl;
    }
}

Caught an exception: ios_base::failbit set

`flags`

Définit ou retourne les valeurs de l'indicateur actuel.

fmtflags flags() const;
fmtflags flags(fmtflags fmtfl);

Paramètres

fmtfl
Nouveau paramètre fmtflags.

Valeur de retour

Paramètre fmtflags précédent ou actif.

Notes

Consultez ios_base::fmtflags la liste des indicateurs.

La première fonction membre retourne les indicateurs de format stockés. La deuxième fonction membre stocke fmtfl dans les indicateurs de format et retourne sa précédente valeur stockée.

Exemple

// ios_base_flags.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>

int main ( )
{
    using namespace std;
    cout << cout.flags( ) << endl;
    cout.flags( ios::dec | ios::boolalpha );
    cout << cout.flags( );
}

513
16896

`fmtflags`

Constantes pour spécifier l'apparence de la sortie.

class ios_base {
public:
   typedef implementation-defined-bitmask-type fmtflags;
   static const fmtflags boolalpha;
   static const fmtflags dec;
   static const fmtflags fixed;
   static const fmtflags hex;
   static const fmtflags internal;
   static const fmtflags left;
   static const fmtflags oct;
   static const fmtflags right;
   static const fmtflags scientific;
   static const fmtflags showbase;
   static const fmtflags showpoint;
   static const fmtflags showpos;
   static const fmtflags skipws;
   static const fmtflags unitbuf;
   static const fmtflags uppercase;
   static const fmtflags adjustfield;
   static const fmtflags basefield;
   static const fmtflags floatfield;
   // ...
};

Notes

Prend en charge les manipulateurs dans ios.

Le type est un type de masque de bits qui décrit un objet pouvant stocker des indicateurs de format. Les valeurs distinctes des indicateurs (éléments) sont :

dec, pour insérer ou extraire des valeurs entières au format décimal.
hex, pour insérer ou extraire des valeurs entières au format hexadécimal.
oct, pour insérer ou extraire des valeurs entières au format octal.
showbase, pour insérer un préfixe qui indique la base d'un champ entier généré.
internal, pour compléter une largeur de champ selon les besoins, en insérant des caractères de remplissage à un point interne d'un champ numérique généré. (Pour plus d’informations sur la définition de la largeur du champ, consultez setw).
left, pour compléter une largeur de champ selon les besoins, en insérant des caractères de remplissage à la fin d'un champ généré (justification à gauche).
right, pour compléter une largeur de champ selon les besoins, en insérant des caractères de remplissage au début d'un champ généré (justification à droite).
boolalpha, pour insérer ou extraire des objets de type bool comme des noms (tels que true et false), et non pas comme des valeurs numériques.
fixed, pour insérer des valeurs à virgule flottante dans un format à virgule fixe (sans champ d'exposant).
scientific, pour insérer des valeurs à virgule flottante au format scientifique (avec un champ d'exposant).
showpoint, pour insérer un séparateur décimal de façon inconditionnelle dans un champ à virgule flottante généré.
showpos, pour insérer un signe plus dans un champ numérique généré non négatif.
skipws, pour ignorer l'espace blanc initial avant certaines extractions.
unitbuf, pour vider la sortie après chaque insertion.
uppercase, pour insérer des équivalents majuscules des lettres minuscules dans certaines insertions.

Les valeurs suivantes sont également utiles :

adjustfield, masque de bits défini comme internal | left | right
basefield, défini en tant que dec | hex | oct
floatfield, défini en tant que fixed | scientific

Pour obtenir des exemples de fonctions qui modifient ces indicateurs de format, consultez <iomanip>.

`getloc`

Retourne l’objet stocké locale .

locale getloc() const;

Valeur de retour

Objet stocké locale .

Exemple

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

int main( )
{
    using namespace std;
    cout << cout.getloc( ).name( ).c_str( ) << endl;
}

`imbue`

Change les paramètres régionaux.

locale imbue(const locale& _Loc);

Paramètres

_Loc
Nouveaux paramètres régionaux.

Valeur de retour

Paramètres régionaux précédents.

Notes

La fonction membre stocke _Loc dans l’objet locale , puis signale l’événement de rappel et imbue_event. Elle retourne la valeur stockée précédente.

Exemple

Consultez basic_ios::imbue un exemple.

`Init`

Crée les objets standard iostream lors de la construction.

class Init { };

Notes

La classe imbriquée décrit un objet dont la construction garantit que les objets standard iostream sont correctement construits, même avant l’exécution d’un constructeur pour un objet statique arbitraire.

`ios_base`

Construit des objets ios_base.

ios_base();

Notes

Le constructeur (protégé) ne fait rien. Un appel ultérieur à basic_ios::init doit initialiser l’objet avant qu’il puisse être détruit en toute sécurité. Par conséquent, la seule utilisation sécurisée pour la classe ios_base est une classe de base pour le modèle basic_iosde classe.

`iostate`

Type des constantes qui décrivent l’état d’un flux.

class ios_base {
public:
   typedef implementation-defined-bitmask-type iostate;
   static const iostate badbit;
   static const iostate eofbit;
   static const iostate failbit;
   static const iostate goodbit;
   // ...
};

Notes

Le type est un type de masque de bits qui décrit un objet pouvant stocker des informations d’état de flux. Les valeurs distinctes des indicateurs (éléments) sont :

badbit, pour enregistrer une perte d’intégrité de la mémoire tampon du flux.
eofbit, pour enregistrer la fin de fichier lors de l’extraction à partir d’un flux.
failbit, pour enregistrer un échec d’extraction d’un champ valide à partir d’un flux.

goodbit est également une valeur utile, où aucun des bits mentionnés précédemment n’est défini ( goodbit est garanti comme étant égal à zéro).

`iword`

Affecte une valeur à stocker comme iword.

long& iword(int idx);

Paramètres

idx
Index de la valeur à stocker en tant que iword.

Notes

La fonction membre retourne une référence à l’idx d’élément du tableau extensible avec des éléments de type long. Tous les éléments sont effectivement présents et contiennent initialement la valeur zéro. La référence retournée n’est pas valide après l’appel suivant à iword l’objet, une fois l’objet modifié par un appel à basic_ios::copyfmt, ou après la destruction de l’objet.

Si idx elle est négative ou si le stockage unique n’est pas disponible pour l’élément, la fonction appelle setstate(badbit) et retourne une référence qui peut ne pas être unique.

Pour obtenir un index unique, pour une utilisation sur tous les objets de type ios_base, appelez xalloc.

Exemple

Consultez xalloc pour un exemple d’utilisation de iword.

`openmode`

Décrit comment interagir avec un flux.

class ios_base {
public:
   typedef implementation-defined-bitmask-type openmode;
   static const openmode  in;
   static const openmode  out;
   static const openmode  ate;
   static const openmode  app;
   static const openmode  trunc;
   static const openmode  binary;
   // ...
};

Notes

Mode d’ouverture pour plusieurs iostream objets. Les valeurs d’indicateur sont les suivantes :

Constant	Effet
`app`	Rechercher à la fin du flux avant chaque écriture
`ate`	Rechercher à la fin du flux immédiatement après l’ouverture
`binary`	Ouvre en mode binaire. (Consultez `fopen` la description du mode binaire.)
`in`	Ouvrir pour la lecture
`out`	Ouvrir pour l’écriture
`trunc`	Supprimer le contenu du fichier après l’ouverture

Exemple

// ios_base_openmode.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>

int main ( )
{
    using namespace std;
    fstream file;
    file.open( "rm.txt", ios_base::out | ios_base::trunc );

    file << "testing";
}

`operator=`

Opérateur d'affectation pour les objets ios_base.

ios_base& operator=(const ios_base& right);

Paramètres

right
Objet de type ios_base.

Valeur de retour

Objet qui est affecté.

Notes

L’opérateur copie les informations de mise en forme stockées, ce qui crée une copie des tableaux extensibles. Elle retourne ensuite *this. La pile de rappels n’est pas copiée.

Cet opérateur est utilisé uniquement par les classes dérivées de ios_base.

`precision`

Spécifie le nombre de chiffres à afficher dans un nombre à virgule flottante.

streamsize precision() const;
streamsize precision(streamsize _Prec);

Paramètres

_Prec
Nombre de chiffres significatifs à afficher, ou nombre de chiffres après la virgule décimale dans la notation fixe.

Valeur de retour

La première fonction membre retourne la précision d’affichage stockée. La deuxième fonction membre stocke _Prec dans la précision d’affichage et retourne sa précédente valeur stockée.

Notes

Les nombres à virgule flottante sont affichés en notation fixe avec fixed.

Exemple

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

int main( )
{
    using namespace std;
    float i = 31.31234F;

    cout.precision( 3 );
    cout << i << endl;          // display three significant digits
    cout << fixed << i << endl; // display three digits after decimal
                                // point
}

31.3
31.312

`pword`

Affecte une valeur à stocker comme pword.

void *& pword(int index);

Paramètres

index
Index de la valeur à stocker en tant que pword.

Notes

La fonction membre retourne une référence à l’index d’élément du tableau extensible avec des éléments de pointeur de typevoid. Tous les éléments sont effectivement présents et contiennent initialement le pointeur Null. La référence retournée n’est pas valide après l’appel suivant à pword l’objet, une fois l’objet modifié par un appel à basic_ios::copyfmt, ou après la destruction de l’objet.

Si l’index est négatif ou si le stockage unique n’est pas disponible pour l’élément, la fonction appelle setstate(badbit) et retourne une référence qui peut ne pas être unique.

Pour obtenir un index unique, pour une utilisation sur tous les objets de type ios_base, appelez xalloc.

Exemple

Consultez xalloc un exemple d’utilisation pword.

`register_callback`

Spécifie une fonction de rappel.

void register_callback(
    event_callback pfn, int idx);

Paramètres

pfn
Pointeur vers la fonction de rappel.

idx
Nombre défini par l’utilisateur.

Notes

La fonction membre envoie (push) la paire {pfn, idx} vers la pile de rappel de la pile de rappels de rappel stockée. Lorsqu’un événement de rappel est signalé, les fonctions sont appelées, dans l’ordre inverse du registre, par l’expression (*pfn)(ev, *this, idx).

Exemple

// ios_base_register_callback.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>

using namespace std;

void callback1( ios_base::event e, ios_base& stream, int arg )
{
    cout << "in callback1" << endl;
    switch ( e )
    {
    case ios_base::erase_event:
        cout << "an erase event" << endl;
        break;
    case ios_base::imbue_event:
        cout << "an imbue event" << endl;
        break;
    case ios_base::copyfmt_event:
        cout << "an copyfmt event" << endl;
        break;
    };
}

void callback2( ios_base::event e, ios_base& stream, int arg )
{
    cout << "in callback2" << endl;
    switch ( e )
    {
    case ios_base::erase_event:
        cout << "an erase event" << endl;
        break;
    case ios_base::imbue_event:
        cout << "an imbue event" << endl;
        break;
    case ios_base::copyfmt_event:
        cout << "an copyfmt event" << endl;
        break;
    };
}

int main( )
{
    // Make sure the imbue will not throw an exception
    // assert( setlocale( LC_ALL, "german" )!=NULL );

    cout.register_callback( callback1, 0 );
    cin.register_callback( callback2, 0 );

    try
    {
        // If no exception because the locale's not found,
        // generate an imbue_event on callback1
        cout.imbue(locale("german"));
    }
    catch(...)
    {
        cout << "exception" << endl;
    }

    // This will
    // (1) erase_event on callback1
    // (2) copyfmt_event on callback2
    cout.copyfmt(cin);

    // We get two erase events from callback2 at the end because
    // both cin and cout have callback2 registered when cin and cout
    // are destroyed at the end of program.
}

in callback1
an imbue event
in callback1
an erase event
in callback2
an copyfmt event
in callback2
an erase event
in callback2
an erase event

`seekdir`

Spécifie le point de départ pour les opérations de décalage.

namespace std {
    class ios_base {
    public:
        typedef implementation-defined-enumerated-type seekdir;
        static const seekdir beg;
        static const seekdir cur;
        static const seekdir end;
        // ...
    };
}

Notes

Le type est un type énuméré qui décrit un objet qui peut stocker le mode de recherche utilisé comme argument pour les fonctions membres de plusieurs iostream classes. Les valeurs distinctes des indicateurs sont :

beg, pour rechercher (modifier la position de lecture ou d’écriture actuelle) par rapport au début d’une séquence (tableau, flux ou fichier).
cur, pour rechercher par rapport à la position actuelle dans une séquence.
end, pour rechercher par rapport à la fin d’une séquence.

Exemple

// ios_base_seekdir.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>

int main ( )
{
    using namespace std;
    fstream file;
    file.open( "rm.txt", ios_base::out | ios_base::trunc );

    file << "testing";
    file.seekp( 0, ios_base::beg );
    file << "a";
    file.seekp( 0, ios_base::end );
    file << "a";
}

`setf`

Définit les indicateurs spécifiés.

fmtflags setf(
    fmtflags _Mask
);
fmtflags setf(
    fmtflags _Mask,
    fmtflags _Unset
);

Paramètres

_Mask
Indicateurs à activer.

_Unset
Indicateurs à désactiver.

Valeur de retour

Indicateurs de format précédents

Notes

La première fonction membre appelle flags(_Mask | _Flags) efficacement (définir les bits sélectionnés), puis retourne les indicateurs de format précédents. La deuxième fonction membre appelle flags(_Mask & fmtfl, flags & ~_Mask) efficacement (remplacez les bits sélectionnés sous un masque), puis retourne les indicateurs de format précédents.

Exemple

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

int main( )
{
    using namespace std;
    int i = 10;
    cout << i << endl;

    cout.unsetf( ios_base::dec );
    cout.setf( ios_base::hex );
    cout << i << endl;

    cout.setf( ios_base::dec );
    cout << i << endl;
    cout.setf( ios_base::hex, ios_base::dec );
    cout << i << endl;
}

`sync_with_stdio`

Garantit que iostream les opérations de bibliothèque runtime C et C se produisent dans l’ordre dans lequel elles apparaissent dans le code source.

static bool sync_with_stdio(
   bool _Sync = true
);

Paramètres

_Sync
Indique si tous les flux sont synchronisés avec stdio.

Valeur de retour

Paramètre précédent pour cette fonction.

Notes

La fonction membre statique stocke un stdio indicateur de synchronisation, qui est initialement true. Quand true, cet indicateur garantit que les opérations sur le même fichier sont correctement synchronisées entre les iostreams fonctions et les fonctions définies dans la bibliothèque standard C++. Sinon, la synchronisation peut ou non être garantie, mais les performances peuvent être améliorées. La fonction stocke _Sync dans l’indicateur stdio de synchronisation et retourne sa valeur stockée précédente. Vous pouvez l’appeler de manière fiable uniquement avant d’effectuer des opérations sur les flux standard.

`unsetf`

Désactive les indicateurs spécifiés.

void unsetf(
   fmtflags _Mask
);

Paramètres

_Mask
Indicateurs que vous souhaitez désactiver.

Notes

La fonction membre appelle flags(~_Mask & flags) efficacement (effacer les bits sélectionnés).

Exemple

Consultez ios_base::setf un exemple d’utilisation unsetf.

`width`

Définit la longueur du flux de sortie.

streamsize width( ) const;
streamsize width(
   streamsize _Wide
);

Paramètres

_Wide
Taille du flux de sortie souhaitée.

Valeur de retour

Paramètre de largeur actuel.

Notes

La première fonction membre retourne la largeur du champ stocké. La deuxième fonction membre stocke _Wide dans la largeur du champ et retourne sa valeur stockée précédente.

Exemple

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

int main( ) {
    using namespace std;

    cout.width( 20 );
    cout << cout.width( ) << endl;
    cout << cout.width( ) << endl;
}

20
0

`xalloc`

Spécifie qu’une variable fait partie du flux.

static int xalloc( );

Valeur de retour

La fonction membre statique retourne une valeur statique stockée, qu’elle incrémente sur chaque appel.

Notes

Vous pouvez utiliser la valeur de retour comme argument d’index unique lors de l’appel des fonctions iword membres ou pword.

Exemple

// ios_base_xalloc.cpp
// compile with: /EHsc
// Lets you store user-defined information.
// iword, jword, xalloc
#include <iostream>

int main( )
{
    using namespace std;

    static const int i = ios_base::xalloc();
    static const int j = ios_base::xalloc();
    cout.iword( i ) = 11;
    cin.iword( i ) = 13;
    cin.pword( j ) = "testing";
    cout << cout.iword( i ) << endl;
    cout << cin.iword( i ) << endl;
    cout << ( char * )cin.pword( j ) << endl;
}

11
13
testing

Voir aussi

Sécurité des threads dans la bibliothèque C++ Standard
iostream, programmation
iostreams, conventions

Partager via

La classe ios_base

Membres

Constructeurs

Typedefs

Énumérations

Constantes

Functions

Opérateurs

Spécifications

event

Notes

Exemple

event_callback

Paramètres

Notes

Exemple

failure

Notes

Exemple

flags

Paramètres

Valeur de retour

Notes

Exemple

fmtflags

Notes

getloc

Valeur de retour

Exemple

imbue

Paramètres

Valeur de retour

Notes

Exemple

Init

Notes

ios_base

Notes

iostate

Notes

iword

Paramètres

Notes

Exemple

openmode

Notes

Exemple

operator=

Paramètres

Valeur de retour

Notes

precision

Paramètres

Valeur de retour

Notes

Exemple

pword

Paramètres

Notes

Exemple

register_callback

Paramètres

Notes

Exemple

seekdir

Notes

Exemple

setf

Paramètres

Valeur de retour

Notes

Exemple

sync_with_stdio

Paramètres

Valeur de retour

Notes

unsetf

Paramètres

Notes

La classe `ios_base`

`event`

`event_callback`

`failure`

`flags`

`fmtflags`

`getloc`

`imbue`

`Init`

`ios_base`

`iostate`

`iword`

`openmode`

`operator=`

`precision`

`pword`

`register_callback`

`seekdir`

`setf`

`sync_with_stdio`

`unsetf`

`width`

`xalloc`