basic_streambuf, classe

Article
10/12/2023

Décrit une classe de base abstraite pour dériver une mémoire tampon de flux qui contrôle la transmission des éléments depuis et vers une représentation spécifique d'un flux.

Syntaxe

template <class Elem, class Tr = char_traits<Elem>>
class basic_streambuf;

Paramètres

Elem
Un char_type.

Tr
Le traits_type du caractère.

Notes

Le modèle de classe décrit une classe de base abstraite pour dériver une mémoire tampon de flux, qui contrôle la transmission d’éléments vers et à partir d’une représentation spécifique d’un flux. Un objet de classe basic_streambuf permet de contrôler un flux avec des éléments de type Tr, également appelé char_type, dont les caractéristiques de caractère sont déterminées par la classe char_traits, également appelée traits_type.

Chaque mémoire tampon de flux contrôle conceptuellement deux flux indépendants : un pour les extractions (entrée) et un pour les insertions (sortie). Une représentation spécifique peut cependant rendre l'un ou l'autre (ou les deux) de ces flux inaccessible. Elle conserve en général une relation entre les deux flux. Ce que vous insérez dans le flux de sortie d’un basic_stringbufElem<, Tr> objet, par exemple, est ce que vous extrayez ultérieurement de son flux d’entrée. Lorsque vous positionnez un flux d’un basic_filebufElem<, Tr> objet, vous positionnez l’autre flux en tandem.

L’interface publique pour le modèle basic_streambuf de classe fournit les opérations communes à toutes les mémoires tampons de flux, mais spécialisées. L'interface protégée fournit les opérations nécessaires pour qu'une représentation spécifique d'un flux effectue son travail. Les fonctions membres virtuelles protégées vous permettent de personnaliser le comportement d'une mémoire tampon de flux dérivée pour une représentation spécifique d'un flux. Chaque mémoire tampon de flux dérivée de cette bibliothèque décrit comment elle spécialise le comportement de ses fonctions membres virtuelles protégées. Le comportement par défaut de la classe de base, souvent à ne rien faire, est décrit dans cet article.

Les fonctions membres protégées restantes contrôlent la copie de et vers le stockage fourni pour mettre en mémoire tampon les transmissions vers et depuis des flux. Par exemple, une mémoire tampon d'entrée est caractérisée par :

eback, un pointeur vers le début de la mémoire tampon.
gptr, un pointeur vers l’élément suivant à lire.
egptr, pointeur au-delà de la fin de la mémoire tampon.

De façon similaire, une mémoire tampon de sortie est caractérisée par :

pbase, un pointeur vers le début de la mémoire tampon.
pptr, un pointeur vers l’élément suivant à écrire.
ppetr, pointeur au-delà de la fin de la mémoire tampon.

Pour toutes les mémoires tampons, le protocole suivant est utilisé :

Si le pointeur suivant est null, c'est qu'il n'existe pas de mémoire tampon. Dans le cas contraire, les trois pointeurs pointent tous dans la même séquence. Ils peuvent être comparés de façon fiable quant à l'ordre.
Pour une mémoire tampon de sortie, si le pointeur suivant est inférieur au pointeur de fin, vous pouvez stocker un élément à la position d'écriture désignée par le pointeur suivant.
Pour une mémoire tampon d'entrée, si le pointeur suivant est inférieur au pointeur de fin, vous pouvez lire un élément à la position de lecture désignée par le pointeur suivant.
Pour une mémoire tampon d'entrée, si le pointeur de début est inférieur au pointeur suivant, vous pouvez replacer un élément à la position de replacement désignée par le pointeur suivant décrémenté.

Toutes les fonctions membres virtuelles protégées que vous écrivez pour une classe dérivée de basic_streambuf<Elem, Tr> doivent coopérer pour maintenir ce protocole.

Objet de classe basic_streambuf<Elem, Tr> stocke les six pointeurs précédemment décrits. Il stocke également un objet de paramètres régionaux dans un objet de type locale pour une éventuelle utilisation par une mémoire tampon de flux dérivée.

Constructeurs

Constructeur	Description
basic_streambuf	Construit un objet de type `basic_streambuf`.

Typedefs

Nom de type	Description
char_type	Associe un nom de type au paramètre de modèle `Elem`.
int_type	Associe un nom de type dans la portée `basic_streambuf` avec le paramètre de modèle `Elem`.
off_type	Associe un nom de type dans la portée `basic_streambuf` avec le paramètre de modèle `Elem`.
pos_type	Associe un nom de type dans la portée `basic_streambuf` avec le paramètre de modèle `Elem`.
traits_type	Associe un nom de type au paramètre de modèle `Tr`.

Fonctions Membre

