diff options
Diffstat (limited to 'libstdc++-v3/docs/html/17_intro/CHECKLIST')
| -rw-r--r-- | libstdc++-v3/docs/html/17_intro/CHECKLIST | 6014 |
1 files changed, 6014 insertions, 0 deletions
diff --git a/libstdc++-v3/docs/html/17_intro/CHECKLIST b/libstdc++-v3/docs/html/17_intro/CHECKLIST new file mode 100644 index 00000000000..bef9635e850 --- /dev/null +++ b/libstdc++-v3/docs/html/17_intro/CHECKLIST @@ -0,0 +1,6014 @@ + + 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. + + ---------------------------------------------------------------------- + <algorithm> <iomanip> <list> <ostream> <streambuf> + <bitset> <ios> <locale> <queue> <string> + <complex> <iosfwd> <map> <set> <typeinfo> +X <deque> <iostream> <memory> <sstream> <utility> + <exception> <istream> <new> <stack> <valarray> + <fstream> <iterator> <numeric> <stdexcept> <vector> + <functional> <limits> + + [C header names must be in std:: to qualify. Related to shadow/ dir.] + <cassert> <ciso646> <csetjmp> <cstdio> <ctime> + <cctype> <climits> <csignal> <cstdlib> <cwchar> +X <cerrno> <clocale> <cstdarg> <cstring> <cwctype> + <cfloat> <cmath> <cstddef> + + Macro: +X errno, declared or defined in <cerrno>. + + Macro fn: +X setjmp(jmp_buf), declared or defined in <csetjmp> +X va_end(va_list), declared or defined in <cstdarg> + + 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 <cstddef> +X NULL +X offsetof +X ptrdiff_t +X size_t + + 18.2 Implementation properties [lib.support.limits] + + <limits>, <climits>, and <cfloat> + + 18.2.1 Numeric limits [lib.limits] + + [Note: the numeric_limits templates are now automatically + generated. ] + +X template<class T> class numeric_limits; + +T enum float_round_style; +T enum float_denorm_style; + +T template<> class numeric_limits<bool>; + +T template<> class numeric_limits<char>; +T template<> class numeric_limits<signed char>; +T template<> class numeric_limits<unsigned char>; +T template<> class numeric_limits<wchar_t>; + +T template<> class numeric_limits<short>; +T template<> class numeric_limits<int>; +T template<> class numeric_limits<long>; +T template<> class numeric_limits<unsigned short>; +T template<> class numeric_limits<unsigned int>; +T template<> class numeric_limits<unsigned long>; + +X template<> class numeric_limits<float>; +X template<> class numeric_limits<double>; +X template<> class numeric_limits<long double>; + + 18.2.1.1 Template class numeric_limits [lib.numeric.limits] +T template<class T> 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 <climits> (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 <cfloat> (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 <cstdlib> (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 <new> 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 <typeinfo> 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 <exception> 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 <cstdarg> (variable arguments), <csetjmp> (nonlocal jumps), + <ctime> (system clock clock(), time()), <csignal> (signal handling), + and <cstdlib> (runtime environment getenv(), system()). + + Table 6--Header <cstdarg> synopsis + Macros: va_arg va_end va_start +X Type: va_list + + Table 7--Header <csetjmp> synopsis + + Macro: setjmp | +X Type: jmp_buf + Function: longjmp + + Table 8--Header <ctime> synopsis + + Macros: CLOCKS_PER_SEC +X Types: clock_t + Functions: clock + + Table 9--Header <csignal> 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 <cstdlib> synopsis + +X Functions: getenv system + + 19.1 Exception classes [lib.std.exceptions] + + Header <stdexcept> 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 <cassert> synopsis + +X Macro: assert + + 19.3 Error numbers [lib.errno] + + Table 3--Header <cerrno> synopsis + +X |Macros: EDOM ERANGE errno | + + + 20.2 Utility components [lib.utility] + + Header <utility> synopsis + + // _lib.operators_, operators: +X namespace rel_ops { +T template<class T> bool operator!=(const T&, const T&); +T template<class T> bool operator> (const T&, const T&); +T template<class T> bool operator<=(const T&, const T&); +T template<class T> bool operator>=(const T&, const T&); + } + // _lib.pairs_, pairs: +T template <class T1, class T2> struct pair; +T template <class T1, class T2> + bool operator==(const pair<T1,T2>&, const pair<T1,T2>&); +T template <class T1, class T2> + bool operator< (const pair<T1,T2>&, const pair<T1,T2>&); +T template <class T1, class T2> + bool operator!=(const pair<T1,T2>&, const pair<T1,T2>&); +T template <class T1, class T2> + bool operator> (const pair<T1,T2>&, const pair<T1,T2>&); +T template <class T1, class T2> + bool operator>=(const pair<T1,T2>&, const pair<T1,T2>&); +T template <class T1, class T2> + bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&); +T template <class T1, class T2> pair<T1,T2> make_pair(const T1&, const T2&); + + + 20.2.2 Pairs [lib.pairs] + +T template <class T1, class T2> + 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<class U, class V> pair(const pair<U, V> &p); + }; + + 20.3 Function objects [lib.function.objects] + + Header <functional> synopsis + + // _lib.base_, base: +V template <class Arg, class Result> struct unary_function; +V template <class Arg1, class Arg2, class Result> struct binary_function; + + // _lib.arithmetic.operations_, arithmetic operations: +V template <class T> struct plus; +V template <class T> struct minus; +V template <class T> struct multiplies; +V template <class T> struct divides; +V template <class T> struct modulus; +V template <class T> struct negate; + // _lib.comparisons_, comparisons: +V template <class T> struct equal_to; +V template <class T> struct not_equal_to; +V template <class T> struct greater; +V template <class T> struct less; +V template <class T> struct greater_equal; +V template <class T> struct less_equal; + // _lib.logical.operations_, logical operations: +V template <class T> struct logical_and; +V template <class T> struct logical_or; +V template <class T> struct logical_not; + // _lib.negators_, negators: + template <class Predicate> struct unary_negate; +V template <class Predicate> + unary_negate<Predicate> not1(const Predicate&); +V template <class Predicate> struct binary_negate; +V template <class Predicate> + binary_negate<Predicate> not2(const Predicate&); + // _lib.binders_, binders: +V template <class Operation> class binder1st; +V template <class Operation, class T> + binder1st<Operation> bind1st(const Operation&, const T&); +V template <class Operation> class binder2nd; +V template <class Operation, class T> + binder2nd<Operation> bind2nd(const Operation&, const T&); + // _lib.function.pointer.adaptors_, adaptors: +V template <class Arg, class Result> class pointer_to_unary_function; +V template <class Arg, class Result> + pointer_to_unary_function<Arg,Result> ptr_fun(Result (*)(Arg)); +V template <class Arg1, class Arg2, class Result> + class pointer_to_binary_function; +V template <class Arg1, class Arg2, class Result> + pointer_to_binary_function<Arg1,Arg2,Result> + ptr_fun(Result (*)(Arg1,Arg2)); + + // _lib.member.pointer.adaptors_, adaptors: +V template<class S, class T> class mem_fun_t; +V template<class S, class T, class A> class mem_fun1_t; +V template<class S, class T> + mem_fun_t<S,T> mem_fun(S (T::*f)()); +V template<class S, class T, class A> + mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)); +V template<class S, class T> class mem_fun_ref_t; +V template<class S, class T, class A> class mem_fun1_ref_t; +V template<class S, class T> + mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); +V template<class S, class T, class A> + mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)); + +V template <class S, class T> class const_mem_fun_t; +V template <class S, class T, class A> class const_mem_fun1_t; +V template <class S, class T> + const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); +V template <class S, class T, class A> + const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const); +V template <class S, class T> class const_mem_fun_ref_t; +V template <class S, class T, class A> class const_mem_fun1_ref_t; +V template <class S, class T> + const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); +V template <class S, class T, class A> + const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const); + } + + 20.3.1 Base [lib.base] + +V template <class Arg, class Result> + struct unary_function { +V typedef Arg argument_type; +V typedef Result result_type; + }; +V template <class Arg1, class Arg2, class Result> + 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 <class T> struct plus : binary_function<T,T,T> { +V T operator()(const T& x, const T& y) const; + }; + +T template <class T> struct minus : binary_function<T,T,T> { +V T operator()(const T& x, const T& y) const; + }; + +T template <class T> struct multiplies : binary_function<T,T,T> { +V T operator()(const T& x, const T& y) const; + }; + +T template <class T> struct divides : binary_function<T,T,T> { +V T operator()(const T& x, const T& y) const; + }; + +T template <class T> struct modulus : binary_function<T,T,T> { +V T operator()(const T& x, const T& y) const; + }; + +T template <class T> struct negate : unary_function<T,T> { +V T operator()(const T& x) const; + }; + + 20.3.3 Comparisons [lib.comparisons] + +T template <class T> struct equal_to : binary_function<T,T,bool> { +V bool operator()(const T& x, const T& y) const; + }; + +T template <class T> struct not_equal_to : binary_function<T,T,bool> { +V bool operator()(const T& x, const T& y) const; + }; + +T template <class T> struct greater : binary_function<T,T,bool> { +V bool operator()(const T& x, const T& y) const; + }; + +T template <class T> struct less : binary_function<T,T,bool> { +V bool operator()(const T& x, const T& y) const; + }; + +T template <class T> struct greater_equal : binary_function<T,T,bool> { +V bool operator()(const T& x, const T& y) const; + }; + +T template <class T> struct less_equal : binary_function<T,T,bool> { +V bool operator()(const T& x, const T& y) const; + }; + + 20.3.4 Logical operations [lib.logical.operations] + +T template <class T> struct logical_and : binary_function<T,T,bool> { +V bool operator()(const T& x, const T& y) const; + }; + +T template <class T> struct logical_or : binary_function<T,T,bool> { +V bool operator()(const T& x, const T& y) const; + }; + +T template <class T> struct logical_not : unary_function<T,bool> { +V bool operator()(const T& x) const; + }; + + 20.3.5 Negators [lib.negators] + +T template <class Predicate> + class unary_negate + : public unary_function<typename Predicate::argument_type,bool> { + public: +T explicit unary_negate(const Predicate& pred); +V bool operator()(const typename Predicate::argument_type& x) const; + }; + +T template <class Predicate> + class binary_negate + : public binary_function<typename Predicate::first_argument_type, + typename Predicate::second_argument_type, bool> { + 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 Operation> + class binder1st + : public unary_function<typename Operation::second_argument_type, + typename Operation::result_type> { + 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 <class Operation, class T> + binder1st<Operation> bind1st(const Operation& op, const T& x); + + 20.3.6.3 Template class binder2nd [lib.binder.2nd] +T template <class Operation> + class binder2nd + : public unary_function<typename Operation::first_argument_type, + typename Operation::result_type> { + 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 <class Operation, class T> + binder2nd<Operation> 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 Arg, class Result> + class pointer_to_unary_function : public unary_function<Arg, Result> { + public: +T explicit pointer_to_unary_function(Result (*f)(Arg)); +V Result operator()(Arg x) const; + }; + +T template <class Arg, class Result> + pointer_to_unary_function<Arg, Result> ptr_fun(Result (*f)(Arg)); + +T template <class Arg1, class Arg2, class Result> + class pointer_to_binary_function : + public binary_function<Arg1,Arg2,Result> { + 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 S, class T> class mem_fun_t + : public unary_function<T*, S> { + public: +T explicit mem_fun_t(S (T::*p)()); +V S operator()(T* p) const; + }; + +T template <class S, class T, class A> class mem_fun1_t + : public binary_function<T*, A, S> { + public: +T explicit mem_fun1_t(S (T::*p)(A)); +V S operator()(T* p, A x) const; + }; + +V template<class S, class T> mem_fun_t<S,T> + mem_fun(S (T::*f)()); +V template<class S, class T, class A> mem_fun1_t<S,T,A> + mem_fun(S (T::*f)(A)); + +T template <class S, class T> class mem_fun_ref_t + : public unary_function<T, S> { + public: +T explicit mem_fun_ref_t(S (T::*p)()); +V S operator()(T& p) const; + }; + +T template <class S, class T, class A> class mem_fun1_ref_t + : public binary_function<T, A, S> { + public: +T explicit mem_fun1_ref_t(S (T::*p)(A)); +V S operator()(T& p, A x) const; + }; + +T template<class S, class T> mem_fun_ref_t<S,T> + mem_fun_ref(S (T::*f)()); + +T template<class S, class T, class A> mem_fun1_ref_t<S,T,A> + mem_fun_ref(S (T::*f)(A)); + +T template <class S, class T> class const_mem_fun_t + : public unary_function<T*, S> { + public: +T explicit const_mem_fun_t(S (T::*p)() const); +V S operator()(const T* p) const; + }; + +T template <class S, class T, class A> class const_mem_fun1_t + : public binary_function<T*, A, S> { + public: +T explicit const mem_fun1_t(S (T::*p)(A) const); +V S operator()(const T* p, A x) const; + }; + +V template<class S, class T> const_mem_fun_t<S,T> + mem_fun(S (T::*f)() const); +V template<class S, class T, class A> const_mem_fun1_t<S,T,A> + mem_fun(S (T::*f)(A) const); + +T template <class S, class T> class const_mem_fun_ref_t + : public unary_function<T, S> { + public: +T explicit const_mem_fun_ref_t(S (T::*p)() const); +V S operator()(const T& p) const; + }; + +T template <class S, class T, class A> class const_mem_fun1_ref_t + : public binary_function<T, A, S> { + public: +T explicit const_mem_fun1_ref_t(S (T::*p)(A) const); +V S operator()(const T& p, A x) const; + }; + +T template<class S, class T> const_mem_fun_ref_t<S,T> + mem_fun_ref(S (T::*f)() const); + +T template<class S, class T, class A> const_mem_fun1_ref_t<S,T,A> + mem_fun_ref(S (T::*f)(A) const); + + 20.4 Memory [lib.memory] + + Header <memory> synopsis + + // _lib.default.allocator_, the default allocator: +T template <class T> class allocator; +T template <> class allocator<void>; +T template <class T, class U> + bool operator==(const allocator<T>&, const allocator<U>&) throw(); +T template <class T, class U> + bool operator!=(const allocator<T>&, const allocator<U>&) throw(); + // _lib.storage.iterator_, raw storage iterator: +T template <class OutputIterator, class T> class raw_storage_iterator; + // _lib.temporary.buffer_, temporary buffers: +T template <class T> + pair<T*,ptrdiff_t> get_temporary_buffer(ptrdiff_t n); +T template <class T> + void return_temporary_buffer(T* p); + // _lib.specialized.algorithms_, specialized algorithms: +T template <class InputIterator, class ForwardIterator> + ForwardIterator + uninitialized_copy(InputIterator first, InputIterator last, + ForwardIterator result); +T template <class ForwardIterator, class T> + void uninitialized_fill(ForwardIterator first, ForwardIterator last, + const T& x); +T template <class ForwardIterator, class Size, class T> + void uninitialized_fill_n(ForwardIterator first, Size n, const T& x); + // _lib.auto.ptr_, pointers: +X template<class X> class auto_ptr; + } + + 20.4.1 The default allocator [lib.default.allocator] + +T template <class T> class allocator; + // specialize for void: +T template <> class allocator<void> { + public: +T typedef void* pointer; +T typedef const void* const_pointer; + // reference-to-void members are impossible. +T typedef void value_type; +T template <class U> struct rebind { typedef allocator<U> other; }; + }; + +T template <class T> 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 <class U> struct rebind { typedef allocator<U> other; }; +T allocator() throw(); +T allocator(const allocator&) throw(); +T template <class U> allocator(const allocator<U>&) throw(); +T ~allocator() throw(); +T pointer address(reference x) const; +T const_pointer address(const_reference x) const; +T pointer allocate( + size_type, allocator<void>::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 <class T1, class T2> + bool operator==(const allocator<T1>&, const allocator<T2>&) throw(); +T template <class T1, class T2> + bool operator!=(const allocator<T1>&, const allocator<T2>&) throw(); + + 20.4.2 Raw storage iterator [lib.storage.iterator] + +T template <class OutputIterator, class T> + class raw_storage_iterator + : public iterator<output_iterator_tag,void,void,void,void> { + public: +T explicit raw_storage_iterator(OutputIterator x); +T raw_storage_iterator<OutputIterator,T>& operator*(); +T raw_storage_iterator<OutputIterator,T>& operator=(const T& element); +T raw_storage_iterator<OutputIterator,T>& operator++(); +T raw_storage_iterator<OutputIterator,T> operator++(int); + }; + + 20.4.3 Temporary buffers [lib.temporary.buffer] + +T template <class T> + pair<T*, ptrdiff_t> get_temporary_buffer(ptrdiff_t n); + +T template <class T> 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 <class InputIterator, class ForwardIterator> + ForwardIterator + uninitialized_copy(InputIterator first, InputIterator last, + ForwardIterator result); + + 20.4.4.2 uninitialized_fill [lib.uninitialized.fill] + +V template <class ForwardIterator, class T> + void uninitialized_fill(ForwardIterator first, ForwardIterator last, + const T& x); + + 20.4.4.3 uninitialized_fill_n [lib.uninitialized.fill.n] + +V template <class ForwardIterator, class Size, class T> + void uninitialized_fill_n(ForwardIterator first, Size n, const T& x); + + 20.4.5 Template class auto_ptr [lib.auto.ptr] + +X template<class X> class auto_ptr { + template <class Y> 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<class Y> auto_ptr(auto_ptr<Y>&) throw(); +T auto_ptr& operator=(auto_ptr&) throw(); +T template<class Y> auto_ptr& operator=(auto_ptr<Y>&) 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_ converions: +X auto_ptr(auto_ptr_ref<X>) throw(); +X template<class Y> operator auto_ptr_ref<Y>() throw(); +X template<class Y> operator auto_ptr<Y>() throw(); + }; + + 20.4.6 C Library [lib.c.malloc] + + Table 7--Header <cstdlib> synopsis + +X Functions: calloc malloc + free realloc + + + Table 8--Header <cstring> synopsis + +X Macro: NULL +X Type: size_t +X Functions: memchr memcmp +X memcpy memmove memset + + Table 9--Header <ctime> 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<class charT> struct char_traits; + shall be provided in the header <string> as a basis for explicit spe- + cializations. + + + 21.1.3.1 struct [lib.char.traits.specializations.char] + char_traits<char> + +T template<> + struct char_traits<char> { +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<wchar_t> + +V template<> + struct char_traits<wchar_t> { +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<class charT> + struct char_traits; +V template <> struct char_traits<char>; +V template <> struct char_traits<wchar_t>; + + // _lib.basic.string_, basic_string: +V template<class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > + class basic_string; +V template<class charT, class traits, class Allocator> + basic_string<charT,traits,Allocator> + operator+(const basic_string<charT,traits,Allocator>& lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + basic_string<charT,traits,Allocator> + operator+(const charT* lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + basic_string<charT,traits,Allocator> + operator+(charT lhs, const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + basic_string<charT,traits,Allocator> + operator+(const basic_string<charT,traits,Allocator>& lhs, + const charT* rhs); +V template<class charT, class traits, class Allocator> + basic_string<charT,traits,Allocator> + operator+(const basic_string<charT,traits,Allocator>& lhs, charT rhs); + +V template<class charT, class traits, class Allocator> + bool operator==(const basic_string<charT,traits,Allocator>& lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator==(const charT* lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator==(const basic_string<charT,traits,Allocator>& lhs, + const charT* rhs); +V template<class charT, class traits, class Allocator> + bool operator!=(const basic_string<charT,traits,Allocator>& lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator!=(const charT* lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator!=(const basic_string<charT,traits,Allocator>& lhs, + const charT* rhs); +V template<class charT, class traits, class Allocator> + bool operator< (const basic_string<charT,traits,Allocator>& lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator< (const basic_string<charT,traits,Allocator>& lhs, + const charT* rhs); +V template<class charT, class traits, class Allocator> + bool operator< (const charT* lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator> (const basic_string<charT,traits,Allocator>& lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator> (const basic_string<charT,traits,Allocator>& lhs, + const charT* rhs); +V template<class charT, class traits, class Allocator> + bool operator> (const charT* lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator<=(const basic_string<charT,traits,Allocator>& lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator<=(const basic_string<charT,traits,Allocator>& lhs, + const charT* rhs); +V template<class charT, class traits, class Allocator> + bool operator<=(const charT* lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator>=(const basic_string<charT,traits,Allocator>& lhs, + const basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + bool operator>=(const basic_string<charT,traits,Allocator>& lhs, + const charT* rhs); +V template<class charT, class traits, class Allocator> + bool operator>=(const charT* lhs, + const basic_string<charT,traits,Allocator>& rhs); + + // _lib.string.special_: +V template<class charT, class traits, class Allocator> + void swap(basic_string<charT,traits,Allocator>& lhs, + basic_string<charT,traits,Allocator>& rhs); +V template<class charT, class traits, class Allocator> + basic_istream<charT,traits>& + operator>>(basic_istream<charT,traits>& is, + basic_string<charT,traits,Allocator>& str); +T template<class charT, class traits, class Allocator> + basic_ostream<charT, traits>& + operator<<(basic_ostream<charT, traits>& os, + const basic_string<charT,traits,Allocator>& str); +V template<class charT, class traits, class Allocator> + basic_istream<charT,traits>& + getline(basic_istream<charT,traits>& is, + basic_string<charT,traits,Allocator>& str, + charT delim); +V template<class charT, class traits, class Allocator> + basic_istream<charT,traits>& + getline(basic_istream<charT,traits>& is, + basic_string<charT,traits,Allocator>& str); +V typedef basic_string<char> string; +T typedef basic_string<wchar_t> wstring; + } + + 21.3 Template class basic_string [lib.basic.string] + +V namespace std { + template<class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > + 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<iterator> reverse_iterator; + typedef std::reverse_iterator<const_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<class InputIterator> + 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<class InputIterator> + 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<class InputIterator> + 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<class InputIterator> + 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<class InputIterator> + 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<charT,traits,Allocator>&); + // _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 <cctype> synopsis + + isalnum isdigit isprint isupper tolower +X isalpha isgraph ispunct isxdigit toupper + iscntrl islower isspace + + Table 11--Header <cwctype> synopsis + +X Macro: WEOF <cwctype> +X Types: wctrans_t wctype_t wint_t <cwctype> + Functions: +X iswalnum iswctype iswlower iswspace towctrans wctrans +X iswalpha iswdigit iswprint iswupper towlower wctype +X iswcntrl iswgraph iswpunct iswxdigit towupper + + Table 12--Header <cstring> synopsis + +X Macro: NULL <cstring> +X Type: size_t <cstring> + 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 <cwchar> synopsis + Macros: NULL <cwchar> WCHAR_MAX WCHAR_MIN WEOF <cwchar> + Types: mbstate_t wint_t <cwchar> 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 <cstdlib> 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 <locale> synopsis + + // _lib.locale_, locale: +T class locale; +T template <class Facet> const Facet& use_facet(const locale&); +T template <class Facet> bool has_facet(const locale&) throw(); + + // _lib.locale.convenience_, convenience interfaces: +T template <class charT> bool isspace (charT c, const locale& loc); +T template <class charT> bool isprint (charT c, const locale& loc); +T template <class charT> bool iscntrl (charT c, const locale& loc); +T template <class charT> bool isupper (charT c, const locale& loc); +T template <class charT> bool islower (charT c, const locale& loc); +T template <class charT> bool isalpha (charT c, const locale& loc); +T template <class charT> bool isdigit (charT c, const locale& loc); +T template <class charT> bool ispunct (charT c, const locale& loc); +T template <class charT> bool isxdigit(charT c, const locale& loc); +T template <class charT> bool isalnum (charT c, const locale& loc); +T template <class charT> bool isgraph (charT c, const locale& loc); +T template <class charT> charT toupper(charT c, const locale& loc); +T template <class charT> charT tolower(charT c, const locale& loc); + // _lib.category.ctype_ and _lib.facet.ctype.special_, ctype: + class ctype_base; +T template <class charT> class ctype; +T template <> class ctype<char>; // specialization +S template <class charT> class ctype_byname; +S template <> class ctype_byname<char>; // specialization +T class codecvt_base; +X template <class internT, class externT, class stateT> class codecvt; +S template <class internT, class externT, class stateT> class codecvt_byname; + // _lib.category.numeric_ and _lib.facet.numpunct_, numeric: +X template <class charT, class InputIterator> class num_get; +X template <class charT, class OutputIterator> class num_put; +T template <class charT> class numpunct; +S template <class charT> class numpunct_byname; + // _lib.category.collate_, collation: +T template <class charT> class collate; +S template <class charT> class collate_byname; + // _lib.category.time_, date and time: +T class time_base; +S template <class charT, class InputIterator> class time_get; +S template <class charT, class InputIterator> class time_get_byname; +S template <class charT, class OutputIterator> class time_put; +S template <class charT, class OutputIterator> class time_put_byname; + // _lib.category.monetary_, money: +T class money_base; +S template <class charT, class InputIterator> class money_get; +S template <class charT, class OutputIterator> class money_put; +S template <class charT, bool Intl> class moneypunct; +S template <class charT, bool Intl> class moneypunct_byname; + // _lib.category.messages_, message retrieval: +T class messages_base; +S template <class charT> class messages; +S template <class charT> 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 <class Facet> 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 <class Facet> locale combine(const locale& other) const; + // locale operations: +X basic_string<char> name() const; +T bool operator==(const locale& other) const; +T bool operator!=(const locale& other) const; +T template <class charT, class Traits, class Allocator> + bool operator()(const basic_string<charT,Traits,Allocator>& s1, + const basic_string<charT,Traits,Allocator>& 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<char>, collate<wchar_t> +T ctype<char>, ctype<wchar_t> +T codecvt<char,char,mbstate_t>, +S codecvt<wchar_t,char,mbstate_t> +T moneypunct<char>, moneypunct<wchar_t> +T moneypunct<char,true>, moneypunct<wchar_t,true>, +S money_get<char>, money_get<wchar_t +S money_put<char>, money_put<wchar_t> +T numpunct<char>, numpunct<wchar_t>, +X num_get<char>, num_get<wchar_t> +X num_put<char>, num_put<wchar_t> +S time_get<char>, time_get<wchar_t>, +S time_put<char>, time_put<wchar_t> +S messages<char>, messages<wchar_t> + + [required instantiations] +S collate_byname<char>, collate_byname<wchar_t> +S ctype_byname<char>, ctype_byname<wchar_t> +S codecvt_byname<char,char,mbstate_t>, +S codecvt_byname<wchar_t,char,mbstate_t> +S moneypunct_byname<char,International>, +S moneypunct_byname<wchar_t,International>, +S money_get<C,InputIterator>, +S money_put<C,OutputIterator> +S numpunct_byname<char>, numpunct_byname<wchar_t> +X num_get<C,InputIterator>, num_put<C,OutputIterator> +S time_get<char,InputIterator>, +S time_get_byname<char,InputIterator>, +S time_get<wchar_t,OutputIterator>, +S time_get_byname<wchar_t,OutputIterator>, +S time_put<char,OutputIterator>, +S time_put_byname<char,OutputIterator>, +S time_put<wchar_t,OutputIterator> +S time_put_byname<wchar_t,OutputIterator> +S messages_byname<char>, messages_byname<wchar_t> + + + 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 charT> + 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 charT> + class ctype_byname : public ctype<charT> { + public: +T typedef ctype<charT>::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<char> + : 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<char> + +X template <> class ctype_byname<char> : public ctype<char> { + 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 internT, class externT, class stateT> + 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 internT, class externT, class stateT> + class codecvt_byname : public codecvt<internT, externT, stateT> { + 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 charT, class InputIterator = istreambuf_iterator<charT> > + 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 charT, class OutputIterator = ostreambuf_iterator<charT> > + 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 charT> + class numpunct : public locale::facet { + public: +T typedef charT char_type; +T typedef basic_string<charT> 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 charT> + class numpunct_byname : public numpunct<charT> { + // this class is specialized for char and wchar_t. + public: +T typedef charT char_type; +T typedef basic_string<charT> 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 charT> + class collate : public locale::facet { + public: +T typedef charT char_type; +T typedef basic_string<charT> 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 charT> + class collate_byname : public collate<charT> { + public: +T typedef basic_string<charT> 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 charT, class InputIterator = istreambuf_iterator<charT> > + 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 charT, class InputIterator = istreambuf_iterator<charT> > + class time_get_byname : public time_get<charT, InputIterator> { + 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 charT, class OutputIterator = ostreambuf_iterator<charT> > + 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 charT, class OutputIterator = ostreambuf_iterator<charT> > + class time_put_byname : public time_put<charT, OutputIterator> + { + 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 charT, + class InputIterator = istreambuf_iterator<charT> > + class money_get : public locale::facet { + public: +T typedef charT char_type; +T typedef InputIterator iter_type; +T typedef basic_string<charT> 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 charT, + class OutputIterator = ostreambuf_iterator<charT> > + class money_put : public locale::facet { + public: +T typedef charT char_type; +T typedef OutputIterator iter_type; +T typedef basic_string<charT> 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 charT, bool International = false> + class moneypunct : public locale::facet, public money_base { + public: +T typedef charT char_type; +T typedef basic_string<charT> 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 charT, bool Intl = false> + class moneypunct_byname : public moneypunct<charT, Intl> { + public: +T typedef money_base::pattern pattern; +T typedef basic_string<charT> 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 charT> + class messages : public locale::facet, public messages_base { + public: +T typedef charT char_type; +T typedef basic_string<charT> string_type; +T explicit messages(size_t refs = 0); +T catalog open(const basic_string<char>& 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<char>&, 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 charT> + class messages_byname : public messages<charT> { + public: +T typedef messages_base::catalog catalog; +T typedef basic_string<charT> 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<char>&, 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 <clocale> 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] + + <deque>, <list>, <queue>, <stack>, and <vector>. + + Header <deque> synopsis + +X template <class T, class Allocator = allocator<T> > class deque; +T template <class T, class Allocator> + bool operator==(const deque<T,Allocator>& x, const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator< (const deque<T,Allocator>& x, const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator!=(const deque<T,Allocator>& x, const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator> (const deque<T,Allocator>& x, const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator>=(const deque<T,Allocator>& x, const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator<=(const deque<T,Allocator>& x, const deque<T,Allocator>& y); +T template <class T, class Allocator> + void swap(deque<T,Allocator>& x, deque<T,Allocator>& y); + } + + Header <list> synopsis + +X template <class T, class Allocator = allocator<T> > class list; +T template <class T, class Allocator> + bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + void swap(list<T,Allocator>& x, list<T,Allocator>& y); + } + + Header <queue> synopsis + + namespace std { +X template <class T, class Container = deque<T> > class queue; +T template <class T, class Container> + bool operator==(const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator< (const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator!=(const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator> (const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator>=(const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator<=(const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container = vector<T>, + class Compare = less<typename Container::value_type> > +T class priority_queue; + } + + Header <stack> synopsis + + namespace std { +T template <class T, class Container = deque<T> > class stack; +T template <class T, class Container> + bool operator==(const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator< (const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator!=(const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator> (const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator>=(const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator<=(const stack<T, Container>& x, + const stack<T, Container>& y); + } + + Header <vector> synopsis + +T template <class T, class Allocator = allocator<T> > class vector; + +T template <class T, class Allocator> + bool operator==(const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator< (const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator!=(const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator> (const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator>=(const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator<=(const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + void swap(vector<T,Allocator>& x, vector<T,Allocator>& y); + +T template <class Allocator> class vector<bool,Allocator>; +T template <class Allocator> + bool operator==(const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator< (const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator!=(const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator> (const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator>=(const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator<=(const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + void swap(vector<bool,Allocator>& x, vector<bool,Allocator>& y); + } + + 23.2.1 Template class deque [lib.deque] + + template <class T, class Allocator = allocator<T> > +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<iterator> reverse_iterator; +T typedef std::reverse_iterator<const_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 <class InputIterator> + deque(InputIterator first, InputIterator last, + const Allocator& = Allocator()); +T deque(const deque<T,Allocator>& x); +T ~deque(); +T deque<T,Allocator>& operator=(const deque<T,Allocator>& x); +T template <class InputIterator> + 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 <class InputIterator> + 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,Allocator>&); +T void clear(); + }; +T template <class T, class Allocator> + bool operator==(const deque<T,Allocator>& x, + const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator< (const deque<T,Allocator>& x, + const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator!=(const deque<T,Allocator>& x, + const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator> (const deque<T,Allocator>& x, + const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator>=(const deque<T,Allocator>& x, + const deque<T,Allocator>& y); +T template <class T, class Allocator> + bool operator<=(const deque<T,Allocator>& x, + const deque<T,Allocator>& y); + // specialized algorithms: +T template <class T, class Allocator> + void swap(deque<T,Allocator>& x, deque<T,Allocator>& y); + + + 23.2.2 Template class list [lib.list] + +X template <class T, class Allocator = allocator<T> > + 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<iterator> reverse_iterator; +T typedef std::reverse_iterator<const_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 <class InputIterator> + list(InputIterator first, InputIterator last, + const Allocator& = Allocator()); +T list(const list<T,Allocator>& x); +T ~list(); +T list<T,Allocator>& operator=(const list<T,Allocator>& x); +T template <class InputIterator> + 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 <class InputIterator> + 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,Allocator>&); +T void clear(); + // _lib.list.ops_ list operations: +T void splice(iterator position, list<T,Allocator>& x); +T void splice(iterator position, list<T,Allocator>& x, iterator i); +T void splice(iterator position, list<T,Allocator>& x, iterator first, + iterator last); +T void remove(const T& value); +T template <class Predicate> void remove_if(Predicate pred); + +T void unique(); +T template <class BinaryPredicate> + void unique(BinaryPredicate binary_pred); +T void merge(list<T,Allocator>& x); +T template <class Compare> void merge(list<T,Allocator>& x, Compare comp); + void sort(); +T template <class Compare> void sort(Compare comp); + void reverse(); + }; +T template <class T, class Allocator> + bool operator==(const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator< (const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator!=(const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator> (const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator>=(const list<T,Allocator>& x, const list<T,Allocator>& y); +T template <class T, class Allocator> + bool operator<=(const list<T,Allocator>& x, const list<T,Allocator>& y); + // specialized algorithms: +T template <class T, class Allocator> + void swap(list<T,Allocator>& x, list<T,Allocator>& y); + + + 23.2.3.1 Template class queue [lib.queue] + +T template <class T, class Container = deque<T> > + 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 <class T, class Container> + bool operator==(const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator< (const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator!=(const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator> (const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator>=(const queue<T, Container>& x, + const queue<T, Container>& y); +T template <class T, class Container> + bool operator<=(const queue<T, Container>& x, + const queue<T, Container>& y); + + 23.2.3.2 Template class priority_queue [lib.priority.queue] + +T template <class T, class Container = vector<T>, + class Compare = less<typename Container::value_type> > + 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 <class InputIterator> + 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 T, class Container = deque<T> > + 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 <class T, class Container> + bool operator==(const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator< (const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator!=(const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator> (const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator>=(const stack<T, Container>& x, + const stack<T, Container>& y); +T template <class T, class Container> + bool operator<=(const stack<T, Container>& x, + const stack<T, Container>& y); + + 23.2.4 Template class vector [lib.vector] + + template <class T, class Allocator = allocator<T> > +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<iterator> reverse_iterator; +T typedef std::reverse_iterator<const_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 <class InputIterator> + vector(InputIterator first, InputIterator last, + const Allocator& = Allocator()); +T vector(const vector<T,Allocator>& x); +T ~vector(); +T vector<T,Allocator>& operator=(const vector<T,Allocator>& x); +T template <class InputIterator> + 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 <class InputIterator> + 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,Allocator>&); +T void clear(); + }; + +T template <class T, class Allocator> + bool operator==(const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator< (const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator!=(const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator> (const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator>=(const vector<T,Allocator>& x, + const vector<T,Allocator>& y); +T template <class T, class Allocator> + bool operator<=(const vector<T,Allocator>& x, + const vector<T,Allocator>& y); + // specialized algorithms: +T template <class T, class Allocator> + void swap(vector<T,Allocator>& x, vector<T,Allocator>& y); + + + 23.2.5 Class vector<bool> [lib.vector.bool] + +X template <class Allocator> class vector<bool, Allocator> { + 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<iterator> reverse_iterator; +T typedef std::reverse_iterator<const_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 <class InputIterator> + vector(InputIterator first, InputIterator last, + const Allocator& = Allocator()); +T vector(const vector<bool,Allocator>& x); +T ~vector(); +T vector<bool,Allocator>& operator=(const vector<bool,Allocator>& x); +T template <class InputIterator> + 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 <class InputIterator> + void insert(iterator position, + InputIterator first, InputIterator last); +T iterator erase(iterator position); +T iterator erase(iterator first, iterator last); +T void swap(vector<bool,Allocator>&); +T static void swap(reference x, reference y); +T void flip(); // flips all bits +T void clear(); + }; + +T template <class Allocator> + bool operator==(const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator< (const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator!=(const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator> (const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator>=(const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); +T template <class Allocator> + bool operator<=(const vector<bool,Allocator>& x, + const vector<bool,Allocator>& y); + // specialized algorithms: +T template <class Allocator> + void swap(vector<bool,Allocator>& x, vector<bool,Allocator>& y); + + 23.3 Associative containers [lib.associative] + + <map> and <set>: + + Header <map> synopsis + + template <class Key, class T, class Compare = less<Key>, + class Allocator = allocator<pair<const Key, T> > > +X class map; + +T template <class Key, class T, class Compare, class Allocator> + bool operator==(const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator< (const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator!=(const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator> (const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator>=(const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator<=(const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + void swap(map<Key,T,Compare,Allocator>& x, + map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare = less<Key>, + class Allocator = allocator<pair<const Key, T> > > + class multimap; +T template <class Key, class T, class Compare, class Allocator> + bool operator==(const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator< (const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator!=(const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator> (const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator>=(const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator<=(const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + void swap(multimap<Key,T,Compare,Allocator>& x, + multimap<Key,T,Compare,Allocator>& y); + } + + Header <set> synopsis + + template <class Key, class Compare = less<Key>, + class Allocator = allocator<Key> > +X class set; + +T template <class Key, class Compare, class Allocator> + bool operator==(const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator< (const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator!=(const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator> (const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator>=(const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator<=(const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + void swap(set<Key,Compare,Allocator>& x, + set<Key,Compare,Allocator>& y); +T template <class Key, class Compare = less<Key>, + class Allocator = allocator<Key> > + class multiset; +T template <class Key, class Compare, class Allocator> + bool operator==(const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator< (const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator!=(const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator> (const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator>=(const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator<=(const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + void swap(multiset<Key,Compare,Allocator>& x, + multiset<Key,Compare,Allocator>& y); + } + + 23.3.1 Template class map [lib.map] + + template <class Key, class T, class Compare = less<Key>, + class Allocator = allocator<pair<const Key, T> > > +X class map { + public: + // types: +T typedef Key key_type; +T typedef T mapped_type; +T typedef pair<const Key, T> 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<iterator> reverse_iterator; +T typedef std::reverse_iterator<const_iterator> const_reverse_iterator; +T class value_compare + : public binary_function<value_type,value_type,bool> { + 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 <class InputIterator> + map(InputIterator first, InputIterator last, + const Compare& comp = Compare(), const Allocator& = Allocator()); +T map(const map<Key,T,Compare,Allocator>& x); +T ~map(); +T map<Key,T,Compare,Allocator>& + operator=(const map<Key,T,Compare,Allocator>& 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<iterator, bool> insert(const value_type& x); +T iterator insert(iterator position, const value_type& x); +T template <class InputIterator> + 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<Key,T,Compare,Allocator>&); +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<iterator,iterator> + equal_range(const key_type& x); +T pair<const_iterator,const_iterator> + equal_range(const key_type& x) const; + }; + +T template <class Key, class T, class Compare, class Allocator> + bool operator==(const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator< (const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator!=(const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator> (const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator>=(const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator<=(const map<Key,T,Compare,Allocator>& x, + const map<Key,T,Compare,Allocator>& y); + // specialized algorithms: +T template <class Key, class T, class Compare, class Allocator> + void swap(map<Key,T,Compare,Allocator>& x, + map<Key,T,Compare,Allocator>& y); + + 23.3.2 Template class multimap [lib.multimap] + + template <class Key, class T, class Compare = less<Key>, + class Allocator = allocator<pair<const Key, T> > > +X class multimap { + public: + // types: +T typedef Key key_type; +T typedef T mapped_type; +T typedef pair<const Key,T> 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<iterator> reverse_iterator; +T typedef std::reverse_iterator<const_iterator> const_reverse_iterator; +T class value_compare + : public binary_function<value_type,value_type,bool> { + 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 <class InputIterator> + multimap(InputIterator first, InputIterator last, + const Compare& comp = Compare(), + const Allocator& = Allocator()); +T multimap(const multimap<Key,T,Compare,Allocator>& x); +T ~multimap(); +T multimap<Key,T,Compare,Allocator>& + operator=(const multimap<Key,T,Compare,Allocator>& 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 <class InputIterator> + 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<Key,T,Compare,Allocator>&); +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<iterator,iterator> equal_range(const key_type& x); +T pair<const_iterator,const_iterator> equal_range(const key_type& x) const; + }; + +T template <class Key, class T, class Compare, class Allocator> + bool operator==(const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator< (const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator!=(const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator> (const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator>=(const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); +T template <class Key, class T, class Compare, class Allocator> + bool operator<=(const multimap<Key,T,Compare,Allocator>& x, + const multimap<Key,T,Compare,Allocator>& y); + // specialized algorithms: +T template <class Key, class T, class Compare, class Allocator> + void swap(multimap<Key,T,Compare,Allocator>& x, + multimap<Key,T,Compare,Allocator>& y); + + + 23.3.3 Template class set [lib.set] + + template <class Key, class Compare = less<Key>, + class Allocator = allocator<Key> > +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<iterator> reverse_iterator; +T typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + // _lib.set.cons_ construct/copy/destroy: +T explicit set(const Compare& comp = Compare(), + const Allocator& = Allocator()); +T template <class InputIterator> + set(InputIterator first, InputIterator last, + const Compare& comp = Compare(), const Allocator& = Allocator()); +T set(const set<Key,Compare,Allocator>& x); +T ~set(); +T set<Key,Compare,Allocator>& + operator=(const set<Key,Compare,Allocator>& 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<iterator,bool> insert(const value_type& x); +T iterator insert(iterator position, const value_type& x); +T template <class InputIterator> +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<Key,Compare,Allocator>&); +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<iterator,iterator> equal_range(const key_type& x) const; + }; +T template <class Key, class Compare, class Allocator> + bool operator==(const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator< (const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator!=(const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator> (const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator>=(const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator<=(const set<Key,Compare,Allocator>& x, + const set<Key,Compare,Allocator>& y); + // specialized algorithms: +T template <class Key, class Compare, class Allocator> + void swap(set<Key,Compare,Allocator>& x, + set<Key,Compare,Allocator>& y); + + 23.3.4 Template class multiset [lib.multiset] + + template <class Key, class Compare = less<Key>, + class Allocator = allocator<Key> > +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<iterator> reverse_iterator; +T typedef std::reverse_iterator<const_iterator> const_reverse_iterator; + + // construct/copy/destroy: +T explicit multiset(const Compare& comp = Compare(), + const Allocator& = Allocator()); +T template <class InputIterator> + multiset(InputIterator first, InputIterator last, + const Compare& comp = Compare(), + const Allocator& = Allocator()); +T multiset(const multiset<Key,Compare,Allocator>& x); +T ~multiset(); +T multiset<Key,Compare,Allocator>& + operator=(const multiset<Key,Compare,Allocator>& 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 <class InputIterator> + 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<Key,Compare,Allocator>&); +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<iterator,iterator> equal_range(const key_type& x) const; + }; + +T template <class Key, class Compare, class Allocator> + bool operator==(const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator< (const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator!=(const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator> (const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator>=(const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); +T template <class Key, class Compare, class Allocator> + bool operator<=(const multiset<Key,Compare,Allocator>& x, + const multiset<Key,Compare,Allocator>& y); + // specialized algorithms: +T template <class Key, class Compare, class Allocator> + void swap(multiset<Key,Compare,Allocator>& x, + multiset<Key,Compare,Allocator>& y); + + 23.3.5 Template class bitset [lib.template.bitset] + + Header <bitset> synopsis + + [What's this stuff? + #include <cstddef> // for size_t + #include <string> + #include <stdexcept> // for invalid_argument, + // out_of_range, overflow_error + #include <iosfwd> // for istream, ostream + ] +X template <size_t N> class bitset; + // _lib.bitset.operators_ bitset operations: +T template <size_t N> + bitset<N> operator&(const bitset<N>&, const bitset<N>&); +T template <size_t N> + bitset<N> operator|(const bitset<N>&, const bitset<N>&); +T template <size_t N> + bitset<N> operator^(const bitset<N>&, const bitset<N>&); +T template <class charT, class traits, size_t N> + basic_istream<charT, traits>& + operator>>(basic_istream<charT, traits>& is, bitset<N>& x); +T template <class charT, class traits, size_t N> + basic_ostream<charT, traits>& + operator<<(basic_ostream<charT, traits>& os, const bitset<N>& x); + +X template<size_t N> 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<class charT, class traits, class Allocator> + explicit bitset( + const basic_string<charT,traits,Allocator>& str, + typename basic_string<charT,traits,Allocator>::size_type pos = 0, + typename basic_string<charT,traits,Allocator>::size_type n = + basic_string<charT,traits,Allocator>::npos); + // _lib.bitset.members_ bitset operations: +T bitset<N>& operator&=(const bitset<N>& rhs); +T bitset<N>& operator|=(const bitset<N>& rhs); +T bitset<N>& operator^=(const bitset<N>& rhs); +T bitset<N>& operator<<=(size_t pos); +T bitset<N>& operator>>=(size_t pos); +T bitset<N>& set(); +T bitset<N>& set(size_t pos, int val = true); +T bitset<N>& reset(); +T bitset<N>& reset(size_t pos); +T bitset<N> operator~() const; +T bitset<N>& flip(); +T bitset<N>& flip(size_t pos); + // element access: +T reference operator[](size_t pos); // for b[i]; +T unsigned long to_ulong() const; +T template <class charT, class traits, class Allocator> + basic_string<charT, traits, Allocator> to_string() const; +T size_t count() const; +T size_t size() const; +T bool operator==(const bitset<N>& rhs) const; +T bool operator!=(const bitset<N>& rhs) const; +T bool test(size_t pos) const; +T bool any() const; +T bool none() const; +T bitset<N> operator<<(size_t pos) const; +T bitset<N> operator>>(size_t pos) const; + }; + + + + + 24.2 Header <iterator> synopsis [lib.iterator.synopsis] + + // _lib.iterator.primitives_, primitives: +T template<class Iterator> struct iterator_traits; +T template<class T> struct iterator_traits<T*>; + +X template<class Category, class T, class Distance = ptrdiff_t, + class Pointer = T*, class Reference = T&> 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 <class InputIterator, class Distance> + void advance(InputIterator& i, Distance n); +T template <class InputIterator> + typename iterator_traits<InputIterator>::difference_type + distance(InputIterator first, InputIterator last); + // _lib.predef.iterators_, predefined iterators: +X template <class Iterator> class reverse_iterator; +T template <class Iterator> + bool operator==( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator<( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator!=( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator>( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator>=( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator<=( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + typename reverse_iterator<Iterator>::difference_type operator-( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + reverse_iterator<Iterator> + operator+( + typename reverse_iterator<Iterator>::difference_type n, + const reverse_iterator<Iterator>& x); + +X template <class Container> class back_insert_iterator; +T template <class Container> + back_insert_iterator<Container> back_inserter(Container& x); +X template <class Container> class front_insert_iterator; +T template <class Container> + front_insert_iterator<Container> front_inserter(Container& x); +X template <class Container> class insert_iterator; +T template <class Container, class Iterator> + insert_iterator<Container> inserter(Container& x, Iterator i); + // _lib.stream.iterators_, stream iterators: +X template <class T, class charT = char, class traits = char_traits<charT>, + class Distance = ptrdiff_t> + class istream_iterator; + template <class T, class charT, class traits, class Distance> +X bool operator==(const istream_iterator<T,charT,traits,Distance>& x, + const istream_iterator<T,charT,traits,Distance>& y); + template <class T, class charT, class traits, class Distance> +X bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, + const istream_iterator<T,charT,traits,Distance>& y); +X template <class T, class charT = char, class traits = char_traits<charT> > + class ostream_iterator; +X template<class charT, class traits = char_traits<charT> > + class istreambuf_iterator; +X template <class charT, class traits> + bool operator==(const istreambuf_iterator<charT,traits>& a, + const istreambuf_iterator<charT,traits>& b); +X template <class charT, class traits> + bool operator!=(const istreambuf_iterator<charT,traits>& a, + const istreambuf_iterator<charT,traits>& b); +T template <class charT, class traits = char_traits<charT> > + class ostreambuf_iterator; + + 24.3 Iterator primitives [lib.iterator.primitives] + +T template<class Iterator> 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<class T> struct iterator_traits<T*> { +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<class T> struct iterator_traits<const T*> { +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<class Category, class T, class Distance = ptrdiff_t, + class Pointer = T*, class Reference = T&> +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 <class Iterator> +X class reverse_iterator : public + iterator<typename iterator_traits<Iterator>::iterator_category, + typename iterator_traits<Iterator>::value_type, + typename iterator_traits<Iterator>::difference_type, + typename iterator_traits<Iterator>::pointer, + typename iterator_traits<Iterator>::reference> { + protected: +T Iterator current; + public: +T typedef Iterator + iterator_type; +T typedef typename iterator_traits<Iterator>::difference_type + difference_type; +T typedef typename iterator_traits<Iterator>::reference + reference; +T typedef typename iterator_traits<Iterator>::pointer + pointer; + +T reverse_iterator(); +T explicit reverse_iterator(Iterator x); +T template <class U> reverse_iterator(const reverse_iterator<U>& 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 <class Iterator> + bool operator==( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator<( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator!=( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator>( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator>=( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + bool operator<=( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + typename reverse_iterator<Iterator>::difference_type operator-( + const reverse_iterator<Iterator>& x, + const reverse_iterator<Iterator>& y); +T template <class Iterator> + reverse_iterator<Iterator> operator+( + typename reverse_iterator<Iterator>::difference_type n, + const reverse_iterator<Iterator>& x); + + + 24.4.2.1 Template class [lib.back.insert.iterator] + back_insert_iterator + + template <class Container> +X class back_insert_iterator : + public iterator<output_iterator_tag,void,void,void,void> { + protected: +T Container* container; + public: +T typedef Container container_type; +T explicit back_insert_iterator(Container& x); +T back_insert_iterator<Container>& + operator=(typename Container::const_reference value); + +T back_insert_iterator<Container>& operator*(); +T back_insert_iterator<Container>& operator++(); +T back_insert_iterator<Container> operator++(int); + }; +T template <class Container> + back_insert_iterator<Container> back_inserter(Container& x); + + + + 24.4.2.3 Template class [lib.front.insert.iterator] + front_insert_iterator + + template <class Container> +X class front_insert_iterator : + public iterator<output_iterator_tag,void,void,void,void> { + protected: +T Container* container; + public: +T typedef Container container_type; +T explicit front_insert_iterator(Container& x); +T front_insert_iterator<Container>& + operator=(typename Container::const_reference value); +T front_insert_iterator<Container>& operator*(); +T front_insert_iterator<Container>& operator++(); +T front_insert_iterator<Container> operator++(int); + }; +T template <class Container> + front_insert_iterator<Container> front_inserter(Container& x); + + + 24.4.2.5 Template class insert_iterator [lib.insert.iterator] + + template <class Container> +X class insert_iterator : + public iterator<output_iterator_tag,void,void,void,void> { + 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<Container>& + operator=(typename Container::const_reference value); +T insert_iterator<Container>& operator*(); +T insert_iterator<Container>& operator++(); +T insert_iterator<Container>& operator++(int); + }; +T template <class Container, class Iterator> + insert_iterator<Container> inserter(Container& x, Iterator i); + + 24.5.1 Template class istream_iterator [lib.istream.iterator] + + template <class T, class charT = char, class traits = char_traits<charT>, + class Distance = ptrdiff_t> +X class istream_iterator: + public iterator<input_iterator_tag, T, Distance, const T*, const T&> { + public: +T typedef charT char_type +T typedef traits traits_type; +T typedef basic_istream<charT,traits> istream_type; +T istream_iterator(); +T istream_iterator(istream_type& s); +T istream_iterator(const istream_iterator<T,charT,traits,Distance>& x); +T ~istream_iterator(); + +T const T& operator*() const; +T const T* operator->() const; +T istream_iterator<T,charT,traits,Distance>& operator++(); +T istream_iterator<T,charT,traits,Distance> operator++(int); + }; + +T template <class T, class charT, class traits, class Distance> + bool operator==(const istream_iterator<T,charT,traits,Distance>& x, + const istream_iterator<T,charT,traits,Distance>& y); +T template <class T, class charT, class traits, class Distance> + bool operator!=(const istream_iterator<T,charT,traits,Distance>& x, + const istream_iterator<T,charT,traits,Distance>& y); + + + 24.5.2 Template class ostream_iterator [lib.ostream.iterator] + + template <class T, class charT = char, class traits = char_traits<charT> > +X class ostream_iterator: + public iterator<output_iterator_tag, void, void, void, void> { + public: +T typedef charT char_type; +T typedef traits traits_type; +T typedef basic_ostream<charT,traits> ostream_type; +T ostream_iterator(ostream_type& s); +T ostream_iterator(ostream_type& s, const charT* delimiter); +T ostream_iterator(const ostream_iterator<T,charT,traits>& x); +T ~ostream_iterator(); +T ostream_iterator<T,charT,traits>& operator=(const T& value); + +T ostream_iterator<T,charT,traits>& operator*(); +T ostream_iterator<T,charT,traits>& operator++(); +T ostream_iterator<T,charT,traits>& operator++(int); + }; + + + 24.5.3 Template class [lib.istreambuf.iterator] + istreambuf_iterator + + template<class charT, class traits = char_traits<charT> > +X class istreambuf_iterator + : public iterator<input_iterator_tag, charT, + typename traits::off_type, charT*, charT&> { + public: +T typedef charT char_type; +T typedef traits traits_type; +T typedef typename traits::int_type int_type; +T typedef basic_streambuf<charT,traits> streambuf_type; +T typedef basic_istream<charT,traits> 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<charT,traits>& operator++(); +T proxy operator++(int); +X bool equal(istreambuf_iterator& b); + }; + +T template <class charT, class traits> + bool operator==(const istreambuf_iterator<charT,traits>& a, + const istreambuf_iterator<charT,traits>& b); + +T template <class charT, class traits> + bool operator!=(const istreambuf_iterator<charT,traits>& a, + const istreambuf_iterator<charT,traits>& b); + + 24.5.3.1 Template class [lib.istreambuf.iterator::proxy] + istreambuf_iterator::proxy + + template <class charT, class traits = char_traits<charT> > +T class istreambuf_iterator<charT, traits>::proxy + { +T charT keep_; +T basic_streambuf<charT,traits>* sbuf_; +T proxy(charT c, + basic_streambuf<charT,traits>* sbuf); + : keep_(c), sbuf_(sbuf) {} + public: +T charT operator*() { return keep_; } + }; + + + + 24.5.4 Template class [lib.ostreambuf.iterator] + ostreambuf_iterator + + template <class charT, class traits = char_traits<charT> > +T class ostreambuf_iterator: + public iterator<output_iterator_tag, void, void, void, void> { + public: +T typedef charT char_type; +T typedef traits traits_type; +T typedef basic_streambuf<charT,traits> streambuf_type; +T typedef basic_ostream<charT,traits> 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 <algorithm> synopsis + + + // _lib.alg.nonmodifying_, non-modifying sequence operations: +T template<class InputIterator, class Function> + Function for_each(InputIterator first, InputIterator last, Function f); +T template<class InputIterator, class T> + InputIterator find(InputIterator first, InputIterator last, + const T& value); +T template<class InputIterator, class Predicate> + InputIterator find_if(InputIterator first, InputIterator last, + Predicate pred); +T template<class ForwardIterator1, class ForwardIterator2> + ForwardIterator1 + find_end(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2); +T template<class ForwardIterator1, class ForwardIterator2, + class BinaryPredicate> + ForwardIterator1 + find_end(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate pred); +T template<class ForwardIterator1, class ForwardIterator2> + ForwardIterator1 + find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2); +T template<class ForwardIterator1, class ForwardIterator2, + class BinaryPredicate> + ForwardIterator1 + find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate pred); +T template<class ForwardIterator> + ForwardIterator adjacent_find(ForwardIterator first, + ForwardIterator last); +T template<class ForwardIterator, class BinaryPredicate> + ForwardIterator adjacent_find(ForwardIterator first, + ForwardIterator last, BinaryPredicate pred); +T template<class InputIterator, class T> + typename iterator_traits<InputIterator>::difference_type + count(InputIterator first, InputIterator last, const T& value); +T template<class InputIterator, class Predicate> + typename iterator_traits<InputIterator>::difference_type + count_if(InputIterator first, InputIterator last, Predicate pred); +T template<class InputIterator1, class InputIterator2> + pair<InputIterator1, InputIterator2> + mismatch(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2); +T template<class InputIterator1, class InputIterator2, class BinaryPredicate> + pair<InputIterator1, InputIterator2> + mismatch(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, BinaryPredicate pred); + +T template<class InputIterator1, class InputIterator2> + bool equal(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2); +T template<class InputIterator1, class InputIterator2, class BinaryPredicate> + bool equal(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, BinaryPredicate pred); +T template<class ForwardIterator1, class ForwardIterator2> + ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2); +T template<class ForwardIterator1, class ForwardIterator2, + class BinaryPredicate> + ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1, + ForwardIterator2 first2, ForwardIterator2 last2, + BinaryPredicate pred); +T template<class ForwardIterator, class Size, class T> + ForwardIterator search_n(ForwardIterator first, ForwardIterator last, + Size count, const T& value); +T template<class ForwardIterator, class Size, class T, class BinaryPredicate> + 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<class InputIterator, class OutputIterator> + OutputIterator copy(InputIterator first, InputIterator last, + OutputIterator result); +T template<class BidirectionalIterator1, class BidirectionalIterator2> + BidirectionalIterator2 + copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last, + BidirectionalIterator2 result); + // _lib.alg.swap_, swap: +T template<class T> void swap(T& a, T& b); +T template<class ForwardIterator1, class ForwardIterator2> + ForwardIterator2 swap_ranges(ForwardIterator1 first1, + ForwardIterator1 last1, ForwardIterator2 first2); +T template<class ForwardIterator1, class ForwardIterator2> + void iter_swap(ForwardIterator1 a, ForwardIterator2 b); +T template<class InputIterator, class OutputIterator, class UnaryOperation> + OutputIterator transform(InputIterator first, InputIterator last, + OutputIterator result, UnaryOperation op); +T template<class InputIterator1, class InputIterator2, class OutputIterator, + class BinaryOperation> + OutputIterator transform(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, OutputIterator result, + BinaryOperation binary_op); + +T template<class ForwardIterator, class T> + void replace(ForwardIterator first, ForwardIterator last, + const T& old_value, const T& new_value); +T template<class ForwardIterator, class Predicate, class T> + void replace_if(ForwardIterator first, ForwardIterator last, + Predicate pred, const T& new_value); +T template<class InputIterator, class OutputIterator, class T> + OutputIterator replace_copy(InputIterator first, InputIterator last, + OutputIterator result, + const T& old_value, const T& new_value); +T template<class Iterator, class OutputIterator, class Predicate, class T> + OutputIterator replace_copy_if(Iterator first, Iterator last, + OutputIterator result, + Predicate pred, const T& new_value); +T template<class ForwardIterator, class T> + void fill(ForwardIterator first, ForwardIterator last, const T& value); +T template<class OutputIterator, class Size, class T> + void fill_n(OutputIterator first, Size n, const T& value); +T template<class ForwardIterator, class Generator> + void generate(ForwardIterator first, ForwardIterator last, Generator gen); +T template<class OutputIterator, class Size, class Generator> + void generate_n(OutputIterator first, Size n, Generator gen); +T template<class ForwardIterator, class T> + ForwardIterator remove(ForwardIterator first, ForwardIterator last, + const T& value); +T template<class ForwardIterator, class Predicate> + ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, + Predicate pred); +T template<class InputIterator, class OutputIterator, class T> + OutputIterator remove_copy(InputIterator first, InputIterator last, + OutputIterator result, const T& value); +T template<class InputIterator, class OutputIterator, class Predicate> + OutputIterator remove_copy_if(InputIterator first, InputIterator last, + OutputIterator result, Predicate pred); +T template<class ForwardIterator> + ForwardIterator unique(ForwardIterator first, ForwardIterator last); +T template<class ForwardIterator, class BinaryPredicate> + ForwardIterator unique(ForwardIterator first, ForwardIterator last, + BinaryPredicate pred); +T template<class InputIterator, class OutputIterator> + OutputIterator unique_copy(InputIterator first, InputIterator last, + OutputIterator result); +T template<class InputIterator, class OutputIterator, class BinaryPredicate> + OutputIterator unique_copy(InputIterator first, InputIterator last, + OutputIterator result, BinaryPredicate pred); +T template<class BidirectionalIterator> + void reverse(BidirectionalIterator first, BidirectionalIterator last); +T template<class BidirectionalIterator, class OutputIterator> + OutputIterator reverse_copy(BidirectionalIterator first, + BidirectionalIterator last, + OutputIterator result); + +T template<class ForwardIterator> + void rotate(ForwardIterator first, ForwardIterator middle, + ForwardIterator last); +T template<class ForwardIterator, class OutputIterator> + OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle, + ForwardIterator last, OutputIterator result); +T template<class RandomAccessIterator> + void random_shuffle(RandomAccessIterator first, + RandomAccessIterator last); +T template<class RandomAccessIterator, class RandomNumberGenerator> + void random_shuffle(RandomAccessIterator first, + RandomAccessIterator last, + RandomNumberGenerator& rand); + // _lib.alg.partitions_, partitions: +T template<class BidirectionalIterator, class Predicate> + BidirectionalIterator partition(BidirectionalIterator first, + BidirectionalIterator last, + Predicate pred); +T template<class BidirectionalIterator, class Predicate> + BidirectionalIterator stable_partition(BidirectionalIterator first, + BidirectionalIterator last, + Predicate pred); + // _lib.alg.sorting_, sorting and related operations: + // _lib.alg.sort_, sorting: +T template<class RandomAccessIterator> + void sort(RandomAccessIterator first, RandomAccessIterator last); +T template<class RandomAccessIterator, class Compare> + void sort(RandomAccessIterator first, RandomAccessIterator last, + Compare comp); +T template<class RandomAccessIterator> + void stable_sort(RandomAccessIterator first, RandomAccessIterator last); +T template<class RandomAccessIterator, class Compare> + void stable_sort(RandomAccessIterator first, RandomAccessIterator last, + Compare comp); +T template<class RandomAccessIterator> + void partial_sort(RandomAccessIterator first, + RandomAccessIterator middle, + RandomAccessIterator last); +T template<class RandomAccessIterator, class Compare> + void partial_sort(RandomAccessIterator first, + RandomAccessIterator middle, + RandomAccessIterator last, Compare comp); +T template<class InputIterator, class RandomAccessIterator> + RandomAccessIterator + partial_sort_copy(InputIterator first, InputIterator last, + RandomAccessIterator result_first, + RandomAccessIterator result_last); +T template<class InputIterator, class RandomAccessIterator, class Compare> + RandomAccessIterator + partial_sort_copy(InputIterator first, InputIterator last, + RandomAccessIterator result_first, + RandomAccessIterator result_last, + Compare comp); + +T template<class RandomAccessIterator> + void nth_element(RandomAccessIterator first, RandomAccessIterator nth, + RandomAccessIterator last); +T template<class RandomAccessIterator, class Compare> + void nth_element(RandomAccessIterator first, RandomAccessIterator nth, + RandomAccessIterator last, Compare comp); + // _lib.alg.binary.search_, binary search: +T template<class ForwardIterator, class T> + ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, + const T& value); +T template<class ForwardIterator, class T, class Compare> + ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, + const T& value, Compare comp); +T template<class ForwardIterator, class T> + ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, + const T& value); +T template<class ForwardIterator, class T, class Compare> + ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, + const T& value, Compare comp); +T template<class ForwardIterator, class T> + pair<ForwardIterator, ForwardIterator> + equal_range(ForwardIterator first, ForwardIterator last, + const T& value); +T template<class ForwardIterator, class T, class Compare> + pair<ForwardIterator, ForwardIterator> + equal_range(ForwardIterator first, ForwardIterator last, + const T& value, Compare comp); +T template<class ForwardIterator, class T> + bool binary_search(ForwardIterator first, ForwardIterator last, + const T& value); +T template<class ForwardIterator, class T, class Compare> + bool binary_search(ForwardIterator first, ForwardIterator last, + const T& value, Compare comp); + // _lib.alg.merge_, merge: +T template<class InputIterator1, class InputIterator2, class OutputIterator> + OutputIterator merge(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result); +T template<class InputIterator1, class InputIterator2, class OutputIterator, + class Compare> + OutputIterator merge(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result, Compare comp); +T template<class BidirectionalIterator> + void inplace_merge(BidirectionalIterator first, + BidirectionalIterator middle, + BidirectionalIterator last); +T template<class BidirectionalIterator, class Compare> + void inplace_merge(BidirectionalIterator first, + BidirectionalIterator middle, + BidirectionalIterator last, Compare comp); + + // _lib.alg.set.operations_, set operations: +T template<class InputIterator1, class InputIterator2> + bool includes(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2); +T template<class InputIterator1, class InputIterator2, class Compare> + bool includes(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, Compare comp); +T template<class InputIterator1, class InputIterator2, class OutputIterator> + OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result); +T template<class InputIterator1, class InputIterator2, class OutputIterator, + class Compare> + OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result, Compare comp); +T template<class InputIterator1, class InputIterator2, class OutputIterator> + OutputIterator set_intersection + (InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result); +T template<class InputIterator1, class InputIterator2, class OutputIterator, + class Compare> + OutputIterator set_intersection + (InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result, Compare comp); +T template<class InputIterator1, class InputIterator2, class OutputIterator> + OutputIterator set_difference + (InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result); +T template<class InputIterator1, class InputIterator2, class OutputIterator, + class Compare> + OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result, Compare comp); +T template<class InputIterator1, class InputIterator2, class OutputIterator> + OutputIterator + set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result); +T template<class InputIterator1, class InputIterator2, class OutputIterator, + class Compare> + OutputIterator + set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + OutputIterator result, Compare comp); + // _lib.alg.heap.operations_, heap operations: +T template<class RandomAccessIterator> + void push_heap(RandomAccessIterator first, RandomAccessIterator last); +T template<class RandomAccessIterator, class Compare> + void push_heap(RandomAccessIterator first, RandomAccessIterator last, + Compare comp); + +T template<class RandomAccessIterator> + void pop_heap(RandomAccessIterator first, RandomAccessIterator last); +T template<class RandomAccessIterator, class Compare> + void pop_heap(RandomAccessIterator first, RandomAccessIterator last, + Compare comp); +T template<class RandomAccessIterator> + void make_heap(RandomAccessIterator first, RandomAccessIterator last); +T template<class RandomAccessIterator, class Compare> + void make_heap(RandomAccessIterator first, RandomAccessIterator last, + Compare comp); +T template<class RandomAccessIterator> + void sort_heap(RandomAccessIterator first, RandomAccessIterator last); +T template<class RandomAccessIterator, class Compare> + void sort_heap(RandomAccessIterator first, RandomAccessIterator last, + Compare comp); + // _lib.alg.min.max_, minimum and maximum: +T template<class T> const T& min(const T& a, const T& b); +T template<class T, class Compare> + const T& min(const T& a, const T& b, Compare comp); +T template<class T> const T& max(const T& a, const T& b); +T template<class T, class Compare> + const T& max(const T& a, const T& b, Compare comp); +T template<class ForwardIterator> + ForwardIterator min_element(ForwardIterator first, ForwardIterator last); +T template<class ForwardIterator, class Compare> + ForwardIterator min_element(ForwardIterator first, ForwardIterator last, + Compare comp); +T template<class ForwardIterator> + ForwardIterator max_element(ForwardIterator first, ForwardIterator last); +T template<class ForwardIterator, class Compare> + ForwardIterator max_element(ForwardIterator first, ForwardIterator last, + Compare comp); +T template<class InputIterator1, class InputIterator2> + bool lexicographical_compare + (InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2); +T template<class InputIterator1, class InputIterator2, class Compare> + bool lexicographical_compare + (InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, InputIterator2 last2, + Compare comp); + + // _lib.alg.permutation.generators_, permutations +T template<class BidirectionalIterator> + bool next_permutation(BidirectionalIterator first, + BidirectionalIterator last); +T template<class BidirectionalIterator, class Compare> + bool next_permutation(BidirectionalIterator first, + BidirectionalIterator last, Compare comp); +T template<class BidirectionalIterator> + bool prev_permutation(BidirectionalIterator first, + BidirectionalIterator last); +T template<class BidirectionalIterator, class Compare> + bool prev_permutation(BidirectionalIterator first, + BidirectionalIterator last, Compare comp); + + + 25.4 C library algorithms [lib.alg.c.library] + + 1 Header <cstdlib> (partial, Table 2): + + Table 2--Header <cstdlib> 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 <complex> synopsis [lib.complex.synopsis] + +T template<class T> class complex; +T template<> class complex<float>; +T template<> class complex<double>; +T template<> class complex<long double>; + // _lib.complex.ops_ operators: +T template<class T> + complex<T> operator+(const complex<T>&, const complex<T>&); +T template<class T> complex<T> operator+(const complex<T>&, const T&); +T template<class T> complex<T> operator+(const T&, const complex<T>&); +T template<class T> complex<T> operator- + (const complex<T>&, const complex<T>&); +T template<class T> complex<T> operator-(const complex<T>&, const T&); +T template<class T> complex<T> operator-(const T&, const complex<T>&); +T template<class T> complex<T> operator* + (const complex<T>&, const complex<T>&); +T template<class T> complex<T> operator*(const complex<T>&, const T&); +T template<class T> complex<T> operator*(const T&, const complex<T>&); +T template<class T> complex<T> operator/ + (const complex<T>&, const complex<T>&); +T template<class T> complex<T> operator/(const complex<T>&, const T&); +T template<class T> complex<T> operator/(const T&, const complex<T>&); +T template<class T> complex<T> operator+(const complex<T>&); +T template<class T> complex<T> operator-(const complex<T>&); +T template<class T> bool operator== + (const complex<T>&, const complex<T>&); +T template<class T> bool operator==(const complex<T>&, const T&); +T template<class T> bool operator==(const T&, const complex<T>&); +T template<class T> bool operator!=(const complex<T>&, const complex<T>&); +T template<class T> bool operator!=(const complex<T>&, const T&); +T template<class T> bool operator!=(const T&, const complex<T>&); +T template<class T, class charT, class traits> + basic_istream<charT, traits>& + operator>>(basic_istream<charT, traits>&, complex<T>&); + +T template<class T, class charT, class traits> + basic_ostream<charT, traits>& + operator<<(basic_ostream<charT, traits>&, const complex<T>&); + // _lib.complex.value.ops_ values: +T template<class T> T real(const complex<T>&); +T template<class T> T imag(const complex<T>&); + +T template<class T> T abs(const complex<T>&); +T template<class T> T arg(const complex<T>&); +T template<class T> T norm(const complex<T>&); +T template<class T> complex<T> conj(const complex<T>&); +T template<class T> complex<T> polar(const T&, const T&); + // _lib.complex.transcendentals_ transcendentals: +T template<class T> complex<T> cos (const complex<T>&); +T template<class T> complex<T> cosh (const complex<T>&); +T template<class T> complex<T> exp (const complex<T>&); +T template<class T> complex<T> log (const complex<T>&); +T template<class T> complex<T> log10(const complex<T>&); +T template<class T> complex<T> pow(const complex<T>&, int); +T template<class T> complex<T> pow(const complex<T>&, const T&); +T template<class T> complex<T> pow(const complex<T>&, const complex<T>&); +T template<class T> complex<T> pow(const T&, const complex<T>&); +T template<class T> complex<T> sin (const complex<T>&); +T template<class T> complex<T> sinh (const complex<T>&); +T template<class T> complex<T> sqrt (const complex<T>&); +T template<class T> complex<T> tan (const complex<T>&); +T template<class T> complex<T> tanh (const complex<T>&); + } + + 26.2.2 Template class complex [lib.complex] + + template<class T> +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<class X> complex(const complex<X>&); + +T T real() const; +T T imag() const; + +T complex<T>& operator= (const T&); +T complex<T>& operator+=(const T&); +T complex<T>& operator-=(const T&); +T complex<T>& operator*=(const T&); +T complex<T>& operator/=(const T&); + +T complex& operator=(const complex&); +T template<class X> complex<T>& operator= (const complex<X>&); +T template<class X> complex<T>& operator+=(const complex<X>&); +T template<class X> complex<T>& operator-=(const complex<X>&); +T template<class X> complex<T>& operator*=(const complex<X>&); +T template<class X> complex<T>& operator/=(const complex<X>&); + }; + +T template<class T> complex<T> operator+ + (const complex<T>&, const complex<T>&); +T template<class T> complex<T> operator+(const complex<T>&, const T&); +T template<class T> complex<T> operator+(const T&, const complex<T>&); + +T template<class T> complex<T> operator- + (const complex<T>&, const complex<T>&); +T template<class T> complex<T> operator-(const complex<T>&, const T&); +T template<class T> complex<T> operator-(const T&, const complex<T>&); + +T template<class T> complex<T> operator* + (const complex<T>&, const complex<T>&); +T template<class T> complex<T> operator*(const complex<T>&, const T&); +T template<class T> complex<T> operator*(const T&, const complex<T>&); + +T template<class T> complex<T> operator/ + (const complex<T>&, const complex<T>&); +T template<class T> complex<T> operator/(const complex<T>&, const T&); +T template<class T> complex<T> operator/(const T&, const complex<T>&); + +T template<class T> complex<T> operator+(const complex<T>&); +T template<class T> complex<T> operator-(const complex<T>&); + +T template<class T> bool operator==(const complex<T>&, const complex<T>&); +T template<class T> bool operator==(const complex<T>&, const T&); +T template<class T> bool operator==(const T&, const complex<T>&); + +T template<class T> bool operator!=(const complex<T>&, const complex<T>&); +T template<class T> bool operator!=(const complex<T>&, const T&); +T template<class T> bool operator!=(const T&, const complex<T>&); + +T template<class T, class charT, class traits> + basic_istream<charT, traits>& + operator>>(basic_istream<charT, traits>&, complex<T>&); + +T template<class T, class charT, class traits> + basic_ostream<charT, traits>& + operator<<(basic_ostream<charT, traits>&, const complex<T>&); + + + 26.2.3 complex specializations [lib.complex.special] + +T template<> class complex<float> { + public: +T typedef float value_type; + +T complex(float re = 0.0f, float im = 0.0f); +T explicit complex(const complex<double>&); +T explicit complex(const complex<long double>&); +T float real() const; +T float imag() const; + +T complex<float>& operator= (float); +T complex<float>& operator+=(float); +T complex<float>& operator-=(float); +T complex<float>& operator*=(float); +T complex<float>& operator/=(float); + +T complex<float>& operator=(const complex<float>&); +T template<class X> complex<float>& operator= (const complex<X>&); +T template<class X> complex<float>& operator+=(const complex<X>&); +T template<class X> complex<float>& operator-=(const complex<X>&); +T template<class X> complex<float>& operator*=(const complex<X>&); +T template<class X> complex<float>& operator/=(const complex<X>&); + }; +T template<> class complex<double> { + public: +T typedef double value_type; + +T complex(double re = 0.0, double im = 0.0); +T complex(const complex<float>&); +T explicit complex(const complex<long double>&); +T double real() const; +T double imag() const; + +T complex<double>& operator= (double); +T complex<double>& operator+=(double); +T complex<double>& operator-=(double); +T complex<double>& operator*=(double); +T complex<double>& operator/=(double); + +T complex<double>& operator=(const complex<double>&); +T template<class X> complex<double>& operator= (const complex<X>&); +T template<class X> complex<double>& operator+=(const complex<X>&); +T template<class X> complex<double>& operator-=(const complex<X>&); +T template<class X> complex<double>& operator*=(const complex<X>&); +T template<class X> complex<double>& operator/=(const complex<X>&); + }; + +T template<> class complex<long double> { + public: +T typedef long double value_type; + +T complex(long double re = 0.0L, long double im = 0.0L); +T complex(const complex<float>&); +T complex(const complex<double>&); +T long double real() const; +T long double imag() const; + +T complex<long double>& operator=(const complex<long double>&); +T complex<long double>& operator= (long double); +T complex<long double>& operator+=(long double); +T complex<long double>& operator-=(long double); +T complex<long double>& operator*=(long double); +T complex<long double>& operator/=(long double); + +T template<class X> complex<long double>& operator= (const complex<X>&); +T template<class X> complex<long double>& operator+=(const complex<X>&); +T template<class X> complex<long double>& operator-=(const complex<X>&); +T template<class X> complex<long double>& operator*=(const complex<X>&); +T template<class X> complex<long double>& operator/=(const complex<X>&); + }; + + 26.3 Numeric arrays [lib.numarray] + + 26.3.1 Header <valarray> synopsis [lib.valarray.synopsis] + +T template<class T> class valarray; // An array of type T +T class slice; +T template<class T> class slice_array; +T class gslice; +T template<class T> class gslice_array; +T template<class T> class mask_array; // a masked array +T template<class T> class indirect_array; // an indirected array + +T template<class T> valarray<T> operator* + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator* (const valarray<T>&, const T&); +T template<class T> valarray<T> operator* (const T&, const valarray<T>&); +T template<class T> valarray<T> operator/ + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator/ (const valarray<T>&, const T&); +T template<class T> valarray<T> operator/ (const T&, const valarray<T>&); +T template<class T> valarray<T> operator% + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator% (const valarray<T>&, const T&); +T template<class T> valarray<T> operator% (const T&, const valarray<T>&); +T template<class T> valarray<T> operator+ + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator+ (const valarray<T>&, const T&); +T template<class T> valarray<T> operator+ (const T&, const valarray<T>&); +T template<class T> valarray<T> operator- + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator- (const valarray<T>&, const T&); +T template<class T> valarray<T> operator- (const T&, const valarray<T>&); +T template<class T> valarray<T> operator^ + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator^ (const valarray<T>&, const T&); +T template<class T> valarray<T> operator^ (const T&, const valarray<T>&); +T template<class T> valarray<T> operator& + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator& (const valarray<T>&, const T&); +T template<class T> valarray<T> operator& (const T&, const valarray<T>&); +T template<class T> valarray<T> operator| + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator| (const valarray<T>&, const T&); +T template<class T> valarray<T> operator| (const T&, const valarray<T>&); +T template<class T> valarray<T> operator<< + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator<<(const valarray<T>&, const T&); +T template<class T> valarray<T> operator<<(const T&, const valarray<T>&); +T template<class T> valarray<T> operator>> + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> operator>>(const valarray<T>&, const T&); +T template<class T> valarray<T> operator>>(const T&, const valarray<T>&); +T template<class T> valarray<bool> operator&& + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<bool> operator&&(const valarray<T>&, const T&); +T template<class T> valarray<bool> operator&&(const T&, const valarray<T>&); +T template<class T> valarray<bool> operator|| + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<bool> operator||(const valarray<T>&, const T&); +T template<class T> valarray<bool> operator||(const T&, const valarray<T>&); + +T template<class T> + valarray<bool> operator==(const valarray<T>&, const valarray<T>&); +T template<class T> valarray<bool> operator==(const valarray<T>&, const T&); +T template<class T> valarray<bool> operator==(const T&, const valarray<T>&); +T template<class T> + valarray<bool> operator!=(const valarray<T>&, const valarray<T>&); +T template<class T> valarray<bool> operator!=(const valarray<T>&, const T&); +T template<class T> valarray<bool> operator!=(const T&, const valarray<T>&); +T template<class T> + valarray<bool> operator< (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<bool> operator< (const valarray<T>&, const T&); +T template<class T> valarray<bool> operator< (const T&, const valarray<T>&); +T template<class T> + valarray<bool> operator> (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<bool> operator> (const valarray<T>&, const T&); +T template<class T> valarray<bool> operator> (const T&, const valarray<T>&); +T template<class T> + valarray<bool> operator<=(const valarray<T>&, const valarray<T>&); +T template<class T> valarray<bool> operator<=(const valarray<T>&, const T&); +T template<class T> valarray<bool> operator<=(const T&, const valarray<T>&); +T template<class T> + valarray<bool> operator>=(const valarray<T>&, const valarray<T>&); +T template<class T> valarray<bool> operator>=(const valarray<T>&, const T&); +T template<class T> valarray<bool> operator>=(const T&, const valarray<T>&); +T template<class T> valarray<T> abs (const valarray<T>&); +T template<class T> valarray<T> acos (const valarray<T>&); +T template<class T> valarray<T> asin (const valarray<T>&); +T template<class T> valarray<T> atan (const valarray<T>&); +T template<class T> valarray<T> atan2 + (const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> atan2(const valarray<T>&, const T&); +T template<class T> valarray<T> atan2(const T&, const valarray<T>&); +T template<class T> valarray<T> cos (const valarray<T>&); +T template<class T> valarray<T> cosh (const valarray<T>&); +T template<class T> valarray<T> exp (const valarray<T>&); +T template<class T> valarray<T> log (const valarray<T>&); +T template<class T> valarray<T> log10(const valarray<T>&); +T template<class T> valarray<T> pow(const valarray<T>&, const valarray<T>&); +T template<class T> valarray<T> pow(const valarray<T>&, const T&); +T template<class T> valarray<T> pow(const T&, const valarray<T>&); +T template<class T> valarray<T> sin (const valarray<T>&); +T template<class T> valarray<T> sinh (const valarray<T>&); +T template<class T> valarray<T> sqrt (const valarray<T>&); +T template<class T> valarray<T> tan (const valarray<T>&); +T template<class T> valarray<T> tanh (const valarray<T>&); + } + + + 26.3.2 Template class valarray [lib.template.valarray] + +T template<class T> 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>&); +T valarray(const gslice_array<T>&); +T valarray(const mask_array<T>&); +T valarray(const indirect_array<T>&); +T ~valarray(); + + // _lib.valarray.assign_ assignment: +T valarray<T>& operator=(const valarray<T>&); +T valarray<T>& operator=(const T&); +T valarray<T>& operator=(const slice_array<T>&); +T valarray<T>& operator=(const gslice_array<T>&); +T valarray<T>& operator=(const mask_array<T>&); +T valarray<T>& operator=(const indirect_array<T>&); + // _lib.valarray.access_ element access: +T T operator[](size_t) const; +T T& operator[](size_t); + // _lib.valarray.sub_ subset operations: +T valarray<T> operator[](slice) const; +T slice_array<T> operator[](slice); +T valarray<T> operator[](const gslice&) const; +T gslice_array<T> operator[](const gslice&); +T valarray<T> operator[](const valarray<bool>&) const; +T mask_array<T> operator[](const valarray<bool>&); +T valarray<T> operator[](const valarray<size_t>&) const; +T indirect_array<T> operator[](const valarray<size_t>&); + // _lib.valarray.unary_ unary operators: +T valarray<T> operator+() const; +T valarray<T> operator-() const; +T valarray<T> operator~() const; +T valarray<T> operator!() const; + // _lib.valarray.cassign_ computed assignment: +T valarray<T>& operator*= (const T&); +T valarray<T>& operator/= (const T&); +T valarray<T>& operator%= (const T&); +T valarray<T>& operator+= (const T&); +T valarray<T>& operator-= (const T&); +T valarray<T>& operator^= (const T&); +T valarray<T>& operator&= (const T&); +T valarray<T>& operator|= (const T&); +T valarray<T>& operator<<=(const T&); +T valarray<T>& operator>>=(const T&); +T valarray<T>& operator*= (const valarray<T>&); +T valarray<T>& operator/= (const valarray<T>&); +T valarray<T>& operator%= (const valarray<T>&); +T valarray<T>& operator+= (const valarray<T>&); +T valarray<T>& operator-= (const valarray<T>&); +T valarray<T>& operator^= (const valarray<T>&); +T valarray<T>& operator|= (const valarray<T>&); +T valarray<T>& operator&= (const valarray<T>&); +T valarray<T>& operator<<=(const valarray<T>&); +T valarray<T>& operator>>=(const valarray<T>&); + // _lib.valarray.members_ member functions: +T size_t size() const; +T T sum() const; +T T min() const; +T T max() const; + +T valarray<T> shift (int) const; +T valarray<T> cshift(int) const; +T valarray<T> apply(T func(T)) const; +T valarray<T> 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 T> class slice_array { + public: +T typedef T value_type; + +T void operator= (const valarray<T>&) const; +T void operator*= (const valarray<T>&) const; +T void operator/= (const valarray<T>&) const; +T void operator%= (const valarray<T>&) const; +T void operator+= (const valarray<T>&) const; +T void operator-= (const valarray<T>&) const; +T void operator^= (const valarray<T>&) const; +T void operator&= (const valarray<T>&) const; +T void operator|= (const valarray<T>&) const; +T void operator<<=(const valarray<T>&) const; +T void operator>>=(const valarray<T>&) 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<size_t>& l, const valarray<size_t>& d); + +T size_t start() const; +T valarray<size_t> size() const; +T valarray<size_t> stride() const; + }; + + + 26.3.7 Template class gslice_array [lib.template.gslice.array] + +T template <class T> class gslice_array { + public: +T typedef T value_type; + +T void operator= (const valarray<T>&) const; +T void operator*= (const valarray<T>&) const; +T void operator/= (const valarray<T>&) const; +T void operator%= (const valarray<T>&) const; +T void operator+= (const valarray<T>&) const; +T void operator-= (const valarray<T>&) const; +T void operator^= (const valarray<T>&) const; +T void operator&= (const valarray<T>&) const; +T void operator|= (const valarray<T>&) const; +T void operator<<=(const valarray<T>&) const; +T void operator>>=(const valarray<T>&) 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 T> class mask_array { + public: +T typedef T value_type; + +T void operator= (const valarray<T>&) const; +T void operator*= (const valarray<T>&) const; +T void operator/= (const valarray<T>&) const; +T void operator%= (const valarray<T>&) const; +T void operator+= (const valarray<T>&) const; +T void operator-= (const valarray<T>&) const; +T void operator^= (const valarray<T>&) const; +T void operator&= (const valarray<T>&) const; +T void operator|= (const valarray<T>&) const; +T void operator<<=(const valarray<T>&) const; +T void operator>>=(const valarray<T>&) 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 T> class indirect_array { + public: +T typedef T value_type; + +T void operator= (const valarray<T>&) const; +T void operator*= (const valarray<T>&) const; +T void operator/= (const valarray<T>&) const; +T void operator%= (const valarray<T>&) const; +T void operator+= (const valarray<T>&) const; +T void operator-= (const valarray<T>&) const; +T void operator^= (const valarray<T>&) const; +T void operator&= (const valarray<T>&) const; +T void operator|= (const valarray<T>&) const; +T void operator<<=(const valarray<T>&) const; +T void operator>>=(const valarray<T>&) 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 <numeric> synopsis + +T template <class InputIterator, class T> + T accumulate(InputIterator first, InputIterator last, T init); + +T template <class InputIterator, class T, class BinaryOperation> + T accumulate(InputIterator first, InputIterator last, T init, + BinaryOperation binary_op); + +T template <class InputIterator1, class InputIterator2, class T> + T inner_product(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, T init); + +T template <class InputIterator1, class InputIterator2, class T, + class BinaryOperation1, class BinaryOperation2> + T inner_product(InputIterator1 first1, InputIterator1 last1, + InputIterator2 first2, T init, + BinaryOperation1 binary_op1, + BinaryOperation2 binary_op2); + +T template <class InputIterator, class OutputIterator> + OutputIterator partial_sum(InputIterator first, + InputIterator last, + OutputIterator result); + +T template <class InputIterator, class OutputIterator, + class BinaryOperation> + OutputIterator partial_sum(InputIterator first, + InputIterator last, + OutputIterator result, + BinaryOperation binary_op); + +T template <class InputIterator, class OutputIterator> + OutputIterator adjacent_difference(InputIterator first, + InputIterator last, + OutputIterator result); + +T template <class InputIterator, class OutputIterator, + class BinaryOperation> + OutputIterator adjacent_difference(InputIterator first, + InputIterator last, + OutputIterator result, + BinaryOperation binary_op); + + + 26.5 C Library [lib.c.math] + + Table 2--Header <cmath> 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 <cstdlib> 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 <iosfwd> synopsis + +X template<class charT> class char_traits; +X template<> class char_traits<char>; +X template<> class char_traits<wchar_t>; +X template<class T> class allocator; +X template <class charT, class traits = char_traits<charT> > + class basic_ios; + +X template <class charT, class traits = char_traits<charT> > + class basic_streambuf; + +X template <class charT, class traits = char_traits<charT> > + class basic_istream; + +X template <class charT, class traits = char_traits<charT> > + class basic_ostream; + +X template <class charT, class traits = char_traits<charT> > + class basic_iostream; + +X template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > + class basic_stringbuf; + +X template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > + class basic_istringstream; + +X template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > + class basic_ostringstream; + +X template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > + class basic_stringstream; + +X template <class charT, class traits = char_traits<charT> > + class basic_filebuf; + +X template <class charT, class traits = char_traits<charT> > + class basic_ifstream; + +X template <class charT, class traits = char_traits<charT> > + class basic_ofstream; + +X template <class charT, class traits = char_traits<charT> > + class basic_fstream; +X template <class charT, class traits = char_traits<charT> > + class istreambuf_iterator; + +X template <class charT, class traits = char_traits<charT> > + class ostreambuf_iterator; +X typedef basic_ios<char> ios; +X typedef basic_ios<wchar_t> wios; +X typedef basic_streambuf<char> streambuf; +X typedef basic_istream<char> istream; +X typedef basic_ostream<char> ostream; +X typedef basic_iostream<char> iostream; +X typedef basic_stringbuf<char> stringbuf; +X typedef basic_istringstream<char> istringstream; +X typedef basic_ostringstream<char> ostringstream; +X typedef basic_stringstream<char> stringstream; +X typedef basic_filebuf<char> filebuf; +X typedef basic_ifstream<char> ifstream; +X typedef basic_ofstream<char> ofstream; +X typedef basic_fstream<char> fstream; +X typedef basic_streambuf<wchar_t> wstreambuf; +X typedef basic_istream<wchar_t> wistream; +X typedef basic_ostream<wchar_t> wostream; +X typedef basic_iostream<wchar_t> wiostream; +X typedef basic_stringbuf<wchar_t> wstringbuf; +X typedef basic_istringstream<wchar_t> wistringstream; +X typedef basic_ostringstream<wchar_t> wostringstream; +X typedef basic_stringstream<wchar_t> wstringstream; + +X typedef basic_filebuf<wchar_t> wfilebuf; +X typedef basic_ifstream<wchar_t> wifstream; +X typedef basic_ofstream<wchar_t> wofstream; +X typedef basic_fstream<wchar_t> wfstream; +X template <class state> class fpos; +X typedef fpos<char_traits<char>::state_type> streampos; +X typedef fpos<char_traits<wchar_t>::state_type> wstreampos; + + 27.3 Standard iostream objects [lib.iostream.objects] + + Header <iostream> synopsis + +T [must also include <istream> and <ostream>] +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 <ios> synopsis + + #include <iosfwd> + +T typedef OFF_T streamoff; +T typedef SZ_T streamsize; +T template <class stateT> class fpos; + + class ios_base; + template <class charT, class traits = char_traits<charT> > + 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 stateT> 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 <class charT, class traits = char_traits<charT> > +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<charT,traits>* sb); +T virtual ~basic_ios(); + // _lib.basic.ios.members_ Members: +T basic_ostream<charT,traits>* tie() const; +T basic_ostream<charT,traits>* tie(basic_ostream<charT,traits>* tiestr); +T basic_streambuf<charT,traits>* rdbuf() const; +T basic_streambuf<charT,traits>* rdbuf(basic_streambuf<charT,traits>* 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<charT,traits>* 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 <streambuf> synopsis + +X template <class charT, class traits = char_traits<charT> > + class basic_streambuf; +T typedef basic_streambuf<char> streambuf; +T typedef basic_streambuf<wchar_t> wstreambuf; + + 27.5.2 Template class [lib.streambuf] + basic_streambuf<charT,traits> + + template <class charT, class traits = char_traits<charT> > +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<char_type,traits>* + 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<char_type,traits>* + 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 <istream> synopsis + +T template <class charT, class traits = char_traits<charT> > + class basic_istream; +T typedef basic_istream<char> istream; +T typedef basic_istream<wchar_t> wistream; + +T template <class charT, class traits = char_traits<charT> > + class basic_iostream; +T typedef basic_iostream<char> iostream; +T typedef basic_iostream<wchar_t> wiostream; + +X template <class charT, class traits> + basic_istream<charT,traits>& ws(basic_istream<charT,traits>& is); + + Header <ostream> synopsis + +X template <class charT, class traits = char_traits<charT> > + class basic_ostream; +T typedef basic_ostream<char> ostream; +T typedef basic_ostream<wchar_t> wostream; + +T template <class charT, class traits> + basic_ostream<charT,traits>& endl(basic_ostream<charT,traits>& os); +T template <class charT, class traits> + basic_ostream<charT,traits>& ends(basic_ostream<charT,traits>& os); +T template <class charT, class traits> + basic_ostream<charT,traits>& flush(basic_ostream<charT,traits>& os); + + Header <iomanip> 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<charT> 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 <class charT, class traits = char_traits<charT> > +T class basic_istream : virtual public basic_ios<charT,traits> { + 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<charT,traits>* sb); +T virtual ~basic_istream(); + // _lib.istream::sentry_ Prefix/suffix: +T class sentry; + + // _lib.istream.formatted_ Formatted input: +T basic_istream<charT,traits>& operator>> + (basic_istream<charT,traits>& (*pf)(basic_istream<charT,traits>&)) +T basic_istream<charT,traits>& operator>> + (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&)) +T basic_istream<charT,traits>& operator>> + (ios_base& (*pf)(ios_base&)) +S basic_istream<charT,traits>& operator>>(bool& n); +S basic_istream<charT,traits>& operator>>(short& n); +S basic_istream<charT,traits>& operator>>(unsigned short& n); +S basic_istream<charT,traits>& operator>>(int& n); +S basic_istream<charT,traits>& operator>>(unsigned int& n); +S basic_istream<charT,traits>& operator>>(long& n); +S basic_istream<charT,traits>& operator>>(unsigned long& n); +S basic_istream<charT,traits>& operator>>(float& f); +S basic_istream<charT,traits>& operator>>(double& f); +S basic_istream<charT,traits>& operator>>(long double& f); +S basic_istream<charT,traits>& operator>>(void*& p); +S basic_istream<charT,traits>& operator>> + (basic_streambuf<char_type,traits>* sb); + // _lib.istream.unformatted_ Unformatted input: +T streamsize gcount() const; +S int_type get(); +S basic_istream<charT,traits>& get(char_type& c); +S basic_istream<charT,traits>& get(char_type* s, streamsize n); +S basic_istream<charT,traits>& get(char_type* s, streamsize n, + char_type delim); +S basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb); +S basic_istream<charT,traits>& get(basic_streambuf<char_type,traits>& sb, + char_type delim); +S basic_istream<charT,traits>& getline(char_type* s, streamsize n); +S basic_istream<charT,traits>& getline(char_type* s, streamsize n, + char_type delim); +S basic_istream<charT,traits>& ignore + (streamsize n = 1, int_type delim = traits::eof()); +S int_type peek(); +S basic_istream<charT,traits>& read (char_type* s, streamsize n); +S streamsize readsome(char_type* s, streamsize n); +S basic_istream<charT,traits>& putback(char_type c); +S basic_istream<charT,traits>& unget(); +S int sync(); + +S pos_type tellg(); +S basic_istream<charT,traits>& seekg(pos_type); +S basic_istream<charT,traits>& seekg(off_type, ios_base::seekdir); + }; + + // _lib.istream::extractors_ character extraction templates: +S template<class charT, class traits> + basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, + charT&); +S template<class traits> + basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, + unsigned char&); +S template<class traits> + basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, + signed char&); + +S template<class charT, class traits> + basic_istream<charT,traits>& operator>>(basic_istream<charT,traits>&, + charT*); +S template<class traits> + basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, + unsigned char*); +S template<class traits> + basic_istream<char,traits>& operator>>(basic_istream<char,traits>&, + signed char*); + + 27.6.1.1.2 Class basic_istream::sentry [lib.istream::sentry] + + + template <class charT,class traits = char_traits<charT> > +S class basic_istream<charT,traits>::sentry { + typedef traits traits_type; +S bool ok_; // exposition only + public: +S explicit sentry(basic_istream<charT,traits>& 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 <class charT, class traits = char_traits<charT> > +T class basic_iostream : + public basic_istream<charT,traits>, + public basic_ostream<charT,traits> { + public: + // constructor/destructor +T explicit basic_iostream(basic_streambuf<charT,traits>* sb); +T virtual ~basic_iostream(); + }; + + + 27.6.2.1 Template class basic_ostream [lib.ostream] + + template <class charT, class traits = char_traits<charT> > +X class basic_ostream : virtual public basic_ios<charT,traits> { + 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<char_type,traits>* sb); +T virtual ~basic_ostream(); + // _lib.ostream::sentry_ Prefix/suffix: +T class sentry; + // _lib.ostream.formatted_ Formatted output: +T basic_ostream<charT,traits>& operator<< + (basic_ostream<charT,traits>& (*pf)(basic_ostream<charT,traits>&)); +T basic_ostream<charT,traits>& operator<< + (basic_ios<charT,traits>& (*pf)(basic_ios<charT,traits>&)); +T basic_ostream<charT,traits>& operator<< + (ios_base& (*pf)(ios_base&)); +T basic_ostream<charT,traits>& operator<<(bool n); +T basic_ostream<charT,traits>& operator<<(short n); +T basic_ostream<charT,traits>& operator<<(unsigned short n); +T basic_ostream<charT,traits>& operator<<(int n); +T basic_ostream<charT,traits>& operator<<(unsigned int n); +T basic_ostream<charT,traits>& operator<<(long n); +T basic_ostream<charT,traits>& operator<<(unsigned long n); +S basic_ostream<charT,traits>& operator<<(float f); +S basic_ostream<charT,traits>& operator<<(double f); +S basic_ostream<charT,traits>& operator<<(long double f); +T basic_ostream<charT,traits>& operator<<(const void* p); +X basic_ostream<charT,traits>& operator<< + (basic_streambuf<char_type,traits>* sb); + // _lib.ostream.unformatted_ Unformatted output: +T basic_ostream<charT,traits>& put(char_type c); +T basic_ostream<charT,traits>& write(const char_type* s, streamsize n); +X basic_ostream<charT,traits>& flush(); + + // _lib.ostream.seeks_ seeks: +S pos_type tellp(); +S basic_ostream<charT,traits>& seekp(pos_type); +S basic_ostream<charT,traits>& seekp(off_type, ios_base::seekdir); + }; + // _lib.ostream.inserters.character_ character inserters +X template<class charT, class traits> + basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, + charT); +X template<class charT, class traits> + basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, + char); + // specialization +X template<class traits> + basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, + char); + // signed and unsigned +X template<class traits> + basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, + signed char); +X template<class traits> + basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, + unsigned char) +X template<class charT, class traits> + basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, + const charT*); +X template<class charT, class traits> + basic_ostream<charT,traits>& operator<<(basic_ostream<charT,traits>&, + const char*); + // partial specializationss +X template<class traits> + basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, + const char*); + // signed and unsigned +X template<class traits> + basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, + const signed char*); +X template<class traits> + basic_ostream<char,traits>& operator<<(basic_ostream<char,traits>&, + const unsigned char*); + + + 27.6.2.3 Class basic_ostream::sentry [lib.ostream::sentry] + + template <class charT,class traits = char_traits<charT> > +X class basic_ostream<charT,traits>::sentry { + bool ok_; // exposition only + public: +X explicit sentry(basic_ostream<charT,traits>& 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 <sstream> synopsis + +X template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > + class basic_stringbuf; + +T typedef basic_stringbuf<char> stringbuf; +T typedef basic_stringbuf<wchar_t> wstringbuf; + + template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > +X class basic_istringstream; + +T typedef basic_istringstream<char> istringstream; +T typedef basic_istringstream<wchar_t> wistringstream; + + template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > +X class basic_ostringstream; +T typedef basic_ostringstream<char> ostringstream; +T typedef basic_ostringstream<wchar_t> wostringstream; + + template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > +X class basic_stringstream; +T typedef basic_stringstream<char> stringstream; +T typedef basic_stringstream<wchar_t> wstringstream; + + 27.7.1 Template class basic_stringbuf [lib.stringbuf] + + template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > +X class basic_stringbuf : public basic_streambuf<charT,traits> { + 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<charT,traits,Allocator>& str, + ios_base::openmode which = ios_base::in | ios_base::out); + // _lib.stringbuf.members_ Get and set: +S basic_string<charT,traits,Allocator> str() const; +S void str(const basic_string<charT,traits,Allocator>& 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<charT,traits>* 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 charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > +X class basic_istringstream : public basic_istream<charT,traits> { + 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<charT,traits,Allocator>& str, + ios_base::openmode which = ios_base::in); + + // _lib.istringstream.members_ Members: +S basic_stringbuf<charT,traits,Allocator>* rdbuf() const; +S basic_string<charT,traits,Allocator> str() const; +S void str(const basic_string<charT,traits,Allocator>& s); + private: + // basic_stringbuf<charT,traits,Allocator> sb; exposition only + }; + + 27.7.3 Class basic_ostringstream [lib.ostringstream] + + template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > +X class basic_ostringstream : public basic_ostream<charT,traits> { + 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<charT,traits,Allocator>& str, + ios_base::openmode which = ios_base::out); + // _lib.ostringstream.members_ Members: +S basic_stringbuf<charT,traits,Allocator>* rdbuf() const; +S basic_string<charT,traits,Allocator> str() const; +S void str(const basic_string<charT,traits,Allocator>& s); + }; + + + 27.7.4 Template class basic_stringstream [lib.stringstream] + + template <class charT, class traits = char_traits<charT>, + class Allocator = allocator<charT> > +X class basic_stringstream + : public basic_iostream<charT,traits> { + 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<charT,traits,Allocator>& str, + ios_base::openmode which = ios_base::out|ios_base::in); + // Members: +S basic_stringbuf<charT,traits,Allocator>* rdbuf() const; +S basic_string<charT,traits,Allocator> str() const; +S void str(const basic_string<charT,traits,Allocator>& str); + }; + + + + 27.8.1 File streams [lib.fstreams] + + + Header <fstream> synopsis + +X template <class charT, class traits = char_traits<charT> > + class basic_filebuf; +T typedef basic_filebuf<char> filebuf; +T typedef basic_filebuf<wchar_t> wfilebuf; + +X template <class charT, class traits = char_traits<charT> > + class basic_ifstream; +T typedef basic_ifstream<char> ifstream; +T typedef basic_ifstream<wchar_t> wifstream; + +X template <class charT, class traits = char_traits<charT> > + class basic_ofstream; +T typedef basic_ofstream<char> ofstream; +T typedef basic_ofstream<wchar_t> wofstream; + +X template <class charT, class traits = char_traits<charT> > + class basic_fstream; +T typedef basic_fstream<char> fstream; +T typedef basic_fstream<wchar_t> wfstream; + + 27.8.1.1 Template class basic_filebuf [lib.filebuf] + + template <class charT, class traits = char_traits<charT> > +X class basic_filebuf : public basic_streambuf<charT,traits> { + 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<charT,traits>* open + (const char* s, ios_base::openmode mode); +X basic_filebuf<charT,traits>* 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<charT,traits>* + 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 <class charT, class traits = char_traits<charT> > +X class basic_ifstream : public basic_istream<charT,traits> { + 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<charT,traits>* 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 <class charT, class traits = char_traits<charT> > +X class basic_ofstream : public basic_ostream<charT,traits> { + 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<charT,traits>* 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 <class charT, class traits=char_traits<charT> > +X class basic_fstream + : public basic_iostream<charT,traits> { + 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<charT,traits>* 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 <cstdio> synopsis + Macros: +X BUFSIZ L_tmpnam SEEK_SET TMP_MAX +X EOF NULL <cstdio> stderr _IOFBF +X FILENAME_MAX SEEK_CUR stdin _IOLBF +X FOPEN_MAX SEEK_END stdout _IONBF + +X Types: FILE fpos_t size_t <cstdio> + 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 <assert.h> <iso646.h> <setjmp.h> <stdio.h> <wchar.h> + <ctype.h> <limits.h> <signal.h> <stdlib.h> <wctype.h> + <errno.h> <locale.h> <stdarg.h> <string.h> + <float.h> <math.h> <stddef.h> <time.h> + + 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 charT, class traits = char_traits<charT> > + 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 charT, class Traits> 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 charT, class traits = char_traits<charT> > + 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 charT, class traits = char_traits<charT> > + class basic_filebuf : public basic_streambuf<charT,traits> { + public: +M basic_filebuf<charT,traits>* open + (const char* s, ios_base::open_mode mode); + // remainder unchanged + }; + template <class charT, class traits = char_traits<charT> > + class basic_ifstream : public basic_istream<charT,traits> { + public: +M void open(const char* s, ios_base::open_mode mode = in); + // remainder unchanged + }; + template <class charT, class traits = char_traits<charT> > + class basic_ofstream : public basic_ostream<charT,traits> { + 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<char> { + 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<char>* setbuf(char* s, streamsize n); + } + + 1.7.4 Class strstream [depr.strstream] + +M class strstream + : public basic_iostream<char> { + public: + // Types +M typedef char char_type; +M typedef typename char_traits<char>::int_type int_type +M typedef typename char_traits<char>::pos_type pos_type; +M typedef typename char_traits<char>::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(); + }; + |