EVAP2

<Streambuf>

Cabecera proporcionando la streambuf clase tampón, para ser utilizado en combinación con las corrientes de entrada / salida.

plantillas de clase

basic_streambuf:

Clase tampón Base para los flujos

 

• basic_streambuf
• basic_filebufbasic_stringbuf

 

 

Esta plantilla está diseñada como base de clase virtual para todos tampón corriente clases. Un búfer de la secuencia es un objeto encargado de realizar la lectura y las operaciones de la escritura corriente de objeto que se asocia con: los delegados stream todas estas operaciones a su asociado búfer de la secuencia objeto , que es un intermediario entre elarroyo y sus secuencias de entrada y salida controlados . Todas corriente objetos, no importa si tamponada o sin búfer, tener un asociado búfer de la secuencia : Algunos tampón corriente pueden entonces establecer tipos para cualquiera que use un intermedio búfer o no. búfer Arroyo objetos guardan internamente, por lo menos:

• A locale objeto, utilizada para las operaciones dependientes del entorno local.
• Un conjunto de indicadores internos para mantener un buffer de entrada: Eback, GPTR, egptr.
• Un conjunto de indicadores internos para mantener un búfer de salida: pbase, PPTR, epptr.

Classes
sreambuff:

Clase tampón Base para los flujos

• streambuf
• filebufstringbuf

 

 

 

 

 

Esta plantilla está diseñada como base de clase virtual para todos tampón corriente clases que manejan caracteres estrechos (de tipo Char ). Es una instancia de basic_streambuf con los siguientes parámetros de plantilla:

 

parámetro de plantilla	definición	comentarios
Gráfico	Char	Alias ​​como miembro char_type
rasgos	char_traits <char>	Alias ​​como miembro traits_type

Un búfer de la secuencia es un objeto encargado de realizar las operaciones de lectura y escritura de la secuencia objeto que se asocia con: los delegados stream todas estas operaciones a su asociado búfer de la secuencia objeto, que es un intermediario entre la corriente y su entrada controlada y salida secuencias . Todas corriente objetos, no importa si tamponada o sin búfer, tienen asociado un búfer de la secuencia : Algunos tampón corriente tipos pueden entonces ajustarse para cualquiera que use un intermedio búfer . o no de amortiguamiento Stream objetos mantener internamente, por lo menos:

• A locale objeto, utilizada para las operaciones dependientes del entorno local.
• Un conjunto de indicadores internos para mantener un buffer de entrada: Eback, GPTR, egptr.
• Un conjunto de indicadores internos para mantener un búfer de salida: pbase, PPTR, epptr. 

wstreambuff:

lase búfer Base para los flujos (de ancho)

• wstreambuf
• wfilebufwstringbuf

 

 

 

 

 

Esta plantilla está diseñada como clase virtual base para todos los búfer de la secuencia clases que manejan caracteres anchos (de tipo wchar_t ). Ver basic_streambuf para obtener más información en la plantilla. Se crea una instancia
basic_streambuf con los siguientes parámetros de plantilla:

parámetro de plantilla	definición	comentarios
Gráfico	wchar_t	Alias ​​como miembro char_type
rasgos	char_traits <wchar_t>	Alias ​​como miembro traits_type

Tipos miembros

Tipo de miembro	definición
char_type	wchar_t
traits_type	char_traits <wchar_t>
int_type	wint_t
pos_type	wstreampos
off_type	streamoff

 ejemplo en c++:

template <class charT, class traits = char_traits<charT> >
   class basic_streambuf {
   public:
//  Tipos:
   typedef charT char_type;
   typedef typename traits::int_type int_type;
   typedef typename traits::pos_type pos_type;
   typedef typename traits::off_type off_type;
   typedef traits traits_type;

//  Localismos:                         
   locale pubimbue(const locale & loc);
   locale getloc() const;

//  Control de buffer y posicionamiento:
   basic_streambuf<char_type,traits>*

       pubsetbuf(char_type* s, streamsize n);
   pos_type pubseekoff(off_type off, ios_base::seekdir way,

        ios_base::openmode which = ios_base::in | ios_base::out);

   pos_type pubseekpos(pos_type sp,

        ios_base::openmode which = ios_base::in | ios_base::out);

   int pubsync();

//  Área de entrada:           
   streamsize in_avail();
   int_type snextc();
   int_type sbumpc();
   int_type sgetc();
   streamsize sgetn(char_type* s, streamsize n);

//  Devolución de caracteres:  
   int_type sputbackc(char_type c);
   int_type sungetc();

//  Área de salida:            
   int_type sputc(char_type c);
   streamsize sputn(const char_type* s, streamsize n);
    

   virtual ~basic_streambuf();  // Destructor (público-virtual)

   protected:                   // Miembros protegidos
   basic_streambuf();           // Constructor por defecto

//  Área de entrada:           
   char_type* eback() const;
   char_type* gptr() const;
   char_type* egptr() const;
   void gbump(int n);
   void setg(char_type* gbeg, char_type* gnext, char_type* gend);

//  Área de salida:            
   char_type* pbase() const;
   char_type* pptr() const;
   char_type* epptr() const;
   void pbump(int n);
   void setp(char_type* pbeg, char_type* pend);

   virtual void imbue(const locale & loc);   // localismo

//  Control de buffer y posicionamiento:  
   virtual basic_streambuf<char_type,traits>*

       setbuf(char_type* s, streamsize n);
   virtual pos_type seekoff(off_type off, ios_base::seekdir way,

        ios_base::openmode which = ios_base::in | ios_base::out);
   virtual pos_type seekpos(pos_type sp,

        ios_base::openmode which = ios_base::in | ios_base::out);
   virtual int sync();

//  Área de entrada:
   virtual int showmanyc();           
   virtual streamsize xsgetn(char_type* s, streamsize n);
   virtual int_type underflow();      
   virtual int_type uflow();          
   virtual int_type pbackfail(int_type c = traits::eof());  

//  Área de salida:
   virtual streamsize xsputn(const char_type* s, streamsize n);
   virtual int_type overflow(int_type c = traits::eof());
};