Fonction membre	Description
eback	Une fonction protégée qui retourne un pointeur vers le début de la mémoire tampon d'entrée.
egptr	Fonction protégée qui retourne un pointeur au-delà de la fin de la mémoire tampon d’entrée.
epptr	Fonction protégée qui retourne un pointeur au-delà de la fin de la mémoire tampon de sortie.
gbump	Une fonction protégée qui ajoute `count` au pointeur suivant pour la mémoire tampon d'entrée.
getloc	Obtient les paramètres régionaux de l'objet `basic_streambuf`.
gptr	Une fonction protégée qui retourne un pointeur vers l'élément suivant de la mémoire tampon d'entrée.
imbue	Fonction virtuelle protégée appelée par pubimbue.
in_avail	Retourne le nombre d'éléments qui sont prêts à être lus dans la mémoire tampon.
overflow	Fonction virtuelle protégée qui peut être appelée quand un nouveau caractère est inséré dans une mémoire tampon saturée.
pbackfail	Une fonction membre virtuelle protégée qui tente de replacer un élément dans le flux d'entrée, puis d'en faire l'élément actif (pointé par le pointeur suivant).
pbase	Une fonction protégée qui retourne un pointeur vers le début de la mémoire tampon de sortie.
pbump	Une fonction protégée qui ajoute `count` au pointeur suivant pour la mémoire tampon de sortie.
pptr	Une fonction protégée qui retourne un pointeur vers l'élément suivant de la mémoire tampon de sortie.
pubimbue	Définit les paramètres régionaux de l'objet `basic_streambuf`.
pubseekoff	Appelle seekoff, une fonction virtuelle protégée qui est remplacée dans une classe dérivée.
pubseekpos	Appelle seekpos, une fonction virtuelle protégée qui est remplacée dans une classe dérivée et réinitialise la position actuelle du pointeur.
pubsetbuf	Appelle setbuf, une fonction virtuelle protégée qui est remplacée dans une classe dérivée.
pubsync	Appelle sync, une fonction virtuelle protégée qui est remplacée dans une classe dérivée et met à jour le flux externe associé à cette mémoire tampon.
sbumpc	Lit et retourne l'élément actuel, en déplaçant le pointeur du flux.
seekoff	La fonction membre virtuelle protégée tente de modifier les positions actuelles des flux contrôlés.
seekpos	La fonction membre virtuelle protégée tente de modifier les positions actuelles des flux contrôlés.
setbuf	La fonction membre virtuelle protégée effectue une opération spécifique à chaque mémoire tampon de flux dérivée.
setg	Une fonction protégée qui stocke `_Gbeg` dans le pointeur de début, `_Gnext` dans le pointeur suivant et `_Gend` dans le pointeur de fin pour la mémoire tampon d'entrée.
setp	Une fonction protégée qui stocke `_Pbeg` dans le pointeur de début et `_Pend` dans le pointeur suivant dans le pointeur de fin pour la mémoire tampon de sortie.
sgetc	Retourne l'élément actuel sans changer la position dans le flux.
sgetn	Retourne le nombre d'éléments lus.
showmanyc	Fonction membre virtuelle protégée qui retourne le nombre de caractères pouvant être extraits du flux d’entrée. Il garantit également que le programme ne sera pas soumis à une attente indéfinie.
snextc	Lit l'élément actuel et retourne l'élément suivant.
sputbackc	Place un `char_type` dans le flux.
sputc	Place un caractère dans le flux.
sputn	Place une chaîne de caractères dans le flux.
stossc	Se déplace après l'élément actuel du flux.
sungetc	Obtient un caractère du flux.
swap	Échange les valeurs de cet objet avec les valeurs du paramètre de l'objet `basic_streambuf`.
sync	Une fonction virtuelle protégée qui tente de synchroniser les flux contrôlés avec tous les flux externes associés.
uflow	Une fonction virtuelle protégée qui extrait l'élément actuel du flux d'entrée.
underflow	Une fonction virtuelle protégée qui extrait l'élément actuel du flux d'entrée.
xsgetn	Une fonction virtuelle protégée qui extrait des éléments du flux d'entrée.
xsputn	Une fonction virtuelle protégée qui insère des éléments dans le flux d'entrée.

Opérateurs

Opérateur	Description
operator=	Assigne les valeurs de cet objet à partir d'un autre objet `basic_streambuf`.

Spécifications

Header :<streambuf>

Espace de noms : std

basic_streambuf ::basic_streambuf

Construit un objet de type basic_streambuf.

basic_streambuf();

basic_streambuf(const basic_streambuf& right);

Paramètres

right
Référence lvalue à l’objet basic_streambuf qui est utilisée pour définir les valeurs de cet objet basic_streambuf.

Notes

Le premier constructeur protégé stocke un pointeur null dans tous les pointeurs contrôlant la mémoire tampon d’entrée et la mémoire tampon de sortie. Il stocke également locale::classic dans l’objet de paramètres régionaux. Pour plus d’informations, consultez locale::classic.

Le deuxième constructeur protégé copie les pointeurs et les paramètres régionaux de droite.

basic_streambuf ::char_type

Associe un nom de type au paramètre de modèle Elem.

typedef Elem char_type;

basic_streambuf ::eback

Une fonction protégée qui retourne un pointeur vers le début de la mémoire tampon d'entrée.

char_type *eback() const;

Valeur de retour

Pointeur vers le début de la mémoire tampon d’entrée.

basic_streambuf ::egptr

