Completion Checklist for the Standard C++ Library Updated: 1999-05-18 Status Code Legend: M - Missing S - Present as stub. X - Partially implemented, or buggy. T - Implemented, pending test/inspection. V - Verified to pass all available test suites. Q - Qualified by inspection for non-testable correctness. P - Portability verified. C - Certified. Lexical notes: Only status codes appear in column 0. Notes relating to conformance issues appear [in brackets]. Note that this checklist does not (yet) include all emendations recommended by the ISO Library Working Group: (restricted site) http://www.cygnus.com/iso/wp/html/fdis/lwg-issues.html The LWG has announced its intention to release a public version of the issues list, URL to be added here. XXX Detailed explanation of status codes: M - Missing: The name is not visible to programs that include the specified header, either at compile or link stage. S - Present as stub: A program can use the name, but no implementation is provided. Programs that use the name link correctly, but cannot usefully be run. X - Partially implemented, or buggy: Some implementation has been provided, but it is known or believed not to conform fully. It may have an incorrect base class, wrong namespace, wrong storage class, or simply not fully implement requirements. However, it may be sufficiently usable to help test other components. T - Implemented, pending test/inspection: Implementation believed to be complete, and informal testing suggests it is ready for formal verification. V - Verified, passes all test suites: Verified to satisfy all generically testable conformance requirements. Q - Qualified by inspection for non-testable correctness: Inspected, "implementation-defined" documentation accepted, local usability criteria satisfied, formally inspected for other untestable conformance. (Untestable requirements include exception-safety, thread-safety, worst-case complexity, memory cleanliness, usefulness.) P - Portability verified: Qualified on all primary target platforms. C - Certified: Formally certified to have passed all tests, inspections, qualifications; approved under "signing authority" to be used to satisfy contractual guarantees. ---------------------------------------------------------------------- X [C header names must be in std:: to qualify. Related to shadow/ dir.] X Macro: X errno, declared or defined in . Macro fn: X setjmp(jmp_buf), declared or defined in X va_end(va_list), declared or defined in Types: X clock_t, div_t, FILE, fpos_t, lconv, ldiv_t, mbstate_t, X ptrdiff_t, sig_atomic_t, size_t, time_t, tm, va_list, X wctrans_t, wctype_t, and wint_t. 1 Which of the functions in the C++ Standard Library are not reentrant subroutines is implementation-defined. 18.1 Types [lib.support.types] X X NULL X offsetof X ptrdiff_t X size_t 18.2 Implementation properties [lib.support.limits] , , and 18.2.1 Numeric limits [lib.limits] [Note: the numeric_limits templates are now automatically generated. ] X template class numeric_limits; T enum float_round_style; T enum float_denorm_style; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; X template<> class numeric_limits; X template<> class numeric_limits; X template<> class numeric_limits; 18.2.1.1 Template class numeric_limits [lib.numeric.limits] T template class numeric_limits { public: T static const bool is_specialized = false; T static T min() throw(); T static T max() throw(); T static const int digits = 0; T static const int digits10 = 0; T static const bool is_signed = false; T static const bool is_integer = false; T static const bool is_exact = false; T static const int radix = 0; T static T epsilon() throw(); T static T round_error() throw(); T static const int min_exponent = 0; T static const int min_exponent10 = 0; T static const int max_exponent = 0; T static const int max_exponent10 = 0; T static const bool has_infinity = false; T static const bool has_quiet_NaN = false; T static const bool has_signaling_NaN = false; T static const float_denorm_style has_denorm = denorm_absent; T static const bool has_denorm_loss = false; T static T infinity() throw(); T static T quiet_NaN() throw(); T static T signaling_NaN() throw(); T static T denorm_min() throw(); T static const bool is_iec559 = false; T static const bool is_bounded = false; T static const bool is_modulo = false; T static const bool traps = false; T static const bool tinyness_before = false; T static const float_round_style round_style = round_toward_zero; }; 18.2.1.3 Type float_round_style [lib.round.style] T enum float_round_style { T round_indeterminate = -1, T round_toward_zero = 0, T round_to_nearest = 1, T round_toward_infinity = 2, T round_toward_neg_infinity = 3 }; 18.2.1.4 Type float_denorm_style [lib.denorm.style] T enum float_denorm_style { T denorm_indeterminate = -1; T denorm_absent = 0; T denorm present = 1; }; 18.2.1.5 numeric_limits specializations [lib.numeric.special] [Note: see Note at 18.2.1. ] 18.2.2 C Library [lib.c.limits] 1 Header (Table 3): CHAR_BIT INT_MAX LONG_MIN SCHAR_MIN UCHAR_MAX USHRT_MAX X CHAR_MAX INT_MIN MB_LEN_MAX SHRT_MAX UINT_MAX CHAR_MIN LONG_MAX SCHAR_MAX SHRT_MIN ULONG_MAX 3 Header (Table 4): DBL_DIG DBL_MIN_EXP FLT_MIN_10_EXP LDBL_MAX_10_EXP DBL_EPSILON FLT_DIG FLT_MIN_EXP LDBL_MAX_EXP DBL_MANT_DIG FLT_EPSILON FLT_RADIX LDBL_MIN X DBL_MAX FLT_MANT_DIG FLT_ROUNDS LDBL_MIN_10_EXP DBL_MAX_10_EXP FLT_MAX LDBL_DIG LDBL_MIN_EXP DBL_MAX_EXP FLT_MAX_10_EXP LDBL_EPSILON DBL_MIN FLT_MAX_EXP LDBL_MANT_DIG DBL_MIN_10_EXP FLT_MIN LDBL_MAX 1 Header (partial), Table 5: X EXIT_FAILURE EXIT_SUCCESS abort atexit exit S abort(void) S extern "C" int atexit(void (*f)(void)) S extern "C++" int atexit(void (*f)(void)) S exit(int status) 18.4 Dynamic memory management [lib.support.dynamic] Header synopsis T class bad_alloc; T struct nothrow_t {}; T extern const nothrow_t nothrow; T typedef void (*new_handler)(); T new_handler set_new_handler(new_handler new_p) throw(); T void* operator new(std::size_t size) throw(std::bad_alloc); T void* operator new(std::size_t size, const std::nothrow_t&) throw(); T void operator delete(void* ptr) throw(); T void operator delete(void* ptr, const std::nothrow_t&) throw(); T void* operator new[](std::size_t size) throw(std::bad_alloc); T void* operator new[](std::size_t size, const std::nothrow_t&) throw(); T void operator delete[](void* ptr) throw(); T void operator delete[](void* ptr, const std::nothrow_t&) throw(); T void* operator new (std::size_t size, void* ptr) throw(); T void* operator new[](std::size_t size, void* ptr) throw(); T void operator delete (void* ptr, void*) throw(); T void operator delete[](void* ptr, void*) throw(); 18.4.2.1 Class bad_alloc [lib.bad.alloc] T class bad_alloc : public exception { public: T bad_alloc() throw(); T bad_alloc(const bad_alloc&) throw(); T bad_alloc& operator=(const bad_alloc&) throw(); T virtual ~bad_alloc() throw(); T virtual const char* what() const throw(); T new_handler set_new_handler(new_handler new_p) throw(); Header synopsis T class type_info; T class bad_cast; T class bad_typeid; 18.5.1 - Class type_info [lib.type.info] T class type_info { public: T virtual ~type_info(); T bool operator==(const type_info& rhs) const; T bool operator!=(const type_info& rhs) const; T bool before(const type_info& rhs) const; T const char* name() const; private: T type_info(const type_info& rhs); T type_info& operator=(const type_info& rhs); }; 18.5.2 - Class bad_cast [lib.bad.cast] T bad_cast() throw(); T virtual const char* bad_cast::what() const throw(); 18.5.3 Class bad_typeid [lib.bad.typeid] T class bad_typeid : public exception { public: T bad_typeid() throw(); T bad_typeid(const bad_typeid&) throw(); T bad_typeid& operator=(const bad_typeid&) throw(); T virtual ~bad_typeid() throw(); T virtual const char* what() const throw(); }; 18.6 Exception handling [lib.support.exception] T Header synopsis T class exception; T class bad_exception; T typedef void (*unexpected_handler)(); T unexpected_handler set_unexpected(unexpected_handler f) throw(); T void unexpected(); T typedef void (*terminate_handler)(); T terminate_handler set_terminate(terminate_handler f) throw(); T void terminate(); T bool uncaught_exception(); 18.6.1 Class exception [lib.exception] T class exception { public: T exception() throw(); T exception(const exception&) throw(); T exception& operator=(const exception&) throw(); T virtual ~exception() throw(); T virtual const char* what() const throw(); }; 18.6.2.1 Class bad_exception [lib.bad.exception] T class bad_exception : public exception { public: T bad_exception() throw(); T bad_exception(const bad_exception&) throw(); T bad_exception& operator=(const bad_exception&) throw(); T virtual ~bad_exception() throw(); T virtual const char* what() const throw(); }; 18.7 Other runtime support [lib.support.runtime] 1 Headers (variable arguments), (nonlocal jumps), (system clock clock(), time()), (signal handling), and (runtime environment getenv(), system()). Table 6--Header synopsis Macros: va_arg va_end va_start X Type: va_list Table 7--Header synopsis Macro: setjmp | X Type: jmp_buf Function: longjmp Table 8--Header synopsis Macros: CLOCKS_PER_SEC X Types: clock_t Functions: clock Table 9--Header synopsis X Macros: SIGABRT SIGILL SIGSEGV SIG_DFL SIG_IGN SIGFPE SIGINT SIGTERM SIG_ERR Type: sig_atomic_t Functions: raise signal Table 10--Header synopsis X Functions: getenv system 19.1 Exception classes [lib.std.exceptions] Header synopsis T class logic_error; T class domain_error; T class invalid_argument; T class length_error; T class out_of_range; T class runtime_error; T class range_error; T class overflow_error; T class underflow_error; 19.1.1 Class logic_error [lib.logic.error] T class logic_error : public exception { public: T explicit logic_error(const string& what_arg); }; 19.1.2 Class domain_error [lib.domain.error] T class domain_error : public logic_error { public: T explicit domain_error(const string& what_arg); }; 19.1.3 Class invalid_argument [lib.invalid.argument] T class invalid_argument : public logic_error { public: T explicit invalid_argument(const string& what_arg); }; 19.1.4 Class length_error [lib.length.error] T class length_error : public logic_error { public: T explicit length_error(const string& what_arg); }; 19.1.5 Class out_of_range [lib.out.of.range] T class out_of_range : public logic_error { public: T explicit out_of_range(const string& what_arg); }; 19.1.6 Class runtime_error [lib.runtime.error] T class runtime_error : public exception { public: T explicit runtime_error(const string& what_arg); }; 19.1.7 Class range_error [lib.range.error] T class range_error : public runtime_error { public: T explicit range_error(const string& what_arg); }; 19.1.8 Class overflow_error [lib.overflow.error] T class overflow_error : public runtime_error { public: T explicit overflow_error(const string& what_arg); }; 19.1.9 Class underflow_error [lib.underflow.error] T class underflow_error : public runtime_error { public: T explicit underflow_error(const string& what_arg); }; 19.2 Assertions [lib.assertions] Table 2--Header synopsis X Macro: assert 19.3 Error numbers [lib.errno] Table 3--Header synopsis X |Macros: EDOM ERANGE errno | 20.2 Utility components [lib.utility] Header synopsis // _lib.operators_, operators: X namespace rel_ops { T template bool operator!=(const T&, const T&); T template bool operator> (const T&, const T&); T template bool operator<=(const T&, const T&); T template bool operator>=(const T&, const T&); } // _lib.pairs_, pairs: T template struct pair; T template bool operator==(const pair&, const pair&); T template bool operator< (const pair&, const pair&); T template bool operator!=(const pair&, const pair&); T template bool operator> (const pair&, const pair&); T template bool operator>=(const pair&, const pair&); T template bool operator<=(const pair&, const pair&); T template pair make_pair(const T1&, const T2&); 20.2.2 Pairs [lib.pairs] T template struct pair { T typedef T1 first_type; T typedef T2 second_type; T T1 first; T T2 second; T pair(); T pair(const T1& x, const T2& y); T template pair(const pair &p); }; 20.3 Function objects [lib.function.objects] Header synopsis // _lib.base_, base: V template struct unary_function; V template struct binary_function; // _lib.arithmetic.operations_, arithmetic operations: V template struct plus; V template struct minus; V template struct multiplies; V template struct divides; V template struct modulus; V template struct negate; // _lib.comparisons_, comparisons: V template struct equal_to; V template struct not_equal_to; V template struct greater; V template struct less; V template struct greater_equal; V template struct less_equal; // _lib.logical.operations_, logical operations: V template struct logical_and; V template struct logical_or; V template struct logical_not; // _lib.negators_, negators: template struct unary_negate; V template unary_negate not1(const Predicate&); V template struct binary_negate; V template binary_negate not2(const Predicate&); // _lib.binders_, binders: V template class binder1st; V template binder1st bind1st(const Operation&, const T&); V template class binder2nd; V template binder2nd bind2nd(const Operation&, const T&); // _lib.function.pointer.adaptors_, adaptors: V template class pointer_to_unary_function; V template pointer_to_unary_function ptr_fun(Result (*)(Arg)); V template class pointer_to_binary_function; V template pointer_to_binary_function ptr_fun(Result (*)(Arg1,Arg2)); // _lib.member.pointer.adaptors_, adaptors: V template class mem_fun_t; V template class mem_fun1_t; V template mem_fun_t mem_fun(S (T::*f)()); V template mem_fun1_t mem_fun(S (T::*f)(A)); V template class mem_fun_ref_t; V template class mem_fun1_ref_t; V template mem_fun_ref_t mem_fun_ref(S (T::*f)()); V template mem_fun1_ref_t mem_fun_ref(S (T::*f)(A)); V template class const_mem_fun_t; V template class const_mem_fun1_t; V template const_mem_fun_t mem_fun(S (T::*f)() const); V template const_mem_fun1_t mem_fun(S (T::*f)(A) const); V template class const_mem_fun_ref_t; V template class const_mem_fun1_ref_t; V template const_mem_fun_ref_t mem_fun_ref(S (T::*f)() const); V template const_mem_fun1_ref_t mem_fun_ref(S (T::*f)(A) const); } 20.3.1 Base [lib.base] V template struct unary_function { V typedef Arg argument_type; V typedef Result result_type; }; V template struct binary_function { V typedef Arg1 first_argument_type; V typedef Arg2 second_argument_type; V typedef Result result_type; }; 20.3.2 Arithmetic operations [lib.arithmetic.operations] T template struct plus : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct minus : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct multiplies : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct divides : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct modulus : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct negate : unary_function { V T operator()(const T& x) const; }; 20.3.3 Comparisons [lib.comparisons] T template struct equal_to : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct not_equal_to : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct greater : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct less : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct greater_equal : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct less_equal : binary_function { V bool operator()(const T& x, const T& y) const; }; 20.3.4 Logical operations [lib.logical.operations] T template struct logical_and : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct logical_or : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct logical_not : unary_function { V bool operator()(const T& x) const; }; 20.3.5 Negators [lib.negators] T template class unary_negate : public unary_function { public: T explicit unary_negate(const Predicate& pred); V bool operator()(const typename Predicate::argument_type& x) const; }; T template class binary_negate : public binary_function { public: T explicit binary_negate(const Predicate& pred); V bool operator()(const typename Predicate::first_argument_type& x, const typename Predicate::second_argument_type& y) const; }; 20.3.6 Binders [lib.binders] 20.3.6.1 Template class binder1st [lib.binder.1st] T template class binder1st : public unary_function { protected: T Operation op; T typename Operation::first_argument_type value; public: V binder1st(const Operation& x, const typename Operation::first_argument_type& y); V typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const; }; 20.3.6.2 bind1st [lib.bind.1st] V template binder1st bind1st(const Operation& op, const T& x); 20.3.6.3 Template class binder2nd [lib.binder.2nd] T template class binder2nd : public unary_function { protected: T Operation op; T typename Operation::second_argument_type value; public: V binder2nd(const Operation& x, const typename Operation::second_argument_type& y); V typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const; }; 20.3.6.4 bind2nd [lib.bind.2nd] T template binder2nd bind2nd(const Operation& op, const T& x); 20.3.7 Adaptors for pointers to [lib.function.pointer.adaptors] functions 1 To allow pointers to (unary and binary) functions to work with func- tion adaptors the library provides: T template class pointer_to_unary_function : public unary_function { public: T explicit pointer_to_unary_function(Result (*f)(Arg)); V Result operator()(Arg x) const; }; T template pointer_to_unary_function ptr_fun(Result (*f)(Arg)); T template class pointer_to_binary_function : public binary_function { public: T explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)); V Result operator()(Arg1 x, Arg2 y) const; }; 20.3.8 Adaptors for pointers to [lib.member.pointer.adaptors] members T template class mem_fun_t : public unary_function { public: T explicit mem_fun_t(S (T::*p)()); V S operator()(T* p) const; }; T template class mem_fun1_t : public binary_function { public: T explicit mem_fun1_t(S (T::*p)(A)); V S operator()(T* p, A x) const; }; V template mem_fun_t mem_fun(S (T::*f)()); V template mem_fun1_t mem_fun(S (T::*f)(A)); T template class mem_fun_ref_t : public unary_function { public: T explicit mem_fun_ref_t(S (T::*p)()); V S operator()(T& p) const; }; T template class mem_fun1_ref_t : public binary_function { public: T explicit mem_fun1_ref_t(S (T::*p)(A)); V S operator()(T& p, A x) const; }; T template mem_fun_ref_t mem_fun_ref(S (T::*f)()); T template mem_fun1_ref_t mem_fun_ref(S (T::*f)(A)); T template class const_mem_fun_t : public unary_function { public: T explicit const_mem_fun_t(S (T::*p)() const); V S operator()(const T* p) const; }; T template class const_mem_fun1_t : public binary_function { public: T explicit const mem_fun1_t(S (T::*p)(A) const); V S operator()(const T* p, A x) const; }; V template const_mem_fun_t mem_fun(S (T::*f)() const); V template const_mem_fun1_t mem_fun(S (T::*f)(A) const); T template class const_mem_fun_ref_t : public unary_function { public: T explicit const_mem_fun_ref_t(S (T::*p)() const); V S operator()(const T& p) const; }; T template class const_mem_fun1_ref_t : public binary_function { public: T explicit const_mem_fun1_ref_t(S (T::*p)(A) const); V S operator()(const T& p, A x) const; }; T template const_mem_fun_ref_t mem_fun_ref(S (T::*f)() const); T template const_mem_fun1_ref_t mem_fun_ref(S (T::*f)(A) const); 20.4 Memory [lib.memory] Header synopsis // _lib.default.allocator_, the default allocator: T template class allocator; T template <> class allocator; T template bool operator==(const allocator&, const allocator&) throw(); T template bool operator!=(const allocator&, const allocator&) throw(); // _lib.storage.iterator_, raw storage iterator: T template class raw_storage_iterator; // _lib.temporary.buffer_, temporary buffers: T template pair get_temporary_buffer(ptrdiff_t n); T template void return_temporary_buffer(T* p); // _lib.specialized.algorithms_, specialized algorithms: T template ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); T template void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); T template void uninitialized_fill_n(ForwardIterator first, Size n, const T& x); // _lib.auto.ptr_, pointers: X template class auto_ptr; } 20.4.1 The default allocator [lib.default.allocator] T template class allocator; // specialize for void: T template <> class allocator { public: T typedef void* pointer; T typedef const void* const_pointer; // reference-to-void members are impossible. T typedef void value_type; T template struct rebind { typedef allocator other; }; }; T template class allocator { public: T typedef size_t size_type; T typedef ptrdiff_t difference_type; T typedef T* pointer; T typedef const T* const_pointer; T typedef T& reference; T typedef const T& const_reference; T typedef T value_type; T template struct rebind { typedef allocator other; }; T allocator() throw(); T allocator(const allocator&) throw(); T template allocator(const allocator&) throw(); T ~allocator() throw(); T pointer address(reference x) const; T const_pointer address(const_reference x) const; T pointer allocate( size_type, allocator::const_pointer hint = 0); T void deallocate(pointer p, size_type n); T size_type max_size() const throw(); T void construct(pointer p, const T& val); T void destroy(pointer p); }; 20.4.1.2 allocator globals [lib.allocator.globals] T template bool operator==(const allocator&, const allocator&) throw(); T template bool operator!=(const allocator&, const allocator&) throw(); 20.4.2 Raw storage iterator [lib.storage.iterator] T template class raw_storage_iterator : public iterator { public: T explicit raw_storage_iterator(OutputIterator x); T raw_storage_iterator& operator*(); T raw_storage_iterator& operator=(const T& element); T raw_storage_iterator& operator++(); T raw_storage_iterator operator++(int); }; 20.4.3 Temporary buffers [lib.temporary.buffer] T template pair get_temporary_buffer(ptrdiff_t n); T template void return_temporary_buffer(T* p); 20.4.4 Specialized algorithms [lib.specialized.algorithms] 20.4.4.1 uninitialized_copy [lib.uninitialized.copy] V template ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); 20.4.4.2 uninitialized_fill [lib.uninitialized.fill] V template void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); 20.4.4.3 uninitialized_fill_n [lib.uninitialized.fill.n] V template void uninitialized_fill_n(ForwardIterator first, Size n, const T& x); 20.4.5 Template class auto_ptr [lib.auto.ptr] X template class auto_ptr { template struct auto_ptr_ref {}; public: T typedef X element_type; // _lib.auto.ptr.cons_ construct/copy/destroy: T explicit auto_ptr(X* p =0) throw(); T auto_ptr(auto_ptr&) throw(); T template auto_ptr(auto_ptr&) throw(); T auto_ptr& operator=(auto_ptr&) throw(); T template auto_ptr& operator=(auto_ptr&) throw(); T ~auto_ptr() throw(); // _lib.auto.ptr.members_ members: T X& operator*() const throw(); T X* operator->() const throw(); T X* get() const throw(); T X* release() throw(); T void reset(X* p =0) throw(); // _lib.auto.ptr.conv_ conversions: X auto_ptr(auto_ptr_ref) throw(); X template operator auto_ptr_ref() throw(); X template operator auto_ptr() throw(); }; 20.4.6 C Library [lib.c.malloc] Table 7--Header synopsis X Functions: calloc malloc free realloc Table 8--Header synopsis X Macro: NULL X Type: size_t X Functions: memchr memcmp X memcpy memmove memset Table 9--Header synopsis X Macros: NULL X Types: size_t clock_t time_t X Struct: tm Functions: X asctime clock difftime localtime strftime X ctime gmtime mktime time 21.1.1 Character traits requirements [lib.char.traits.require] 2 The struct template T template struct char_traits; shall be provided in the header as a basis for explicit spe- cializations. 21.1.3.1 struct [lib.char.traits.specializations.char] char_traits T template<> struct char_traits { T typedef char char_type; T typedef int int_type; T typedef streamoff off_type; T typedef streampos pos_type; T typedef mbstate_t state_type; T static void assign(char_type& c1, const char_type& c2); T static bool eq(const char_type& c1, const char_type& c2); T static bool lt(const char_type& c1, const char_type& c2); T static int compare(const char_type* s1, const char_type* s2, size_t n); T static size_t length(const char_type* s); T static const char_type* find(const char_type* s, size_t n, const char_type& a); T static char_type* move(char_type* s1, const char_type* s2, size_t n); T static char_type* copy(char_type* s1, const char_type* s2, size_t n); T static char_type* assign(char_type* s, size_t n, char_type a); T static int_type not_eof(const int_type& c); T static char_type to_char_type(const int_type& c); T static int_type to_int_type(const char_type& c); T static bool eq_int_type(const int_type& c1, const int_type& c2); T static int_type eof(); }; 21.1.3.2 struct [lib.char.traits.specializations.wchar.t] char_traits V template<> struct char_traits { V typedef wchar_t char_type; V typedef wint_t int_type; V typedef streamoff off_type; V typedef wstreampos pos_type; V typedef mbstate_t state_type; V static void assign(char_type& c1, const char_type& c2); V static bool eq(const char_type& c1, const char_type& c2); V static bool lt(const char_type& c1, const char_type& c2); V static int compare(const char_type* s1, const char_type* s2, size_t n); V static size_t length(const char_type* s); V static const char_type* find(const char_type* s, size_t n, const char_type& a); V static char_type* move(char_type* s1, const char_type* s2, size_t n); V static char_type* copy(char_type* s1, const char_type* s2, size_t n); V static char_type* assign(char_type* s, size_t n, char_type a); V static int_type not_eof(const int_type& c); V static char_type to_char_type(const int_type& c); V static int_type to_int_type(const char_type& c); V static bool eq_int_type(const int_type& c1, const int_type& c2); V static int_type eof(); }; 21.2 String classes [lib.string.classes] // _lib.char.traits_, character traits: V template struct char_traits; V template <> struct char_traits; V template <> struct char_traits; // _lib.basic.string_, basic_string: V template, class Allocator = allocator > class basic_string; V template basic_string operator+(const basic_string& lhs, const basic_string& rhs); V template basic_string operator+(const charT* lhs, const basic_string& rhs); V template basic_string operator+(charT lhs, const basic_string& rhs); V template basic_string operator+(const basic_string& lhs, const charT* rhs); V template basic_string operator+(const basic_string& lhs, charT rhs); V template bool operator==(const basic_string& lhs, const basic_string& rhs); V template bool operator==(const charT* lhs, const basic_string& rhs); V template bool operator==(const basic_string& lhs, const charT* rhs); V template bool operator!=(const basic_string& lhs, const basic_string& rhs); V template bool operator!=(const charT* lhs, const basic_string& rhs); V template bool operator!=(const basic_string& lhs, const charT* rhs); V template bool operator< (const basic_string& lhs, const basic_string& rhs); V template bool operator< (const basic_string& lhs, const charT* rhs); V template bool operator< (const charT* lhs, const basic_string& rhs); V template bool operator> (const basic_string& lhs, const basic_string& rhs); V template bool operator> (const basic_string& lhs, const charT* rhs); V template bool operator> (const charT* lhs, const basic_string& rhs); V template bool operator<=(const basic_string& lhs, const basic_string& rhs); V template bool operator<=(const basic_string& lhs, const charT* rhs); V template bool operator<=(const charT* lhs, const basic_string& rhs); V template bool operator>=(const basic_string& lhs, const basic_string& rhs); V template bool operator>=(const basic_string& lhs, const charT* rhs); V template bool operator>=(const charT* lhs, const basic_string& rhs); // _lib.string.special_: V template void swap(basic_string& lhs, basic_string& rhs); V template basic_istream& operator>>(basic_istream& is, basic_string& str); T template basic_ostream& operator<<(basic_ostream& os, const basic_string& str); V template basic_istream& getline(basic_istream& is, basic_string& str, charT delim); V template basic_istream& getline(basic_istream& is, basic_string& str); V typedef basic_string string; T typedef basic_string wstring; } 21.3 Template class basic_string [lib.basic.string] V namespace std { template, class Allocator = allocator > class basic_string { public: // types: typedef traits traits_type; typedef typename traits::char_type value_type; typedef Allocator allocator_type; typedef typename Allocator::size_type size_type; typedef typename Allocator::difference_type difference_type; typedef typename Allocator::reference reference; typedef typename Allocator::const_reference const_reference; typedef typename Allocator::pointer pointer; typedef typename Allocator::const_pointer const_pointer; typedef implementation defined iterator; typedef implementation defined const_iterator; typedef std::reverse_iterator reverse_iterator; typedef std::reverse_iterator const_reverse_iterator; static const size_type npos = -1; // _lib.string.cons_ construct/copy/destroy: V explicit basic_string(const Allocator& a = Allocator()); V basic_string(const basic_string& str, size_type pos = 0, size_type n = npos, const Allocator& a = Allocator()); V basic_string(const charT* s, size_type n, const Allocator& a = Allocator()); V basic_string(const charT* s, const Allocator& a = Allocator()); V basic_string(size_type n, charT c, const Allocator& a = Allocator()); V template basic_string(InputIterator begin, InputIterator end, const Allocator& a = Allocator()); V ~basic_string(); V basic_string& operator=(const basic_string& str); V basic_string& operator=(const charT* s); V basic_string& operator=(charT c); // _lib.string.iterators_ iterators: V iterator begin(); V const_iterator begin() const; V iterator end(); V const_iterator end() const; V reverse_iterator rbegin(); V const_reverse_iterator rbegin() const; V reverse_iterator rend(); V const_reverse_iterator rend() const; // _lib.string.capacity_ capacity: V size_type size() const; V size_type length() const; V size_type max_size() const; V void resize(size_type n, charT c); V void resize(size_type n); V size_type capacity() const; V void reserve(size_type res_arg = 0); V void clear(); V bool empty() const; // _lib.string.access_ element access: V const_reference operator[](size_type pos) const; V reference operator[](size_type pos); V const_reference at(size_type n) const; V reference at(size_type n); // _lib.string.modifiers_ modifiers: V basic_string& operator+=(const basic_string& str); V basic_string& operator+=(const charT* s); V basic_string& operator+=(charT c); V basic_string& append(const basic_string& str); V basic_string& append(const basic_string& str, size_type pos, size_type n); V basic_string& append(const charT* s, size_type n); V basic_string& append(const charT* s); V basic_string& append(size_type n, charT c); V template basic_string& append(InputIterator first, InputIterator last); V void push_back(const charT); V basic_string& assign(const basic_string&); V basic_string& assign(const basic_string& str, size_type pos, size_type n); V basic_string& assign(const charT* s, size_type n); V basic_string& assign(const charT* s); V basic_string& assign(size_type n, charT c); V template basic_string& assign(InputIterator first, InputIterator last); V basic_string& insert(size_type pos1, const basic_string& str); V basic_string& insert(size_type pos1, const basic_string& str, size_type pos2, size_type n); V basic_string& insert(size_type pos, const charT* s, size_type n); V basic_string& insert(size_type pos, const charT* s); V basic_string& insert(size_type pos, size_type n, charT c); V iterator insert(iterator p, charT c); V void insert(iterator p, size_type n, charT c); V template void insert(iterator p, InputIterator first, InputIterator last); V basic_string& erase(size_type pos = 0, size_type n = npos); V iterator erase(iterator position); V iterator erase(iterator first, iterator last); V basic_string& replace(size_type pos1, size_type n1, const basic_string& str); V basic_string& replace(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2); V basic_string& replace(size_type pos, size_type n1, const charT* s, size_type n2); V basic_string& replace(size_type pos, size_type n1, const charT* s); V basic_string& replace(size_type pos, size_type n1, size_type n2, charT c); V basic_string& replace(iterator i1, iterator i2, const basic_string& str); V basic_string& replace(iterator i1, iterator i2, const charT* s, size_type n); V basic_string& replace(iterator i1, iterator i2, const charT* s); V basic_string& replace(iterator i1, iterator i2, size_type n, charT c); V template basic_string& replace(iterator i1, iterator i2, InputIterator j1, InputIterator j2); V size_type copy(charT* s, size_type n, size_type pos = 0) const; V void swap(basic_string&); // _lib.string.ops_ string operations: V const charT* c_str() const; // explicit V const charT* data() const; V allocator_type get_allocator() const; V size_type find (const basic_string& str, size_type pos = 0) const; V size_type find (const charT* s, size_type pos, size_type n) const; V size_type find (const charT* s, size_type pos = 0) const; V size_type find (charT c, size_type pos = 0) const; V size_type rfind(const basic_string& str, size_type pos = npos) const; V size_type rfind(const charT* s, size_type pos, size_type n) const; V size_type rfind(const charT* s, size_type pos = npos) const; V size_type rfind(charT c, size_type pos = npos) const; V size_type find_first_of(const basic_string& str, size_type pos = 0) const; V size_type find_first_of(const charT* s, size_type pos, size_type n) const; V size_type find_first_of(const charT* s, size_type pos = 0) const; V size_type find_first_of(charT c, size_type pos = 0) const; V size_type find_last_of (const basic_string& str, size_type pos = npos) const; V size_type find_last_of (const charT* s, size_type pos, size_type n) const; V size_type find_last_of (const charT* s, size_type pos = npos) const; V size_type find_last_of (charT c, size_type pos = npos) const; V size_type find_first_not_of(const basic_string& str, size_type pos = 0) const; V size_type find_first_not_of(const charT* s, size_type pos, size_type n) const; V size_type find_first_not_of(const charT* s, size_type pos = 0) const; V size_type find_first_not_of(charT c, size_type pos = 0) const; V size_type find_last_not_of (const basic_string& str, size_type pos = npos) const; V size_type find_last_not_of (const charT* s, size_type pos, size_type n) const; V size_type find_last_not_of (const charT* s, size_type pos = npos) const; V size_type find_last_not_of (charT c, size_type pos = npos) const; V basic_string substr(size_type pos = 0, size_type n = npos) const; V int compare(const basic_string& str) const; V int compare(size_type pos1, size_type n1, const basic_string& str) const; V int compare(size_type pos1, size_type n1, const basic_string& str, size_type pos2, size_type n2) const; V int compare(const charT* s) const; V int compare(size_type pos1, size_type n1, const charT* s, size_type n2 = npos) const; }; } 21.4 Null-terminated sequence utilities [lib.c.strings] Table 10--Header synopsis isalnum isdigit isprint isupper tolower X isalpha isgraph ispunct isxdigit toupper iscntrl islower isspace Table 11--Header synopsis X Macro: WEOF X Types: wctrans_t wctype_t wint_t Functions: X iswalnum iswctype iswlower iswspace towctrans wctrans X iswalpha iswdigit iswprint iswupper towlower wctype X iswcntrl iswgraph iswpunct iswxdigit towupper Table 12--Header synopsis X Macro: NULL X Type: size_t Functions: X memchr strcat strcspn strncpy strtok X memcmp strchr strerror strpbrk strxfrm X memcpy strcmp strlen strrchr X memmove strcoll strncat strspn X memset strcpy strncmp strstr Table 13--Header synopsis Macros: NULL WCHAR_MAX WCHAR_MIN WEOF Types: mbstate_t wint_t size_t Functions: X btowc getwchar ungetwc wcscpy wcsrtombs wmemchr X fgetwc mbrlen vfwprintf wcscspn wcsspn wmemcmp X fgetws mbrtowc vswprintf wcsftime wcsstr wmemcpy X fputwc mbsinit vwprintf wcslen wcstod wmemmove X fputws mbsrtowcs wcrtomb wcsncat wcstok wmemset X fwide putwc wcscat wcsncmp wcstol wprintf X fwprintf putwchar wcschr wcsncpy wcstoul wscanf X fwscanf swprintf wcscmp wcspbrk wcsxfrm X getwc swscanf wcscoll wcsrchr wctob Table 14--Header synopsis Macros: MB_CUR_MAX Functions: X atol mblen strtod wctomb X atof mbstowcs strtol wcstombs X atoi mbtowc strtoul X const char* strchr(const char* s, int c); X char* strchr( char* s, int c); X const char* strpbrk(const char* s1, const char* s2); X char* strpbrk( char* s1, const char* s2); X const char* strrchr(const char* s, int c); X char* strrchr( char* s, int c); X const char* strstr(const char* s1, const char* s2); X char* strstr( char* s1, const char* s2); X const void* memchr(const void* s, int c, size_t n); X void* memchr( void* s, int c, size_t n); X const wchar_t* wcschr(const wchar_t* s, wchar_t c); X wchar_t* wcschr( wchar_t* s, wchar_t c); X const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2); X wchar_t* wcspbrk( wchar_t* s1, const wchar_t* s2); X const wchar_t* wcsrchr(const wchar_t* s, wchar_t c); X wchar_t* wcsrchr( wchar_t* s, wchar_t c); X const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2); X wchar_t* wcsstr( wchar_t* s1, const wchar_t* s2); X const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n); X wchar_t* wmemchr( wchar_t* s, wchar_t c, size_t n); [for initial efforts on the above, see shadow/string.h] 22.1 Locales [lib.locales] Header synopsis // _lib.locale_, locale: T class locale; T template const Facet& use_facet(const locale&); T template bool has_facet(const locale&) throw(); // _lib.locale.convenience_, convenience interfaces: T template bool isspace (charT c, const locale& loc); T template bool isprint (charT c, const locale& loc); T template bool iscntrl (charT c, const locale& loc); T template bool isupper (charT c, const locale& loc); T template bool islower (charT c, const locale& loc); T template bool isalpha (charT c, const locale& loc); T template bool isdigit (charT c, const locale& loc); T template bool ispunct (charT c, const locale& loc); T template bool isxdigit(charT c, const locale& loc); T template bool isalnum (charT c, const locale& loc); T template bool isgraph (charT c, const locale& loc); T template charT toupper(charT c, const locale& loc); T template charT tolower(charT c, const locale& loc); // _lib.category.ctype_ and _lib.facet.ctype.special_, ctype: class ctype_base; T template class ctype; T template <> class ctype; // specialization S template class ctype_byname; S template <> class ctype_byname; // specialization T class codecvt_base; X template class codecvt; S template class codecvt_byname; // _lib.category.numeric_ and _lib.facet.numpunct_, numeric: X template class num_get; X template class num_put; T template class numpunct; S template class numpunct_byname; // _lib.category.collate_, collation: T template class collate; S template class collate_byname; // _lib.category.time_, date and time: T class time_base; S template class time_get; S template class time_get_byname; S template class time_put; S template class time_put_byname; // _lib.category.monetary_, money: T class money_base; S template class money_get; S template class money_put; S template class moneypunct; S template class moneypunct_byname; // _lib.category.messages_, message retrieval: T class messages_base; S template class messages; S template class messages_byname; 22.1.1 Class locale [lib.locale] X class locale { public: // types: T class facet; T class id; T typedef int category; T static const category // values assigned here are for exposition only T none = 0, T collate = 0x010, ctype = 0x020, T monetary = 0x040, numeric = 0x080, T time = 0x100, messages = 0x200, T all = collate | ctype | monetary | numeric | time | messages; // construct/copy/destroy: T locale() throw() T locale(const locale& other) throw() X explicit locale(const char* std_name); X locale(const locale& other, const char* std_name, category); T template locale(const locale& other, Facet* f); T locale(const locale& other, const locale& one, category); T ~locale() throw(); // non-virtual T const locale& operator=(const locale& other) throw(); T template locale combine(const locale& other) const; // locale operations: X basic_string name() const; T bool operator==(const locale& other) const; T bool operator!=(const locale& other) const; T template bool operator()(const basic_string& s1, const basic_string& s2) const; // global locale objects: T static locale global(const locale&); T static const locale& classic(); }; 22.1.1.1 locale types [lib.locale.types] 22.1.1.1.1 Type locale::category [lib.locale.category] T typedef int category; T none, collate, ctype, monetary, numeric, time, and messages [required locale members] T collate, collate T ctype, ctype T codecvt, S codecvt T moneypunct, moneypunct T moneypunct, moneypunct, S money_get, money_get, money_put T numpunct, numpunct, X num_get, num_get X num_put, num_put S time_get, time_get, S time_put, time_put S messages, messages [required instantiations] S collate_byname, collate_byname S ctype_byname, ctype_byname S codecvt_byname, S codecvt_byname S moneypunct_byname, S moneypunct_byname, S money_get, S money_put S numpunct_byname, numpunct_byname X num_get, num_put S time_get, S time_get_byname, S time_get, S time_get_byname, S time_put, S time_put_byname, S time_put S time_put_byname S messages_byname, messages_byname 22.1.1.1.2 Class locale::facet [lib.locale.facet] T class locale::facet { protected: T explicit facet(size_t refs = 0); T virtual ~facet(); private: T facet(const facet&); // not defined T void operator=(const facet&); // not defined }; } 22.1.1.1.3 Class locale::id [lib.locale.id] T class locale::id { public: T id(); private: T void operator=(const id&); // not defined T id(const id&); // not defined }; } 22.2.1 The ctype category [lib.category.ctype] T class ctype_base { public: T enum mask { // numeric values are for exposition only. T space=, print=, cntrl=, upper=, lower=, T alpha=, digit=, punct=, xdigit=, T alnum=, graph= }; }; 22.2.1.1 Template class ctype [lib.locale.ctype] T template class ctype : public locale::facet, public ctype_base { public: T typedef charT char_type; T explicit ctype(size_t refs = 0); T bool is(mask m, charT c) const; T const charT* is(const charT* low, const charT* high, mask* vec) const; T const charT* scan_is(mask m, const charT* low, const charT* high) const; T const charT* scan_not(mask m, const charT* low, const charT* high) const; T charT toupper(charT c) const; T const charT* toupper(charT* low, const charT* high) const; T charT tolower(charT c) const; T const charT* tolower(charT* low, const charT* high) const; T charT widen(char c) const; T const char* widen(const char* low, const char* high, charT* to) const; T char narrow(charT c, char dfault) const; T const charT* narrow(const charT* low, const charT*, char dfault, char* to) const; T static locale::id id; protected: T ~ctype(); // virtual T virtual bool do_is(mask m, charT c) const; T virtual const charT* do_is(const charT* low, const charT* high, mask* vec) const; T virtual const charT* do_scan_is(mask m, const charT* low, const charT* high) const; T virtual const charT* do_scan_not(mask m, const charT* low, const charT* high) const; T virtual charT do_toupper(charT) const; T virtual const charT* do_toupper(charT* low, const charT* high) const; T virtual charT do_tolower(charT) const; T virtual const charT* do_tolower(charT* low, const charT* high) const; T virtual charT do_widen(char) const; T virtual const char* do_widen(const char* low, const char* high, charT* dest) const; T virtual char do_narrow(charT, char dfault) const; T virtual const charT* do_narrow(const charT* low, const charT* high, char dfault, char* dest) const; }; 22.2.1.2 Template class ctype_byname [lib.locale.ctype.byname] X template class ctype_byname : public ctype { public: T typedef ctype::mask mask; S explicit ctype_byname(const char*, size_t refs = 0); protected: S ~ctype_byname(); // virtual S virtual bool do_is(mask m, charT c) const; S virtual const charT* do_is(const charT* low, const charT* high, mask* vec) const; S virtual const char* do_scan_is(mask m, const charT* low, const charT* high) const; S virtual const char* do_scan_not(mask m, const charT* low, const charT* high) const; S virtual charT do_toupper(charT) const; S virtual const charT* do_toupper(charT* low, const charT* high) const; S virtual charT do_tolower(charT) const; S virtual const charT* do_tolower(charT* low, const charT* high) const; S virtual charT do_widen(char) const; S virtual const char* do_widen(const char* low, const char* high, charT* dest) const; S virtual char do_narrow(charT, char dfault) const; S virtual const charT* do_narrow(const charT* low, const charT* high, char dfault, char* dest) const; }; 22.2.1.3 ctype specializations [lib.facet.ctype.special] T template <> class ctype : public locale::facet, public ctype_base { public: T typedef char char_type; T explicit ctype(const mask* tab = 0, bool del = false, size_t refs = 0); T bool is(mask m, char c) const; T const char* is(const char* low, const char* high, mask* vec) const; T const char* scan_is (mask m, const char* low, const char* high) const; T const char* scan_not(mask m, const char* low, const char* high) const; T char toupper(char c) const; T const char* toupper(char* low, const char* high) const; T char tolower(char c) const; T const char* tolower(char* low, const char* high) const; T char widen(char c) const; T const char* widen(const char* low, const char* high, char* to) const; T char narrow(char c, char dfault) const; T const char* narrow(const char* low, const char* high, char dfault, char* to) const; T static locale::id id; T static const size_t table_size = IMPLEMENTATION_DEFINED; protected: T const mask* table() const throw(); T static const mask* classic_table() throw(); T ~ctype(); // virtual T virtual char do_toupper(char c) const; T virtual const char* do_toupper(char* low, const char* high) const; T virtual char do_tolower(char c) const; T virtual const char* do_tolower(char* low, const char* high) const; T virtual char do_widen(char c) const; T virtual const char* do_widen(const char* low, const char* high, char* to) const; T virtual char do_narrow(char c, char dfault) const; T virtual const char* do_narrow(const char* low, const char* high, char dfault, char* to) const; }; 22.2.1.4 Class [lib.locale.ctype.byname.special] ctype_byname X template <> class ctype_byname : public ctype { public: S explicit ctype_byname(const char*, size_t refs = 0); protected: S ~ctype_byname(); // virtual S virtual char do_toupper(char c) const; S virtual const char* do_toupper(char* low, const char* high) const; S virtual char do_tolower(char c) const; S virtual const char* do_tolower(char* low, const char* high) const; S virtual char do_widen(char c) const; S virtual const char* do_widen(char* low, const char* high, char* to) const; S virtual char do_widen(char c) const; S virtual const char* do_widen(char* low, const char* high) const; }; 22.2.1.5 Template class codecvt [lib.locale.codecvt] T class codecvt_base { public: T enum result { ok, partial, error, noconv }; }; T template class codecvt : public locale::facet, public codecvt_base { public: T typedef internT intern_type; T typedef externT extern_type; T typedef stateT state_type; T explicit codecvt(size_t refs = 0) T result out(stateT& state, const internT* from, const internT* from_end, const internT*& from_next, externT* to, externT* to_limit, externT*& to_next) const; T result unshift(stateT& state, externT* to, externT* to_limit, externT*& to_next) const; T result in(stateT& state, const externT* from, const externT* from_end, const externT*& from_next, internT* to, internT* to_limit, internT*& to_next) const; T int encoding() const throw(); T bool always_noconv() const throw(); T int length(const stateT&, const externT* from, const externT* end, size_t max) const; T int max_length() const throw(); T static locale::id id; protected: T ~codecvt(); // virtual T virtual result do_out(stateT& state, const internT* from, const internT* from_end, const internT*& from_next, externT* to, externT* to_limit, externT*& to_next) const; T virtual result do_in(stateT& state, T const externT* from, const externT* from_end, const externT*& from_next, internT* to, internT* to_limit, internT*& to_next) const; T virtual result do_unshift(stateT& state, externT* to, externT* to_limit, externT*& to_next) const; T virtual int do_encoding() const throw(); T virtual bool do_always_noconv() const throw(); T virtual int do_length(const stateT&, const externT* from, const externT* end, size_t max) const; T virtual int do_max_length() const throw(); }; } 22.2.1.6 Template class [lib.locale.codecvt.byname] codecvt_byname X template class codecvt_byname : public codecvt { public: S explicit codecvt_byname(const char*, size_t refs = 0); protected: S ~codecvt_byname(); // virtual S virtual result do_out(stateT& state, const internT* from, const internT* from_end, const internT*& from_next, externT* to, externT* to_limit, externT*& to_next) const; S virtual result do_in(stateT& state, const externT* from, const externT* from_end, const externT*& from_next, internT* to, internT* to_limit, internT*& to_next) const; S virtual result do_unshift(stateT& state, externT* to, externT* to_limit, externT*& to_next) const; S virtual int do_encoding() const throw(); S virtual bool do_always_noconv() const throw(); S virtual int do_length(const stateT&, const externT* from, const externT* end, size_t max) const; S virtual result do_unshift(stateT& state, externT* to, externT* to_limit, externT*& to_next) const; S virtual int do_max_length() const throw(); }; 22.2.2.1 Template class num_get [lib.locale.num.get] X template > class num_get : public locale::facet { public: T typedef charT char_type; T typedef InputIterator iter_type; T explicit num_get(size_t refs = 0); T iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, bool& v) const; T iter_type get(iter_type in, iter_type end, ios_base& , ios_base::iostate& err, long& v) const; T iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, unsigned short& v) const; T iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, unsigned int& v) const; T iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, unsigned long& v) const; T iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, float& v) const; T iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, double& v) const; T iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, long double& v) const; T iter_type get(iter_type in, iter_type end, ios_base&, ios_base::iostate& err, void*& v) const; T static locale::id id; protected: T ~num_get(); // virtual T virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, bool& v) const; S virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, long& v) const; S virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, unsigned short& v) const; S virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, unsigned int& v) const; S virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, unsigned long& v) const; S virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, float& v) const; S virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, double& v) const; S virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, long double& v) const; S virtual iter_type do_get(iter_type, iter_type, ios_base&, ios_base::iostate& err, void*& v) const; }; 22.2.2.2 Template class num_put [lib.locale.nm.put] X template > class num_put : public locale::facet { public: T typedef charT char_type; T typedef OutputIterator iter_type; T explicit num_put(size_t refs = 0); T iter_type put(iter_type s, ios_base& f, char_type fill, bool v) const; T iter_type put(iter_type s, ios_base& f, char_type fill, long v) const; T iter_type put(iter_type s, ios_base& f, char_type fill, unsigned long v) const; T iter_type put(iter_type s, ios_base& f, char_type fill, double v) const; T iter_type put(iter_type s, ios_base& f, char_type fill, long double v) const; T iter_type put(iter_type s, ios_base& f, char_type fill, const void* v) const; T static locale::id id; protected: T ~num_put(); // virtual T virtual iter_type do_put(iter_type, ios_base&, char_type fill, bool v) const; T virtual iter_type do_put(iter_type, ios_base&, char_type fill, long v) const; T virtual iter_type do_put(iter_type, ios_base&, char_type fill, unsigned long) const; S virtual iter_type do_put(iter_type, ios_base&, char_type fill, double v) const; S virtual iter_type do_put(iter_type, ios_base&, char_type fill, long double v) const; T virtual iter_type do_put(iter_type, ios_base&, char_type fill, const void* v) const; }; } 22.2.3.1 Template class numpunct [lib.locale.numpunct] T template class numpunct : public locale::facet { public: T typedef charT char_type; T typedef basic_string string_type; T explicit numpunct(size_t refs = 0); T char_type decimal_point() const; T char_type thousands_sep() const; T string grouping() const; T string_type truename() const; T string_type falsename() const; T static locale::id id; protected: T ~numpunct(); // virtual T virtual char_type do_decimal_point() const; T virtual char_type do_thousands_sep() const; T virtual string do_grouping() const; T virtual string_type do_truename() const; // for bool T virtual string_type do_falsename() const; // for bool }; } 22.2.3.2 Template class [lib.locale.numpunct.byname] numpunct_byname X template class numpunct_byname : public numpunct { // this class is specialized for char and wchar_t. public: T typedef charT char_type; T typedef basic_string string_type; S explicit numpunct_byname(const char*, size_t refs = 0); protected: S ~numpunct_byname(); // virtual S virtual char_type do_decimal_point() const; S virtual char_type do_thousands_sep() const; S virtual string do_grouping() const; S virtual string_type do_truename() const; // for bool S virtual string_type do_falsename() const; // for bool }; 22.2.4.1 Template class collate [lib.locale.collate] T template class collate : public locale::facet { public: T typedef charT char_type; T typedef basic_string string_type; T explicit collate(size_t refs = 0); T int compare(const charT* low1, const charT* high1, const charT* low2, const charT* high2) const; T string_type transform(const charT* low, const charT* high) const; T long hash(const charT* low, const charT* high) const; T static locale::id id; protected: T ~collate(); // virtual T virtual int do_compare(const charT* low1, const charT* high1, const charT* low2, const charT* high2) const; T virtual string_type do_transform (const charT* low, const charT* high) const; T virtual long do_hash (const charT* low, const charT* high) const; }; 22.2.4.2 Template class [lib.locale.collate.byname] collate_byname X template class collate_byname : public collate { public: T typedef basic_string string_type; T explicit collate_byname(const char*, size_t refs = 0); protected: S ~collate_byname(); // virtual S virtual int do_compare(const charT* low1, const charT* high1, const charT* low2, const charT* high2) const; S virtual string_type do_transform (const charT* low, const charT* high) const; S virtual long do_hash (const charT* low, const charT* high) const; }; 22.2.5.1 Template class time_get [lib.locale.time.get] T class time_base { public: T enum dateorder { no_order, dmy, mdy, ymd, ydm }; }; [Note: semantics of time_get members are implementation-defined. To complete implementation requires documenting behavior.] X template > class time_get : public locale::facet, public time_base { public: T typedef charT char_type; T typedef InputIterator iter_type; T explicit time_get(size_t refs = 0); T dateorder date_order() const { return do_date_order(); } T iter_type get_time(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err, tm* t) const; T iter_type get_date(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err, tm* t) const; T iter_type get_weekday(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err, tm* t) const; T iter_type get_monthname(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err, tm* t) const; T iter_type get_year(iter_type s, iter_type end, ios_base& f, ios_base::iostate& err, tm* t) const; T static locale::id id; protected: ~time_get(); // virtual X virtual dateorder do_date_order() const; S virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&, ios_base::iostate& err, tm* t) const; S virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&, ios_base::iostate& err, tm* t) const; S virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&, ios_base::iostate& err, tm* t) const; S virtual iter_type do_get_monthname(iter_type s, ios_base&, ios_base::iostate& err, tm* t) const; S virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&, ios_base::iostate& err, tm* t) const; }; 22.2.5.2 Template class [lib.locale.time.get.byname] time_get_byname X template > class time_get_byname : public time_get { public: T typedef time_base::dateorder dateorder; T typedef InputIterator iter_type S explicit time_get_byname(const char*, size_t refs = 0); protected: S ~time_get_byname(); // virtual S virtual dateorder do_date_order() const; S virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&, ios_base::iostate& err, tm* t) const; S virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&, ios_base::iostate& err, tm* t) const; T virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&, ios_base::iostate& err, tm* t) const; T virtual iter_type do_get_monthname(iter_type s, iter_type end, ios_base&, ios_base::iostate& err, tm* t) const; S virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&, ios_base::iostate& err, tm* t) const; }; } 22.2.5.3 Template class time_put [lib.locale.time.put] X template > class time_put : public locale::facet { public: T typedef charT char_type; T typedef OutputIterator iter_type; T explicit time_put(size_t refs = 0); // the following is implemented in terms of other member functions. S iter_type put(iter_type s, ios_base& f, char_type fill, const tm* tmb, const charT* pattern, const charT* pat_end) const; T iter_type put(iter_type s, ios_base& f, char_type fill, const tm* tmb, char format, char modifier = 0) const; T static locale::id id; protected: T ~time_put(); // virtual S virtual iter_type do_put(iter_type s, ios_base&, char_type, const tm* t, char format, char modifier) const; }; 22.2.5.4 Template class [lib.locale.time.put.byname] time_put_byname T template > class time_put_byname : public time_put { public: T typedef charT char_type; T typedef OutputIterator iter_type; T explicit time_put_byname(const char*, size_t refs = 0); protected: T ~time_put_byname(); // virtual S virtual iter_type do_put(iter_type s, ios_base&, char_type, const tm* t, char format, char modifier) const; }; 22.2.6.1 Template class money_get [lib.locale.money.get] X template > class money_get : public locale::facet { public: T typedef charT char_type; T typedef InputIterator iter_type; T typedef basic_string string_type; T explicit money_get(size_t refs = 0); T iter_type get(iter_type s, iter_type end, bool intl, ios_base& f, ios_base::iostate& err, long double& units) const; T iter_type get(iter_type s, iter_type end, bool intl, ios_base& f, ios_base::iostate& err, string_type& digits) const; T static locale::id id; protected: T ~money_get(); // virtual S virtual iter_type do_get(iter_type, iter_type, bool, ios_base&, ios_base::iostate& err, long double& units) const; S virtual iter_type do_get(iter_type, iter_type, bool, ios_base&, ios_base::iostate& err, string_type& digits) const; }; 22.2.6.2 Template class money_put [lib.locale.money.put] X template > class money_put : public locale::facet { public: T typedef charT char_type; T typedef OutputIterator iter_type; T typedef basic_string string_type; T explicit money_put(size_t refs = 0); T iter_type put(iter_type s, bool intl, ios_base& f, char_type fill, long double units) const; T iter_type put(iter_type s, bool intl, ios_base& f, char_type fill, const string_type& digits) const; T static locale::id id; protected: T ~money_put(); // virtual S virtual iter_type do_put(iter_type, bool, ios_base&, char_type fill, long double units) const; S virtual iter_type do_put(iter_type, bool, ios_base&, char_type fill, const string_type& digits) const; }; 22.2.6.3 Template class moneypunct [lib.locale.moneypunct] T class money_base { public: T enum part { none, space, symbol, sign, value }; T struct pattern { char field[4]; }; }; X template class moneypunct : public locale::facet, public money_base { public: T typedef charT char_type; T typedef basic_string string_type; T explicit moneypunct(size_t refs = 0); T charT decimal_point() const; T charT thousands_sep() const; T string grouping() const; T string_type curr_symbol() const; T string_type positive_sign() const; T string_type negative_sign() const; T int frac_digits() const; T pattern pos_format() const; T pattern neg_format() const; T static locale::id id; T static const bool intl = International; protected: T ~moneypunct(); // virtual S virtual charT do_decimal_point() const; S virtual charT do_thousands_sep() const; S virtual string do_grouping() const; S virtual string_type do_curr_symbol() const; S virtual string_type do_positive_sign() const; S virtual string_type do_negative_sign() const; S virtual int do_frac_digits() const; T virtual pattern do_pos_format() const; T virtual pattern do_neg_format() const; }; } 22.2.6.4 Template class [lib.locale.moneypunct.byname] moneypunct_byname X template class moneypunct_byname : public moneypunct { public: T typedef money_base::pattern pattern; T typedef basic_string string_type; T explicit moneypunct_byname(const char*, size_t refs = 0); protected: T ~moneypunct_byname(); // virtual S virtual charT do_decimal_point() const; S virtual charT do_thousands_sep() const; S virtual string do_grouping() const; S virtual string_type do_curr_symbol() const; S virtual string_type do_positive_sign() const; S virtual string_type do_negative_sign() const; S virtual int do_frac_digits() const; S virtual pattern do_pos_format() const; S virtual pattern do_neg_format() const; }; 22.2.7.1 Template class messages [lib.locale.messages] T class messages_base { public: T typedef int catalog; }; X template class messages : public locale::facet, public messages_base { public: T typedef charT char_type; T typedef basic_string string_type; T explicit messages(size_t refs = 0); T catalog open(const basic_string& fn, const locale&) const; T string_type get(catalog c, int set, int msgid, const string_type& dfault) const; T void close(catalog c) const; T static locale::id id; protected: T ~messages(); // virtual S virtual catalog do_open(const basic_string&, const locale&) const; S virtual string_type do_get(catalog, int set, int msgid, const string_type& dfault) const; S virtual void do_close(catalog) const; }; 22.2.7.2 Template class [lib.locale.messages.byname] messages_byname X template class messages_byname : public messages { public: T typedef messages_base::catalog catalog; T typedef basic_string string_type; T explicit messages_byname(const char*, size_t refs = 0); protected: T ~messages_byname(); // virtual S virtual catalog do_open(const basic_string&, const locale&) const; S virtual string_type do_get(catalog, int set, int msgid, const string_type& dfault) const; S virtual void do_close(catalog) const; }; 22.3 C Library Locales [lib.c.locales] Table 13--Header synopsis Macros: X LC_ALL LC_COLLATE LC_CTYPE X LC_MONETARY LC_NUMERIC LC_TIME X NULL X Struct: lconv X Functions: localeconv setlocale 23.2 Sequences [lib.sequences] , , , , and . Header synopsis X template > class deque; T template bool operator==(const deque& x, const deque& y); T template bool operator< (const deque& x, const deque& y); T template bool operator!=(const deque& x, const deque& y); T template bool operator> (const deque& x, const deque& y); T template bool operator>=(const deque& x, const deque& y); T template bool operator<=(const deque& x, const deque& y); T template void swap(deque& x, deque& y); } Header synopsis X template > class list; T template bool operator==(const list& x, const list& y); T template bool operator< (const list& x, const list& y); T template bool operator!=(const list& x, const list& y); T template bool operator> (const list& x, const list& y); T template bool operator>=(const list& x, const list& y); T template bool operator<=(const list& x, const list& y); T template void swap(list& x, list& y); } Header synopsis namespace std { X template > class queue; T template bool operator==(const queue& x, const queue& y); T template bool operator< (const queue& x, const queue& y); T template bool operator!=(const queue& x, const queue& y); T template bool operator> (const queue& x, const queue& y); T template bool operator>=(const queue& x, const queue& y); T template bool operator<=(const queue& x, const queue& y); T template , class Compare = less > T class priority_queue; } Header synopsis namespace std { T template > class stack; T template bool operator==(const stack& x, const stack& y); T template bool operator< (const stack& x, const stack& y); T template bool operator!=(const stack& x, const stack& y); T template bool operator> (const stack& x, const stack& y); T template bool operator>=(const stack& x, const stack& y); T template bool operator<=(const stack& x, const stack& y); } Header synopsis T template > class vector; T template bool operator==(const vector& x, const vector& y); T template bool operator< (const vector& x, const vector& y); T template bool operator!=(const vector& x, const vector& y); T template bool operator> (const vector& x, const vector& y); T template bool operator>=(const vector& x, const vector& y); T template bool operator<=(const vector& x, const vector& y); T template void swap(vector& x, vector& y); T template class vector; T template bool operator==(const vector& x, const vector& y); T template bool operator< (const vector& x, const vector& y); T template bool operator!=(const vector& x, const vector& y); T template bool operator> (const vector& x, const vector& y); T template bool operator>=(const vector& x, const vector& y); T template bool operator<=(const vector& x, const vector& y); T template void swap(vector& x, vector& y); } 23.2.1 Template class deque [lib.deque] template > X class deque { public: // types: T typedef typename Allocator::reference reference; T typedef typename Allocator::const_reference const_reference; X typedef implementation defined iterator; X typedef implementation defined const_iterator; T typedef implementation defined size_type; T typedef implementation defined difference_type; T typedef T value_type; T typedef Allocator allocator_type; T typedef typename Allocator::pointer pointer; T typedef typename Allocator::const_pointer const_pointer; T typedef std::reverse_iterator reverse_iterator; T typedef std::reverse_iterator const_reverse_iterator; // _lib.deque.cons_ construct/copy/destroy: T explicit deque(const Allocator& = Allocator()); T explicit deque(size_type n, const T& value = T(), const Allocator& = Allocator()); T template deque(InputIterator first, InputIterator last, const Allocator& = Allocator()); T deque(const deque& x); T ~deque(); T deque& operator=(const deque& x); T template void assign(InputIterator first, InputIterator last); T void assign(size_type n, const T& t); T allocator_type get_allocator() const; // iterators: T iterator begin(); T const_iterator begin() const; T iterator end(); T const_iterator end() const; T reverse_iterator rbegin(); T const_reverse_iterator rbegin() const; T reverse_iterator rend(); T const_reverse_iterator rend() const; // _lib.deque.capacity_ capacity: T size_type size() const; T size_type max_size() const; T void resize(size_type sz, T c = T()); T bool empty() const; // element access: T reference operator[](size_type n); T const_reference operator[](size_type n) const; T reference at(size_type n); T const_reference at(size_type n) const; T reference front(); T const_reference front() const; T reference back(); T const_reference back() const; // _lib.deque.modifiers_ modifiers: T void push_front(const T& x); T void push_back(const T& x); T iterator insert(iterator position, const T& x); T void insert(iterator position, size_type n, const T& x); T template void insert (iterator position, InputIterator first, InputIterator last); T void pop_front(); T void pop_back(); T iterator erase(iterator position); T iterator erase(iterator first, iterator last); T void swap(deque&); T void clear(); }; T template bool operator==(const deque& x, const deque& y); T template bool operator< (const deque& x, const deque& y); T template bool operator!=(const deque& x, const deque& y); T template bool operator> (const deque& x, const deque& y); T template bool operator>=(const deque& x, const deque& y); T template bool operator<=(const deque& x, const deque& y); // specialized algorithms: T template void swap(deque& x, deque& y); 23.2.2 Template class list [lib.list] X template > class list { public: // types: T typedef typename Allocator::reference reference; T typedef typename Allocator::const_reference const_reference; X typedef implementation defined iterator; X typedef implementation defined const_iterator; T typedef implementation defined size_type; T typedef implementation defined difference_type; T typedef T value_type; T typedef Allocator allocator_type; T typedef typename Allocator::pointer pointer; T typedef typename Allocator::const_pointer const_pointer; T typedef std::reverse_iterator reverse_iterator; T typedef std::reverse_iterator const_reverse_iterator; // _lib.list.cons_ construct/copy/destroy: T explicit list(const Allocator& = Allocator()); T explicit list(size_type n, const T& value = T(), const Allocator& = Allocator()); T template list(InputIterator first, InputIterator last, const Allocator& = Allocator()); T list(const list& x); T ~list(); T list& operator=(const list& x); T template void assign(InputIterator first, InputIterator last); T void assign(size_type n, const T& t); T allocator_type get_allocator() const; // iterators: T iterator begin(); T const_iterator begin() const; T iterator end(); T const_iterator end() const; T reverse_iterator rbegin(); T const_reverse_iterator rbegin() const; T reverse_iterator rend(); T const_reverse_iterator rend() const; // _lib.list.capacity_ capacity: T bool empty() const; T size_type size() const; T size_type max_size() const; T void resize(size_type sz, T c = T()); // element access: T reference front(); T const_reference front() const; T reference back(); T const_reference back() const; // _lib.list.modifiers_ modifiers: T void push_front(const T& x); T void pop_front(); T void push_back(const T& x); T void pop_back(); T iterator insert(iterator position, const T& x); T void insert(iterator position, size_type n, const T& x); T template void insert(iterator position, InputIterator first, InputIterator last); T iterator erase(iterator position); T iterator erase(iterator position, iterator last); T void swap(list&); T void clear(); // _lib.list.ops_ list operations: T void splice(iterator position, list& x); T void splice(iterator position, list& x, iterator i); T void splice(iterator position, list& x, iterator first, iterator last); T void remove(const T& value); T template void remove_if(Predicate pred); T void unique(); T template void unique(BinaryPredicate binary_pred); T void merge(list& x); T template void merge(list& x, Compare comp); void sort(); T template void sort(Compare comp); void reverse(); }; T template bool operator==(const list& x, const list& y); T template bool operator< (const list& x, const list& y); T template bool operator!=(const list& x, const list& y); T template bool operator> (const list& x, const list& y); T template bool operator>=(const list& x, const list& y); T template bool operator<=(const list& x, const list& y); // specialized algorithms: T template void swap(list& x, list& y); 23.2.3.1 Template class queue [lib.queue] T template > class queue { public: T typedef typename Container::value_type value_type; T typedef typename Container::size_type size_type; T typedef Container container_type; protected: T Container c; public: T explicit queue(const Container& = Container()); T bool empty() const { return c.empty(); } T size_type size() const { return c.size(); } T value_type& front() { return c.front(); } T const value_type& front() const { return c.front(); } T value_type& back() { return c.back(); } T const value_type& back() const { return c.back(); } T void push(const value_type& x) { c.push_back(x); } T void pop() { c.pop_front(); } }; T template bool operator==(const queue& x, const queue& y); T template bool operator< (const queue& x, const queue& y); T template bool operator!=(const queue& x, const queue& y); T template bool operator> (const queue& x, const queue& y); T template bool operator>=(const queue& x, const queue& y); T template bool operator<=(const queue& x, const queue& y); 23.2.3.2 Template class priority_queue [lib.priority.queue] T template , class Compare = less > class priority_queue { public: T typedef typename Container::value_type value_type; T typedef typename Container::size_type size_type; T typedef Container container_type; protected: T Container c; T Compare comp; public: T explicit priority_queue(const Compare& x = Compare(), const Container& = Container()); T template priority_queue(InputIterator first, InputIterator last, const Compare& x = Compare(), const Container& = Container()); T bool empty() const { return c.empty(); } T size_type size() const { return c.size(); } T const value_type& top() const { return c.front(); } T void push(const value_type& x); T void pop(); }; 23.2.3.3 Template class stack [lib.stack] T template > class stack { public: T typedef typename Container::value_type value_type; T typedef typename Container::size_type size_type; T typedef Container container_type; protected: T Container c; public: T explicit stack(const Container& = Container()); T bool empty() const { return c.empty(); } T size_type size() const { return c.size(); } T value_type& top() { return c.back(); } T const value_type& top() const { return c.back(); } T void push(const value_type& x) { c.push_back(x); } T void pop() { c.pop_back(); } }; T template bool operator==(const stack& x, const stack& y); T template bool operator< (const stack& x, const stack& y); T template bool operator!=(const stack& x, const stack& y); T template bool operator> (const stack& x, const stack& y); T template bool operator>=(const stack& x, const stack& y); T template bool operator<=(const stack& x, const stack& y); 23.2.4 Template class vector [lib.vector] template > X class vector { public: // types: T typedef typename Allocator::reference reference; T typedef typename Allocator::const_reference const_reference; X typedef implementation defined iterator; X typedef implementation defined const_iterator; T typedef implementation defined size_type; T typedef implementation defined difference_type; T typedef T value_type; T typedef Allocator allocator_type; T typedef typename Allocator::pointer pointer; T typedef typename Allocator::const_pointer const_pointer T typedef std::reverse_iterator reverse_iterator; T typedef std::reverse_iterator const_reverse_iterator; // _lib.vector.cons_ construct/copy/destroy: T explicit vector(const Allocator& = Allocator()); T explicit vector(size_type n, const T& value = T(), const Allocator& = Allocator()); T template vector(InputIterator first, InputIterator last, const Allocator& = Allocator()); T vector(const vector& x); T ~vector(); T vector& operator=(const vector& x); T template void assign(InputIterator first, InputIterator last); T void assign(size_type n, const T& u); T allocator_type get_allocator() const; // iterators: T iterator begin(); T const_iterator begin() const; T iterator end(); T const_iterator end() const; T reverse_iterator rbegin(); T const_reverse_iterator rbegin() const; T reverse_iterator rend(); T const_reverse_iterator rend() const; // _lib.vector.capacity_ capacity: T size_type size() const; T size_type max_size() const; T void resize(size_type sz, T c = T()); T size_type capacity() const; T bool empty() const; T void reserve(size_type n); // element access: T reference operator[](size_type n); T const_reference operator[](size_type n) const; T const_reference at(size_type n) const; T reference at(size_type n); T reference front(); T const_reference front() const; T reference back(); T const_reference back() const; // _lib.vector.modifiers_ modifiers: T void push_back(const T& x); T void pop_back(); T iterator insert(iterator position, const T& x); T void insert(iterator position, size_type n, const T& x); T template void insert(iterator position, InputIterator first, InputIterator last); T iterator erase(iterator position); T iterator erase(iterator first, iterator last); T void swap(vector&); T void clear(); }; T template bool operator==(const vector& x, const vector& y); T template bool operator< (const vector& x, const vector& y); T template bool operator!=(const vector& x, const vector& y); T template bool operator> (const vector& x, const vector& y); T template bool operator>=(const vector& x, const vector& y); T template bool operator<=(const vector& x, const vector& y); // specialized algorithms: T template void swap(vector& x, vector& y); 23.2.5 Class vector [lib.vector.bool] X template class vector { public: // types: T typedef bool const_reference; X typedef implementation defined iterator; X typedef implementation defined const_iterator; T typedef implementation defined size_type; T typedef implementation defined difference_type; T typedef bool value_type; T typedef Allocator allocator_type; T typedef implementation defined pointer; T typedef implementation defined const_pointer T typedef std::reverse_iterator reverse_iterator; T typedef std::reverse_iterator const_reverse_iterator; // bit reference: T class reference { friend class vector; T reference(); public: T ~reference(); T operator bool() const; T reference& operator=(const bool x); T reference& operator=(const reference& x); T void flip(); // flips the bit }; // construct/copy/destroy: T explicit vector(const Allocator& = Allocator()); T explicit vector(size_type n, const bool& value = bool(), const Allocator& = Allocator()); T template vector(InputIterator first, InputIterator last, const Allocator& = Allocator()); T vector(const vector& x); T ~vector(); T vector& operator=(const vector& x); T template void assign(InputIterator first, InputIterator last); T void assign(size_type n, const T& t); T allocator_type get_allocator() const; // iterators: T iterator begin(); T const_iterator begin() const; T iterator end(); T const_iterator end() const; T reverse_iterator rbegin(); T const_reverse_iterator rbegin() const; T reverse_iterator rend(); T const_reverse_iterator rend() const; // capacity: T size_type size() const; T size_type max_size() const; T void resize(size_type sz, bool c = false); T size_type capacity() const; T bool empty() const; T void reserve(size_type n); // element access: T reference operator[](size_type n); T const_reference operator[](size_type n) const; T const_reference at(size_type n) const; T reference at(size_type n); T reference front(); T const_reference front() const; T reference back(); T const_reference back() const; // modifiers: T void push_back(const bool& x); T void pop_back(); T iterator insert(iterator position, const bool& x); T void insert (iterator position, size_type n, const bool& x); T template void insert(iterator position, InputIterator first, InputIterator last); T iterator erase(iterator position); T iterator erase(iterator first, iterator last); T void swap(vector&); T static void swap(reference x, reference y); T void flip(); // flips all bits T void clear(); }; T template bool operator==(const vector& x, const vector& y); T template bool operator< (const vector& x, const vector& y); T template bool operator!=(const vector& x, const vector& y); T template bool operator> (const vector& x, const vector& y); T template bool operator>=(const vector& x, const vector& y); T template bool operator<=(const vector& x, const vector& y); // specialized algorithms: T template void swap(vector& x, vector& y); 23.3 Associative containers [lib.associative] and : Header synopsis template , class Allocator = allocator > > X class map; T template bool operator==(const map& x, const map& y); T template bool operator< (const map& x, const map& y); T template bool operator!=(const map& x, const map& y); T template bool operator> (const map& x, const map& y); T template bool operator>=(const map& x, const map& y); T template bool operator<=(const map& x, const map& y); T template void swap(map& x, map& y); T template , class Allocator = allocator > > class multimap; T template bool operator==(const multimap& x, const multimap& y); T template bool operator< (const multimap& x, const multimap& y); T template bool operator!=(const multimap& x, const multimap& y); T template bool operator> (const multimap& x, const multimap& y); T template bool operator>=(const multimap& x, const multimap& y); T template bool operator<=(const multimap& x, const multimap& y); T template void swap(multimap& x, multimap& y); } Header synopsis template , class Allocator = allocator > X class set; T template bool operator==(const set& x, const set& y); T template bool operator< (const set& x, const set& y); T template bool operator!=(const set& x, const set& y); T template bool operator> (const set& x, const set& y); T template bool operator>=(const set& x, const set& y); T template bool operator<=(const set& x, const set& y); T template void swap(set& x, set& y); T template , class Allocator = allocator > class multiset; T template bool operator==(const multiset& x, const multiset& y); T template bool operator< (const multiset& x, const multiset& y); T template bool operator!=(const multiset& x, const multiset& y); T template bool operator> (const multiset& x, const multiset& y); T template bool operator>=(const multiset& x, const multiset& y); T template bool operator<=(const multiset& x, const multiset& y); T template void swap(multiset& x, multiset& y); } 23.3.1 Template class map [lib.map] template , class Allocator = allocator > > X class map { public: // types: T typedef Key key_type; T typedef T mapped_type; T typedef pair value_type; T typedef Compare key_compare; T typedef Allocator allocator_type; T typedef typename Allocator::reference reference; T typedef typename Allocator::const_reference const_reference; X typedef implementation defined iterator; X typedef implementation defined const_iterator; T typedef implementation defined size_type; T typedef implementation defined difference_type; T typedef typename Allocator::pointer pointer; T typedef typename Allocator::const_pointer const_pointer; T typedef std::reverse_iterator reverse_iterator; T typedef std::reverse_iterator const_reverse_iterator; T class value_compare : public binary_function { friend class map; protected: T Compare comp; T value_compare(Compare c) : comp(c) {} public: T bool operator()(const value_type& x, const value_type& y) const { return comp(x.first, y.first); } }; // _lib.map.cons_ construct/copy/destroy: T explicit map(const Compare& comp = Compare(), const Allocator& = Allocator()); T template map(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); T map(const map& x); T ~map(); T map& operator=(const map& x); // iterators: T iterator begin(); T const_iterator begin() const; T iterator end(); T const_iterator end() const; T reverse_iterator rbegin(); T const_reverse_iterator rbegin() const; T reverse_iterator rend(); T const_reverse_iterator rend() const; // capacity: T bool empty() const; T size_type size() const; T size_type max_size() const; // _lib.map.access_ element access: T T& operator[](const key_type& x); // modifiers: T pair insert(const value_type& x); T iterator insert(iterator position, const value_type& x); T template void insert(InputIterator first, InputIterator last); T void erase(iterator position); T size_type erase(const key_type& x); T void erase(iterator first, iterator last); T void swap(map&); T void clear(); // observers: T key_compare key_comp() const; T value_compare value_comp() const; // _lib.map.ops_ map operations: T iterator find(const key_type& x); T const_iterator find(const key_type& x) const; T size_type count(const key_type& x) const; T iterator lower_bound(const key_type& x); T const_iterator lower_bound(const key_type& x) const; T iterator upper_bound(const key_type& x); T const_iterator upper_bound(const key_type& x) const; T pair equal_range(const key_type& x); T pair equal_range(const key_type& x) const; }; T template bool operator==(const map& x, const map& y); T template bool operator< (const map& x, const map& y); T template bool operator!=(const map& x, const map& y); T template bool operator> (const map& x, const map& y); T template bool operator>=(const map& x, const map& y); T template bool operator<=(const map& x, const map& y); // specialized algorithms: T template void swap(map& x, map& y); 23.3.2 Template class multimap [lib.multimap] template , class Allocator = allocator > > X class multimap { public: // types: T typedef Key key_type; T typedef T mapped_type; T typedef pair value_type; T typedef Compare key_compare; T typedef Allocator allocator_type; T typedef typename Allocator::reference reference; T typedef typename Allocator::const_reference const_reference; X typedef implementation defined iterator; X typedef implementation defined const_iterator; T typedef implementation defined size_type; T typedef implementation defined difference_type T typedef typename Allocator::pointer pointer; T typedef typename Allocator::const_pointer const_pointer; T typedef std::reverse_iterator reverse_iterator; T typedef std::reverse_iterator const_reverse_iterator; T class value_compare : public binary_function { friend class multimap; protected: T Compare comp; T value_compare(Compare c) : comp(c) {} public: T bool operator()(const value_type& x, const value_type& y) const { return comp(x.first, y.first); } }; // construct/copy/destroy: T explicit multimap(const Compare& comp = Compare(), const Allocator& = Allocator()); T template multimap(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); T multimap(const multimap& x); T ~multimap(); T multimap& operator=(const multimap& x); T allocator_type get_allocator() const; // iterators: T iterator begin(); T const_iterator begin() const; T iterator end(); T const_iterator end() const; T reverse_iterator rbegin(); T const_reverse_iterator rbegin() const; T reverse_iterator rend(); T const_reverse_iterator rend() const; // capacity: T bool empty() const; T size_type size() const; T size_type max_size() const; // modifiers: T iterator insert(const value_type& x); T iterator insert(iterator position, const value_type& x); T template void insert(InputIterator first, InputIterator last); T void erase(iterator position); T size_type erase(const key_type& x); T void erase(iterator first, iterator last); T void swap(multimap&); T void clear(); // observers: T key_compare key_comp() const; T value_compare value_comp() const; // map operations: T iterator find(const key_type& x); T const_iterator find(const key_type& x) const; T size_type count(const key_type& x) const; T iterator lower_bound(const key_type& x); T const_iterator lower_bound(const key_type& x) const; T iterator upper_bound(const key_type& x); T const_iterator upper_bound(const key_type& x) const; T pair equal_range(const key_type& x); T pair equal_range(const key_type& x) const; }; T template bool operator==(const multimap& x, const multimap& y); T template bool operator< (const multimap& x, const multimap& y); T template bool operator!=(const multimap& x, const multimap& y); T template bool operator> (const multimap& x, const multimap& y); T template bool operator>=(const multimap& x, const multimap& y); T template bool operator<=(const multimap& x, const multimap& y); // specialized algorithms: T template void swap(multimap& x, multimap& y); 23.3.3 Template class set [lib.set] template , class Allocator = allocator > X class set { public: // types: T typedef Key key_type; T typedef Key value_type; T typedef Compare key_compare; T typedef Compare value_compare; T typedef Allocator allocator_type; T typedef typename Allocator::reference reference; T typedef typename Allocator::const_reference const_reference; X typedef implementation defined iterator; X typedef implementation defined const_iterator; T typedef implementation defined size_type; T typedef implementation defined difference_type; T typedef typename Allocator::pointer pointer; T typedef typename Allocator::const_pointer const_pointer; T typedef std::reverse_iterator reverse_iterator; T typedef std::reverse_iterator const_reverse_iterator; // _lib.set.cons_ construct/copy/destroy: T explicit set(const Compare& comp = Compare(), const Allocator& = Allocator()); T template set(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); T set(const set& x); T ~set(); T set& operator=(const set& x); T allocator_type get_allocator() const; // iterators: T iterator begin(); T const_iterator begin() const; T iterator end(); T const_iterator end() const; T reverse_iterator rbegin(); T const_reverse_iterator rbegin() const; T reverse_iterator rend(); T const_reverse_iterator rend() const; // capacity: T bool empty() const; T size_type size() const; T size_type max_size() const; // modifiers: T pair insert(const value_type& x); T iterator insert(iterator position, const value_type& x); T template T void insert(InputIterator first, InputIterator last); T void erase(iterator position); T size_type erase(const key_type& x); T void erase(iterator first, iterator last); T void swap(set&); T void clear(); // observers: T key_compare key_comp() const; T value_compare value_comp() const; // set operations: T iterator find(const key_type& x) const; T size_type count(const key_type& x) const; T iterator lower_bound(const key_type& x) const; T iterator upper_bound(const key_type& x) const; T pair equal_range(const key_type& x) const; }; T template bool operator==(const set& x, const set& y); T template bool operator< (const set& x, const set& y); T template bool operator!=(const set& x, const set& y); T template bool operator> (const set& x, const set& y); T template bool operator>=(const set& x, const set& y); T template bool operator<=(const set& x, const set& y); // specialized algorithms: T template void swap(set& x, set& y); 23.3.4 Template class multiset [lib.multiset] template , class Allocator = allocator > X class multiset { public: // types: T typedef Key key_type; T typedef Key value_type; T typedef Compare key_compare; T typedef Compare value_compare; T typedef Allocator allocator_type; T typedef typename Allocator::reference reference; T typedef typename Allocator::const_reference const_reference; X typedef implementation defined iterator; X typedef implementation defined const_iterator; T typedef implementation defined size_type; T typedef implementation defined difference_type T typedef typename Allocator::pointer pointer; T typedef typename Allocator::const_pointer const_pointer; T typedef std::reverse_iterator reverse_iterator; T typedef std::reverse_iterator const_reverse_iterator; // construct/copy/destroy: T explicit multiset(const Compare& comp = Compare(), const Allocator& = Allocator()); T template multiset(InputIterator first, InputIterator last, const Compare& comp = Compare(), const Allocator& = Allocator()); T multiset(const multiset& x); T ~multiset(); T multiset& operator=(const multiset& x); T allocator_type get_allocator() const; // iterators: T iterator begin(); T const_iterator begin() const; T iterator end(); T const_iterator end() const; T reverse_iterator rbegin(); T const_reverse_iterator rbegin() const; T reverse_iterator rend(); T const_reverse_iterator rend() const; // capacity: T bool empty() const; T size_type size() const; T size_type max_size() const; // modifiers: T iterator insert(const value_type& x); T iterator insert(iterator position, const value_type& x); T template void insert(InputIterator first, InputIterator last); T void erase(iterator position); T size_type erase(const key_type& x); T void erase(iterator first, iterator last); T void swap(multiset&); T void clear(); // observers: T key_compare key_comp() const; T value_compare value_comp() const; // set operations: T iterator find(const key_type& x) const; T size_type count(const key_type& x) const; T iterator lower_bound(const key_type& x) const; T iterator upper_bound(const key_type& x) const; T pair equal_range(const key_type& x) const; }; T template bool operator==(const multiset& x, const multiset& y); T template bool operator< (const multiset& x, const multiset& y); T template bool operator!=(const multiset& x, const multiset& y); T template bool operator> (const multiset& x, const multiset& y); T template bool operator>=(const multiset& x, const multiset& y); T template bool operator<=(const multiset& x, const multiset& y); // specialized algorithms: T template void swap(multiset& x, multiset& y); 23.3.5 Template class bitset [lib.template.bitset] Header synopsis [What's this stuff? #include // for size_t #include #include // for invalid_argument, // out_of_range, overflow_error #include // for istream, ostream ] X template class bitset; // _lib.bitset.operators_ bitset operations: T template bitset operator&(const bitset&, const bitset&); T template bitset operator|(const bitset&, const bitset&); T template bitset operator^(const bitset&, const bitset&); T template basic_istream& operator>>(basic_istream& is, bitset& x); T template basic_ostream& operator<<(basic_ostream& os, const bitset& x); X template class bitset { public: // bit reference: T class reference { friend class bitset; T reference(); public: T ~reference(); T reference& operator=(bool x); // for b[i] = x; T reference& operator=(const reference&); // for b[i] = b[j]; T bool operator~() const; // flips the bit T operator bool() const; // for x = b[i]; T reference& flip(); // for b[i].flip(); }; // _lib.bitset.cons_ constructors: T bitset(); T bitset(unsigned long val); T template explicit bitset( const basic_string& str, typename basic_string::size_type pos = 0, typename basic_string::size_type n = basic_string::npos); // _lib.bitset.members_ bitset operations: T bitset& operator&=(const bitset& rhs); T bitset& operator|=(const bitset& rhs); T bitset& operator^=(const bitset& rhs); T bitset& operator<<=(size_t pos); T bitset& operator>>=(size_t pos); T bitset& set(); T bitset& set(size_t pos, int val = true); T bitset& reset(); T bitset& reset(size_t pos); T bitset operator~() const; T bitset& flip(); T bitset& flip(size_t pos); // element access: T reference operator[](size_t pos); // for b[i]; T unsigned long to_ulong() const; T template basic_string to_string() const; T size_t count() const; T size_t size() const; T bool operator==(const bitset& rhs) const; T bool operator!=(const bitset& rhs) const; T bool test(size_t pos) const; T bool any() const; T bool none() const; T bitset operator<<(size_t pos) const; T bitset operator>>(size_t pos) const; }; 24.2 Header synopsis [lib.iterator.synopsis] // _lib.iterator.primitives_, primitives: T template struct iterator_traits; T template struct iterator_traits; X template struct iterator; T struct input_iterator_tag {}; T struct output_iterator_tag {}; T struct forward_iterator_tag: public input_iterator_tag {}; T struct bidirectional_iterator_tag: public forward_iterator_tag {}; T struct random_access_iterator_tag: public bidirectional_iterator_tag {}; // _lib.iterator.operations_, iterator operations: T template void advance(InputIterator& i, Distance n); T template typename iterator_traits::difference_type distance(InputIterator first, InputIterator last); // _lib.predef.iterators_, predefined iterators: X template class reverse_iterator; T template bool operator==( const reverse_iterator& x, const reverse_iterator& y); T template bool operator<( const reverse_iterator& x, const reverse_iterator& y); T template bool operator!=( const reverse_iterator& x, const reverse_iterator& y); T template bool operator>( const reverse_iterator& x, const reverse_iterator& y); T template bool operator>=( const reverse_iterator& x, const reverse_iterator& y); T template bool operator<=( const reverse_iterator& x, const reverse_iterator& y); T template typename reverse_iterator::difference_type operator-( const reverse_iterator& x, const reverse_iterator& y); T template reverse_iterator operator+( typename reverse_iterator::difference_type n, const reverse_iterator& x); X template class back_insert_iterator; T template back_insert_iterator back_inserter(Container& x); X template class front_insert_iterator; T template front_insert_iterator front_inserter(Container& x); X template class insert_iterator; T template insert_iterator inserter(Container& x, Iterator i); // _lib.stream.iterators_, stream iterators: X template , class Distance = ptrdiff_t> class istream_iterator; template X bool operator==(const istream_iterator& x, const istream_iterator& y); template X bool operator!=(const istream_iterator& x, const istream_iterator& y); X template > class ostream_iterator; X template > class istreambuf_iterator; X template bool operator==(const istreambuf_iterator& a, const istreambuf_iterator& b); X template bool operator!=(const istreambuf_iterator& a, const istreambuf_iterator& b); T template > class ostreambuf_iterator; 24.3 Iterator primitives [lib.iterator.primitives] T template struct iterator_traits { T typedef typename Iterator::difference_type difference_type; T typedef typename Iterator::value_type value_type; T typedef typename Iterator::pointer pointer; T typedef typename Iterator::reference reference; T typedef typename Iterator::iterator_category iterator_category; }; T template struct iterator_traits { T typedef ptrdiff_t difference_type; T typedef T value_type; T typedef T* pointer; T typedef T& reference; T typedef random_access_iterator_tag iterator_category; }; T template struct iterator_traits { T typedef ptrdiff_t difference_type; T typedef T value_type; T typedef const T* pointer; T typedef const T& reference; T typedef random_access_iterator_tag iterator_category; }; 24.3.2 Basic iterator [lib.iterator.basic] template X struct iterator { T typedef T value_type; T typedef Distance difference_type; T typedef Pointer pointer; T typedef Reference reference; T typedef Category iterator_category; }; 24.3.3 Standard iterator tags [lib.std.iterator.tags] T struct input_iterator_tag {}; T struct output_iterator_tag {}; T struct forward_iterator_tag: public input_iterator_tag {}; T struct bidirectional_iterator_tag: public forward_iterator_tag {}; T struct random_access_iterator_tag: public bidirectional_iterator_tag {}; 24.4.1 Reverse iterators [lib.reverse.iterators] template X class reverse_iterator : public iterator::iterator_category, typename iterator_traits::value_type, typename iterator_traits::difference_type, typename iterator_traits::pointer, typename iterator_traits::reference> { protected: T Iterator current; public: T typedef Iterator iterator_type; T typedef typename iterator_traits::difference_type difference_type; T typedef typename iterator_traits::reference reference; T typedef typename iterator_traits::pointer pointer; T reverse_iterator(); T explicit reverse_iterator(Iterator x); T template reverse_iterator(const reverse_iterator& u); T Iterator base() const; // explicit T reference operator*() const; T pointer operator->() const; T reverse_iterator& operator++(); T reverse_iterator operator++(int); T reverse_iterator& operator--(); T reverse_iterator operator--(int); T reverse_iterator operator+ (difference_type n) const; T reverse_iterator& operator+=(difference_type n); T reverse_iterator operator- (difference_type n) const; T reverse_iterator& operator-=(difference_type n); T reference operator[](difference_type n) const; }; T template bool operator==( const reverse_iterator& x, const reverse_iterator& y); T template bool operator<( const reverse_iterator& x, const reverse_iterator& y); T template bool operator!=( const reverse_iterator& x, const reverse_iterator& y); T template bool operator>( const reverse_iterator& x, const reverse_iterator& y); T template bool operator>=( const reverse_iterator& x, const reverse_iterator& y); T template bool operator<=( const reverse_iterator& x, const reverse_iterator& y); T template typename reverse_iterator::difference_type operator-( const reverse_iterator& x, const reverse_iterator& y); T template reverse_iterator operator+( typename reverse_iterator::difference_type n, const reverse_iterator& x); 24.4.2.1 Template class [lib.back.insert.iterator] back_insert_iterator template X class back_insert_iterator : public iterator { protected: T Container* container; public: T typedef Container container_type; T explicit back_insert_iterator(Container& x); T back_insert_iterator& operator=(typename Container::const_reference value); T back_insert_iterator& operator*(); T back_insert_iterator& operator++(); T back_insert_iterator operator++(int); }; T template back_insert_iterator back_inserter(Container& x); 24.4.2.3 Template class [lib.front.insert.iterator] front_insert_iterator template X class front_insert_iterator : public iterator { protected: T Container* container; public: T typedef Container container_type; T explicit front_insert_iterator(Container& x); T front_insert_iterator& operator=(typename Container::const_reference value); T front_insert_iterator& operator*(); T front_insert_iterator& operator++(); T front_insert_iterator operator++(int); }; T template front_insert_iterator front_inserter(Container& x); 24.4.2.5 Template class insert_iterator [lib.insert.iterator] template X class insert_iterator : public iterator { protected: T Container* container; T typename Container::iterator iter; public: T typedef Container container_type; T insert_iterator(Container& x, typename Container::iterator i); T insert_iterator& operator=(typename Container::const_reference value); T insert_iterator& operator*(); T insert_iterator& operator++(); T insert_iterator& operator++(int); }; T template insert_iterator inserter(Container& x, Iterator i); 24.5.1 Template class istream_iterator [lib.istream.iterator] template , class Distance = ptrdiff_t> X class istream_iterator: public iterator { public: T typedef charT char_type T typedef traits traits_type; T typedef basic_istream istream_type; T istream_iterator(); T istream_iterator(istream_type& s); T istream_iterator(const istream_iterator& x); T ~istream_iterator(); T const T& operator*() const; T const T* operator->() const; T istream_iterator& operator++(); T istream_iterator operator++(int); }; T template bool operator==(const istream_iterator& x, const istream_iterator& y); T template bool operator!=(const istream_iterator& x, const istream_iterator& y); 24.5.2 Template class ostream_iterator [lib.ostream.iterator] template > X class ostream_iterator: public iterator { public: T typedef charT char_type; T typedef traits traits_type; T typedef basic_ostream ostream_type; T ostream_iterator(ostream_type& s); T ostream_iterator(ostream_type& s, const charT* delimiter); T ostream_iterator(const ostream_iterator& x); T ~ostream_iterator(); T ostream_iterator& operator=(const T& value); T ostream_iterator& operator*(); T ostream_iterator& operator++(); T ostream_iterator& operator++(int); }; 24.5.3 Template class [lib.istreambuf.iterator] istreambuf_iterator template > X class istreambuf_iterator : public iterator { public: T typedef charT char_type; T typedef traits traits_type; T typedef typename traits::int_type int_type; T typedef basic_streambuf streambuf_type; T typedef basic_istream istream_type; T class proxy; // exposition only T istreambuf_iterator() throw(); T istreambuf_iterator(istream_type& s) throw(); T istreambuf_iterator(streambuf_type* s) throw(); T istreambuf_iterator(const proxy& p) throw(); T charT operator*() const; T istreambuf_iterator& operator++(); T proxy operator++(int); X bool equal(istreambuf_iterator& b); }; T template bool operator==(const istreambuf_iterator& a, const istreambuf_iterator& b); T template bool operator!=(const istreambuf_iterator& a, const istreambuf_iterator& b); 24.5.3.1 Template class [lib.istreambuf.iterator::proxy] istreambuf_iterator::proxy template > T class istreambuf_iterator::proxy { T charT keep_; T basic_streambuf* sbuf_; T proxy(charT c, basic_streambuf* sbuf); : keep_(c), sbuf_(sbuf) {} public: T charT operator*() { return keep_; } }; 24.5.4 Template class [lib.ostreambuf.iterator] ostreambuf_iterator template > T class ostreambuf_iterator: public iterator { public: T typedef charT char_type; T typedef traits traits_type; T typedef basic_streambuf streambuf_type; T typedef basic_ostream ostream_type; public: T ostreambuf_iterator(ostream_type& s) throw(); T ostreambuf_iterator(streambuf_type* s) throw(); T ostreambuf_iterator& operator=(charT c); T ostreambuf_iterator& operator*(); T ostreambuf_iterator& operator++(); T ostreambuf_iterator& operator++(int); T bool failed() const throw(); }; Header synopsis // _lib.alg.nonmodifying_, non-modifying sequence operations: T template Function for_each(InputIterator first, InputIterator last, Function f); T template InputIterator find(InputIterator first, InputIterator last, const T& value); T template InputIterator find_if(InputIterator first, InputIterator last, Predicate pred); T template ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2); T template ForwardIterator1 find_end(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); T template ForwardIterator1 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2); T template ForwardIterator1 find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); T template ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last); T template ForwardIterator adjacent_find(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); T template typename iterator_traits::difference_type count(InputIterator first, InputIterator last, const T& value); T template typename iterator_traits::difference_type count_if(InputIterator first, InputIterator last, Predicate pred); T template pair mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); T template pair mismatch(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred); T template bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2); T template bool equal(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, BinaryPredicate pred); T template ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2); T template ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred); T template ForwardIterator search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value); T template ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last, Size count, const T& value, BinaryPredicate pred); // _lib.alg.modifying.operations_, modifying sequence operations: // _lib.alg.copy_, copy: T template OutputIterator copy(InputIterator first, InputIterator last, OutputIterator result); T template BidirectionalIterator2 copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, BidirectionalIterator2 result); // _lib.alg.swap_, swap: T template void swap(T& a, T& b); T template ForwardIterator2 swap_ranges(ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2); T template void iter_swap(ForwardIterator1 a, ForwardIterator2 b); T template OutputIterator transform(InputIterator first, InputIterator last, OutputIterator result, UnaryOperation op); T template OutputIterator transform(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, OutputIterator result, BinaryOperation binary_op); T template void replace(ForwardIterator first, ForwardIterator last, const T& old_value, const T& new_value); T template void replace_if(ForwardIterator first, ForwardIterator last, Predicate pred, const T& new_value); T template OutputIterator replace_copy(InputIterator first, InputIterator last, OutputIterator result, const T& old_value, const T& new_value); T template OutputIterator replace_copy_if(Iterator first, Iterator last, OutputIterator result, Predicate pred, const T& new_value); T template void fill(ForwardIterator first, ForwardIterator last, const T& value); T template void fill_n(OutputIterator first, Size n, const T& value); T template void generate(ForwardIterator first, ForwardIterator last, Generator gen); T template void generate_n(OutputIterator first, Size n, Generator gen); T template ForwardIterator remove(ForwardIterator first, ForwardIterator last, const T& value); T template ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, Predicate pred); T template OutputIterator remove_copy(InputIterator first, InputIterator last, OutputIterator result, const T& value); T template OutputIterator remove_copy_if(InputIterator first, InputIterator last, OutputIterator result, Predicate pred); T template ForwardIterator unique(ForwardIterator first, ForwardIterator last); T template ForwardIterator unique(ForwardIterator first, ForwardIterator last, BinaryPredicate pred); T template OutputIterator unique_copy(InputIterator first, InputIterator last, OutputIterator result); T template OutputIterator unique_copy(InputIterator first, InputIterator last, OutputIterator result, BinaryPredicate pred); T template void reverse(BidirectionalIterator first, BidirectionalIterator last); T template OutputIterator reverse_copy(BidirectionalIterator first, BidirectionalIterator last, OutputIterator result); T template void rotate(ForwardIterator first, ForwardIterator middle, ForwardIterator last); T template OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle, ForwardIterator last, OutputIterator result); T template void random_shuffle(RandomAccessIterator first, RandomAccessIterator last); T template void random_shuffle(RandomAccessIterator first, RandomAccessIterator last, RandomNumberGenerator& rand); // _lib.alg.partitions_, partitions: T template BidirectionalIterator partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred); T template BidirectionalIterator stable_partition(BidirectionalIterator first, BidirectionalIterator last, Predicate pred); // _lib.alg.sorting_, sorting and related operations: // _lib.alg.sort_, sorting: T template void sort(RandomAccessIterator first, RandomAccessIterator last); T template void sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); T template void stable_sort(RandomAccessIterator first, RandomAccessIterator last); T template void stable_sort(RandomAccessIterator first, RandomAccessIterator last, Compare comp); T template void partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last); T template void partial_sort(RandomAccessIterator first, RandomAccessIterator middle, RandomAccessIterator last, Compare comp); T template RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last); T template RandomAccessIterator partial_sort_copy(InputIterator first, InputIterator last, RandomAccessIterator result_first, RandomAccessIterator result_last, Compare comp); T template void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last); T template void nth_element(RandomAccessIterator first, RandomAccessIterator nth, RandomAccessIterator last, Compare comp); // _lib.alg.binary.search_, binary search: T template ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value); T template ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); T template ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value); T template ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); T template pair equal_range(ForwardIterator first, ForwardIterator last, const T& value); T template pair equal_range(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); T template bool binary_search(ForwardIterator first, ForwardIterator last, const T& value); T template bool binary_search(ForwardIterator first, ForwardIterator last, const T& value, Compare comp); // _lib.alg.merge_, merge: T template OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result); T template OutputIterator merge(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); T template void inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last); T template void inplace_merge(BidirectionalIterator first, BidirectionalIterator middle, BidirectionalIterator last, Compare comp); // _lib.alg.set.operations_, set operations: T template bool includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); T template bool includes(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp); T template OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result); T template OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); T template OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result); T template OutputIterator set_intersection (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); T template OutputIterator set_difference (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result); T template OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); T template OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result); T template OutputIterator set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, OutputIterator result, Compare comp); // _lib.alg.heap.operations_, heap operations: T template void push_heap(RandomAccessIterator first, RandomAccessIterator last); T template void push_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); T template void pop_heap(RandomAccessIterator first, RandomAccessIterator last); T template void pop_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); T template void make_heap(RandomAccessIterator first, RandomAccessIterator last); T template void make_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); T template void sort_heap(RandomAccessIterator first, RandomAccessIterator last); T template void sort_heap(RandomAccessIterator first, RandomAccessIterator last, Compare comp); // _lib.alg.min.max_, minimum and maximum: T template const T& min(const T& a, const T& b); T template const T& min(const T& a, const T& b, Compare comp); T template const T& max(const T& a, const T& b); T template const T& max(const T& a, const T& b, Compare comp); T template ForwardIterator min_element(ForwardIterator first, ForwardIterator last); T template ForwardIterator min_element(ForwardIterator first, ForwardIterator last, Compare comp); T template ForwardIterator max_element(ForwardIterator first, ForwardIterator last); T template ForwardIterator max_element(ForwardIterator first, ForwardIterator last, Compare comp); T template bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2); T template bool lexicographical_compare (InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, Compare comp); // _lib.alg.permutation.generators_, permutations T template bool next_permutation(BidirectionalIterator first, BidirectionalIterator last); T template bool next_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); T template bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last); T template bool prev_permutation(BidirectionalIterator first, BidirectionalIterator last, Compare comp); 25.4 C library algorithms [lib.alg.c.library] 1 Header (partial, Table 2): Table 2--Header synopsis Functions: bsearch qsort X extern "C" void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); X extern "C++" void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *)); X extern "C" void qsort(void* base, size_t nmemb, size_t size, int (*compar)(const void*, const void*)); X extern "C++" void qsort(void* base, size_t nmemb, size_t size, int (*compar)(const void*, const void*)); 26.2 Complex numbers [lib.complex.numbers] 26.2.1 Header synopsis [lib.complex.synopsis] T template class complex; T template<> class complex; T template<> class complex; T template<> class complex; // _lib.complex.ops_ operators: T template complex operator+(const complex&, const complex&); T template complex operator+(const complex&, const T&); T template complex operator+(const T&, const complex&); T template complex operator- (const complex&, const complex&); T template complex operator-(const complex&, const T&); T template complex operator-(const T&, const complex&); T template complex operator* (const complex&, const complex&); T template complex operator*(const complex&, const T&); T template complex operator*(const T&, const complex&); T template complex operator/ (const complex&, const complex&); T template complex operator/(const complex&, const T&); T template complex operator/(const T&, const complex&); T template complex operator+(const complex&); T template complex operator-(const complex&); T template bool operator== (const complex&, const complex&); T template bool operator==(const complex&, const T&); T template bool operator==(const T&, const complex&); T template bool operator!=(const complex&, const complex&); T template bool operator!=(const complex&, const T&); T template bool operator!=(const T&, const complex&); T template basic_istream& operator>>(basic_istream&, complex&); T template basic_ostream& operator<<(basic_ostream&, const complex&); // _lib.complex.value.ops_ values: T template T real(const complex&); T template T imag(const complex&); T template T abs(const complex&); T template T arg(const complex&); T template T norm(const complex&); T template complex conj(const complex&); T template complex polar(const T&, const T&); // _lib.complex.transcendentals_ transcendentals: T template complex cos (const complex&); T template complex cosh (const complex&); T template complex exp (const complex&); T template complex log (const complex&); T template complex log10(const complex&); T template complex pow(const complex&, int); T template complex pow(const complex&, const T&); T template complex pow(const complex&, const complex&); T template complex pow(const T&, const complex&); T template complex sin (const complex&); T template complex sinh (const complex&); T template complex sqrt (const complex&); T template complex tan (const complex&); T template complex tanh (const complex&); } 26.2.2 Template class complex [lib.complex] template T class complex { public: T typedef T value_type; T complex(const T& re = T(), const T& im = T()); T complex(const complex&); T template complex(const complex&); T T real() const; T T imag() const; T complex& operator= (const T&); T complex& operator+=(const T&); T complex& operator-=(const T&); T complex& operator*=(const T&); T complex& operator/=(const T&); T complex& operator=(const complex&); T template complex& operator= (const complex&); T template complex& operator+=(const complex&); T template complex& operator-=(const complex&); T template complex& operator*=(const complex&); T template complex& operator/=(const complex&); }; T template complex operator+ (const complex&, const complex&); T template complex operator+(const complex&, const T&); T template complex operator+(const T&, const complex&); T template complex operator- (const complex&, const complex&); T template complex operator-(const complex&, const T&); T template complex operator-(const T&, const complex&); T template complex operator* (const complex&, const complex&); T template complex operator*(const complex&, const T&); T template complex operator*(const T&, const complex&); T template complex operator/ (const complex&, const complex&); T template complex operator/(const complex&, const T&); T template complex operator/(const T&, const complex&); T template complex operator+(const complex&); T template complex operator-(const complex&); T template bool operator==(const complex&, const complex&); T template bool operator==(const complex&, const T&); T template bool operator==(const T&, const complex&); T template bool operator!=(const complex&, const complex&); T template bool operator!=(const complex&, const T&); T template bool operator!=(const T&, const complex&); T template basic_istream& operator>>(basic_istream&, complex&); T template basic_ostream& operator<<(basic_ostream&, const complex&); 26.2.3 complex specializations [lib.complex.special] T template<> class complex { public: T typedef float value_type; T complex(float re = 0.0f, float im = 0.0f); T explicit complex(const complex&); T explicit complex(const complex&); T float real() const; T float imag() const; T complex& operator= (float); T complex& operator+=(float); T complex& operator-=(float); T complex& operator*=(float); T complex& operator/=(float); T complex& operator=(const complex&); T template complex& operator= (const complex&); T template complex& operator+=(const complex&); T template complex& operator-=(const complex&); T template complex& operator*=(const complex&); T template complex& operator/=(const complex&); }; T template<> class complex { public: T typedef double value_type; T complex(double re = 0.0, double im = 0.0); T complex(const complex&); T explicit complex(const complex&); T double real() const; T double imag() const; T complex& operator= (double); T complex& operator+=(double); T complex& operator-=(double); T complex& operator*=(double); T complex& operator/=(double); T complex& operator=(const complex&); T template complex& operator= (const complex&); T template complex& operator+=(const complex&); T template complex& operator-=(const complex&); T template complex& operator*=(const complex&); T template complex& operator/=(const complex&); }; T template<> class complex { public: T typedef long double value_type; T complex(long double re = 0.0L, long double im = 0.0L); T complex(const complex&); T complex(const complex&); T long double real() const; T long double imag() const; T complex& operator=(const complex&); T complex& operator= (long double); T complex& operator+=(long double); T complex& operator-=(long double); T complex& operator*=(long double); T complex& operator/=(long double); T template complex& operator= (const complex&); T template complex& operator+=(const complex&); T template complex& operator-=(const complex&); T template complex& operator*=(const complex&); T template complex& operator/=(const complex&); }; 26.3 Numeric arrays [lib.numarray] 26.3.1 Header synopsis [lib.valarray.synopsis] T template class valarray; // An array of type T T class slice; T template class slice_array; T class gslice; T template class gslice_array; T template class mask_array; // a masked array T template class indirect_array; // an indirected array T template valarray operator* (const valarray&, const valarray&); T template valarray operator* (const valarray&, const T&); T template valarray operator* (const T&, const valarray&); T template valarray operator/ (const valarray&, const valarray&); T template valarray operator/ (const valarray&, const T&); T template valarray operator/ (const T&, const valarray&); T template valarray operator% (const valarray&, const valarray&); T template valarray operator% (const valarray&, const T&); T template valarray operator% (const T&, const valarray&); T template valarray operator+ (const valarray&, const valarray&); T template valarray operator+ (const valarray&, const T&); T template valarray operator+ (const T&, const valarray&); T template valarray operator- (const valarray&, const valarray&); T template valarray operator- (const valarray&, const T&); T template valarray operator- (const T&, const valarray&); T template valarray operator^ (const valarray&, const valarray&); T template valarray operator^ (const valarray&, const T&); T template valarray operator^ (const T&, const valarray&); T template valarray operator& (const valarray&, const valarray&); T template valarray operator& (const valarray&, const T&); T template valarray operator& (const T&, const valarray&); T template valarray operator| (const valarray&, const valarray&); T template valarray operator| (const valarray&, const T&); T template valarray operator| (const T&, const valarray&); T template valarray operator<< (const valarray&, const valarray&); T template valarray operator<<(const valarray&, const T&); T template valarray operator<<(const T&, const valarray&); T template valarray operator>> (const valarray&, const valarray&); T template valarray operator>>(const valarray&, const T&); T template valarray operator>>(const T&, const valarray&); T template valarray operator&& (const valarray&, const valarray&); T template valarray operator&&(const valarray&, const T&); T template valarray operator&&(const T&, const valarray&); T template valarray operator|| (const valarray&, const valarray&); T template valarray operator||(const valarray&, const T&); T template valarray operator||(const T&, const valarray&); T template valarray operator==(const valarray&, const valarray&); T template valarray operator==(const valarray&, const T&); T template valarray operator==(const T&, const valarray&); T template valarray operator!=(const valarray&, const valarray&); T template valarray operator!=(const valarray&, const T&); T template valarray operator!=(const T&, const valarray&); T template valarray operator< (const valarray&, const valarray&); T template valarray operator< (const valarray&, const T&); T template valarray operator< (const T&, const valarray&); T template valarray operator> (const valarray&, const valarray&); T template valarray operator> (const valarray&, const T&); T template valarray operator> (const T&, const valarray&); T template valarray operator<=(const valarray&, const valarray&); T template valarray operator<=(const valarray&, const T&); T template valarray operator<=(const T&, const valarray&); T template valarray operator>=(const valarray&, const valarray&); T template valarray operator>=(const valarray&, const T&); T template valarray operator>=(const T&, const valarray&); T template valarray abs (const valarray&); T template valarray acos (const valarray&); T template valarray asin (const valarray&); T template valarray atan (const valarray&); T template valarray atan2 (const valarray&, const valarray&); T template valarray atan2(const valarray&, const T&); T template valarray atan2(const T&, const valarray&); T template valarray cos (const valarray&); T template valarray cosh (const valarray&); T template valarray exp (const valarray&); T template valarray log (const valarray&); T template valarray log10(const valarray&); T template valarray pow(const valarray&, const valarray&); T template valarray pow(const valarray&, const T&); T template valarray pow(const T&, const valarray&); T template valarray sin (const valarray&); T template valarray sinh (const valarray&); T template valarray sqrt (const valarray&); T template valarray tan (const valarray&); T template valarray tanh (const valarray&); } 26.3.2 Template class valarray [lib.template.valarray] T template class valarray { public: T typedef T value_type; // _lib.valarray.cons_ construct/destroy: T valarray(); T explicit valarray(size_t); T valarray(const T&, size_t); T valarray(const T*, size_t); T valarray(const valarray&); T valarray(const slice_array&); T valarray(const gslice_array&); T valarray(const mask_array&); T valarray(const indirect_array&); T ~valarray(); // _lib.valarray.assign_ assignment: T valarray& operator=(const valarray&); T valarray& operator=(const T&); T valarray& operator=(const slice_array&); T valarray& operator=(const gslice_array&); T valarray& operator=(const mask_array&); T valarray& operator=(const indirect_array&); // _lib.valarray.access_ element access: T T operator[](size_t) const; T T& operator[](size_t); // _lib.valarray.sub_ subset operations: T valarray operator[](slice) const; T slice_array operator[](slice); T valarray operator[](const gslice&) const; T gslice_array operator[](const gslice&); T valarray operator[](const valarray&) const; T mask_array operator[](const valarray&); T valarray operator[](const valarray&) const; T indirect_array operator[](const valarray&); // _lib.valarray.unary_ unary operators: T valarray operator+() const; T valarray operator-() const; T valarray operator~() const; T valarray operator!() const; // _lib.valarray.cassign_ computed assignment: T valarray& operator*= (const T&); T valarray& operator/= (const T&); T valarray& operator%= (const T&); T valarray& operator+= (const T&); T valarray& operator-= (const T&); T valarray& operator^= (const T&); T valarray& operator&= (const T&); T valarray& operator|= (const T&); T valarray& operator<<=(const T&); T valarray& operator>>=(const T&); T valarray& operator*= (const valarray&); T valarray& operator/= (const valarray&); T valarray& operator%= (const valarray&); T valarray& operator+= (const valarray&); T valarray& operator-= (const valarray&); T valarray& operator^= (const valarray&); T valarray& operator|= (const valarray&); T valarray& operator&= (const valarray&); T valarray& operator<<=(const valarray&); T valarray& operator>>=(const valarray&); // _lib.valarray.members_ member functions: T size_t size() const; T T sum() const; T T min() const; T T max() const; T valarray shift (int) const; T valarray cshift(int) const; T valarray apply(T func(T)) const; T valarray apply(T func(const T&)) const; T void resize(size_t sz, T c = T()); }; } 26.3.4 Class slice [lib.class.slice] T class slice { public: T slice(); T slice(size_t, size_t, size_t); T size_t start() const; T size_t size() const; T size_t stride() const; }; } 26.3.5 Template class slice_array [lib.template.slice.array] T template class slice_array { public: T typedef T value_type; T void operator= (const valarray&) const; T void operator*= (const valarray&) const; T void operator/= (const valarray&) const; T void operator%= (const valarray&) const; T void operator+= (const valarray&) const; T void operator-= (const valarray&) const; T void operator^= (const valarray&) const; T void operator&= (const valarray&) const; T void operator|= (const valarray&) const; T void operator<<=(const valarray&) const; T void operator>>=(const valarray&) const; T void operator=(const T&); T ~slice_array(); private: T slice_array(); T slice_array(const slice_array&); T slice_array& operator=(const slice_array&); }; } 26.3.6 The gslice class [lib.class.gslice] T class gslice { public: T gslice(); T gslice(size_t s, const valarray& l, const valarray& d); T size_t start() const; T valarray size() const; T valarray stride() const; }; 26.3.7 Template class gslice_array [lib.template.gslice.array] T template class gslice_array { public: T typedef T value_type; T void operator= (const valarray&) const; T void operator*= (const valarray&) const; T void operator/= (const valarray&) const; T void operator%= (const valarray&) const; T void operator+= (const valarray&) const; T void operator-= (const valarray&) const; T void operator^= (const valarray&) const; T void operator&= (const valarray&) const; T void operator|= (const valarray&) const; T void operator<<=(const valarray&) const; T void operator>>=(const valarray&) const; T void operator=(const T&); T ~gslice_array(); private: T gslice_array(); T gslice_array(const gslice_array&); T gslice_array& operator=(const gslice_array&); }; 26.3.8 Template class mask_array [lib.template.mask.array] T template class mask_array { public: T typedef T value_type; T void operator= (const valarray&) const; T void operator*= (const valarray&) const; T void operator/= (const valarray&) const; T void operator%= (const valarray&) const; T void operator+= (const valarray&) const; T void operator-= (const valarray&) const; T void operator^= (const valarray&) const; T void operator&= (const valarray&) const; T void operator|= (const valarray&) const; T void operator<<=(const valarray&) const; T void operator>>=(const valarray&) const; T void operator=(const T&); T ~mask_array(); private: T mask_array(); T mask_array(const mask_array&); T mask_array& operator=(const mask_array&); // remainder implementation defined }; 26.3.9 Template class [lib.template.indirect.array] indirect_array T template class indirect_array { public: T typedef T value_type; T void operator= (const valarray&) const; T void operator*= (const valarray&) const; T void operator/= (const valarray&) const; T void operator%= (const valarray&) const; T void operator+= (const valarray&) const; T void operator-= (const valarray&) const; T void operator^= (const valarray&) const; T void operator&= (const valarray&) const; T void operator|= (const valarray&) const; T void operator<<=(const valarray&) const; T void operator>>=(const valarray&) const; T void operator=(const T&); T ~indirect_array(); private: T indirect_array(); T indirect_array(const indirect_array&); T indirect_array& operator=(const indirect_array&); // remainder implementation defined }; 26.4 Generalized numeric operations [lib.numeric.ops] Header synopsis T template T accumulate(InputIterator first, InputIterator last, T init); T template T accumulate(InputIterator first, InputIterator last, T init, BinaryOperation binary_op); T template T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init); T template T inner_product(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init, BinaryOperation1 binary_op1, BinaryOperation2 binary_op2); T template OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result); T template OutputIterator partial_sum(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op); T template OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result); T template OutputIterator adjacent_difference(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation binary_op); 26.5 C Library [lib.c.math] Table 2--Header synopsis X Macro: HUGE_VAL Functions: X acos cos fmod modf tan X asin cosh frexp pow tanh X atan exp ldexp sin X atan2 fabs log sinh X ceil floor log10 sqrt Table 3--Header synopsis X Macros: RAND_MAX X Types: div_t ldiv_t Functions: X abs labs srand X div ldiv rand X long abs(long); // labs() X ldiv_t div(long, long); // ldiv() X float abs (float); X float acos (float); X float asin (float); X float atan (float); X float atan2(float, float); X float ceil (float); X float cos (float); X float cosh (float); X float exp (float); X float fabs (float); X float floor(float); X float fmod (float, float); X float frexp(float, int*); X float ldexp(float, int); X float log (float); X float log10(float); X float modf (float, float*); X float pow (float, float); X float pow (float, int); X float sin (float); X float sinh (float); X float sqrt (float); X float tan (float); X float tanh (float); X double abs(double); // fabs() X double pow(double, int); X long double abs (long double); X long double acos (long double); X long double asin (long double); X long double atan (long double); X long double atan2(long double, long double); X long double ceil (long double); X long double cos (long double); X long double cosh (long double); X long double exp (long double); X long double fabs (long double); X long double floor(long double); X long double fmod (long double, long double); X long double frexp(long double, int*); X long double ldexp(long double, int); X long double log (long double); X long double log10(long double); X long double modf (long double, long double*); X long double pow (long double, long double); X long double pow (long double, int); X long double sin (long double); X long double sinh (long double); X long double sqrt (long double); X long double tan (long double); X long double tanh (long double); Header synopsis X template class char_traits; X template<> class char_traits; X template<> class char_traits; X template class allocator; X template > class basic_ios; X template > class basic_streambuf; X template > class basic_istream; X template > class basic_ostream; X template > class basic_iostream; X template , class Allocator = allocator > class basic_stringbuf; X template , class Allocator = allocator > class basic_istringstream; X template , class Allocator = allocator > class basic_ostringstream; X template , class Allocator = allocator > class basic_stringstream; X template > class basic_filebuf; X template > class basic_ifstream; X template > class basic_ofstream; X template > class basic_fstream; X template > class istreambuf_iterator; X template > class ostreambuf_iterator; X typedef basic_ios ios; X typedef basic_ios wios; X typedef basic_streambuf streambuf; X typedef basic_istream istream; X typedef basic_ostream ostream; X typedef basic_iostream iostream; X typedef basic_stringbuf stringbuf; X typedef basic_istringstream istringstream; X typedef basic_ostringstream ostringstream; X typedef basic_stringstream stringstream; X typedef basic_filebuf filebuf; X typedef basic_ifstream ifstream; X typedef basic_ofstream ofstream; X typedef basic_fstream fstream; X typedef basic_streambuf wstreambuf; X typedef basic_istream wistream; X typedef basic_ostream wostream; X typedef basic_iostream wiostream; X typedef basic_stringbuf wstringbuf; X typedef basic_istringstream wistringstream; X typedef basic_ostringstream wostringstream; X typedef basic_stringstream wstringstream; X typedef basic_filebuf wfilebuf; X typedef basic_ifstream wifstream; X typedef basic_ofstream wofstream; X typedef basic_fstream wfstream; X template class fpos; X typedef fpos::state_type> streampos; X typedef fpos::state_type> wstreampos; 27.3 Standard iostream objects [lib.iostream.objects] Header synopsis T [must also include and ] T extern istream cin; T extern ostream cout; T extern ostream cerr; T extern ostream clog; T extern wistream wcin; T extern wostream wcout; T extern wostream wcerr; T extern wostream wclog; 27.4 Iostreams base classes [lib.iostreams.base] Header synopsis #include T typedef OFF_T streamoff; T typedef SZ_T streamsize; T template class fpos; class ios_base; template > class basic_ios; // _lib.std.ios.manip_, manipulators: T ios_base& boolalpha (ios_base& str); T ios_base& noboolalpha(ios_base& str); T ios_base& showbase (ios_base& str); T ios_base& noshowbase (ios_base& str); T ios_base& showpoint (ios_base& str); T ios_base& noshowpoint(ios_base& str); T ios_base& showpos (ios_base& str); T ios_base& noshowpos (ios_base& str); T ios_base& skipws (ios_base& str); T ios_base& noskipws (ios_base& str); T ios_base& nouppercase(ios_base& str); T ios_base& uppercase (ios_base& str); M ios_base& unitbuf (ios_base& str); M ios_base& nounitbuf (ios_base& str); // _lib.adjustfield.manip_ adjustfield: T ios_base& internal (ios_base& str); T ios_base& left (ios_base& str); T ios_base& right (ios_base& str); // _lib.basefield.manip_ basefield: T ios_base& dec (ios_base& str); T ios_base& hex (ios_base& str); T ios_base& oct (ios_base& str); // _lib.floatfield.manip_ floatfield: T ios_base& fixed (ios_base& str); T ios_base& scientific (ios_base& str); 27.4.2 Class ios_base [lib.ios.base] T class ios_base { public: class failure; T typedef T1 fmtflags; T static const fmtflags boolalpha; T static const fmtflags dec; T static const fmtflags fixed; T static const fmtflags hex; T static const fmtflags internal; T static const fmtflags left; T static const fmtflags oct; T static const fmtflags right; T static const fmtflags scientific; T static const fmtflags showbase; T static const fmtflags showpoint; T static const fmtflags showpos; T static const fmtflags skipws; X static const fmtflags unitbuf; T static const fmtflags uppercase; T static const fmtflags adjustfield; T static const fmtflags basefield; T static const fmtflags floatfield; typedef T2 iostate; T static const iostate badbit; T static const iostate eofbit; T static const iostate failbit; T static const iostate goodbit; T typedef T3 openmode; T static const openmode app; T static const openmode ate; T static const openmode binary; T static const openmode in; T static const openmode out; T static const openmode trunc; T typedef T4 seekdir; T static const seekdir beg; T static const seekdir cur; T static const seekdir end; T class Init; // _lib.fmtflags.state_ fmtflags state: T fmtflags flags() const; T fmtflags flags(fmtflags fmtfl); T fmtflags setf(fmtflags fmtfl); T fmtflags setf(fmtflags fmtfl, fmtflags mask); T void unsetf(fmtflags mask); T streamsize precision() const; T streamsize precision(streamsize prec); T streamsize width() const; T streamsize width(streamsize wide); // _lib.ios.base.locales_ locales: T locale imbue(const locale& loc); T locale getloc() const; // _lib.ios.base.storage_ storage: T static int xalloc(); T long& iword(int index); T void*& pword(int index); // destructor T virtual ~ios_base(); // _lib.ios.base.callback_ callbacks; T enum event { erase_event, imbue_event, copyfmt_event }; T typedef void (*event_callback)(event, ios_base&, int index); T void register_callback(event_call_back fn, int index); T static bool sync_with_stdio(bool sync = true); protected: T ios_base(); }; 27.4.2.1.1 Class ios_base::failure [lib.ios::failure] T class ios_base::failure : public exception { public: T explicit failure(const string& msg); T virtual ~failure(); T virtual const char* what() const throw(); }; 27.4.2.1.6 Class ios_base::Init [lib.ios::Init] T class ios_base::Init { public: T Init(); T ~Init(); }; 27.4.3 Template class fpos [lib.fpos] X template class fpos { public: // _lib.fpos.members_ Members T stateT state() const; T void state(stateT); private; T stateT st; // exposition only }; 27.4.5 Template class basic_ios [lib.ios] template > X class basic_ios : public ios_base { public: // Types: T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; T operator void*() const T bool operator!() const T iostate rdstate() const; T void clear(iostate state = goodbit); T void setstate(iostate state); T bool good() const; T bool eof() const; T bool fail() const; T bool bad() const; T iostate exceptions() const; T void exceptions(iostate except); // _lib.basic.ios.cons_ Constructor/destructor: T explicit basic_ios(basic_streambuf* sb); T virtual ~basic_ios(); // _lib.basic.ios.members_ Members: T basic_ostream* tie() const; T basic_ostream* tie(basic_ostream* tiestr); T basic_streambuf* rdbuf() const; T basic_streambuf* rdbuf(basic_streambuf* sb); X basic_ios& copyfmt(const basic_ios& rhs); T char_type fill() const; T char_type fill(char_type ch); // _lib.ios.base.locales_ locales: T locale imbue(const locale& loc); X char narrow(char_type c, char dfault) const; X char_type widen(char c) const; protected: basic_ios(); T void init(basic_streambuf* sb); private: T basic_ios(const basic_ios& ); // not defined T basic_ios& operator=(const basic_ios&); // not defined }; 27.5 Stream buffers [lib.stream.buffers] Header synopsis X template > class basic_streambuf; T typedef basic_streambuf streambuf; T typedef basic_streambuf wstreambuf; 27.5.2 Template class [lib.streambuf] basic_streambuf template > X class basic_streambuf { public: // Types: T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; T virtual ~basic_streambuf(); // _lib.streambuf.locales_ locales: T locale pubimbue(const locale &loc); T locale getloc() const; // _lib.streambuf.buffer_ buffer and positioning: T basic_streambuf* pubsetbuf(char_type* s, streamsize n); T pos_type pubseekoff(off_type off, ios_base::seekdir way, ios_base::openmode which = ios_base::in | ios_base::out); T pos_type pubseekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out); T int pubsync(); // Get and put areas: // _lib.streambuf.pub.get_ Get area: T streamsize in_avail(); T int_type snextc(); T int_type sbumpc(); T int_type sgetc(); T streamsize sgetn(char_type* s, streamsize n); // _lib.streambuf.pub.pback_ Putback: X int_type sputbackc(char_type c); X int_type sungetc(); // _lib.streambuf.pub.put_ Put area: T int_type sputc(char_type c); X streamsize sputn(const char_type* s, streamsize n); protected: T basic_streambuf(); // _lib.streambuf.get.area_ Get area: T char_type* eback() const; T char_type* gptr() const; T char_type* egptr() const; T void gbump(int n); T void setg(char_type* gbeg, char_type* gnext, char_type* gend); // _lib.streambuf.put.area_ Put area: T char_type* pbase() const; T char_type* pptr() const; T char_type* epptr() const; T void pbump(int n); T void setp(char_type* pbeg, char_type* pend); // _lib.streambuf.virtuals_ virtual functions: // _lib.streambuf.virt.locales_ Locales: T virtual void imbue(const locale &loc); // _lib.streambuf.virt.buffer_ Buffer management and positioning: T virtual basic_streambuf* setbuf(char_type* s, streamsize n); T virtual pos_type seekoff(off_type off, ios_base::seekdir way, ios_base::openmode which = ios_base::in | ios_base::out); T virtual pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out); T virtual int sync(); // _lib.streambuf.virt.get_ Get area: T virtual int showmanyc(); T virtual streamsize xsgetn(char_type* s, streamsize n); T virtual int_type underflow(); T virtual int_type uflow(); // _lib.streambuf.virt.pback_ Putback: T virtual int_type pbackfail(int_type c = traits::eof()); // _lib.streambuf.virt.put_ Put area: X virtual streamsize xsputn(const char_type* s, streamsize n); T virtual int_type overflow (int_type c = traits::eof()); }; 27.6 Formatting and manipulators [lib.iostream.format] Header synopsis T template > class basic_istream; T typedef basic_istream istream; T typedef basic_istream wistream; T template > class basic_iostream; T typedef basic_iostream iostream; T typedef basic_iostream wiostream; X template basic_istream& ws(basic_istream& is); Header synopsis X template > class basic_ostream; T typedef basic_ostream ostream; T typedef basic_ostream wostream; T template basic_ostream& endl(basic_ostream& os); T template basic_ostream& ends(basic_ostream& os); T template basic_ostream& flush(basic_ostream& os); Header synopsis // Types T1, T2, ... are unspecified implementation types T T1 resetiosflags(ios_base::fmtflags mask); T T2 setiosflags (ios_base::fmtflags mask); T T3 setbase(int base); T template T4 setfill(charT c); T T5 setprecision(int n); T T6 setw(int n); 27.6.1.1 Template class basic_istream [lib.istream] template > T class basic_istream : virtual public basic_ios { public: // Types (inherited from basic_ios (_lib.ios_)): T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; // _lib.istream.cons_ Constructor/destructor: T explicit basic_istream(basic_streambuf* sb); T virtual ~basic_istream(); // _lib.istream::sentry_ Prefix/suffix: T class sentry; // _lib.istream.formatted_ Formatted input: T basic_istream& operator>> (basic_istream& (*pf)(basic_istream&)) T basic_istream& operator>> (basic_ios& (*pf)(basic_ios&)) T basic_istream& operator>> (ios_base& (*pf)(ios_base&)) S basic_istream& operator>>(bool& n); S basic_istream& operator>>(short& n); S basic_istream& operator>>(unsigned short& n); S basic_istream& operator>>(int& n); S basic_istream& operator>>(unsigned int& n); S basic_istream& operator>>(long& n); S basic_istream& operator>>(unsigned long& n); S basic_istream& operator>>(float& f); S basic_istream& operator>>(double& f); S basic_istream& operator>>(long double& f); S basic_istream& operator>>(void*& p); S basic_istream& operator>> (basic_streambuf* sb); // _lib.istream.unformatted_ Unformatted input: T streamsize gcount() const; S int_type get(); S basic_istream& get(char_type& c); S basic_istream& get(char_type* s, streamsize n); S basic_istream& get(char_type* s, streamsize n, char_type delim); S basic_istream& get(basic_streambuf& sb); S basic_istream& get(basic_streambuf& sb, char_type delim); S basic_istream& getline(char_type* s, streamsize n); S basic_istream& getline(char_type* s, streamsize n, char_type delim); S basic_istream& ignore (streamsize n = 1, int_type delim = traits::eof()); S int_type peek(); S basic_istream& read (char_type* s, streamsize n); S streamsize readsome(char_type* s, streamsize n); S basic_istream& putback(char_type c); S basic_istream& unget(); S int sync(); S pos_type tellg(); S basic_istream& seekg(pos_type); S basic_istream& seekg(off_type, ios_base::seekdir); }; // _lib.istream::extractors_ character extraction templates: S template basic_istream& operator>>(basic_istream&, charT&); S template basic_istream& operator>>(basic_istream&, unsigned char&); S template basic_istream& operator>>(basic_istream&, signed char&); S template basic_istream& operator>>(basic_istream&, charT*); S template basic_istream& operator>>(basic_istream&, unsigned char*); S template basic_istream& operator>>(basic_istream&, signed char*); 27.6.1.1.2 Class basic_istream::sentry [lib.istream::sentry] template > S class basic_istream::sentry { typedef traits traits_type; S bool ok_; // exposition only public: S explicit sentry(basic_istream& is, bool noskipws = false); S ~sentry(); S operator bool() const { return ok_; } private: T sentry(const sentry&); // not defined T sentry& operator=(const sentry&); // not defined }; 27.6.1.5 Template class basic_iostream [lib.iostreamclass] template > T class basic_iostream : public basic_istream, public basic_ostream { public: // constructor/destructor T explicit basic_iostream(basic_streambuf* sb); T virtual ~basic_iostream(); }; 27.6.2.1 Template class basic_ostream [lib.ostream] template > X class basic_ostream : virtual public basic_ios { public: // Types (inherited from basic_ios (_lib.ios_)): T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; // _lib.ostream.cons_ Constructor/destructor: T explicit basic_ostream(basic_streambuf* sb); T virtual ~basic_ostream(); // _lib.ostream::sentry_ Prefix/suffix: T class sentry; // _lib.ostream.formatted_ Formatted output: T basic_ostream& operator<< (basic_ostream& (*pf)(basic_ostream&)); T basic_ostream& operator<< (basic_ios& (*pf)(basic_ios&)); T basic_ostream& operator<< (ios_base& (*pf)(ios_base&)); T basic_ostream& operator<<(bool n); T basic_ostream& operator<<(short n); T basic_ostream& operator<<(unsigned short n); T basic_ostream& operator<<(int n); T basic_ostream& operator<<(unsigned int n); T basic_ostream& operator<<(long n); T basic_ostream& operator<<(unsigned long n); S basic_ostream& operator<<(float f); S basic_ostream& operator<<(double f); S basic_ostream& operator<<(long double f); T basic_ostream& operator<<(const void* p); X basic_ostream& operator<< (basic_streambuf* sb); // _lib.ostream.unformatted_ Unformatted output: T basic_ostream& put(char_type c); T basic_ostream& write(const char_type* s, streamsize n); X basic_ostream& flush(); // _lib.ostream.seeks_ seeks: S pos_type tellp(); S basic_ostream& seekp(pos_type); S basic_ostream& seekp(off_type, ios_base::seekdir); }; // _lib.ostream.inserters.character_ character inserters X template basic_ostream& operator<<(basic_ostream&, charT); X template basic_ostream& operator<<(basic_ostream&, char); // specialization X template basic_ostream& operator<<(basic_ostream&, char); // signed and unsigned X template basic_ostream& operator<<(basic_ostream&, signed char); X template basic_ostream& operator<<(basic_ostream&, unsigned char) X template basic_ostream& operator<<(basic_ostream&, const charT*); X template basic_ostream& operator<<(basic_ostream&, const char*); // partial specializationss X template basic_ostream& operator<<(basic_ostream&, const char*); // signed and unsigned X template basic_ostream& operator<<(basic_ostream&, const signed char*); X template basic_ostream& operator<<(basic_ostream&, const unsigned char*); 27.6.2.3 Class basic_ostream::sentry [lib.ostream::sentry] template > X class basic_ostream::sentry { bool ok_; // exposition only public: X explicit sentry(basic_ostream& os); X ~sentry(); X operator bool() const { return ok_; } private X sentry(const sentry&); // not defined X sentry& operator=(const sentry&); // not defined }; 27.7 String-based streams [lib.string.streams] Header synopsis X template , class Allocator = allocator > class basic_stringbuf; T typedef basic_stringbuf stringbuf; T typedef basic_stringbuf wstringbuf; template , class Allocator = allocator > X class basic_istringstream; T typedef basic_istringstream istringstream; T typedef basic_istringstream wistringstream; template , class Allocator = allocator > X class basic_ostringstream; T typedef basic_ostringstream ostringstream; T typedef basic_ostringstream wostringstream; template , class Allocator = allocator > X class basic_stringstream; T typedef basic_stringstream stringstream; T typedef basic_stringstream wstringstream; 27.7.1 Template class basic_stringbuf [lib.stringbuf] template , class Allocator = allocator > X class basic_stringbuf : public basic_streambuf { public: T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; // _lib.stringbuf.cons_ Constructors: S explicit basic_stringbuf(ios_base::openmode which = ios_base::in | ios_base::out); S explicit basic_stringbuf (const basic_string& str, ios_base::openmode which = ios_base::in | ios_base::out); // _lib.stringbuf.members_ Get and set: S basic_string str() const; S void str(const basic_string& s); protected: // _lib.stringbuf.virtuals_ Overridden virtual functions: S virtual int_type underflow(); S virtual int_type pbackfail(int_type c = traits::eof()); S virtual int_type overflow (int_type c = traits::eof()); S virtual basic_streambuf* setbuf(charT*, streamsize); S virtual pos_type seekoff(off_type off, ios_base::seekdir way, ios_base::openmode which = ios_base::in | ios_base::out); S virtual pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out); }; 27.7.2 Template class basic_istringstream [lib.istringstream] template , class Allocator = allocator > X class basic_istringstream : public basic_istream { public: T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; // _lib.istringstream.cons_ Constructors: S explicit basic_istringstream(ios_base::openmode which = ios_base::in); S explicit basic_istringstream( const basic_string& str, ios_base::openmode which = ios_base::in); // _lib.istringstream.members_ Members: S basic_stringbuf* rdbuf() const; S basic_string str() const; S void str(const basic_string& s); private: // basic_stringbuf sb; exposition only }; 27.7.3 Class basic_ostringstream [lib.ostringstream] template , class Allocator = allocator > X class basic_ostringstream : public basic_ostream { public: // Types: T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; // _lib.ostringstream.cons_ Constructors/destructor: S explicit basic_ostringstream(ios_base::openmode which = ios_base::out); S explicit basic_ostringstream( const basic_string& str, ios_base::openmode which = ios_base::out); // _lib.ostringstream.members_ Members: S basic_stringbuf* rdbuf() const; S basic_string str() const; S void str(const basic_string& s); }; 27.7.4 Template class basic_stringstream [lib.stringstream] template , class Allocator = allocator > X class basic_stringstream : public basic_iostream { public: // Types T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; // constructors/destructors S explicit basic_stringstream( ios_base::openmode which = ios_base::out|ios_base::in); S explicit basic_stringstream( const basic_string& str, ios_base::openmode which = ios_base::out|ios_base::in); // Members: S basic_stringbuf* rdbuf() const; S basic_string str() const; S void str(const basic_string& str); }; 27.8.1 File streams [lib.fstreams] Header synopsis X template > class basic_filebuf; T typedef basic_filebuf filebuf; T typedef basic_filebuf wfilebuf; X template > class basic_ifstream; T typedef basic_ifstream ifstream; T typedef basic_ifstream wifstream; X template > class basic_ofstream; T typedef basic_ofstream ofstream; T typedef basic_ofstream wofstream; X template > class basic_fstream; T typedef basic_fstream fstream; T typedef basic_fstream wfstream; 27.8.1.1 Template class basic_filebuf [lib.filebuf] template > X class basic_filebuf : public basic_streambuf { public: T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; // _lib.filebuf.cons_ Constructors/destructor: X basic_filebuf(); X virtual ~basic_filebuf(); // _lib.filebuf.members_ Members: T bool is_open() const; X basic_filebuf* open (const char* s, ios_base::openmode mode); X basic_filebuf* close(); protected: // _lib.filebuf.virtuals_ Overridden virtual functions: X virtual streamsize showmanyc(); X virtual int_type underflow(); X virtual int_type uflow(); X virtual int_type pbackfail(int_type c = traits::eof()); X virtual int_type overflow (int_type c = traits::eof()); S virtual basic_streambuf* setbuf(char_type* s, streamsize n); S virtual pos_type seekoff(off_type off, ios_base::seekdir way, ios_base::openmode which = ios_base::in | ios_base::out); S virtual pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out); S virtual int sync(); S virtual void imbue(const locale& loc); }; 27.8.1.5 Template class basic_ifstream [lib.ifstream] template > X class basic_ifstream : public basic_istream { public: T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; // _lib.ifstream.cons_ Constructors: S basic_ifstream(); S explicit basic_ifstream(const char* s, ios_base::openmode mode = ios_base::in); // _lib.ifstream.members_ Members: S basic_filebuf* rdbuf() const; S bool is_open(); S void open(const char* s, ios_base::openmode mode = ios_base::in); S void close(); }; 27.8.1.8 Template class basic_ofstream [lib.ofstream] template > X class basic_ofstream : public basic_ostream { public: T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; // _lib.ofstream.cons_ Constructors: X basic_ofstream(); X explicit basic_ofstream(const char* s, ios_base::openmode mode = ios_base::out); // _lib.ofstream.members_ Members: X basic_filebuf* rdbuf() const; T bool is_open(); X void open(const char* s, ios_base::openmode mode = ios_base::out); X void close(); }; 27.8.1.11 Template class basic_fstream [lib.fstream] template > X class basic_fstream : public basic_iostream { public: T typedef charT char_type; T typedef typename traits::int_type int_type; T typedef typename traits::pos_type pos_type; T typedef typename traits::off_type off_type; T typedef traits traits_type; // constructors/destructor S basic_fstream(); S explicit basic_fstream( const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); // Members: S basic_filebuf* rdbuf() const; S bool is_open(); S void open( const char* s, ios_base::openmode mode = ios_base::in|ios_base::out); S void close(); }; 27.8.2 C Library files [lib.c.files] Table 13--Header synopsis Macros: X BUFSIZ L_tmpnam SEEK_SET TMP_MAX X EOF NULL stderr _IOFBF X FILENAME_MAX SEEK_CUR stdin _IOLBF X FOPEN_MAX SEEK_END stdout _IONBF X Types: FILE fpos_t size_t Functions: X clearerr fgets fscanf gets rewind X fclose fopen fseek perror scanf tmpnam X feof fprintf fsetpos printf setbuf ungetc X ferror fputc ftell putc setvbuf vprintf X fflush fputs fwrite puts sprintf vfprintf X fgetc fread getc remove sscanf vsprintf X fgetpos freopen getchar putchar rename tmpfile 1.5 Standard C library headers [depr.c.headers] X 1.6 Old iostreams members [depr.ios.members] [Note: these should be #ifdef'd to permit diagnostics if used.] namespace std { class ios_base { public: T typedef T1 io_state; T typedef T2 open_mode; T typedef T3 seek_dir; T typedef OFF_T streamoff; T typedef OFF_T streampos; // remainder unchanged }; } [Note: these should be #ifdef'd to permit diagnostics if used.] namespace std { template > class basic_streambuf { public: T void stossc(); // remainder unchanged }; } 8 An implementation may provide the following member functions that overload signatures specified in clause _lib.iostreams_: [Note: the following overloads should be #ifdef'd to permit diagnostics to be emitted, by default, if used.] template class basic_ios { public: M void clear(io_state state); M void setstate(io_state state); // remainder unchanged }; class ios_base { public: M void exceptions(io_state); // remainder unchanged }; template > class basic_streambuf { public: M pos_type pubseekoff(off_type off, ios_base::seek_dir way, ios_base::open_mode which = ios_base::in | ios_base::out); M pos_type pubseekpos(pos_type sp, ios_base::open_mode which = ios_base::in | ios_base::out); // remainder unchanged }; template > class basic_filebuf : public basic_streambuf { public: M basic_filebuf* open (const char* s, ios_base::open_mode mode); // remainder unchanged }; template > class basic_ifstream : public basic_istream { public: M void open(const char* s, ios_base::open_mode mode = in); // remainder unchanged }; template > class basic_ofstream : public basic_ostream { public: M void open(const char* s, ios_base::open_mode mode = out | trunc); // remainder unchanged }; } 1.7.1 Class strstreambuf [depr.strstreambuf] [Note: It should be possible to adopt these components with only minor changes from the 2.8 version of the library.] M class strstreambuf : public basic_streambuf { public: M explicit strstreambuf(streamsize alsize_arg = 0); M strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*)); M strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0); M strstreambuf(const char* gnext_arg, streamsize n); M strstreambuf(signed char* gnext_arg, streamsize n, signed char* pbeg_arg = 0); M strstreambuf(const signed char* gnext_arg, streamsize n); M strstreambuf(unsigned char* gnext_arg, streamsize n, unsigned char* pbeg_arg = 0); M strstreambuf(const unsigned char* gnext_arg, streamsize n); M virtual ~strstreambuf(); M void freeze(bool freezefl = true); M char* str(); M int pcount(); protected: M virtual int_type overflow (int_type c = EOF); M virtual int_type pbackfail(int_type c = EOF); M virtual int_type underflow(); M virtual pos_type seekoff(off_type off, ios_base::seekdir way, ios_base::openmode which = ios_base::in | ios_base::out); M virtual pos_type seekpos(pos_type sp, ios_base::openmode which = ios_base::in | ios_base::out); M virtual streambuf* setbuf(char* s, streamsize n); } 1.7.4 Class strstream [depr.strstream] M class strstream : public basic_iostream { public: // Types M typedef char char_type; M typedef typename char_traits::int_type int_type M typedef typename char_traits::pos_type pos_type; M typedef typename char_traits::off_type off_type; // consturctors/destructor M strstream(); M strstream(char* s, int n, ios_base::openmode mode = ios_base::in|ios_base::out); M virtual ~strstream(); // Members: M strstreambuf* rdbuf() const; M void freeze(bool freezefl = true); M int pcount() const; M char* str(); };