Partager via


La classe ios_base

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_iosde 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;
}
C

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