Fonction protégée qui retourne un pointeur au-delà de la fin de la mémoire tampon d’entrée.

char_type *egptr() const;

Valeur de retour

Pointeur au-delà de la fin de la mémoire tampon d’entrée.

basic_streambuf ::ppetr

Fonction protégée qui retourne un pointeur au-delà de la fin de la mémoire tampon de sortie.

char_type *epptr() const;

Valeur de retour

Pointeur au-delà de la fin de la mémoire tampon de sortie.

basic_streambuf ::gbump

Fonction protégée qui ajoute le nombre au pointeur suivant pour la mémoire tampon d’entrée.

void gbump(int count);

Paramètres

count
Quantité de laquelle faire avancer le pointeur.

basic_streambuf ::getloc

Obtient les paramètres régionaux de l’objet basic_streambuf.

locale getloc() const;

Valeur de retour

Objet des paramètres régionaux stocké.

Notes

Pour plus d’informations, consultez ios_base::getloc.

Exemple

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

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

basic_streambuf ::gptr

Une fonction protégée qui retourne un pointeur vers l'élément suivant de la mémoire tampon d'entrée.

char_type *gptr() const;

Valeur de retour

Pointeur vers l’élément suivant de la mémoire tampon d’entrée.

basic_streambuf ::imbue

Fonction virtuelle protégée appelée par pubimbue.

virtual void imbue(const locale& _Loc);

Paramètres

_Loc
Référence à des paramètres régionaux.

Notes

Le comportement par défaut consiste à n’effectuer aucune opération.

basic_streambuf ::in_avail

Retourne le nombre d'éléments qui sont prêts à être lus dans la mémoire tampon.

streamsize in_avail();

Valeur de retour

Nombre d’éléments prêts à être lus dans la mémoire tampon.

Notes

Si une position de lecture est disponible, la fonction membre retourne le gptr egptr - . Sinon, elle retourne showmanyc.

Exemple

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

int main( )
{
   using namespace std;
   char c;
   // cin's buffer is empty, in_avail will return 0
   cout << cin.rdbuf( )->in_avail( ) << endl;
   cin >> c;
   cout << cin.rdbuf( )->in_avail( ) << endl;
}

basic_streambuf ::int_type

Associe un nom de type de la portée basic_streambuf à l’un des types d’un paramètre de modèle.

typedef typename traits_type::int_type int_type;

basic_streambuf ::off_type

Associe un nom de type de la portée basic_streambuf à l’un des types d’un paramètre de modèle.

typedef typename traits_type::off_type off_type;

basic_streambuf ::operator=

Assigne les valeurs de cet objet à partir d'un autre objet basic_streambuf.

basic_streambuf& operator=(const basic_streambuf& right);

Paramètres

right
Référence lvalue à l'objet basic_streambuf qui est utilisée pour affecter des valeurs à cet objet.

Notes

L’opérateur membre protégé copie à partir de droite les pointeurs qui contrôlent la mémoire tampon d’entrée et la mémoire tampon de sortie. Il stocke également right.getloc() dans le locale object. Elle retourne *this.

basic_streambuf ::overflow

Fonction virtuelle protégée qui peut être appelée quand un nouveau caractère est inséré dans une mémoire tampon saturée.

virtual int_type overflow(int_type _Meta = traits_type::eof());

Paramètres

_Méta
Caractère à insérer dans la mémoire tampon ou traits_type::eof.

Valeur de retour

Si la fonction ne peut pas réussir, elle retourne traits_type ::eof ou lève une exception. Sinon, elle retourne traits_type::not_eof(_ Meta). Le comportement par défaut consiste à retourner traits_type::eof.

Notes

Si _Meta ne correspond pas à traits_type ::eof, la fonction membre virtuelle protégée tente d’insérer l’élément traits_type ::to_char_type(_Meta) dans le flux de sortie. Elle peut le faire de différentes manières :

Si une write position est disponible, elle peut stocker l’élément dans la position d’écriture et incrémenter le pointeur suivant pour la mémoire tampon de sortie.
Elle peut rendre disponible une position d’écriture en allouant du stockage nouveau ou supplémentaire à la mémoire tampon de sortie.
Elle peut rendre disponible une position d’écriture en écrivant, dans une destination externe quelconque, tout ou partie des éléments entre le pointeur de début et le suivant pour la mémoire tampon de sortie.

La fonction overflow virtuelle, avec les fonctions sync et underflow, définit les caractéristiques de la classe dérivée de streambuf. Chaque classe dérivée peut implémenter la fonction overflow de différentes façons, mais l’interface avec la classe de flux d’appel est la même.

La fonction overflow est souvent appelée par les fonctions publiques streambuf comme sputc et sputn quand la zone de placement est saturée, mais les autres classes, y compris les classes de flux, peuvent appeler overflow à tout moment.

La fonction consomme les caractères de la zone de placement entre les pointeurs pbase et pptr, puis réinitialise la zone de placement. La overflow fonction doit également consommer nCh (si nCh ce n’est pas le cas EOF), ou elle peut choisir de placer ce caractère dans la nouvelle zone put afin qu’elle soit consommée lors de l’appel suivant.

