<assert.h> | <inttypes.h> | <signal.h> | <stdio.h> | <wchar.h> | |
<stdlib.h> | <wctype.h> | ||||
<ctype.h> | <limits.h> | <stdarg.h> | <string.h> | ||
<errno.h> | <locale.h> | ||||
<fenv.h> | <math.h> | <stddef.h> | <time.h> | ||
<float.h> | <setjmp.h> | <stdint.h> | <uchar.h> |
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> struct is_pod;
template<class T> class tuple_size<volatile T>;
template<class T> class tuple_size<const volatile T>;
template<size_t I, class T> class tuple_element<I, volatile T>;
template<size_t I, class T> class tuple_element<I, const volatile T>;
template<class T> class variant_size<volatile T>;
template<class T> class variant_size<const volatile T>;
template<size_t I, class T> class variant_alternative<I, volatile T>;
template<size_t I, class T> class variant_alternative<I, const volatile T>;
constexpr pointer operator->() const;
void reserve();
using byte_string = basic_string<char, char_traits<char>, ByteAlloc>;
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);
using int_type = typename wide_string::traits_type::int_type;
state_type state() const;
using state_type = typename Codecvt::state_type;
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);
using wide_string = basic_string<Elem, char_traits<Elem>, WideAlloc>;
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);
using state_type = typename Codecvt::state_type;
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
#define ATOMIC_FLAG_INIT see below