Partager via


La classe basic_ios

Le modèle de classe décrit les fonctions de stockage et de membre communes aux flux d’entrée (du modèle basic_istreamde classe) et aux flux de sortie (du modèle basic_ostreamde classe) qui dépendent des paramètres du modèle. (La classe ios_base décrit ce qui est courant et non dépendant des paramètres du modèle.) Un objet de classe basic_ios<class Elem, class Traits> permet de contrôler un flux avec des éléments de type Elem, dont les caractéristiques de caractère sont déterminées par la classe Traits.

Syntaxe

template <class Elem, class Traits>
class basic_ios : public ios_base

Paramètres

Elem
Type de caractère.

Traits
Type fournissant des informations sur le type de caractère, valeur par défaut char_traits < Elem >.

Notes

Objet de classe basic_ios<class Elem, class Traits> stocke :

Pour plus d’informations, consultez basic_istream et basic_streambuf.

Constructeurs

Constructeur Description
basic_ios Construit la classe basic_ios.

Typedefs

Nom de type Description
char_type Synonyme pour le paramètre du modèle Elem.
int_type Synonyme de Traits::int_type.
off_type Synonyme de Traits::off_type.
pos_type Synonyme de Traits::pos_type.
traits_type Synonyme pour le paramètre du modèle Traits.

Fonctions Membre

Fonction membre Description
bad Indique une perte d'intégrité de la mémoire tampon du flux.
clear Efface tous les indicateurs d'erreur.
copyfmt Copie les indicateurs d'un flux vers un autre.
eof Indique si la fin d'un flux a été atteinte.
exceptions Indique les exceptions qui seront levées par le flux.
fail Indique l'échec de l'extraction d'un champ valide dans un flux.
fill Spécifie ou retourne le caractère qui sera utilisé lorsque le texte n’est pas aussi large que le flux.
good Indique que le flux est en bon état.
imbue Change les paramètres régionaux.
init Appelé par les constructeurs basic_ios.
move Déplace toutes les valeurs, sauf le pointeur vers la mémoire tampon du flux, du paramètre vers l'objet actuel.
narrow Trouve le caractère équivalent à un type char_type donné.
rdbuf Dirige le flux vers la mémoire tampon spécifiée.
rdstate Lit l'état des bits pour les indicateurs.
set_rdbuf Affecte une mémoire tampon de flux comme mémoire tampon de lecture pour cet objet de flux.
setstate Définit des indicateurs supplémentaires.
swap Échange les valeurs de cet objet basic_ios avec celles d'un autre objet basic_ios. Les pointeurs vers les mémoires tampons de flux ne sont pas échangés.
tie Garantit qu'un flux est traité avant un autre flux.
widen Trouve le type char_type équivalent à un caractère donné.

Opérateurs

Opérateur Description
explicit operator bool Permet l'utilisation d'un objet basic_ios comme bool. La conversion de type automatique est désactivée pour éviter des effets secondaires involontaires courants.
operator void * Indique si le flux est toujours en bon état.
operator! Indique si le flux n’est pas incorrect.

Spécifications

En-tête : <ios>

Espace de noms : std

basic_ios::bad

Indique une perte d’intégrité de la mémoire tampon de flux

bool bad() const;

Valeur de retour

true si rdstate & badbit est différent de zéro ; sinon, false.

Pour plus d’informations sur badbit, consultez ios_base::iostate.

Exemple

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

int main( void )
{
    using namespace std;
    bool b = cout.bad( );
    cout << boolalpha;
    cout << b << endl;

    b = cout.good( );
    cout << b << endl;
}

basic_ios::basic_ios

Construit la classe basic_ios.

explicit basic_ios(basic_streambuf<Elem,  Traits>* sb);
basic_ios();

Paramètres

sb
Mémoire tampon standard pour stocker les éléments d’entrée ou de sortie.

Notes