La définition du mot consommation varie selon les classes dérivées. Par exemple, la classe filebuf écrit ses caractères dans un fichier, tandis que la classe strstreambuf les conserve dans sa mémoire tampon et (si la mémoire tampon est désignée comme étant dynamique) étend la mémoire tampon en réponse à un appel à la fonction overflow. Cette extension est obtenue en libérant l’ancienne mémoire tampon et en la remplaçant par une nouvelle mémoire tampon plus grande. Les pointeurs sont ajustés selon les besoins.

basic_streambuf ::p backfail

Une fonction membre virtuelle protégée qui tente de replacer un élément dans le flux d'entrée, puis d'en faire l'élément actif (pointé par le pointeur suivant).

virtual int_type pbackfail(int_type _Meta = traits_type::eof());

Paramètres

_Méta
Caractère à insérer dans la mémoire tampon ou traits_type::eof.

Valeur de retour

Si la fonction ne peut pas réussir, elle retourne traits_type ::eof ou lève une exception. Sinon, elle retourne une autre valeur. Le comportement par défaut consiste à retourner traits_type::eof.

Notes

Si _Meta compare égale à traits_type ::eof, l’élément à renvoyer est effectivement celui déjà présent dans le flux avant l’élément actuel. Sinon, cet élément est remplacé par traits_type ::to_char_type(_Meta). La fonction peut remettre un élément de différentes manières :

Si une position où remettre l’élément est disponible, elle peut stocker l’élément dans cette position et décrémenter le pointeur suivant pour la mémoire tampon d’entrée.
Elle peut rendre disponible une position en allouant du stockage nouveau ou supplémentaire à la mémoire tampon d’entrée.
Pour une mémoire tampon de flux avec des flux d’entrée et de sortie courants, elle peut rendre disponible une position en écrivant, dans une destination externe quelconque, tout ou partie des éléments entre le pointeur de début et le suivant pour la mémoire tampon de sortie.

basic_streambuf ::p base

Une fonction protégée qui retourne un pointeur vers le début de la mémoire tampon de sortie.

char_type *pbase() const;

Valeur de retour

Pointeur vers le début de la mémoire tampon de sortie.

basic_streambuf ::p bump

Fonction protégée qui ajoute le nombre au pointeur suivant pour la mémoire tampon de sortie.

void pbump(int count);

Paramètres

count
Nombre de caractères duquel avancer la position d’écriture.

basic_streambuf ::p os_type

Associe un nom de type de la portée basic_streambuf à l’un des types d’un paramètre de modèle.

typedef typename traits_type::pos_type pos_type;

basic_streambuf ::p ptr

Une fonction protégée qui retourne un pointeur vers l'élément suivant de la mémoire tampon de sortie.

char_type *pptr() const;

Valeur de retour

Pointeur vers l’élément suivant de la mémoire tampon de sortie.

basic_streambuf ::p ubimbue

Définit les paramètres régionaux de l’objet basic_streambuf.

locale pubimbue(const locale& _Loc);

Paramètres

_Loc
Référence à des paramètres régionaux.

Valeur de retour

Valeur précédente stockée dans l’objet de paramètres régionaux.

Notes

La fonction membre stocke _ Loc dans l’objet de paramètres régionaux et appelle imbue.

Exemple

Consultez basic_ios::imbue pour obtenir un exemple d’utilisation de pubimbue.

basic_streambuf ::p ubseekoff

Appelle seekoff, une fonction virtuelle protégée qui est remplacée dans une classe dérivée.

pos_type pubseekoff(off_type _Off,
    ios_base::seekdir _Way,
    ios_base::openmode _Which = ios_base::in | ios_base::out);

Paramètres

_De
Position à rechercher par rapport à _Way.

_Manière
Point de départ des opérations de décalage. Consultez seekdir pour connaître les valeurs possibles.

_Quel
Spécifie le mode pour la position du pointeur. Par défaut, vous êtes autorisé à modifier les positions de lecture et d’écriture.

Valeur de retour

Retourne la nouvelle position ou une position de flux non valide (seekoff(_ Off, _Way, _Which)).

Notes

Déplace le pointeur par rapport à _Way.

basic_streambuf ::p ubseekpos

Appelle seekpos, une fonction virtuelle protégée qui est remplacée dans une classe dérivée et réinitialise la position actuelle du pointeur.

pos_type pubseekpos(pos_type _Sp, ios_base::openmode _Which = ios_base::in | ios_base::out);

Paramètres

_Sp
Position à rechercher.

_Quel
Spécifie le mode pour la position du pointeur. Par défaut, vous êtes autorisé à modifier les positions de lecture et d’écriture.

Valeur de retour

Nouvelle position ou position de flux non valide. Pour déterminer si la position du flux est non valide, comparez la valeur de retour à pos_type(off_type(-1)).

Notes

La fonction membre retourne seekpos(_ Sp, _Which).

basic_streambuf ::p ubsetbuf

Appelle setbuf, une fonction virtuelle protégée qui est remplacée dans une classe dérivée.

