template<class T> bool operator!=(const T& x, const T& y);
template<class T> bool operator>(const T& x, const T& y);
template<class T> bool operator<=(const T& x, const T& y);
template<class T> bool operator>=(const T& x, const T& y);
explicit strstreambuf(streamsize alsize_arg);
strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = nullptr);
strstreambuf(signed char* gnext_arg, streamsize n,
signed char* pbeg_arg = nullptr);
strstreambuf(unsigned char* gnext_arg, streamsize n,
unsigned char* pbeg_arg = nullptr);
strstreambuf(const char* gnext_arg, streamsize n);
strstreambuf(const signed char* gnext_arg, streamsize n);
strstreambuf(const unsigned char* gnext_arg, streamsize n);
virtual ~strstreambuf();
void freeze(bool freezefl = true);
char* str();
int pcount() const;
int_type overflow(int_type c = EOF) override;
int_type pbackfail(int_type c = EOF) override;
int_type underflow() override;
pos_type seekoff(off_type off, seekdir way, openmode which = in | out) override;
Conditions | Result | |
(which & ios::in) != 0 | positions the input sequence | |
(which & ios::out) != 0 | positions the output sequence | |
(which & (ios::in | ios::out)) == (ios::in | ios::out) and either way == ios::beg or way == ios::end | positions both the input and the output sequences | |
Otherwise | the positioning operation fails. |
pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out) override;
streambuf<char>* setbuf(char* s, streamsize n) override;
explicit istrstream(const char* s);
explicit istrstream(char* s);
istrstream(const char* s, streamsize n);
istrstream(char* s, streamsize n);
ostrstream();
ostrstream(char* s, int n, ios_base::openmode mode = ios_base::out);
strstream();
strstream(char* s, int n,
ios_base::openmode mode = ios_base::in|ios_base::out);
virtual ~strstream();
template<class T>
void destroy(T* p);
template<class T> struct is_pod;
template<size_t Len, size_t Align = default-alignment>
struct aligned_storage;
template<size_t Len, class... Types>
struct aligned_union;
template<class T> struct tuple_size<volatile T>;
template<class T> struct tuple_size<const volatile T>;
template<size_t I, class T> struct tuple_element<I, volatile T>;
template<size_t I, class T> struct tuple_element<I, const volatile T>;
template<class T> struct variant_size<volatile T>;
template<class T> struct variant_size<const volatile T>;
template<size_t I, class T> struct variant_alternative<I, volatile T>;
template<size_t I, class T> struct variant_alternative<I, const volatile T>;
constexpr pointer operator->() const;
void reserve();
size_t converted() const noexcept;
wide_string from_bytes(char byte);
wide_string from_bytes(const char* ptr);
wide_string from_bytes(const byte_string& str);
wide_string from_bytes(const char* first, const char* last);
state_type state() const;
byte_string to_bytes(Elem wchar);
byte_string to_bytes(const Elem* wptr);
byte_string to_bytes(const wide_string& wstr);
byte_string to_bytes(const Elem* first, const Elem* last);
explicit wstring_convert(Codecvt* pcvt);
wstring_convert(Codecvt* pcvt, state_type state);
explicit wstring_convert(const byte_string& byte_err,
const wide_string& wide_err = wide_string());
~wstring_convert();
state_type state() const;
streambuf* rdbuf() const;
streambuf* rdbuf(streambuf* bytebuf);
explicit wbuffer_convert(
streambuf* bytebuf,
Codecvt* pcvt = new Codecvt,
state_type state = state_type());
~wbuffer_convert();
template<class Source>
path u8path(const Source& source);
template<class InputIterator>
path u8path(InputIterator first, InputIterator last);
template<class T>
void atomic_init(volatile atomic<T>* object, typename atomic<T>::value_type desired) noexcept;
template<class T>
void atomic_init(atomic<T>* object, typename atomic<T>::value_type desired) noexcept;
#define ATOMIC_VAR_INIT(value) see below