Le premier constructeur initialise ses objets membres en appelant init(_ Sb). Le deuxième constructeur (protégé) laisse ses objets membres non initialisés. Un appel ultérieur pour init initialiser l’objet avant de pouvoir être détruit en toute sécurité.

basic_ios::char_type

Synonyme pour le paramètre du modèle Elem.

typedef Elem char_type;

basic_ios::clear

Efface tous les indicateurs d'erreur.

void clear(iostate state = goodbit, bool reraise = false);
void clear(io_state state);

Paramètres

state
(Facultatif) Indicateurs que vous souhaitez définir après avoir désactivé tous les indicateurs. La valeur par défaut est goodbit.

reraise
(Facultatif) Spécifie si l’exception doit être re-levée. false La valeur par défaut est (ne déclenche pas à nouveau l’exception).

Notes

Les indicateurs sont goodbit, , failbiteofbitet badbit. Tester ces indicateurs avec good, bad, eofet fail

La fonction membre remplace les informations d'état de flux stockées par :

state | (rdbuf != 0 goodbit : badbit)

S’il state&exceptions est différent de zéro, il lève ensuite un objet de classe failure.

Pour plus d’informations, consultez rdbuf et exceptions.

Exemple

Consultez rdstate et getline pour obtenir des exemples à l’aide clearde .

basic_ios::copyfmt

Copie les indicateurs d'un flux vers un autre.

basic_ios<Elem, Traits>& copyfmt(
const basic_ios<Elem, Traits>& right);

Paramètres

right
Flux dont vous voulez copier les indicateurs.

Valeur de retour

Objet this du flux vers lequel vous copiez les indicateurs.

Notes

La fonction membre signale l’événement erase_eventde rappel . Il copie ensuite à partir du right *this caractère de remplissage, du pointeur de liaison et des informations de mise en forme. Avant de modifier le masque d’exception, il signale l’événement copyfmt_eventde rappel . Si une fois la copie terminée, state&exceptions n’est pas différente de zéro, la fonction appelle clear efficacement avec l’argument rdstate. Elle retourne *this.

Exemple

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

int main( )
{
    using namespace std;
    ofstream x( "test.txt" );
    int i = 10;

    x << showpos;
    cout << i << endl;
    cout.copyfmt( x );
    cout << i << endl;
}

basic_ios::eof

Indique si la fin d'un flux a été atteinte.

bool eof() const;

Valeur de retour

true si la fin du flux a été atteinte, false dans le cas contraire.

Notes

La fonction membre retourne true si rdstate & eofbit elle n’est pas nulle. Pour plus d’informations sur eofbit, consultez ios_base::iostate.

Exemple

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

using namespace std;

int main( int argc, char* argv[] )
{
    fstream   fs;
    int n = 1;
    fs.open( "basic_ios_eof.txt" );   // an empty file
    cout << boolalpha
    cout << fs.eof() << endl;
    fs >> n;   // Read the char in the file
    cout << fs.eof() << endl;
}

basic_ios::exceptions

Indique les exceptions qui seront levées par le flux.

iostate exceptions() const;
void exceptions(iostate Newexcept);
void exceptions(io_state Newexcept);

Paramètres

Newexcept
Indicateurs pour lesquels vous voulez lever une exception.

Valeur de retour

Indicateurs actuellement spécifiés pour lever une exception pour le flux.

Notes

La première fonction membre retourne le masque d’exception stocké. La deuxième fonction membre stocke _Except dans le masque d’exception et retourne sa valeur stockée précédente. Le stockage d’un nouveau masque d’exception peut lever une exception comme l’appel clear( rdstate ).

Exemple

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

int main( )
{
    using namespace std;

    cout << cout.exceptions( ) << endl;
    cout.exceptions( ios::eofbit );
    cout << cout.exceptions( ) << endl;
    try
    {
        cout.clear( ios::eofbit );   // Force eofbit on
    }
    catch ( exception &e )
    {
        cout.clear( );
        cout << "Caught the exception." << endl;
        cout << "Exception class: " << typeid(e).name()  << endl;
        cout << "Exception description: " << e.what() << endl;
    }
}
0
1
Caught the exception.
Exception class: class std::ios_base::failure
Exception description: ios_base::eofbit set