basic_streambuf<Elem, Tr> *pubsetbuf(
    char_type* _Buffer,
    streamsize count);

Paramètres

_Tampon
Pointeur vers char_type pour cette instanciation.

count
Taille de la mémoire tampon.

Valeur de retour

Retourne setbuf( _Buffer, count).

basic_streambuf ::p ubsync

Appelle sync, une fonction virtuelle protégée qui est remplacée dans une classe dérivée et met à jour le flux externe associé à cette mémoire tampon.

int pubsync();

Valeur de retour

Retourne la synchronisation ou -1 en cas d’échec.

basic_streambuf ::sbumpc

Lit et retourne l'élément actuel, en déplaçant le pointeur du flux.

int_type sbumpc();

Valeur de retour

Élément actuel.

Notes

Si une position de lecture est disponible, la fonction membre retourne traits_type ::to_int_type(*gptr) et incrémente le pointeur suivant pour la mémoire tampon d’entrée. Sinon, elle retourne uflow.

Exemple

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

int main( )
{
   using namespace std;
   int i = 0;
   i = cin.rdbuf( )->sbumpc( );
   cout << i << endl;
}

33
51

basic_streambuf ::seekoff

Fonction membre virtuelle protégée qui tente de modifier les positions actuelles des flux contrôlés.

virtual pos_type seekoff(
    off_type _Off,
    ios_base::seekdir _Way,
    ios_base::openmode _Which = ios_base::in | ios_base::out);

Paramètres

_De
Position à rechercher par rapport à _Way.

_Manière
Point de départ des opérations de décalage. Consultez seekdir pour connaître les valeurs possibles.

_Quel
Spécifie le mode pour la position du pointeur. Par défaut, vous êtes autorisé à modifier les positions de lecture et d’écriture.

Valeur de retour

Retourne la nouvelle position ou une position de flux non valide (seekoff (_ Désactivé, _Way, _Which)).

Notes

La nouvelle position est déterminée comme suit :

Si _Way == ios_base::beg, la nouvelle position est le début du flux plus _ Off.
Si _Way == ios_base::cur, la nouvelle position est la position actuelle du flux plus _ Off.
Si _Way == ios_base::end, la nouvelle position est la fin du flux plus _ Off.

En règle générale, si which & ios_base::in est différent de zéro, le flux d’entrée est affecté et si which & ios_base::out est différent de zéro, le flux de sortie est affecté. Toutefois, l’utilisation réelle de ce paramètre varie selon les mémoires tampons de flux dérivées.

Si la fonction réussit à modifier la ou les positions du flux, elle retourne la ou les positions du flux qui en résultent. Sinon, elle retourne une position de flux non valide. Le comportement par défaut consiste à retourner une position de flux non valide.

basic_streambuf ::seekpos

Fonction membre virtuelle protégée qui tente de modifier les positions actuelles des flux contrôlés.

virtual pos_type seekpos(pos_type _Sp, ios_base::openmode _Which = ios_base::in | ios_base::out);

Paramètres

_Sp
Position à rechercher.

_Quel
Spécifie le mode pour la position du pointeur. Par défaut, vous êtes autorisé à modifier les positions de lecture et d’écriture.

Valeur de retour

Nouvelle position ou position de flux non valide. Pour déterminer si la position du flux est non valide, comparez la valeur de retour à pos_type(off_type(-1)).

Notes

La nouvelle position est _ Sp.

Si la fonction réussit à modifier la ou les positions du flux, elle retourne la ou les positions du flux qui en résultent. Sinon, elle retourne une position de flux non valide (-1). Le comportement par défaut consiste à retourner une position de flux non valide.

basic_streambuf ::setbuf

Fonction membre virtuelle protégée qui effectue une opération spécifique pour chaque mémoire tampon de flux dérivée.

virtual basic_streambuf<Elem, Tr> *setbuf(
    char_type* _Buffer,
    streamsize count);

Paramètres

_Tampon
Pointeur vers une mémoire tampon.

count
Taille de la mémoire tampon.

Valeur de retour

Le comportement par défaut consiste à retourner this.

Notes

Consultez basic_filebuf. setbuf fournit une zone de mémoire pour l’objet streambuf à utiliser. La façon dont la mémoire tampon est utilisée est définie dans les classes dérivées.

basic_streambuf ::setg

Fonction protégée qui stocke _ Gbeg dans le pointeur de début, _Gnext dans le pointeur suivant et _Gend dans le pointeur de fin pour la mémoire tampon d’entrée.

void setg(char_type* _Gbeg,
    char_type* _Gnext,
    char_type* _Gend);

Paramètres

_Gbeg
Pointeur vers le début de la mémoire tampon.

_Gnext
Pointeur vers un emplacement situé au milieu de la mémoire tampon.

_Gend
Pointeur vers la fin de la mémoire tampon.

basic_streambuf ::setp

Fonction protégée qui stocke _Pbeg dans le pointeur de début et _Pend dans le pointeur final pour la mémoire tampon de sortie.

void setp(char_type* _Pbeg, char_type* _Pend);

Paramètres

_Pbeg
Pointeur vers le début de la mémoire tampon.

