Completion Checklist for the Standard C++ Library Updated: 2003-04-25 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: http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-toc.html Detailed explanation of status codes: M - Missing: The name is not visible to programs that include the specified header, either at compile or link stage. S - Present as stub: A program can use the name, but no implementation is provided. Programs that use the name link correctly, but cannot usefully be run. X - Partially implemented, or buggy: Some implementation has been provided, but it is known or believed not to conform fully. It may have an incorrect base class, wrong namespace, wrong storage class, or simply not fully implement requirements. However, it may be sufficiently usable to help test other components. T - Implemented, pending test/inspection: Implementation believed to be complete, and informal testing suggests it is ready for formal verification. V - Verified, passes all test suites: Verified to satisfy all generically testable conformance requirements. Q - Qualified by inspection for non-testable correctness: Inspected, "implementation-defined" documentation accepted, local usability criteria satisfied, formally inspected for other untestable conformance. (Untestable requirements include exception-safety, thread-safety, worst-case complexity, memory cleanliness, usefulness.) P - Portability verified: Qualified on all primary target platforms. C - Certified: Formally certified to have passed all tests, inspections, qualifications; approved under "signing authority" to be used to satisfy contractual guarantees. ---------------------------------------------------------------------- X [C header names must be in std:: to qualify. Related to shadow/ dir.] X Macro: X errno, declared or defined in . Macro fn: X setjmp(jmp_buf), declared or defined in X va_end(va_list), declared or defined in Types: X clock_t, div_t, FILE, fpos_t, lconv, ldiv_t, mbstate_t, X ptrdiff_t, sig_atomic_t, size_t, time_t, tm, va_list, X wctrans_t, wctype_t, and wint_t. 1 Which of the functions in the C++ Standard Library are not reentrant subroutines is implementation-defined. 18.1 Types [lib.support.types] X X NULL X offsetof X ptrdiff_t X size_t 18.2 Implementation properties [lib.support.limits] , , and 18.2.1 Numeric limits [lib.limits] X template class numeric_limits; T enum float_round_style; T enum float_denorm_style; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; T template<> class numeric_limits; X template<> class numeric_limits; X template<> class numeric_limits; X template<> class numeric_limits; 18.2.1.1 Template class numeric_limits [lib.numeric.limits] T template class numeric_limits { public: T static const bool is_specialized = false; T static T min() throw(); T static T max() throw(); T static const int digits = 0; T static const int digits10 = 0; T static const bool is_signed = false; T static const bool is_integer = false; T static const bool is_exact = false; T static const int radix = 0; T static T epsilon() throw(); T static T round_error() throw(); T static const int min_exponent = 0; T static const int min_exponent10 = 0; T static const int max_exponent = 0; T static const int max_exponent10 = 0; T static const bool has_infinity = false; T static const bool has_quiet_NaN = false; T static const bool has_signaling_NaN = false; T static const float_denorm_style has_denorm = denorm_absent; T static const bool has_denorm_loss = false; T static T infinity() throw(); T static T quiet_NaN() throw(); T static T signaling_NaN() throw(); T static T denorm_min() throw(); T static const bool is_iec559 = false; T static const bool is_bounded = false; T static const bool is_modulo = false; T static const bool traps = false; T static const bool tinyness_before = false; T static const float_round_style round_style = round_toward_zero; }; 18.2.1.3 Type float_round_style [lib.round.style] T enum float_round_style { T round_indeterminate = -1, T round_toward_zero = 0, T round_to_nearest = 1, T round_toward_infinity = 2, T round_toward_neg_infinity = 3 }; 18.2.1.4 Type float_denorm_style [lib.denorm.style] T enum float_denorm_style { T denorm_indeterminate = -1; T denorm_absent = 0; T denorm present = 1; }; 18.2.1.5 numeric_limits specializations [lib.numeric.special] [Note: see Note at 18.2.1. ] 18.2.2 C Library [lib.c.limits] 1 Header (Table 3): CHAR_BIT INT_MAX LONG_MIN SCHAR_MIN UCHAR_MAX USHRT_MAX X CHAR_MAX INT_MIN MB_LEN_MAX SHRT_MAX UINT_MAX CHAR_MIN LONG_MAX SCHAR_MAX SHRT_MIN ULONG_MAX 3 Header (Table 4): DBL_DIG DBL_MIN_EXP FLT_MIN_10_EXP LDBL_MAX_10_EXP DBL_EPSILON FLT_DIG FLT_MIN_EXP LDBL_MAX_EXP DBL_MANT_DIG FLT_EPSILON FLT_RADIX LDBL_MIN X DBL_MAX FLT_MANT_DIG FLT_ROUNDS LDBL_MIN_10_EXP DBL_MAX_10_EXP FLT_MAX LDBL_DIG LDBL_MIN_EXP DBL_MAX_EXP FLT_MAX_10_EXP LDBL_EPSILON DBL_MIN FLT_MAX_EXP LDBL_MANT_DIG DBL_MIN_10_EXP FLT_MIN LDBL_MAX 1 Header (partial), Table 5: X EXIT_FAILURE EXIT_SUCCESS abort atexit exit S abort(void) S extern "C" int atexit(void (*f)(void)) S extern "C++" int atexit(void (*f)(void)) S exit(int status) 18.4 Dynamic memory management [lib.support.dynamic] Header synopsis T class bad_alloc; T struct nothrow_t {}; T extern const nothrow_t nothrow; T typedef void (*new_handler)(); T new_handler set_new_handler(new_handler new_p) throw(); T void* operator new(std::size_t size) throw(std::bad_alloc); T void* operator new(std::size_t size, const std::nothrow_t&) throw(); T void operator delete(void* ptr) throw(); T void operator delete(void* ptr, const std::nothrow_t&) throw(); T void* operator new[](std::size_t size) throw(std::bad_alloc); T void* operator new[](std::size_t size, const std::nothrow_t&) throw(); T void operator delete[](void* ptr) throw(); T void operator delete[](void* ptr, const std::nothrow_t&) throw(); T void* operator new (std::size_t size, void* ptr) throw(); T void* operator new[](std::size_t size, void* ptr) throw(); T void operator delete (void* ptr, void*) throw(); T void operator delete[](void* ptr, void*) throw(); 18.4.2.1 Class bad_alloc [lib.bad.alloc] T class bad_alloc : public exception { public: T bad_alloc() throw(); T bad_alloc(const bad_alloc&) throw(); T bad_alloc& operator=(const bad_alloc&) throw(); T virtual ~bad_alloc() throw(); T virtual const char* what() const throw(); T new_handler set_new_handler(new_handler new_p) throw(); Header synopsis T class type_info; T class bad_cast; T class bad_typeid; 18.5.1 - Class type_info [lib.type.info] T class type_info { public: T virtual ~type_info(); T bool operator==(const type_info& rhs) const; T bool operator!=(const type_info& rhs) const; T bool before(const type_info& rhs) const; T const char* name() const; private: T type_info(const type_info& rhs); T type_info& operator=(const type_info& rhs); }; 18.5.2 - Class bad_cast [lib.bad.cast] T bad_cast() throw(); T virtual const char* bad_cast::what() const throw(); 18.5.3 Class bad_typeid [lib.bad.typeid] T class bad_typeid : public exception { public: T bad_typeid() throw(); T bad_typeid(const bad_typeid&) throw(); T bad_typeid& operator=(const bad_typeid&) throw(); T virtual ~bad_typeid() throw(); T virtual const char* what() const throw(); }; 18.6 Exception handling [lib.support.exception] T Header synopsis T class exception; T class bad_exception; T typedef void (*unexpected_handler)(); T unexpected_handler set_unexpected(unexpected_handler f) throw(); T void unexpected(); T typedef void (*terminate_handler)(); T terminate_handler set_terminate(terminate_handler f) throw(); T void terminate(); T bool uncaught_exception(); 18.6.1 Class exception [lib.exception] T class exception { public: T exception() throw(); T exception(const exception&) throw(); T exception& operator=(const exception&) throw(); T virtual ~exception() throw(); T virtual const char* what() const throw(); }; 18.6.2.1 Class bad_exception [lib.bad.exception] T class bad_exception : public exception { public: T bad_exception() throw(); T bad_exception(const bad_exception&) throw(); T bad_exception& operator=(const bad_exception&) throw(); T virtual ~bad_exception() throw(); T virtual const char* what() const throw(); }; 18.7 Other runtime support [lib.support.runtime] 1 Headers (variable arguments), (nonlocal jumps), (system clock clock(), time()), (signal handling), and (runtime environment getenv(), system()). Table 6--Header synopsis Macros: va_arg va_end va_start X Type: va_list Table 7--Header synopsis Macro: setjmp | X Type: jmp_buf Function: longjmp Table 8--Header synopsis Macros: CLOCKS_PER_SEC X Types: clock_t Functions: clock Table 9--Header synopsis X Macros: SIGABRT SIGILL SIGSEGV SIG_DFL SIG_IGN SIGFPE SIGINT SIGTERM SIG_ERR Type: sig_atomic_t Functions: raise signal Table 10--Header synopsis X Functions: getenv system 19.1 Exception classes [lib.std.exceptions] Header synopsis T class logic_error; T class domain_error; T class invalid_argument; T class length_error; T class out_of_range; T class runtime_error; T class range_error; T class overflow_error; T class underflow_error; 19.1.1 Class logic_error [lib.logic.error] T class logic_error : public exception { public: T explicit logic_error(const string& what_arg); }; 19.1.2 Class domain_error [lib.domain.error] T class domain_error : public logic_error { public: T explicit domain_error(const string& what_arg); }; 19.1.3 Class invalid_argument [lib.invalid.argument] T class invalid_argument : public logic_error { public: T explicit invalid_argument(const string& what_arg); }; 19.1.4 Class length_error [lib.length.error] T class length_error : public logic_error { public: T explicit length_error(const string& what_arg); }; 19.1.5 Class out_of_range [lib.out.of.range] T class out_of_range : public logic_error { public: T explicit out_of_range(const string& what_arg); }; 19.1.6 Class runtime_error [lib.runtime.error] T class runtime_error : public exception { public: T explicit runtime_error(const string& what_arg); }; 19.1.7 Class range_error [lib.range.error] T class range_error : public runtime_error { public: T explicit range_error(const string& what_arg); }; 19.1.8 Class overflow_error [lib.overflow.error] T class overflow_error : public runtime_error { public: T explicit overflow_error(const string& what_arg); }; 19.1.9 Class underflow_error [lib.underflow.error] T class underflow_error : public runtime_error { public: T explicit underflow_error(const string& what_arg); }; 19.2 Assertions [lib.assertions] Table 2--Header synopsis X Macro: assert 19.3 Error numbers [lib.errno] Table 3--Header synopsis X |Macros: EDOM ERANGE errno | 20.2 Utility components [lib.utility] Header synopsis // _lib.operators_, operators: T namespace rel_ops { T template bool operator!=(const T&, const T&); T template bool operator> (const T&, const T&); T template bool operator<=(const T&, const T&); T template bool operator>=(const T&, const T&); } // _lib.pairs_, pairs: T template struct pair; T template bool operator==(const pair&, const pair&); T template bool operator< (const pair&, const pair&); T template bool operator!=(const pair&, const pair&); T template bool operator> (const pair&, const pair&); T template bool operator>=(const pair&, const pair&); T template bool operator<=(const pair&, const pair&); T template pair make_pair(const T1&, const T2&); 20.2.2 Pairs [lib.pairs] T template struct pair { T typedef T1 first_type; T typedef T2 second_type; T T1 first; T T2 second; T pair(); T pair(const T1& x, const T2& y); T template pair(const pair &p); }; 20.3 Function objects [lib.function.objects] Header synopsis // _lib.base_, base: V template struct unary_function; V template struct binary_function; // _lib.arithmetic.operations_, arithmetic operations: V template struct plus; V template struct minus; V template struct multiplies; V template struct divides; V template struct modulus; V template struct negate; // _lib.comparisons_, comparisons: V template struct equal_to; V template struct not_equal_to; V template struct greater; V template struct less; V template struct greater_equal; V template struct less_equal; // _lib.logical.operations_, logical operations: V template struct logical_and; V template struct logical_or; V template struct logical_not; // _lib.negators_, negators: template struct unary_negate; V template unary_negate not1(const Predicate&); V template struct binary_negate; V template binary_negate not2(const Predicate&); // _lib.binders_, binders: V template class binder1st; V template binder1st bind1st(const Operation&, const T&); V template class binder2nd; V template binder2nd bind2nd(const Operation&, const T&); // _lib.function.pointer.adaptors_, adaptors: V template class pointer_to_unary_function; V template pointer_to_unary_function ptr_fun(Result (*)(Arg)); V template class pointer_to_binary_function; V template pointer_to_binary_function ptr_fun(Result (*)(Arg1,Arg2)); // _lib.member.pointer.adaptors_, adaptors: V template class mem_fun_t; V template class mem_fun1_t; V template mem_fun_t mem_fun(S (T::*f)()); V template mem_fun1_t mem_fun(S (T::*f)(A)); V template class mem_fun_ref_t; V template class mem_fun1_ref_t; V template mem_fun_ref_t mem_fun_ref(S (T::*f)()); V template mem_fun1_ref_t mem_fun_ref(S (T::*f)(A)); V template class const_mem_fun_t; V template class const_mem_fun1_t; V template const_mem_fun_t mem_fun(S (T::*f)() const); V template const_mem_fun1_t mem_fun(S (T::*f)(A) const); V template class const_mem_fun_ref_t; V template class const_mem_fun1_ref_t; V template const_mem_fun_ref_t mem_fun_ref(S (T::*f)() const); V template const_mem_fun1_ref_t mem_fun_ref(S (T::*f)(A) const); } 20.3.1 Base [lib.base] V template struct unary_function { V typedef Arg argument_type; V typedef Result result_type; }; V template struct binary_function { V typedef Arg1 first_argument_type; V typedef Arg2 second_argument_type; V typedef Result result_type; }; 20.3.2 Arithmetic operations [lib.arithmetic.operations] T template struct plus : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct minus : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct multiplies : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct divides : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct modulus : binary_function { V T operator()(const T& x, const T& y) const; }; T template struct negate : unary_function { V T operator()(const T& x) const; }; 20.3.3 Comparisons [lib.comparisons] T template struct equal_to : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct not_equal_to : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct greater : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct less : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct greater_equal : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct less_equal : binary_function { V bool operator()(const T& x, const T& y) const; }; 20.3.4 Logical operations [lib.logical.operations] T template struct logical_and : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct logical_or : binary_function { V bool operator()(const T& x, const T& y) const; }; T template struct logical_not : unary_function { V bool operator()(const T& x) const; }; 20.3.5 Negators [lib.negators] T template class unary_negate : public unary_function { public: T explicit unary_negate(const Predicate& pred); V bool operator()(const typename Predicate::argument_type& x) const; }; T template class binary_negate : public binary_function { public: T explicit binary_negate(const Predicate& pred); V bool operator()(const typename Predicate::first_argument_type& x, const typename Predicate::second_argument_type& y) const; }; 20.3.6 Binders [lib.binders] 20.3.6.1 Template class binder1st [lib.binder.1st] T template class binder1st : public unary_function { protected: T Operation op; T typename Operation::first_argument_type value; public: V binder1st(const Operation& x, const typename Operation::first_argument_type& y); V typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const; }; 20.3.6.2 bind1st [lib.bind.1st] V template binder1st bind1st(const Operation& op, const T& x); 20.3.6.3 Template class binder2nd [lib.binder.2nd] T template class binder2nd : public unary_function { protected: T Operation op; T typename Operation::second_argument_type value; public: V binder2nd(const Operation& x, const typename Operation::second_argument_type& y); V typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const; }; 20.3.6.4 bind2nd [lib.bind.2nd] T template binder2nd bind2nd(const Operation& op, const T& x); 20.3.7 Adaptors for pointers to [lib.function.pointer.adaptors] functions 1 To allow pointers to (unary and binary) functions to work with func- tion adaptors the library provides: T template class pointer_to_unary_function : public unary_function { public: T explicit pointer_to_unary_function(Result (*f)(Arg)); V Result operator()(Arg x) const; }; T template pointer_to_unary_function ptr_fun(Result (*f)(Arg)); T template class pointer_to_binary_function : public binary_function { public: T explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2)); V Result operator()(Arg1 x, Arg2 y) const; }; 20.3.8 Adaptors for pointers to [lib.member.pointer.adaptors] members T template class mem_fun_t : public unary_function { public: T explicit mem_fun_t(S (T::*p)()); V S operator()(T* p) const; }; T template class mem_fun1_t : public binary_function { public: T explicit mem_fun1_t(S (T::*p)(A)); V S operator()(T* p, A x) const; }; V template mem_fun_t mem_fun(S (T::*f)()); V template mem_fun1_t mem_fun(S (T::*f)(A)); T template class mem_fun_ref_t : public unary_function { public: T explicit mem_fun_ref_t(S (T::*p)()); V S operator()(T& p) const; }; T template class mem_fun1_ref_t : public binary_function { public: T explicit mem_fun1_ref_t(S (T::*p)(A)); V S operator()(T& p, A x) const; }; T template mem_fun_ref_t mem_fun_ref(S (T::*f)()); T template mem_fun1_ref_t mem_fun_ref(S (T::*f)(A)); T template class const_mem_fun_t : public unary_function { public: T explicit const_mem_fun_t(S (T::*p)() const); V S operator()(const T* p) const; }; T template class const_mem_fun1_t : public binary_function { public: T explicit const mem_fun1_t(S (T::*p)(A) const); V S operator()(const T* p, A x) const; }; V template const_mem_fun_t mem_fun(S (T::*f)() const); V template const_mem_fun1_t mem_fun(S (T::*f)(A) const); T template class const_mem_fun_ref_t : public unary_function { public: T explicit const_mem_fun_ref_t(S (T::*p)() const); V S operator()(const T& p) const; }; T template class const_mem_fun1_ref_t : public binary_function { public: T explicit const_mem_fun1_ref_t(S (T::*p)(A) const); V S operator()(const T& p, A x) const; }; T template const_mem_fun_ref_t mem_fun_ref(S (T::*f)() const); T template const_mem_fun1_ref_t mem_fun_ref(S (T::*f)(A) const); 20.4 Memory [lib.memory] Header synopsis // _lib.default.allocator_, the default allocator: T template class allocator; T template <> class allocator; T template bool operator==(const allocator&, const allocator&) throw(); T template bool operator!=(const allocator&, const allocator&) throw(); // _lib.storage.iterator_, raw storage iterator: T template class raw_storage_iterator; // _lib.temporary.buffer_, temporary buffers: T template pair get_temporary_buffer(ptrdiff_t n); T template void return_temporary_buffer(T* p); // _lib.specialized.algorithms_, specialized algorithms: T template ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); T template void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); T template void uninitialized_fill_n(ForwardIterator first, Size n, const T& x); // _lib.auto.ptr_, pointers: X template class auto_ptr; } 20.4.1 The default allocator [lib.default.allocator] T template class allocator; // specialize for void: T template <> class allocator { public: T typedef void* pointer; T typedef const void* const_pointer; // reference-to-void members are impossible. T typedef void value_type; T template struct rebind { typedef allocator other; }; }; T template class allocator { public: T typedef size_t size_type; T typedef ptrdiff_t difference_type; T typedef T* pointer; T typedef const T* const_pointer; T typedef T& reference; T typedef const T& const_reference; T typedef T value_type; T template struct rebind { typedef allocator other; }; T allocator() throw(); T allocator(const allocator&) throw(); T template allocator(const allocator&) throw(); T ~allocator() throw(); T pointer address(reference x) const; T const_pointer address(const_reference x) const; T pointer allocate( size_type, allocator::const_pointer hint = 0); T void deallocate(pointer p, size_type n); T size_type max_size() const throw(); T void construct(pointer p, const T& val); T void destroy(pointer p); }; 20.4.1.2 allocator globals [lib.allocator.globals] T template bool operator==(const allocator&, const allocator&) throw(); T template bool operator!=(const allocator&, const allocator&) throw(); 20.4.2 Raw storage iterator [lib.storage.iterator] T template class raw_storage_iterator : public iterator { public: T explicit raw_storage_iterator(OutputIterator x); T raw_storage_iterator& operator*(); T raw_storage_iterator& operator=(const T& element); T raw_storage_iterator& operator++(); T raw_storage_iterator operator++(int); }; 20.4.3 Temporary buffers [lib.temporary.buffer] T template pair get_temporary_buffer(ptrdiff_t n); T template void return_temporary_buffer(T* p); 20.4.4 Specialized algorithms [lib.specialized.algorithms] 20.4.4.1 uninitialized_copy [lib.uninitialized.copy] V template ForwardIterator uninitialized_copy(InputIterator first, InputIterator last, ForwardIterator result); 20.4.4.2 uninitialized_fill [lib.uninitialized.fill] V template void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x); 20.4.4.3 uninitialized_fill_n [lib.uninitialized.fill.n] V template void uninitialized_fill_n(ForwardIterator first, Size n, const T& x); 20.4.5 Template class auto_ptr [lib.auto.ptr] X template class auto_ptr { template struct auto_ptr_ref {}; public: T typedef X element_type; // _lib.auto.ptr.cons_ construct/copy/destroy: T explicit auto_ptr(X* p =0) throw(); T auto_ptr(auto_ptr&) throw(); T template auto_ptr(auto_ptr&) throw(); T auto_ptr& operator=(auto_ptr&) throw(); T template auto_ptr& operator=(auto_ptr&) throw(); T ~auto_ptr() throw(); // _lib.auto.ptr.members_ members: T X& operator*() const throw(); T X* operator->() const throw(); T X* get() const throw(); T X* release() throw(); T void reset(X* p =0) throw(); // _lib.auto.ptr.conv_ conversions: X auto_ptr(auto_ptr_ref) throw(); X template operator auto_ptr_ref() throw(); X template operator auto_ptr() throw(); }; 20.4.6 C Library [lib.c.malloc] Table 7--Header synopsis X Functions: calloc malloc free realloc Table 8--Header synopsis X Macro: NULL X Type: size_t X Functions: memchr memcmp X memcpy memmove memset Table 9--Header synopsis X Macros: NULL X Types: size_t clock_t time_t X Struct: tm Functions: X asctime clock difftime localtime strftime X ctime gmtime mktime time 21.1.1 Character traits requirements [lib.char.traits.require] 2 The struct template T template struct char_traits; shall be provided in the header as a basis for explicit spe- cializations. 21.1.3.1 struct [lib.char.traits.specializations.char] char_traits T template<> struct char_traits { T typedef char char_type; T typedef int int_type; T typedef streamoff off_type; T typedef streampos pos_type; T typedef mbstate_t state_type; T static void assign(char_type& c1, const char_type& c2); T static bool eq(const char_type& c1, const char_type& c2); T static bool lt(const char_type& c1, const char_type& c2); T static int compare(const char_type* s1, const char_type* s2, size_t n); T static size_t length(const char_type* s); T static const char_type* find(const char_type* s, size_t n, const char_type& a); T static char_type* move(char_type* s1, const char_type* s2, size_t n); T static char_type* copy(char_type* s1, const char_type* s2, size_t n); T static char_type* assign(char_type* s, size_t n, char_type a); T static int_type not_eof(const int_type& c); T static char_type to_char_type(const int_type& c); T static int_type to_int_type(const char_type& c); T static bool eq_int_type(const int_type& c1, const int_type& c2); T static int_type eof(); }; 21.1.3.2 struct [lib.char.traits.specializations.wchar.t] char_traits V template<> struct char_traits { V typedef wchar_t char_type; V typedef wint_t int_type; V typedef streamoff off_type; V typedef wstreampos pos_type; V typedef mbstate_t state_type; V static void assign(char_type& c1, const char_type& c2); V static bool eq(const char_type& c1, const char_type& c2); V static bool lt(const char_type& c1, const char_type& c2); V static int compare(const char_type* s1, const char_type* s2, size_t n); V static size_t length(const char_type* s); V static const char_type* find(const char_type* s, size_t n, const char_type& a); V static char_type* move(char_type* s1, const char_type* s2, size_t n); V static char_type* copy(char_type* s1, const char_type* s2, size_t n); V static char_type* assign(char_type* s, size_t n, char_type a); V static int_type not_eof(const int_type& c); V static char_type to_char_type(const int_type& c); V static int_type to_int_type(const char_type& c); V static bool eq_int_type(const int_type& c1, const int_type& c2); V static int_type eof(); }; 21.2 String classes [lib.string.classes] // _lib.char.traits_, character traits: V template struct char_traits; V template <> struct char_traits; V template <> struct char_traits; // _lib.basic.string_, basic_string: V template, class Allocator = allocator > class basic_string; V template basic_string operator+(const basic_string& lhs, const basic_string& rhs); V template basic_string operator+(const charT* lhs, const basic_string& rhs); V template basic_string operator+(charT lhs, const basic_string& rhs); V template basic_string operator+(const basic_string& lhs, const charT* rhs); V template basic_string operator+(const basic_string& lhs, charT rhs); V template bool operator==(const basic_string& lhs, const basic_string& rhs); V template bool operator==(const charT* lhs, const basic_string& rhs); V template bool operator==(const basic_string& lhs, const charT* rhs); V template bool operator!=(const basic_string& lhs, const basic_string& rhs); V template bool operator!=(const charT* lhs, const basic_string& rhs); V template bool operator!=(const basic_string& lhs, const charT* rhs); V template bool operator< (const basic_string& lhs, const basic_string& rhs); V template bool operator< (const basic_string& lhs, const charT* rhs); V template bool operator< (const charT* lhs, const basic_string& rhs); V template bool operator> (const basic_string& lhs, const basic_string& rhs); V template bool operator> (const basic_string& lhs, const charT* rhs); V template bool operator> (const charT* lhs, const basic_string& rhs); V template bool operator<=(const basic_string& lhs, const basic_string& rhs); V template bool operator<=(const basic_string& lhs, const charT* rhs); V template bool operator<=(const charT* lhs, const basic_string& rhs); V template bool operator>=(const basic_string& lhs, const basic_string& rhs); V template bool operator>=(const basic_string& lhs, const charT* rhs); V template bool operator>=(const charT* lhs, const basic_string& rhs); // _lib.string.special_: V template void swap(basic_string& lhs, basic_string& rhs); V template basic_istream& operator>>(basic_istream& is, basic_string& str); T template basic_ostream& operator<<(basic_ostream