basic_ios::fail

Indique l'échec de l'extraction d'un champ valide dans un flux.

bool fail() const;

Valeur de retour

true s’il rdstate & (badbit|failbit) n’est pas différent de zéro, sinon false.

Pour plus d’informations sur failbit, consultez ios_base::iostate.

Exemple

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

int main( void )
{
    using namespace std;
    bool b = cout.fail( );
    cout << boolalpha;
    cout << b << endl;
}

basic_ios::fill

Spécifie ou retourne le caractère qui sera utilisé lorsque le texte n’est pas aussi large que le flux.

char_type fill() const;
char_type fill(char_type Char);

Paramètres

Char
Caractère souhaité comme caractère de remplissage.

Valeur de retour

Caractère de remplissage actuel.

Notes

La première fonction membre retourne le caractère de remplissage stocké. La deuxième fonction membre stocke Char dans le caractère de remplissage et retourne sa précédente valeur stockée.

Exemple

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

int main( )
{
    using namespace std;

    cout << setw( 5 ) << 'a' << endl;
    cout.fill( 'x' );
    cout << setw( 5 ) << 'a' << endl;
    cout << cout.fill( ) << endl;
}
a
xxxxa
x

basic_ios::good

Indique que le flux est en bon état.

bool good() const;

Valeur de retour

truesi rdstate == goodbit (aucun indicateur d’état n’est défini), sinon. false

Pour plus d’informations sur goodbit, consultez ios_base::iostate.

Exemple

Consultez basic_ios::bad un exemple d’utilisation good.

basic_ios::imbue

Change les paramètres régionaux.

locale imbue(const locale& Loc);

Paramètres

Loc
Chaîne de paramètres régionaux.

Valeur de retour

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

Notes

Si rdbuf ce n’est pas un NULL pointeur, la fonction membre appelle

rdbuf-> pubimbue(_ Loc)

Dans tous les cas, elle retourne ios_base::imbue(_ Loc).

Pour plus d’informations, consultez pubimbue et ios_base::imbue.

Exemple

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

int main( )
{
    using namespace std;

    cout.imbue( locale( "french_france" ) );
    double x = 1234567.123456;
    cout << x << endl;
}

basic_ios::init

Appelé par les constructeurs basic_ios.

void init(basic_streambuf<Elem,Traits>* _Sb, bool _Isstd = false);

Paramètres

_Sb
Mémoire tampon standard pour stocker les éléments d’entrée ou de sortie.

_Isstd
Spécifie s’il s’agit d’un flux standard.

Notes

La fonction membre stocke les valeurs de tous les objets membres, afin que :

  • rdbuf retourne _Sb.

  • tie retourne un NULL pointeur.

  • rdstate retourne goodbit s’il _Sb n’est pas différent de zéro ; sinon, il retourne badbit.

  • exceptions retourne goodbit.

  • flags retourne skipws | dec. Pour plus d’informations, consultez skipws et dec.

  • width retourne 0.

  • precision retourne 6.

  • fill retourne le caractère d’espace.

  • getloc retourne locale::classic.

  • iword retourne zéro et pword retourne un NULL pointeur pour toutes les valeurs d’argument.

basic_ios::int_type

Synonyme de traits_type::int_type.

typedef typename traits_type::int_type int_type;

basic_ios::move

Déplace toutes les valeurs, sauf le pointeur vers la mémoire tampon du flux, du paramètre vers l'objet actuel.

void move(basic_ios&& right);

Paramètres

right
Objet ios_base à partir duquel déplacer les valeurs.

Notes

La fonction membre protégée déplace toutes les valeurs stockées à right l’exception *this du stocké stream buffer pointer, qui n’est pas modifié et défini sur right un NULL pointeur dans *this. Le stockage tie pointer est défini sur un NULL pointeur dans right.