_Pend
Pointeur vers la fin de la mémoire tampon.

basic_streambuf ::sgetc

Retourne l'élément actuel sans changer la position dans le flux.

int_type sgetc();

Valeur de retour

Élément actuel.

Notes

Si une position de lecture est disponible, la fonction membre retourne traits_type::to_int_type( *gptr). Sinon, elle retourne underflow.

Exemple

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

int main( )
{
   using namespace std;
   ifstream myfile( "basic_streambuf_sgetc.txt", ios::in );

   char i = myfile.rdbuf( )->sgetc( );
   cout << i << endl;
   i = myfile.rdbuf( )->sgetc( );
   cout << i << endl;
}

basic_streambuf ::sgetn

Extrait jusqu’à compter les caractères de la mémoire tampon d’entrée et les stocke dans le ptr de mémoire tampon fourni.

Cette méthode est potentiellement dangereuse, car elle suppose que l’appelant vérifie que les valeurs passées sont correctes.

streamsize sgetn(
    char_type* ptr,
    streamsize count);

Paramètres

ptr
Mémoire tampon qui contient les caractères extraits.

count
Nombre d’éléments à lire.

Valeur de retour

Nombre d’éléments lus. Pour plus d’informations, consultez streamize pour plus d’informations.

Notes

La fonction membre retourne xsgetn( ptr, count).

Exemple

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

int main()
{
    using namespace std;

    ifstream myfile("basic_streambuf_sgetn.txt", ios::in);
    char a[10];

    // Extract 3 characters from myfile and store them in a.
    streamsize i = myfile.rdbuf()->sgetn(&a[0], 3);  // C4996
    a[i] = myfile.widen('\0');

    // Display the size and contents of the buffer passed to sgetn.
    cout << i << " " << a << endl;

    // Display the contents of the original input buffer.
    cout << myfile.rdbuf() << endl;
}

basic_streambuf ::showmanyc

Fonction membre virtuelle protégée qui retourne le nombre de caractères qui peuvent être extraits du flux d’entrée et s’assurer que le programme ne sera pas soumis à une attente indéfinie.

virtual streamsize showmanyc();

Valeur de retour

Le comportement par défaut consiste à retourner zéro.

basic_streambuf ::snextc

Lit l'élément actuel et retourne l'élément suivant.

int_type snextc();

Valeur de retour

Élément suivant dans le flux.

Notes

La fonction membre appelle sbumpc et, si cette fonction retourne traits_type::eof, retourne traits_type::eof. Sinon, elle retourne sgetc.

Exemple

// basic_streambuf_snextc.cpp
// compile with: /EHsc
#include <iostream>
int main( )
{
   using namespace std;
   int i = 0;
   i = cin.rdbuf( )->snextc( );
   // cout << ( int )char_traits<char>::eof << endl;
   cout << i << endl;
}

aa

aa97

basic_streambuf ::sputbackc

Place un char_type dans le flux.

int_type sputbackc(char_type _Ch);

Paramètres

_Ch
Le caractère .

Valeur de retour

Retourne le caractère ou un échec.

Notes

Si une position de putback est disponible et que _Ch compare le caractère stocké dans cette position, la fonction membre décrémente le pointeur suivant pour la mémoire tampon d’entrée et retourne traits_type ::to_int_type( _Ch). Sinon, elle retourne pbackfail( _Ch).

Exemple

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

int main( )
{
    using namespace std;

    ifstream myfile("basic_streambuf_sputbackc.txt",
        ios::in);

    int i = myfile.rdbuf()->sbumpc();
    cout << (char)i << endl;
    int j = myfile.rdbuf()->sputbackc('z');
    if (j == 'z')
    {
        cout << "it worked" << endl;
    }
    i = myfile.rdbuf()->sgetc();
    cout << (char)i << endl;
}

basic_streambuf ::sputc

Place un caractère dans le flux.

int_type sputc(char_type _Ch);

Paramètres

_Ch
Le caractère .

Valeur de retour

Retourne le caractère, en cas de réussite.

Notes

Si une write position valeur est disponible, la fonction membre stocke _Ch dans la position d’écriture, incrémente le pointeur suivant pour la mémoire tampon de sortie et retourne traits_type ::to_int_type( _Ch). Sinon, elle retourne overflow( _Ch).

Exemple

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

int main( )
{
   using namespace std;

   int i = cout.rdbuf( )->sputc( 'a' );
   cout << endl << ( char )i << endl;
}

a
a

basic_streambuf ::sputn

Place une chaîne de caractères dans le flux.

streamsize sputn(const char_type* ptr, streamsize count);

Paramètres

ptr
La chaîne de caractères.

count
Le nombre de caractères.

Valeur de retour

Nombre de caractères insérés dans le flux.

Notes

La fonction membre retourne xsputn( ptr, count). Pour plus d’informations, consultez la section Remarques de ce membre pour plus d’informations.

Exemple

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

int main()
{
    using namespace std;

    streamsize i = cout.rdbuf()->sputn("test", 4);
    cout << endl << i << endl;
}

test
4

