std::strstreambuf::strstreambuf(3)

NAME
std::strstreambuf::strstreambuf - std::strstreambuf::strstreambuf

Synopsis
   explicit strstreambuf( std::streamsize alsize = 0 (deprecated in C++98)
   ); (until C++11)
   strstreambuf() : strstreambuf(0) {} (since C++11)(removed in
   explicit strstreambuf( std::streamsize alsize ); C++26)
   strstreambuf( void* (*palloc)(std::size_t), void (2) (deprecated in C++98)
   (*pfree)(void*) ); (removed in C++26)
   strstreambuf( char* gnext, std::streamsize n, char* (3) (deprecated in C++98)
   pbeg = 0 ); (removed in C++26)
   strstreambuf( signed char* gnext, std::streamsize (1) (4) (deprecated in C++98)
   n, signed char* pbeg = 0 ); (removed in C++26)
   strstreambuf( unsigned char* gnext, std::streamsize (5) (deprecated in C++98)
   n, unsigned char* pbeg = 0 ); (removed in C++26)
   strstreambuf( const char* gnext, std::streamsize n (6) (deprecated in C++98)
   ); (removed in C++26)
   strstreambuf( const signed char* gnext, (7) (deprecated in C++98)
   std::streamsize n ); (removed in C++26)
   strstreambuf( const unsigned char* gnext, (8) (deprecated in C++98)
   std::streamsize n ); (removed in C++26)
   1) Constructs a std::strstreambuf object: initializes the base class by calling the
   default constructor of std::streambuf, initializes the buffer state to "dynamic"
   (the buffer will be allocated as needed), initializes allocated size to the provided
   alsize, initializes the allocation and the deallocation functions to null (will use
   new[] and delete[]).
   2) Constructs a std::strstreambuf object: initializes the base class by calling the
   default constructor of std::streambuf, initializes the buffer state to "dynamic"
   (the buffer will be allocated as needed), initializes allocated size to unspecified
   value, initializes the allocation function to palloc and the deallocation function
   to pfree.
   3-5) Constructs a std::strstreambuf object in following steps:
   a) Initializes the base class by calling the default constructor of std::streambuf.
   b) Initializes the buffer state to "constant" (the buffer is a user-provided
   fixed-size buffer).
   c) Determines the number of elements in the user-provided array as follows: if n is
   greater than zero, n is used. If n is zero, std::strlen(gnext) is executed to
   determine the buffer size. If n is negative, INT_MAX is used.
   d) Configures the std::basic_streambuf pointers as follows: If pbeg is a null
   pointer, calls setg(gnext, gnext, gnext + N). If pbeg is not a null pointer,
   executes setg(gnext, gnext, pbeg) and setp(pbeg, pbeg + N), where N is the number of
   elements in the array as determined earlier.
   6-8) Same as strstreambuf((char*)gnext, n), except the "constant" bit is set in the
   buffer state bitmask (output to this buffer is not allowed).

Parameters
   alsize - the initial size of the dynamically allocated buffer
   palloc - pointer to user-provided allocation function
   pfree - pointer to user-provided deallocation function
   gnext - pointer to the start of the get area in the user-provided array
   pbeg - pointer to the start of the put area in the user-provided array
   n - the number of bytes in the get area (if pbeg is null) or in the put area
            (if pbeg is not null) of the user-provided array

Notes
   These constructors are typically called by the constructors of std::strstream.
   Defect reports
   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.
     DR Applied to Behavior as published Correct behavior
   P0935R0 C++11 default constructor was explicit made implicit

Example
// Run this code
 #include <iostream>
 #include <strstream>
 int main()
 {
     std::strstreambuf dyn; // dynamic
     std::strstream dyn_s; // equivalent stream
     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); // user-provided output buffer
     std::ostrstream user_s(buf, 10); // equivalent stream
     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"); // equivalent stream
     int i, j, k;
     lit_s >> i >> j >> k;
     std::cout << i << ' ' << j << ' ' << k << '\n';
 }

Output:
 1.23
 1.23
 1 2 3

See also
   constructor constructs a strstream object, optionally allocating the buffer
                 (public member function of std::strstream)