basic_ios::narrow

Trouve le caractère équivalent à un type char_type donné.

char narrow(char_type Char, char Default = '\0') const;

Paramètres

Char
char à convertir.

Default
char à retourné si aucun équivalent n’est trouvé.

Valeur de retour

char équivalent à un char_type donné.

Notes

La fonction membre retourne use_facet<ctype<E>>(getloc()).narrow(Char, Default).

Pour plus d’informations, consultez use_facet et getloc.

Exemple

// basic_ios_narrow.cpp
// compile with: /EHsc
#include <ios>
#include <iostream>
#include <wchar.h>

int main( )
{
    using namespace std;
    wchar_t *x = L"test";
    char y[10];
    cout << x[0] << endl;
    wcout << x << endl;
    y[0] = wcout.narrow( x[0] );
    cout << y[0] << endl;
}

basic_ios::off_type

Synonyme de traits_type::off_type.

typedef typename traits_type::off_type off_type;

basic_ios::operator void *

Indique si le flux est toujours en bon état.

operator void *() const;

Valeur de retour

L’opérateur retourne un NULL pointeur uniquement si fail.

Exemple

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

int main( )
{
    using namespace std;
    cout << (bool)(&cout != 0) << endl;   // Stream is still good
}
1

basic_ios::operator!

Indique si le flux n’est pas incorrect.

bool operator!() const;

Valeur de retour

Retourne la même chose que l’appel basic_ios::fail

Exemple

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

int main( )
{
    using namespace std;
    cout << !cout << endl;   // Stream is not bad
}
0

basic_ios::operator bool

Permet l'utilisation d'un objet basic_ios comme bool. La conversion de type automatique est désactivée pour éviter des effets secondaires involontaires courants.

explicit operator bool() const;

Notes

Retourne true si le flux n’a aucune erreur ; sinon false.

basic_ios::pos_type

Synonyme de traits_type::pos_type.

typedef typename traits_type::pos_type pos_type;

basic_ios::rdbuf

Dirige le flux vers la mémoire tampon spécifiée.

basic_streambuf<Elem, Traits> *rdbuf() const;
basic_streambuf<Elem, Traits> *rdbuf(
basic_streambuf<Elem, Traits>* _Sb);

Paramètres

_Sb
Un flux.

Notes

La première fonction membre retourne le pointeur de mémoire tampon de flux stocké.

La deuxième fonction membre stocke _Sb dans le pointeur de mémoire tampon de flux stocké et retourne la valeur précédemment stockée.

Exemple

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

int main( )
{
    using namespace std;
    ofstream file( "rdbuf.txt" );
    streambuf *x = cout.rdbuf( file.rdbuf( ) );
    cout << "test" << endl;   // Goes to file
    cout.rdbuf(x);
    cout << "test2" << endl;
}
test2

basic_ios::rdstate

Lit l’état d’erreur du flux.

iostate rdstate() const;

Valeur de retour

Informations de l’état de flux stocké.

Exemple

// basic_ios_rdstate.cpp
// compile with: /EHsc
#include <iostream>
#include <fstream>
using namespace std;

void TestFlags( ios& x )
{
    cout << ( x.rdstate( ) & ios::badbit ) << endl;
    cout << ( x.rdstate( ) & ios::failbit ) << endl;
    cout << ( x.rdstate( ) & ios::eofbit ) << endl;
    cout << endl;
}

int main( )
{
    fstream x( "c:\test.txt", ios::out );
    x.clear( );
    TestFlags( x );
    x.clear( ios::badbit | ios::failbit | ios::eofbit );
    TestFlags( x );
}
0
0
0

4
2
1

basic_ios::setstate

Définit les indicateurs d’erreur de flux spécifiés (les indicateurs d’état d’erreur de flux actuellement définis restent inchangés) :

flag Description
goodbit Aucune erreur
badbit Erreur irrécupérable
failbit Échec de l’opération d’E/S, par exemple une erreur de mise en forme ou d’extraction
eofbit Le flux a atteint la fin du fichier
void setstate(iostate _State);