basic_streambuf ::stossc

Se déplace après l'élément actuel du flux.

void stossc();

Notes

La fonction membre appelle sbumpc. Une implémentation n’est pas nécessaire pour fournir cette fonction membre.

Exemple

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

int main( )
{
   using namespace std;
   ifstream myfile( "basic_streambuf_stossc.txt", ios::in );

   myfile.rdbuf( )->stossc( );
   char i = myfile.rdbuf( )->sgetc( );
   cout << i << endl;
}

basic_streambuf ::sungetc

Obtient un caractère du flux.

int_type sungetc();

Valeur de retour

Retourne le caractère ou un échec.

Notes

Si une position de remise est disponible, la fonction membre décrémente le pointeur suivant pour la mémoire tampon d’entrée et retourne traits_type::to_int_type( *gptr). Toutefois, il n’est pas toujours possible de déterminer le dernier caractère lu afin qu’il puisse être capturé dans l’état de la mémoire tampon actuelle. Si la valeur est true, la fonction retourne pbackfail. Pour éviter cette situation, effectuez le suivi du caractère à remettre en arrière et à appeler sputbackc(ch), ce qui n’échouera pas si vous ne l’appelez pas au début du flux et que vous n’essayez pas de remettre plusieurs caractères.

Exemple

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

int main( )
{
   using namespace std;

   ifstream myfile( "basic_streambuf_sungetc.txt", ios::in );

   // Read and increment
   int i = myfile.rdbuf( )->sbumpc( );
   cout << ( char )i << endl;

   // Read and increment
   i = myfile.rdbuf( )->sbumpc( );
   cout << ( char )i << endl;

   // Decrement, read, and do not increment
   i = myfile.rdbuf( )->sungetc( );
   cout << ( char )i << endl;

   i = myfile.rdbuf( )->sungetc( );
   cout << ( char )i << endl;

   i = myfile.rdbuf( )->sbumpc( );
   cout << ( char )i << endl;
}

basic_streambuf ::swap

Échange les valeurs de cet objet avec celles de l'objet basic_streambuf fourni.

void swap(basic_streambuf& right);

Paramètres

right
Référence lvalue à l'objet basic_streambuf utilisée pour échanger des valeurs.

Notes

La fonction membre protégée échange avec le droit tous les pointeurs contrôlant le input buffer et le output buffer. Elle échange également right.getloc() avec l’objet locale.

basic_streambuf ::sync

Une fonction virtuelle protégée qui tente de synchroniser les flux contrôlés avec tous les flux externes associés.

virtual int sync();

Valeur de retour

Si la fonction ne peut pas réussir, elle retourne -1. Le comportement par défaut consiste à retourner zéro.

Notes

sync implique l’écriture de tous les éléments entre le pointeur de début et le suivant pour la mémoire tampon de sortie. Il n’implique pas de remettre des éléments entre les pointeurs suivants et finaux pour la mémoire tampon d’entrée.

basic_streambuf ::traits_type

Associe un nom de type au paramètre de modèle Tr.

typedef Tr traits_type;

basic_streambuf ::uflow

Une fonction virtuelle protégée qui extrait l'élément actuel du flux d'entrée.

virtual int_type uflow();

Valeur de retour

Élément actuel.

Notes

La fonction membre virtuelle protégée essaie d’extraire l’élément actuel ch du flux d’entrée, puis avance la position du flux actuel et retourne l’élément sous la forme traits_type::to_int_type( ch). Elle peut le faire de différentes manières :

Si une position de lecture est disponible, elle accepte ch comme élément stocké dans la position de lecture et avance le pointeur suivant pour la mémoire tampon d’entrée.
Elle peut lire un élément directement à partir d’une source externe et le remettre avec la valeur ch.
Pour une mémoire tampon de flux avec des flux d’entrée et de sortie communs, elle peut rendre disponible une position de lecture en écrivant dans une destination externe quelconque tout ou partie des éléments entre le pointeur de début et le suivant pour la mémoire tampon de sortie. Sinon, elle peut allouer du stockage nouveau ou supplémentaire à la mémoire tampon d’entrée. La fonction lit ensuite un ou plusieurs éléments à partir d’une source externe.

Si la fonction ne peut pas réussir, elle retourne traits_type ::eof ou lève une exception. Sinon, elle retourne l’élément actuel ch dans le flux d’entrée, converti comme décrit ci-dessus, et avance le pointeur suivant pour la mémoire tampon d’entrée. Le comportement par défaut consiste à appeler underflow et, si cette fonction retourne traits_type::eof,à retourner traits_type::eof. Sinon, la fonction retourne l’élément actuel ch dans le flux d’entrée, converti comme décrit précédemment, et avance le pointeur suivant pour la mémoire tampon d’entrée.

basic_streambuf ::underflow

Fonction virtuelle protégée pour extraire l'élément actif du flux d'entrée.

virtual int_type underflow();

Valeur de retour

Élément actuel.

Notes

La fonction membre virtuelle protégée s’efforce d’extraire l’élément actuel ch du flux d’entrée, sans avancer la position du flux actuel, et le retourne comme traits_type::to_int_type( ch). Elle peut le faire de différentes manières :

