Namespaces
Variants

std::strstreambuf:: strstreambuf

From cppreference.net
C++
Input/output library
std::strstreambuf
(1)
explicit strstreambuf ( std:: streamsize alsize = 0 ) ;
(obsolète en C++98)
(jusqu'à C++11)
strstreambuf ( ) : strstreambuf ( 0 ) { }
explicit strstreambuf ( std:: streamsize alsize ) ;
(depuis C++11) (supprimé en C++26)
strstreambuf ( void * ( * palloc ) ( std:: size_t ) , void ( * pfree ) ( void * ) ) ;
(2) (obsolète en C++98)
(supprimé en C++26)
strstreambuf ( char * gnext, std:: streamsize n, char * pbeg = 0 ) ;
(3) (obsolète en C++98)
(supprimé en C++26)
strstreambuf ( signed char * gnext, std:: streamsize n, signed char * pbeg = 0 ) ;
(4) (obsolète en C++98)
(supprimé en C++26)
strstreambuf ( unsigned char * gnext, std:: streamsize n, unsigned char * pbeg = 0 ) ;
(5) (obsolète en C++98)
(supprimé en C++26)
strstreambuf ( const char * gnext, std:: streamsize n ) ;
(6) (obsolète en C++98)
(supprimé en C++26)
strstreambuf ( const signed char * gnext, std:: streamsize n ) ;
(7) (obsolète en C++98)
(supprimé en C++26)
strstreambuf ( const unsigned char * gnext, std:: streamsize n ) ;
(8) (obsolète en C++98)
(supprimé en C++26)
1) Construit un objet std::strstreambuf : initialise la classe de base en appelant le constructeur par défaut de std::streambuf , initialise l'état du tampon à "dynamique" (le tampon sera alloué selon les besoins), initialise la taille allouée à la valeur fournie alsize , initialise les fonctions d'allocation et de désallocation à null (utilisera new [ ] et delete [ ] ).
2) Construit un objet std::strstreambuf : initialise la classe de base en appelant le constructeur par défaut de std::streambuf , initialise l'état du tampon à "dynamique" (le tampon sera alloué selon les besoins), initialise la taille allouée à une valeur non spécifiée, initialise la fonction d'allocation à palloc et la fonction de désallocation à pfree .
3-5) Construit un objet std::strstreambuf en suivant les étapes suivantes :
a) Initialise la classe de base en appelant le constructeur par défaut de std::streambuf .
b) Initialise l'état du tampon à "constant" (le tampon est un tampon de taille fixe fourni par l'utilisateur).
c) Détermine le nombre d'éléments dans le tableau fourni par l'utilisateur comme suit : si n est supérieur à zéro, n est utilisé. Si n est égal à zéro, std:: strlen ( gnext ) est exécuté pour déterminer la taille du tampon. Si n est négatif, INT_MAX est utilisé.
d) Configure les pointeurs de std::basic_streambuf comme suit : Si pbeg est un pointeur nul, appelle setg ( gnext, gnext, gnext + N ) . Si pbeg n'est pas un pointeur nul, exécute setg ( gnext, gnext, pbeg ) et setp ( pbeg, pbeg + N ) , où N est le nombre d'éléments dans le tableau tel que déterminé précédemment.
6-8) Identique à strstreambuf ( ( char * ) gnext, n ) , sauf que le bit "constant" est défini dans le masque de bits d'état du tampon (l'écriture dans ce tampon n'est pas autorisée).

Table des matières

Paramètres

alsize - la taille initiale du tampon alloué dynamiquement
palloc - pointeur vers la fonction d'allocation fournie par l'utilisateur
pfree - pointeur vers la fonction de désallocation fournie par l'utilisateur
gnext - pointeur vers le début de la zone de lecture dans le tableau fourni par l'utilisateur
pbeg - pointeur vers le début de la zone d'écriture dans le tableau fourni par l'utilisateur
n - le nombre d'octets dans la zone de lecture (si pbeg est nul) ou dans la zone d'écriture (si pbeg n'est pas nul) du tableau fourni par l'utilisateur

Notes

Ces constructeurs sont généralement appelés par les constructeurs de std:: strstream .

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
P0935R0 C++11 default constructor was explicit made implicit

Exemple

Exécuter ce code 
#include <iostream>
#include <strstream>
int main()
{
    std::strstreambuf dyn; // dynamique
    std::strstream dyn_s; // flux équivalent
    dyn_s << 1.23 << std::ends;
    std::cout << dyn_s.str() << '\n';
    dyn_s.freeze(false);
    char buf[10];
    std::strstreambuf user(buf, 10, buf); // tampon de sortie fourni par l'utilisateur
    std::ostrstream user_s(buf, 10); // flux équivalent
    user_s << 1.23 << std::ends;
    std::cout << buf << '\n';
    std::strstreambuf lit("1 2 3", 5); // constant
    std::istrstream lit_s("1 2 3"); // flux équivalent
    int i, j, k;
    lit_s >> i >> j >> k;
    std::cout << i << ' ' << j << ' ' << k << '\n';
}

Sortie : 

1.23
1.23
1 2 3

Voir aussi

construit un objet strstream , allouant optionnellement le tampon
(fonction membre publique de std::strstream )