Paramètres

_State
Indicateurs supplémentaires à définir.

Notes

La fonction membre appelle clear(_ state | rdstate)essentiellement .

Pour plus d’informations, consultez clear et rdstate.

Exemple

// basic_ios_setstate.cpp
// compile with: /EHsc
#include <ios>
#include <iostream>
using namespace std;

int main( )
{
    bool b = cout.bad( );
    cout << b << endl;   // Good
    cout.clear( ios::badbit );
    b = cout.bad( );
    // cout.clear( );
    cout << b << endl;   // Is bad, good
    b = cout.fail( );
    cout << b << endl;   // Not failed
    cout.setstate( ios::failbit );
    b = cout.fail( );
    cout.clear( );
    cout << b << endl;   // Is failed, good
    return 0;
}
0
1

basic_ios::set_rdbuf

Affecte une mémoire tampon de flux comme mémoire tampon de lecture pour cet objet de flux.

void set_rdbuf(
basic_streambuf<Elem, Tr>* strbuf)

Paramètres

strbuf
Mémoire tampon de flux qui doit devenir la mémoire tampon de lecture.

Notes

La fonction membre protégée stocke strbuf dans le pointeur de la mémoire tampon de flux. Il n’appelle clearpas .

basic_ios::tie

Garantit qu'un flux est traité avant un autre flux.

basic_ostream<Elem, Traits> *tie() const;
basic_ostream<Elem, Traits> *tie(
basic_ostream<Elem, Traits>* str);

Paramètres

str
Un flux.

Valeur de retour

La première fonction membre retourne le pointeur de lien stocké. La deuxième fonction membre stocke str dans le pointeur de lien et retourne sa précédente valeur stockée.

Notes

tie entraîne la synchronisation de deux flux, de sorte que les opérations sur un flux se produisent après la fin des opérations sur l’autre flux.

Exemple

Dans l’exemple suivant, en liant cin cout, il est garanti que la Enter a number: chaîne passe à la console avant que le nombre lui-même soit extrait cinde . Cela élimine la possibilité que la chaîne « Entrer un nombre : » reste assise dans la mémoire tampon lorsque le nombre est lu, de sorte que nous sommes certains que l’utilisateur a réellement une invite à répondre. Par défaut, cin et cout sont liés.

#include <ios>
#include <iostream>

int main( )
{
    using namespace std;
    int i;
    cin.tie( &cout );
    cout << "Enter a number:";
    cin >> i;
}

basic_ios::traits_type

Synonyme pour le paramètre du modèle Traits.

typedef Traits traits_type;

basic_ios::widen

Trouve le char_type équivalent à un char donné.

char_type widen(char Char) const;

Paramètres

Char
Caractère à convertir.

Valeur de retour

Trouve le char_type équivalent à un char donné.

Notes

La fonction membre retourne use_facet<ctype<E>>(getloc).widen(Char).

Pour plus d’informations, consultez use_facet et getloc.

Exemple

// basic_ios_widen.cpp
// compile with: /EHsc
#include <ios>
#include <iostream>
#include <wchar.h>

int main( )
{
    using namespace std;
    char *z = "Hello";
    wchar_t y[2] = {0,0};
    cout << z[0] << endl;
    y[0] = wcout.widen( z[0] );
    wcout << &y[0] << endl;
}

basic_ios::swap

Échange les valeurs de cet objet basic_ios avec celles d'un autre objet basic_ios. Toutefois, les pointeurs vers les mémoires tampons de flux ne sont pas échangés.

void swap(basic_ios&& right);

Paramètres

right
Objet basic_ios utilisé pour échanger des valeurs.

Notes

La fonction de membre protégée échange toutes les valeurs stockées dans right avec *this, sauf le stream buffer pointer stocké.

Voir aussi

Sécurité des threads dans la bibliothèque C++ Standard
iostream Programmation
iostreams Conventions