Si une position de lecture est disponible, ch est l’élément stocké dans la position de lecture. Pour plus d’informations, consultez la section Notes de basic_streambuf, classe.
Elle peut rendre disponible une position de lecture en allouant du stockage nouveau ou supplémentaire à la mémoire tampon d’entrée, puis en lisant un ou plusieurs éléments à partir d’une source externe. Pour plus d’informations, consultez la section Notes de basic_streambuf, classe.

Si la fonction ne peut pas réussir, elle retourne traits_type::eof() ou lève une exception. Sinon, elle retourne l’élément actuel dans le flux d’entrée, converti comme décrit précédemment. Le comportement par défaut consiste à retourner traits_type::eof().

La fonction underflow virtuelle, avec les fonctions sync et underflow, définit les caractéristiques de la classe dérivée de streambuf. Chaque classe dérivée peut implémenter underflow de différentes façons, mais l’interface avec la classe de flux d’appel est la même.

La fonction underflow est souvent appelée par les fonctions publiques streambuf comme sgetc et sgetn quand la zone de récupération est vide, mais les autres classes, y compris les classes de flux, peuvent appeler underflow à tout moment.

La fonction underflow fournit des caractères à la zone de récupération à partir de la source d’entrée. Si la zone de récupération contient des caractères, underflow retourne le premier caractère. Si la zone de récupération est vide, la fonction remplit la zone et retourne le caractère suivant (qu’elle laisse dans la zone de récupération). Si plus aucun caractère n’est disponible, underflow retourne EOF et laisse vide la zone de récupération.

Dans la classe strstreambuf, underflow ajuste le pointeur egptr pour accéder au stockage alloué dynamiquement par un appel à overflow.

basic_streambuf ::xsgetn

Fonction virtuelle protégée qui extrait les éléments du flux d’entrée.

Cette méthode est potentiellement dangereuse, car elle suppose que l’appelant vérifie que les valeurs passées sont correctes.

virtual streamsize xsgetn(
    char_type* ptr,
    streamsize count);

Paramètres

ptr
Mémoire tampon qui contient les caractères extraits.

count
Nombre d’éléments à extraire.

Valeur de retour

Nombre d’éléments extraits.

Notes

La fonction membre virtuelle protégée extrait jusqu’à compter les éléments du flux d’entrée, comme s’il s’agit d’appels répétés à sbumpc et les stocke dans le tableau commençant par ptr. Elle retourne le nombre d’éléments extraits.

basic_streambuf ::xsputn

Fonction virtuelle protégée qui insère les éléments dans le flux de sortie.

virtual streamsize xsputn(const char_type* ptr, streamsize count);

Paramètres

ptr
Pointeur vers les éléments à insérer.

count
Nombre d’éléments à insérer.

Valeur de retour

Nombre d’éléments insérés dans le flux.

Notes

La fonction membre virtuelle protégée insère jusqu’à compter les éléments dans le flux de sortie, comme s’il s’agit d’appels répétés à sputc, à partir du tableau commençant par ptr. L’insertion de caractères dans le flux de sortie s’arrête une fois que tous les caractères de nombre ont été écrits, ou si l’appel sputc( count) retournerait traits::eof(). Elle retourne le nombre d’éléments insérés.

Voir aussi

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

Partage via

basic_streambuf, classe

Syntaxe

Paramètres

Notes

Constructeurs

Typedefs

Fonctions Membre

Opérateurs

Spécifications

basic_streambuf ::basic_streambuf

Paramètres

Notes

basic_streambuf ::char_type

basic_streambuf ::eback

Valeur de retour

basic_streambuf ::egptr

Valeur de retour

basic_streambuf ::ppetr

Valeur de retour

basic_streambuf ::gbump

Paramètres

basic_streambuf ::getloc

Valeur de retour

Notes

Exemple

basic_streambuf ::gptr

Valeur de retour

basic_streambuf ::imbue

Paramètres

Notes

basic_streambuf ::in_avail

Valeur de retour

Notes

Exemple

basic_streambuf ::int_type

basic_streambuf ::off_type

basic_streambuf ::operator=

Paramètres

Notes

basic_streambuf ::overflow

Paramètres

Valeur de retour

Notes

basic_streambuf ::p backfail

Paramètres

Valeur de retour

Notes

basic_streambuf ::p base

Valeur de retour

basic_streambuf ::p bump

Paramètres

basic_streambuf ::p os_type

basic_streambuf ::p ptr

Valeur de retour

basic_streambuf ::p ubimbue

Paramètres

Valeur de retour

Notes

Exemple

basic_streambuf ::p ubseekoff

Paramètres

Valeur de retour

Notes

basic_streambuf ::p ubseekpos

Paramètres

Valeur de retour

Notes

basic_streambuf ::p ubsetbuf

Paramètres

Valeur de retour

basic_streambuf ::p ubsync

Valeur de retour

basic_streambuf ::sbumpc

Valeur de retour

Notes

Exemple

basic_streambuf ::seekoff

Paramètres

Valeur de retour