l4/pkg/libstdc++-v3/contrib/libstdc++-v3-4.3.3/doc/xml/manual/status_cxx1998.xml

   1 <sect2 id="manual.intro.status.standard.1998" xreflabel="Status C++ 1998">
   2 <?dbhtml filename="standard_cxx1998.html"?>
   3
   4 <sect2info>
   5   <keywordset>
   6     <keyword>
   7       ISO C++
   8     </keyword>
   9     <keyword>
  10       1998
  11     </keyword>
  12   </keywordset>
  13 </sect2info>
  14
  15 <title>C++ 1998</title>
  16
  17 <sect3 id="standard.1998" xreflabel="Status C++ 1998">
  18   <title>Checklist</title>
  19
  20 <literallayout>
  21    Completion Checklist for the Standard C++ Library
  22    Updated: 2003-04-25
  23
  24    Status Code Legend:
  25     M - Missing
  26     S - Present as stub.
  27     X - Partially implemented, or buggy.
  28     T - Implemented, pending test/inspection.
  29     V - Verified to pass all available test suites.
  30     Q - Qualified by inspection for non-testable correctness.
  31     P - Portability verified.
  32     C - Certified.
  33
  34    Lexical notes:
  35    Only status codes appear in column 0.  Notes relating to conformance
  36    issues appear [in brackets].
  37
  38    Note that this checklist does not (yet) include all emendations
  39    recommended by the ISO Library Working Group:
  40    http://anubis.dkuug.dk/jtc1/sc22/wg21/docs/lwg-toc.html
  41
  42    Detailed explanation of status codes:
  43
  44     M - Missing:  The name is not visible to programs that include
  45         the specified header, either at compile or link stage.
  46
  47     S - Present as stub:  A program can use the name, but no implementation
  48         is provided.  Programs that use the name link correctly, but
  49         cannot usefully be run.
  50
  51     X - Partially implemented, or buggy:  Some implementation has been
  52         provided, but it is known or believed not to conform fully.
  53         It may have an incorrect base class, wrong namespace, wrong
  54         storage class, or simply not fully implement requirements.
  55         However, it may be sufficiently usable to help test other
  56         components.
  57
  58     T - Implemented, pending test/inspection:  Implementation believed
  59         to be complete, and informal testing suggests it is ready for
  60         formal verification.
  61
  62     V - Verified, passes all test suites:  Verified to satisfy all
  63         generically testable conformance requirements.
  64
  65     Q - Qualified by inspection for non-testable correctness:
  66         Inspected, "implementation-defined" documentation accepted,
  67         local usability criteria satisfied, formally inspected for
  68         other untestable conformance.  (Untestable requirements
  69         include exception-safety, thread-safety, worst-case
  70         complexity, memory cleanliness, usefulness.)
  71
  72     P - Portability verified:  Qualified on all primary target platforms.
  73
  74     C - Certified:  Formally certified to have passed all tests,
  75         inspections, qualifications; approved under "signing authority"
  76         to be used to satisfy contractual guarantees.
  77
  78    ----------------------------------------------------------------------
  79        &lt;algorithm&gt;    &lt;iomanip&gt;    &lt;list&gt;      &lt;ostream&gt;     &lt;streambuf&gt;
  80        &lt;bitset&gt;       &lt;ios&gt;        &lt;locale&gt;    &lt;queue&gt;       &lt;string&gt;
  81        &lt;complex&gt;      &lt;iosfwd&gt;     &lt;map&gt;       &lt;set&gt;         &lt;typeinfo&gt;
  82 X      &lt;deque&gt;        &lt;iostream&gt;   &lt;memory&gt;    &lt;sstream&gt;     &lt;utility&gt;
  83        &lt;exception&gt;    &lt;istream&gt;    &lt;new&gt;       &lt;stack&gt;       &lt;valarray&gt;
  84        &lt;fstream&gt;      &lt;iterator&gt;   &lt;numeric&gt;   &lt;stdexcept&gt;   &lt;vector&gt;
  85        &lt;functional&gt;   &lt;limits&gt;
  86
  87    [C header names must be in std:: to qualify.  Related to shadow/ dir.]
  88            &lt;cassert&gt; &lt;ciso646&gt; &lt;csetjmp&gt; &lt;cstdio&gt;  &lt;ctime&gt;
  89            &lt;cctype&gt;  &lt;climits&gt; &lt;csignal&gt; &lt;cstdlib&gt; &lt;cwchar&gt;
  90 X          &lt;cerrno&gt;  &lt;clocale&gt; &lt;cstdarg&gt; &lt;cstring&gt; &lt;cwctype&gt;
  91            &lt;cfloat&gt;  &lt;cmath&gt;   &lt;cstddef&gt;
  92
  93     Macro:
  94 X   errno,  declared  or  defined in &lt;cerrno&gt;.
  95
  96     Macro fn:
  97 X   setjmp(jmp_buf), declared or defined in &lt;csetjmp&gt;
  98 X   va_end(va_list), declared or defined in &lt;cstdarg&gt;
  99
 100     Types:
 101 X   clock_t, div_t, FILE, fpos_t, lconv, ldiv_t, mbstate_t,
 102 X   ptrdiff_t, sig_atomic_t, size_t,  time_t,  tm,  va_list,
 103 X   wctrans_t, wctype_t, and wint_t.
 104
 105    1 Which  of  the functions in the C++ Standard Library are not reentrant
 106     subroutines is implementation-defined.
 107
 108    18.1  Types                                        [lib.support.types]
 109 X      &lt;cstddef&gt;
 110 X      NULL
 111 X      offsetof
 112 X      ptrdiff_t
 113 X      size_t
 114
 115    18.2  Implementation properties                   [lib.support.limits]
 116
 117     &lt;limits&gt;, &lt;climits&gt;, and &lt;cfloat&gt;
 118
 119    18.2.1  Numeric limits                                    [lib.limits]
 120
 121 X   template&lt;class T&gt; class numeric_limits;
 122
 123 T   enum float_round_style;
 124 T   enum float_denorm_style;
 125
 126 T   template&lt;&gt; class numeric_limits&lt;bool&gt;;
 127
 128 T   template&lt;&gt; class numeric_limits&lt;char&gt;;
 129 T   template&lt;&gt; class numeric_limits&lt;signed char&gt;;
 130 T   template&lt;&gt; class numeric_limits&lt;unsigned char&gt;;
 131 T   template&lt;&gt; class numeric_limits&lt;wchar_t&gt;;
 132
 133 T   template&lt;&gt; class numeric_limits&lt;short&gt;;
 134 T   template&lt;&gt; class numeric_limits&lt;int&gt;;
 135 T   template&lt;&gt; class numeric_limits&lt;long&gt;;
 136 T   template&lt;&gt; class numeric_limits&lt;unsigned short&gt;;
 137 T   template&lt;&gt; class numeric_limits&lt;unsigned int&gt;;
 138 T   template&lt;&gt; class numeric_limits&lt;unsigned long&gt;;
 139
 140 X   template&lt;&gt; class numeric_limits&lt;float&gt;;
 141 X   template&lt;&gt; class numeric_limits&lt;double&gt;;
 142 X   template&lt;&gt; class numeric_limits&lt;long double&gt;;
 143
 144    18.2.1.1  Template class numeric_limits           [lib.numeric.limits]
 145 T   template&lt;class T&gt; class numeric_limits {
 146     public:
 147 T     static const bool is_specialized = false;
 148 T     static T min() throw();
 149 T     static T max() throw();
 150 T     static const int  digits = 0;
 151 T     static const int  digits10 = 0;
 152 T     static const bool is_signed = false;
 153 T     static const bool is_integer = false;
 154 T     static const bool is_exact = false;
 155 T     static const int  radix = 0;
 156 T     static T epsilon() throw();
 157 T     static T round_error() throw();
 158
 159 T     static const int  min_exponent = 0;
 160 T     static const int  min_exponent10 = 0;
 161 T     static const int  max_exponent = 0;
 162 T     static const int  max_exponent10 = 0;
 163
 164 T     static const bool has_infinity = false;
 165 T     static const bool has_quiet_NaN = false;
 166 T     static const bool has_signaling_NaN = false;
 167 T     static const float_denorm_style has_denorm = denorm_absent;
 168 T     static const bool has_denorm_loss = false;
 169 T     static T infinity() throw();
 170 T     static T quiet_NaN() throw();
 171 T     static T signaling_NaN() throw();
 172 T     static T denorm_min() throw();
 173
 174 T     static const bool is_iec559 = false;
 175 T     static const bool is_bounded = false;
 176 T     static const bool is_modulo = false;
 177
 178 T     static const bool traps = false;
 179 T     static const bool tinyness_before = false;
 180 T     static const float_round_style round_style = round_toward_zero;
 181     };
 182
 183    18.2.1.3  Type float_round_style                     [lib.round.style]
 184
 185 T   enum float_round_style {
 186 T     round_indeterminate       = -1,
 187 T     round_toward_zero         =  0,
 188 T     round_to_nearest          =  1,
 189 T     round_toward_infinity     =  2,
 190 T     round_toward_neg_infinity =  3
 191     };
 192
 193    18.2.1.4  Type float_denorm_style                   [lib.denorm.style]
 194
 195 T   enum float_denorm_style {
 196 T     denorm_indeterminate = -1;
 197 T     denorm_absent = 0;
 198 T     denorm present = 1;
 199     };
 200
 201    18.2.1.5  numeric_limits specializations         [lib.numeric.special]
 202
 203    [Note: see Note at 18.2.1.  ]
 204
 205    18.2.2  C Library                                       [lib.c.limits]
 206
 207    1 Header &lt;climits&gt; (Table 3):
 208       CHAR_BIT   INT_MAX    LONG_MIN     SCHAR_MIN   UCHAR_MAX   USHRT_MAX
 209 X     CHAR_MAX   INT_MIN    MB_LEN_MAX   SHRT_MAX    UINT_MAX
 210       CHAR_MIN   LONG_MAX   SCHAR_MAX    SHRT_MIN    ULONG_MAX
 211
 212    3 Header &lt;cfloat&gt; (Table 4):
 213
 214     DBL_DIG          DBL_MIN_EXP      FLT_MIN_10_EXP   LDBL_MAX_10_EXP
 215     DBL_EPSILON      FLT_DIG          FLT_MIN_EXP      LDBL_MAX_EXP
 216     DBL_MANT_DIG     FLT_EPSILON      FLT_RADIX        LDBL_MIN
 217 X   DBL_MAX          FLT_MANT_DIG     FLT_ROUNDS       LDBL_MIN_10_EXP
 218     DBL_MAX_10_EXP   FLT_MAX          LDBL_DIG         LDBL_MIN_EXP
 219     DBL_MAX_EXP      FLT_MAX_10_EXP   LDBL_EPSILON
 220     DBL_MIN          FLT_MAX_EXP      LDBL_MANT_DIG
 221     DBL_MIN_10_EXP   FLT_MIN          LDBL_MAX
 222
 223
 224         1 Header &lt;cstdlib&gt; (partial), Table 5:
 225 X             EXIT_FAILURE     EXIT_SUCCESS
 226               abort   atexit   exit
 227
 228 S    abort(void)
 229 S    extern "C" int atexit(void (*f)(void))
 230 S    extern "C++" int atexit(void (*f)(void))
 231 S    exit(int status)
 232
 233    18.4  Dynamic memory management                  [lib.support.dynamic]
 234
 235    Header &lt;new&gt; synopsis
 236
 237 T    class bad_alloc;
 238 T    struct nothrow_t {};
 239 T    extern const nothrow_t nothrow;
 240 T    typedef void (*new_handler)();
 241 T    new_handler set_new_handler(new_handler new_p) throw();
 242
 243 T    void* operator new(std::size_t size) throw(std::bad_alloc);
 244 T    void* operator new(std::size_t size, const std::nothrow_t&amp;) throw();
 245 T    void  operator delete(void* ptr) throw();
 246 T    void  operator delete(void* ptr, const std::nothrow_t&amp;) throw();
 247 T    void* operator new[](std::size_t size) throw(std::bad_alloc);
 248 T    void* operator new[](std::size_t size, const std::nothrow_t&amp;) throw();
 249 T    void  operator delete[](void* ptr) throw();
 250 T    void  operator delete[](void* ptr, const std::nothrow_t&amp;) throw();
 251 T    void* operator new  (std::size_t size, void* ptr) throw();
 252 T    void* operator new[](std::size_t size, void* ptr) throw();
 253 T    void  operator delete  (void* ptr, void*) throw();
 254 T    void  operator delete[](void* ptr, void*) throw();
 255
 256    18.4.2.1  Class bad_alloc                              [lib.bad.alloc]
 257
 258 T   class bad_alloc : public exception {
 259     public:
 260 T     bad_alloc() throw();
 261 T     bad_alloc(const bad_alloc&amp;) throw();
 262 T     bad_alloc&amp; operator=(const bad_alloc&amp;) throw();
 263 T     virtual ~bad_alloc() throw();
 264 T     virtual const char* what() const throw();
 265
 266
 267
 268 T  new_handler set_new_handler(new_handler new_p) throw();
 269
 270
 271      Header &lt;typeinfo&gt; synopsis
 272
 273 T    class type_info;
 274 T    class bad_cast;
 275 T    class bad_typeid;
 276
 277    18.5.1 - Class type_info [lib.type.info]
 278
 279 T    class type_info {
 280     public:
 281 T      virtual ~type_info();
 282 T      bool operator==(const type_info&amp; rhs) const;
 283 T      bool operator!=(const type_info&amp; rhs) const;
 284 T      bool before(const type_info&amp; rhs) const;
 285 T      const char* name() const;
 286     private:
 287 T      type_info(const type_info&amp; rhs);
 288 T      type_info&amp; operator=(const type_info&amp; rhs);
 289     };
 290
 291    18.5.2 - Class bad_cast [lib.bad.cast]
 292
 293 T  bad_cast() throw();
 294 T  virtual const char* bad_cast::what() const throw();
 295
 296    18.5.3  Class bad_typeid                              [lib.bad.typeid]
 297
 298 T    class bad_typeid : public exception {
 299     public:
 300 T      bad_typeid() throw();
 301 T      bad_typeid(const bad_typeid&amp;) throw();
 302 T      bad_typeid&amp; operator=(const bad_typeid&amp;) throw();
 303 T      virtual ~bad_typeid() throw();
 304 T      virtual const char* what() const throw();
 305     };
 306
 307    18.6  Exception handling                       [lib.support.exception]
 308
 309 T      Header &lt;exception&gt; synopsis
 310
 311 T    class exception;
 312 T    class bad_exception;
 313
 314 T    typedef void (*unexpected_handler)();
 315 T    unexpected_handler set_unexpected(unexpected_handler f) throw();
 316 T    void unexpected();
 317 T    typedef void (*terminate_handler)();
 318 T    terminate_handler set_terminate(terminate_handler f) throw();
 319 T    void terminate();
 320 T    bool uncaught_exception();
 321
 322    18.6.1  Class exception                                [lib.exception]
 323
 324 T    class exception {
 325      public:
 326 T      exception() throw();
 327 T      exception(const exception&amp;) throw();
 328 T      exception&amp; operator=(const exception&amp;) throw();
 329 T      virtual ~exception() throw();
 330 T      virtual const char* what() const throw();
 331     };
 332
 333    18.6.2.1  Class bad_exception                      [lib.bad.exception]
 334 T    class bad_exception : public exception {
 335     public:
 336 T      bad_exception() throw();
 337 T      bad_exception(const bad_exception&amp;) throw();
 338 T      bad_exception&amp; operator=(const bad_exception&amp;) throw();
 339 T      virtual ~bad_exception() throw();
 340 T      virtual const char* what() const throw();
 341     };
 342
 343    18.7  Other runtime support                      [lib.support.runtime]
 344
 345    1 Headers &lt;cstdarg&gt; (variable arguments),  &lt;csetjmp&gt;  (nonlocal  jumps),
 346     &lt;ctime&gt;  (system  clock clock(), time()), &lt;csignal&gt; (signal handling),
 347     and &lt;cstdlib&gt; (runtime environment getenv(), system()).
 348
 349                     Table 6--Header &lt;cstdarg&gt; synopsis
 350                  Macros:   va_arg    va_end   va_start
 351 X                Type:     va_list
 352
 353                     Table 7--Header &lt;csetjmp&gt; synopsis
 354
 355                           Macro:      setjmp |
 356 X                         Type:       jmp_buf
 357                           Function:   longjmp
 358
 359                      Table 8--Header &lt;ctime&gt; synopsis
 360
 361                       Macros:      CLOCKS_PER_SEC
 362 X                     Types:       clock_t
 363                       Functions:   clock
 364
 365                     Table 9--Header &lt;csignal&gt; synopsis
 366
 367 X        Macros:      SIGABRT        SIGILL   SIGSEGV   SIG_DFL
 368          SIG_IGN      SIGFPE         SIGINT   SIGTERM   SIG_ERR
 369          Type:        sig_atomic_t
 370          Functions:   raise          signal
 371
 372                    Table 10--Header &lt;cstdlib&gt; synopsis
 373
 374 X                     Functions:   getenv   system
 375
 376    19.1  Exception classes                           [lib.std.exceptions]
 377
 378    Header &lt;stdexcept&gt; synopsis
 379
 380 T     class logic_error;
 381 T     class domain_error;
 382 T     class invalid_argument;
 383 T     class length_error;
 384 T     class out_of_range;
 385 T     class runtime_error;
 386 T     class range_error;
 387 T     class overflow_error;
 388 T     class underflow_error;
 389
 390    19.1.1  Class logic_error                            [lib.logic.error]
 391 T   class logic_error : public exception {
 392     public:
 393 T     explicit logic_error(const string&amp; what_arg);
 394     };
 395
 396    19.1.2  Class domain_error                          [lib.domain.error]
 397
 398 T   class domain_error : public logic_error {
 399     public:
 400 T     explicit domain_error(const string&amp; what_arg);
 401     };
 402
 403    19.1.3  Class invalid_argument                  [lib.invalid.argument]
 404
 405 T   class invalid_argument : public logic_error {
 406     public:
 407 T     explicit invalid_argument(const string&amp; what_arg);
 408     };
 409
 410    19.1.4  Class length_error                          [lib.length.error]
 411
 412 T   class length_error : public logic_error {
 413     public:
 414 T     explicit length_error(const string&amp; what_arg);
 415     };
 416
 417    19.1.5  Class out_of_range                          [lib.out.of.range]
 418
 419 T   class out_of_range : public logic_error {
 420     public:
 421 T     explicit out_of_range(const string&amp; what_arg);
 422     };
 423
 424
 425    19.1.6  Class runtime_error                        [lib.runtime.error]
 426
 427 T   class runtime_error : public exception {
 428     public:
 429 T     explicit runtime_error(const string&amp; what_arg);
 430     };
 431
 432
 433    19.1.7  Class range_error                            [lib.range.error]
 434
 435 T   class range_error : public runtime_error {
 436     public:
 437 T     explicit range_error(const string&amp; what_arg);
 438     };
 439
 440    19.1.8  Class overflow_error                      [lib.overflow.error]
 441
 442 T   class overflow_error : public runtime_error {
 443     public:
 444 T     explicit overflow_error(const string&amp; what_arg);
 445     };
 446
 447
 448    19.1.9  Class underflow_error                    [lib.underflow.error]
 449
 450 T   class underflow_error : public runtime_error {
 451     public:
 452 T     explicit underflow_error(const string&amp; what_arg);
 453     };
 454
 455
 456    19.2  Assertions                                      [lib.assertions]
 457
 458                     Table 2--Header &lt;cassert&gt; synopsis
 459
 460 X                         Macro:   assert
 461
 462    19.3  Error numbers                                        [lib.errno]
 463
 464                     Table 3--Header &lt;cerrno&gt; synopsis
 465
 466 X                    |Macros:   EDOM   ERANGE   errno |
 467
 468
 469    20.2  Utility components                                 [lib.utility]
 470
 471    Header &lt;utility&gt; synopsis
 472
 473     // _lib.operators_, operators:
 474 T    namespace rel_ops {
 475 T      template&lt;class T&gt; bool operator!=(const T&amp;, const T&amp;);
 476 T      template&lt;class T&gt; bool operator&gt; (const T&amp;, const T&amp;);
 477 T      template&lt;class T&gt; bool operator&lt;=(const T&amp;, const T&amp;);
 478 T      template&lt;class T&gt; bool operator&gt;=(const T&amp;, const T&amp;);
 479     }
 480     // _lib.pairs_, pairs:
 481 T   template &lt;class T1, class T2&gt; struct pair;
 482 T   template &lt;class T1, class T2&gt;
 483       bool operator==(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
 484 T   template &lt;class T1, class T2&gt;
 485       bool operator&lt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
 486 T   template &lt;class T1, class T2&gt;
 487       bool operator!=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
 488 T   template &lt;class T1, class T2&gt;
 489       bool operator&gt; (const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
 490 T   template &lt;class T1, class T2&gt;
 491       bool operator&gt;=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
 492 T   template &lt;class T1, class T2&gt;
 493       bool operator&lt;=(const pair&lt;T1,T2&gt;&amp;, const pair&lt;T1,T2&gt;&amp;);
 494 T   template &lt;class T1, class T2&gt; pair&lt;T1,T2&gt; make_pair(const T1&amp;, const T2&amp;);
 495
 496
 497    20.2.2  Pairs                                              [lib.pairs]
 498
 499 T  template &lt;class T1, class T2&gt;
 500    struct pair {
 501 T    typedef T1 first_type;
 502 T    typedef T2 second_type;
 503
 504 T    T1 first;
 505 T    T2 second;
 506 T    pair();
 507 T    pair(const T1&amp; x, const T2&amp; y);
 508 T    template&lt;class U, class V&gt; pair(const pair&lt;U, V&gt; &amp;p);
 509    };
 510
 511    20.3  Function objects                          [lib.function.objects]
 512
 513    Header &lt;functional&gt; synopsis
 514
 515     // _lib.base_, base:
 516 V   template &lt;class Arg, class Result&gt; struct unary_function;
 517 V   template &lt;class Arg1, class Arg2, class Result&gt; struct binary_function;
 518
 519     // _lib.arithmetic.operations_, arithmetic operations:
 520 V   template &lt;class T&gt; struct plus;
 521 V   template &lt;class T&gt; struct minus;
 522 V   template &lt;class T&gt; struct multiplies;
 523 V   template &lt;class T&gt; struct divides;
 524 V   template &lt;class T&gt; struct modulus;
 525 V   template &lt;class T&gt; struct negate;
 526     // _lib.comparisons_, comparisons:
 527 V   template &lt;class T&gt; struct equal_to;
 528 V   template &lt;class T&gt; struct not_equal_to;
 529 V   template &lt;class T&gt; struct greater;
 530 V   template &lt;class T&gt; struct less;
 531 V   template &lt;class T&gt; struct greater_equal;
 532 V   template &lt;class T&gt; struct less_equal;
 533     // _lib.logical.operations_, logical operations:
 534 V   template &lt;class T&gt; struct logical_and;
 535 V   template &lt;class T&gt; struct logical_or;
 536 V   template &lt;class T&gt; struct logical_not;
 537     // _lib.negators_, negators:
 538     template &lt;class Predicate&gt; struct unary_negate;
 539 V   template &lt;class Predicate&gt;
 540       unary_negate&lt;Predicate&gt;  not1(const Predicate&amp;);
 541 V   template &lt;class Predicate&gt; struct binary_negate;
 542 V   template &lt;class Predicate&gt;
 543       binary_negate&lt;Predicate&gt; not2(const Predicate&amp;);
 544     // _lib.binders_, binders:
 545 V   template &lt;class Operation&gt;  class binder1st;
 546 V   template &lt;class Operation, class T&gt;
 547       binder1st&lt;Operation&gt; bind1st(const Operation&amp;, const T&amp;);
 548 V   template &lt;class Operation&gt; class binder2nd;
 549 V   template &lt;class Operation, class T&gt;
 550       binder2nd&lt;Operation&gt; bind2nd(const Operation&amp;, const T&amp;);
 551     // _lib.function.pointer.adaptors_, adaptors:
 552 V   template &lt;class Arg, class Result&gt; class pointer_to_unary_function;
 553 V   template &lt;class Arg, class Result&gt;
 554       pointer_to_unary_function&lt;Arg,Result&gt; ptr_fun(Result (*)(Arg));
 555 V   template &lt;class Arg1, class Arg2, class Result&gt;
 556       class pointer_to_binary_function;
 557 V   template &lt;class Arg1, class Arg2, class Result&gt;
 558       pointer_to_binary_function&lt;Arg1,Arg2,Result&gt;
 559         ptr_fun(Result (*)(Arg1,Arg2));
 560
 561     // _lib.member.pointer.adaptors_, adaptors:
 562 V   template&lt;class S, class T&gt; class mem_fun_t;
 563 V   template&lt;class S, class T, class A&gt; class mem_fun1_t;
 564 V   template&lt;class S, class T&gt;
 565         mem_fun_t&lt;S,T&gt; mem_fun(S (T::*f)());
 566 V   template&lt;class S, class T, class A&gt;
 567         mem_fun1_t&lt;S,T,A&gt; mem_fun(S (T::*f)(A));
 568 V   template&lt;class S, class T&gt; class mem_fun_ref_t;
 569 V   template&lt;class S, class T, class A&gt; class mem_fun1_ref_t;
 570 V   template&lt;class S, class T&gt;
 571         mem_fun_ref_t&lt;S,T&gt; mem_fun_ref(S (T::*f)());
 572 V   template&lt;class S, class T, class A&gt;
 573         mem_fun1_ref_t&lt;S,T,A&gt; mem_fun_ref(S (T::*f)(A));
 574
 575 V   template &lt;class S, class T&gt; class const_mem_fun_t;
 576 V   template &lt;class S, class T, class A&gt; class const_mem_fun1_t;
 577 V   template &lt;class S, class T&gt;
 578       const_mem_fun_t&lt;S,T&gt; mem_fun(S (T::*f)() const);
 579 V   template &lt;class S, class T, class A&gt;
 580       const_mem_fun1_t&lt;S,T,A&gt; mem_fun(S (T::*f)(A) const);
 581 V   template &lt;class S, class T&gt; class const_mem_fun_ref_t;
 582 V   template &lt;class S, class T, class A&gt; class const_mem_fun1_ref_t;
 583 V   template &lt;class S, class T&gt;
 584       const_mem_fun_ref_t&lt;S,T&gt; mem_fun_ref(S (T::*f)() const);
 585 V   template &lt;class S, class T, class A&gt;
 586       const_mem_fun1_ref_t&lt;S,T,A&gt; mem_fun_ref(S (T::*f)(A) const);
 587    }
 588
 589    20.3.1  Base                                                [lib.base]
 590
 591 V   template &lt;class Arg, class Result&gt;
 592     struct unary_function {
 593 V     typedef Arg    argument_type;
 594 V     typedef Result result_type;
 595     };
 596 V   template &lt;class Arg1, class Arg2, class Result&gt;
 597     struct binary_function {
 598 V     typedef Arg1   first_argument_type;
 599 V     typedef Arg2   second_argument_type;
 600 V     typedef Result result_type;
 601     };
 602
 603    20.3.2  Arithmetic operations              [lib.arithmetic.operations]
 604
 605 T  template &lt;class T&gt; struct plus : binary_function&lt;T,T,T&gt; {
 606 V   T operator()(const T&amp; x, const T&amp; y) const;
 607    };
 608
 609 T  template &lt;class T&gt; struct minus : binary_function&lt;T,T,T&gt; {
 610 V   T operator()(const T&amp; x, const T&amp; y) const;
 611    };
 612
 613 T  template &lt;class T&gt; struct multiplies : binary_function&lt;T,T,T&gt; {
 614 V   T operator()(const T&amp; x, const T&amp; y) const;
 615    };
 616
 617 T  template &lt;class T&gt; struct divides : binary_function&lt;T,T,T&gt; {
 618 V   T operator()(const T&amp; x, const T&amp; y) const;
 619    };
 620
 621 T  template &lt;class T&gt; struct modulus : binary_function&lt;T,T,T&gt; {
 622 V   T operator()(const T&amp; x, const T&amp; y) const;
 623    };
 624
 625 T  template &lt;class T&gt; struct negate : unary_function&lt;T,T&gt; {
 626 V   T operator()(const T&amp; x) const;
 627    };
 628
 629    20.3.3  Comparisons                                  [lib.comparisons]
 630
 631 T  template &lt;class T&gt; struct equal_to : binary_function&lt;T,T,bool&gt; {
 632 V   bool operator()(const T&amp; x, const T&amp; y) const;
 633    };
 634
 635 T  template &lt;class T&gt; struct not_equal_to : binary_function&lt;T,T,bool&gt; {
 636 V   bool operator()(const T&amp; x, const T&amp; y) const;
 637    };
 638
 639 T  template &lt;class T&gt; struct greater : binary_function&lt;T,T,bool&gt; {
 640 V   bool operator()(const T&amp; x, const T&amp; y) const;
 641    };
 642
 643 T  template &lt;class T&gt; struct less : binary_function&lt;T,T,bool&gt; {
 644 V   bool operator()(const T&amp; x, const T&amp; y) const;
 645    };
 646
 647 T  template &lt;class T&gt; struct greater_equal : binary_function&lt;T,T,bool&gt; {
 648 V   bool operator()(const T&amp; x, const T&amp; y) const;
 649    };
 650
 651 T  template &lt;class T&gt; struct less_equal : binary_function&lt;T,T,bool&gt; {
 652 V   bool operator()(const T&amp; x, const T&amp; y) const;
 653    };
 654
 655    20.3.4  Logical operations                    [lib.logical.operations]
 656
 657 T  template &lt;class T&gt; struct logical_and : binary_function&lt;T,T,bool&gt; {
 658 V   bool operator()(const T&amp; x, const T&amp; y) const;
 659    };
 660
 661 T  template &lt;class T&gt; struct logical_or : binary_function&lt;T,T,bool&gt; {
 662 V   bool operator()(const T&amp; x, const T&amp; y) const;
 663    };
 664
 665 T  template &lt;class T&gt; struct logical_not : unary_function&lt;T,bool&gt; {
 666 V   bool operator()(const T&amp; x) const;
 667    };
 668
 669    20.3.5  Negators                                        [lib.negators]
 670
 671 T  template &lt;class Predicate&gt;
 672     class unary_negate
 673       : public unary_function&lt;typename Predicate::argument_type,bool&gt; {
 674    public:
 675 T   explicit unary_negate(const Predicate&amp; pred);
 676 V   bool operator()(const typename Predicate::argument_type&amp; x) const;
 677    };
 678
 679 T  template &lt;class Predicate&gt;
 680     class binary_negate
 681       : public binary_function&lt;typename Predicate::first_argument_type,
 682           typename Predicate::second_argument_type, bool&gt; {
 683     public:
 684 T     explicit binary_negate(const Predicate&amp; pred);
 685 V     bool operator()(const typename Predicate::first_argument_type&amp;  x,
 686           const typename Predicate::second_argument_type&amp; y) const;
 687     };
 688
 689
 690    20.3.6  Binders                                          [lib.binders]
 691
 692    20.3.6.1  Template class binder1st                    [lib.binder.1st]
 693 T   template &lt;class Operation&gt;
 694     class binder1st
 695       : public unary_function&lt;typename Operation::second_argument_type,
 696                               typename Operation::result_type&gt; {
 697     protected:
 698 T     Operation                      op;
 699 T     typename Operation::first_argument_type value;
 700     public:
 701 V     binder1st(const Operation&amp; x,
 702                 const typename Operation::first_argument_type&amp; y);
 703 V     typename Operation::result_type
 704         operator()(const typename Operation::second_argument_type&amp; x) const;
 705     };
 706
 707    20.3.6.2  bind1st                                       [lib.bind.1st]
 708
 709 V  template &lt;class Operation, class T&gt;
 710     binder1st&lt;Operation&gt; bind1st(const Operation&amp; op, const T&amp; x);
 711
 712    20.3.6.3  Template class binder2nd                    [lib.binder.2nd]
 713 T   template &lt;class Operation&gt;
 714     class binder2nd
 715       : public unary_function&lt;typename Operation::first_argument_type,
 716                               typename Operation::result_type&gt; {
 717     protected:
 718 T     Operation                       op;
 719 T     typename Operation::second_argument_type value;
 720     public:
 721 V     binder2nd(const Operation&amp; x,
 722                 const typename Operation::second_argument_type&amp; y);
 723 V     typename Operation::result_type
 724         operator()(const typename Operation::first_argument_type&amp; x) const;
 725     };
 726
 727    20.3.6.4  bind2nd                                       [lib.bind.2nd]
 728
 729 T  template &lt;class Operation, class T&gt;
 730     binder2nd&lt;Operation&gt; bind2nd(const Operation&amp; op, const T&amp; x);
 731
 732
 733    20.3.7  Adaptors for pointers to       [lib.function.pointer.adaptors]
 734        functions
 735
 736    1 To  allow  pointers to (unary and binary) functions to work with func-
 737    tion adaptors the library provides:
 738
 739 T   template &lt;class Arg, class Result&gt;
 740     class pointer_to_unary_function : public unary_function&lt;Arg, Result&gt; {
 741     public:
 742 T     explicit pointer_to_unary_function(Result (*f)(Arg));
 743 V     Result operator()(Arg x) const;
 744     };
 745
 746 T  template &lt;class Arg, class Result&gt;
 747     pointer_to_unary_function&lt;Arg, Result&gt; ptr_fun(Result (*f)(Arg));
 748
 749 T       template &lt;class Arg1, class Arg2, class Result&gt;
 750         class pointer_to_binary_function :
 751           public binary_function&lt;Arg1,Arg2,Result&gt; {
 752         public:
 753 T         explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
 754 V         Result operator()(Arg1 x, Arg2 y) const;
 755         };
 756
 757
 758    20.3.8  Adaptors for pointers to         [lib.member.pointer.adaptors]
 759        members
 760
 761 T  template &lt;class S, class T&gt; class mem_fun_t
 762           : public unary_function&lt;T*, S&gt; {
 763    public:
 764 T   explicit mem_fun_t(S (T::*p)());
 765 V   S operator()(T* p) const;
 766    };
 767
 768 T   template &lt;class S, class T, class A&gt; class mem_fun1_t
 769           : public binary_function&lt;T*, A, S&gt; {
 770     public:
 771 T     explicit mem_fun1_t(S (T::*p)(A));
 772 V     S operator()(T* p, A x) const;
 773    };
 774
 775 V   template&lt;class S, class T&gt; mem_fun_t&lt;S,T&gt;
 776        mem_fun(S (T::*f)());
 777 V   template&lt;class S, class T, class A&gt; mem_fun1_t&lt;S,T,A&gt;
 778        mem_fun(S (T::*f)(A));
 779
 780 T   template &lt;class S, class T&gt; class mem_fun_ref_t
 781           : public unary_function&lt;T, S&gt; {
 782     public:
 783 T     explicit mem_fun_ref_t(S (T::*p)());
 784 V     S operator()(T&amp; p) const;
 785    };
 786
 787 T   template &lt;class S, class T, class A&gt; class mem_fun1_ref_t
 788           : public binary_function&lt;T, A, S&gt; {
 789     public:
 790 T     explicit mem_fun1_ref_t(S (T::*p)(A));
 791 V     S operator()(T&amp; p, A x) const;
 792    };
 793
 794 T   template&lt;class S, class T&gt; mem_fun_ref_t&lt;S,T&gt;
 795        mem_fun_ref(S (T::*f)());
 796
 797 T   template&lt;class S, class T, class A&gt; mem_fun1_ref_t&lt;S,T,A&gt;
 798        mem_fun_ref(S (T::*f)(A));
 799
 800 T  template &lt;class S, class T&gt; class const_mem_fun_t
 801         : public unary_function&lt;T*, S&gt; {
 802    public:
 803 T   explicit const_mem_fun_t(S (T::*p)() const);
 804 V   S operator()(const T* p) const;
 805    };
 806
 807 T  template &lt;class S, class T, class A&gt; class const_mem_fun1_t
 808         : public binary_function&lt;T*, A, S&gt; {
 809    public:
 810 T   explicit const mem_fun1_t(S (T::*p)(A) const);
 811 V   S operator()(const T* p, A x) const;
 812    };
 813
 814 V   template&lt;class S, class T&gt; const_mem_fun_t&lt;S,T&gt;
 815        mem_fun(S (T::*f)() const);
 816 V   template&lt;class S, class T, class A&gt; const_mem_fun1_t&lt;S,T,A&gt;
 817        mem_fun(S (T::*f)(A) const);
 818
 819 T   template &lt;class S, class T&gt; class const_mem_fun_ref_t
 820           : public unary_function&lt;T, S&gt; {
 821     public:
 822 T     explicit const_mem_fun_ref_t(S (T::*p)() const);
 823 V     S operator()(const T&amp; p) const;
 824    };
 825
 826 T   template &lt;class S, class T, class A&gt; class const_mem_fun1_ref_t
 827           : public binary_function&lt;T, A, S&gt; {
 828     public:
 829 T     explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
 830 V     S operator()(const T&amp; p, A x) const;
 831    };
 832
 833 T   template&lt;class S, class T&gt; const_mem_fun_ref_t&lt;S,T&gt;
 834        mem_fun_ref(S (T::*f)() const);
 835
 836 T   template&lt;class S, class T, class A&gt; const_mem_fun1_ref_t&lt;S,T,A&gt;
 837         mem_fun_ref(S (T::*f)(A) const);
 838
 839    20.4  Memory                                              [lib.memory]
 840
 841    Header &lt;memory&gt; synopsis
 842
 843     // _lib.default.allocator_, the default allocator:
 844 T   template &lt;class T&gt; class allocator;
 845 T   template &lt;&gt; class allocator&lt;void&gt;;
 846 T   template &lt;class T, class U&gt;
 847       bool operator==(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) throw();
 848 T   template &lt;class T, class U&gt;
 849       bool operator!=(const allocator&lt;T&gt;&amp;, const allocator&lt;U&gt;&amp;) throw();
 850     // _lib.storage.iterator_, raw storage iterator:
 851 T   template &lt;class OutputIterator, class T&gt; class raw_storage_iterator;
 852     // _lib.temporary.buffer_, temporary buffers:
 853 T   template &lt;class T&gt;
 854       pair&lt;T*,ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n);
 855 T   template &lt;class T&gt;
 856       void return_temporary_buffer(T* p);
 857     // _lib.specialized.algorithms_, specialized algorithms:
 858 T   template &lt;class InputIterator, class ForwardIterator&gt;
 859       ForwardIterator
 860         uninitialized_copy(InputIterator first, InputIterator last,
 861                            ForwardIterator result);
 862 T   template &lt;class ForwardIterator, class T&gt;
 863       void uninitialized_fill(ForwardIterator first, ForwardIterator last,
 864                               const T&amp; x);
 865 T   template &lt;class ForwardIterator, class Size, class T&gt;
 866       void uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x);
 867     // _lib.auto.ptr_, pointers:
 868 X   template&lt;class X&gt; class auto_ptr;
 869    }
 870
 871    20.4.1  The default allocator                  [lib.default.allocator]
 872
 873 T   template &lt;class T&gt; class allocator;
 874     // specialize for void:
 875 T   template &lt;&gt; class allocator&lt;void&gt; {
 876     public:
 877 T     typedef void*       pointer;
 878 T     typedef const void* const_pointer;
 879       // reference-to-void members are impossible.
 880 T     typedef void  value_type;
 881 T     template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };
 882     };
 883
 884 T   template &lt;class T&gt; class allocator {
 885      public:
 886 T     typedef size_t    size_type;
 887 T     typedef ptrdiff_t difference_type;
 888 T     typedef T*        pointer;
 889 T     typedef const T*  const_pointer;
 890 T     typedef T&amp;        reference;
 891 T     typedef const T&amp;  const_reference;
 892 T     typedef T         value_type;
 893 T     template &lt;class U&gt; struct rebind { typedef allocator&lt;U&gt; other; };
 894 T     allocator() throw();
 895 T     allocator(const allocator&amp;) throw();
 896 T     template &lt;class U&gt; allocator(const allocator&lt;U&gt;&amp;) throw();
 897 T    ~allocator() throw();
 898 T     pointer address(reference x) const;
 899 T     const_pointer address(const_reference x) const;
 900 T     pointer allocate(
 901         size_type, allocator&lt;void&gt;::const_pointer hint = 0);
 902 T     void deallocate(pointer p, size_type n);
 903 T     size_type max_size() const throw();
 904 T     void construct(pointer p, const T&amp; val);
 905 T     void destroy(pointer p);
 906     };
 907
 908    20.4.1.2  allocator globals                    [lib.allocator.globals]
 909
 910 T  template &lt;class T1, class T2&gt;
 911     bool operator==(const allocator&lt;T1&gt;&amp;, const allocator&lt;T2&gt;&amp;) throw();
 912 T  template &lt;class T1, class T2&gt;
 913     bool operator!=(const allocator&lt;T1&gt;&amp;, const allocator&lt;T2&gt;&amp;) throw();
 914
 915    20.4.2  Raw storage iterator                    [lib.storage.iterator]
 916
 917 T   template &lt;class OutputIterator, class T&gt;
 918     class raw_storage_iterator
 919       : public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
 920     public:
 921 T     explicit raw_storage_iterator(OutputIterator x);
 922 T     raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator*();
 923 T     raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator=(const T&amp; element);
 924 T     raw_storage_iterator&lt;OutputIterator,T&gt;&amp; operator++();
 925 T     raw_storage_iterator&lt;OutputIterator,T&gt;  operator++(int);
 926     };
 927
 928    20.4.3  Temporary buffers                       [lib.temporary.buffer]
 929
 930 T  template &lt;class T&gt;
 931     pair&lt;T*, ptrdiff_t&gt; get_temporary_buffer(ptrdiff_t n);
 932
 933 T  template &lt;class T&gt; void return_temporary_buffer(T* p);
 934
 935    20.4.4  Specialized algorithms            [lib.specialized.algorithms]
 936
 937    20.4.4.1  uninitialized_copy                  [lib.uninitialized.copy]
 938
 939 V  template &lt;class InputIterator, class ForwardIterator&gt;
 940     ForwardIterator
 941       uninitialized_copy(InputIterator first, InputIterator last,
 942                          ForwardIterator result);
 943
 944    20.4.4.2  uninitialized_fill                  [lib.uninitialized.fill]
 945
 946 V  template &lt;class ForwardIterator, class T&gt;
 947     void uninitialized_fill(ForwardIterator first, ForwardIterator last,
 948                             const T&amp; x);
 949
 950    20.4.4.3  uninitialized_fill_n              [lib.uninitialized.fill.n]
 951
 952 V  template &lt;class ForwardIterator, class Size, class T&gt;
 953     void uninitialized_fill_n(ForwardIterator first, Size n, const T&amp; x);
 954
 955    20.4.5  Template class auto_ptr                         [lib.auto.ptr]
 956
 957 X   template&lt;class X&gt; class auto_ptr {
 958       template &lt;class Y&gt; struct auto_ptr_ref {};
 959     public:
 960 T     typedef X element_type;
 961       // _lib.auto.ptr.cons_ construct/copy/destroy:
 962 T     explicit auto_ptr(X* p =0) throw();
 963 T     auto_ptr(auto_ptr&amp;) throw();
 964 T     template&lt;class Y&gt; auto_ptr(auto_ptr&lt;Y&gt;&amp;) throw();
 965 T     auto_ptr&amp; operator=(auto_ptr&amp;) throw();
 966 T     template&lt;class Y&gt; auto_ptr&amp; operator=(auto_ptr&lt;Y&gt;&amp;) throw();
 967 T    ~auto_ptr() throw();
 968       // _lib.auto.ptr.members_ members:
 969 T     X&amp; operator*() const throw();
 970 T     X* operator-&gt;() const throw();
 971 T     X* get() const throw();
 972 T     X* release() throw();
 973 T     void reset(X* p =0) throw();
 974
 975       // _lib.auto.ptr.conv_ conversions:
 976 X     auto_ptr(auto_ptr_ref&lt;X&gt;) throw();
 977 X     template&lt;class Y&gt; operator auto_ptr_ref&lt;Y&gt;() throw();
 978 X     template&lt;class Y&gt; operator auto_ptr&lt;Y&gt;() throw();
 979     };
 980
 981    20.4.6  C Library                                       [lib.c.malloc]
 982
 983                     Table 7--Header &lt;cstdlib&gt; synopsis
 984
 985 X                    Functions:   calloc   malloc
 986                                   free     realloc
 987
 988
 989                     Table 8--Header &lt;cstring&gt; synopsis
 990
 991 X                    Macro:       NULL
 992 X                    Type:        size_t
 993 X                    Functions:   memchr    memcmp
 994 X                    memcpy       memmove   memset
 995
 996                      Table 9--Header &lt;ctime&gt; synopsis
 997
 998 X          Macros:   NULL
 999 X          Types:    size_t   clock_t    time_t
1000 X          Struct:   tm
1001            Functions:
1002 X          asctime   clock    difftime   localtime   strftime
1003 X          ctime     gmtime   mktime     time
1004
1005    21.1.1  Character traits requirements        [lib.char.traits.require]
1006
1007    2 The struct template
1008 T  template&lt;class charT&gt; struct char_traits;
1009    shall be provided in the header &lt;string&gt; as a basis for  explicit spe-
1010    cializations.
1011
1012
1013    21.1.3.1  struct                [lib.char.traits.specializations.char]
1014        char_traits&lt;char&gt;
1015
1016 T   template&lt;&gt;
1017     struct char_traits&lt;char&gt; {
1018 T     typedef char        char_type;
1019 T     typedef int         int_type;
1020 T     typedef streamoff   off_type;
1021 T     typedef streampos   pos_type;
1022 T     typedef mbstate_t   state_type;
1023
1024 T     static void assign(char_type&amp; c1, const char_type&amp; c2);
1025 T     static bool eq(const char_type&amp; c1, const char_type&amp; c2);
1026 T     static bool lt(const char_type&amp; c1, const char_type&amp; c2);
1027
1028 T     static int compare(const char_type* s1, const char_type* s2, size_t n);
1029 T     static size_t length(const char_type* s);
1030 T     static const char_type* find(const char_type* s, size_t n,
1031                                    const char_type&amp; a);
1032 T     static char_type* move(char_type* s1, const char_type* s2, size_t n);
1033 T     static char_type* copy(char_type* s1, const char_type* s2, size_t n);
1034 T     static char_type* assign(char_type* s, size_t n, char_type a);
1035
1036 T     static int_type not_eof(const int_type&amp; c);
1037 T     static char_type to_char_type(const int_type&amp; c);
1038 T     static int_type to_int_type(const char_type&amp; c);
1039 T     static bool eq_int_type(const int_type&amp; c1, const int_type&amp; c2);
1040 T     static int_type eof();
1041     };
1042
1043    21.1.3.2  struct             [lib.char.traits.specializations.wchar.t]
1044        char_traits&lt;wchar_t&gt;
1045
1046 V   template&lt;&gt;
1047     struct char_traits&lt;wchar_t&gt; {
1048 V     typedef wchar_t      char_type;
1049 V     typedef wint_t       int_type;
1050 V     typedef streamoff   off_type;
1051 V     typedef wstreampos   pos_type;
1052 V     typedef mbstate_t    state_type;
1053
1054 V     static void assign(char_type&amp; c1, const char_type&amp; c2);
1055 V     static bool eq(const char_type&amp; c1, const char_type&amp; c2);
1056 V     static bool lt(const char_type&amp; c1, const char_type&amp; c2);
1057
1058 V     static int compare(const char_type* s1, const char_type* s2, size_t n);
1059 V     static size_t length(const char_type* s);
1060 V     static const char_type* find(const char_type* s, size_t n,
1061                                    const char_type&amp; a);
1062 V     static char_type* move(char_type* s1, const char_type* s2, size_t n);
1063 V     static char_type* copy(char_type* s1, const char_type* s2, size_t n);
1064 V     static char_type* assign(char_type* s, size_t n, char_type a);
1065
1066 V     static int_type not_eof(const int_type&amp; c);
1067 V     static char_type to_char_type(const int_type&amp; c);
1068 V     static int_type to_int_type(const char_type&amp; c);
1069 V     static bool eq_int_type(const int_type&amp; c1, const int_type&amp; c2);
1070 V     static int_type eof();
1071     };
1072
1073    21.2  String classes                              [lib.string.classes]
1074
1075     // _lib.char.traits_, character traits:
1076 V   template&lt;class charT&gt;
1077       struct char_traits;
1078 V   template &lt;&gt; struct char_traits&lt;char&gt;;
1079 V   template &lt;&gt; struct char_traits&lt;wchar_t&gt;;
1080
1081     // _lib.basic.string_, basic_string:
1082 V   template&lt;class charT, class traits = char_traits&lt;charT&gt;,
1083              class Allocator = allocator&lt;charT&gt; &gt;
1084       class basic_string;
1085 V   template&lt;class charT, class traits, class Allocator&gt;
1086       basic_string&lt;charT,traits,Allocator&gt;
1087         operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1088                   const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1089 V   template&lt;class charT, class traits, class Allocator&gt;
1090       basic_string&lt;charT,traits,Allocator&gt;
1091         operator+(const charT* lhs,
1092                   const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1093 V   template&lt;class charT, class traits, class Allocator&gt;
1094       basic_string&lt;charT,traits,Allocator&gt;
1095         operator+(charT lhs, const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1096 V   template&lt;class charT, class traits, class Allocator&gt;
1097       basic_string&lt;charT,traits,Allocator&gt;
1098         operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1099                   const charT* rhs);
1100 V   template&lt;class charT, class traits, class Allocator&gt;
1101       basic_string&lt;charT,traits,Allocator&gt;
1102         operator+(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs, charT rhs);
1103
1104 V   template&lt;class charT, class traits, class Allocator&gt;
1105       bool operator==(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1106                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1107 V   template&lt;class charT, class traits, class Allocator&gt;
1108       bool operator==(const charT* lhs,
1109                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1110 V   template&lt;class charT, class traits, class Allocator&gt;
1111       bool operator==(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1112                       const charT* rhs);
1113 V   template&lt;class charT, class traits, class Allocator&gt;
1114       bool operator!=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1115                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1116 V   template&lt;class charT, class traits, class Allocator&gt;
1117       bool operator!=(const charT* lhs,
1118                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1119 V   template&lt;class charT, class traits, class Allocator&gt;
1120       bool operator!=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1121                       const charT* rhs);
1122 V   template&lt;class charT, class traits, class Allocator&gt;
1123       bool operator&lt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1124                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1125 V   template&lt;class charT, class traits, class Allocator&gt;
1126       bool operator&lt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1127                       const charT* rhs);
1128 V   template&lt;class charT, class traits, class Allocator&gt;
1129       bool operator&lt; (const charT* lhs,
1130                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1131 V   template&lt;class charT, class traits, class Allocator&gt;
1132       bool operator&gt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1133                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1134 V   template&lt;class charT, class traits, class Allocator&gt;
1135       bool operator&gt; (const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1136                       const charT* rhs);
1137 V   template&lt;class charT, class traits, class Allocator&gt;
1138       bool operator&gt; (const charT* lhs,
1139                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1140 V   template&lt;class charT, class traits, class Allocator&gt;
1141       bool operator&lt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1142                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1143 V   template&lt;class charT, class traits, class Allocator&gt;
1144       bool operator&lt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1145                       const charT* rhs);
1146 V   template&lt;class charT, class traits, class Allocator&gt;
1147       bool operator&lt;=(const charT* lhs,
1148                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1149 V   template&lt;class charT, class traits, class Allocator&gt;
1150       bool operator&gt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1151                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1152 V   template&lt;class charT, class traits, class Allocator&gt;
1153       bool operator&gt;=(const basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1154                       const charT* rhs);
1155 V   template&lt;class charT, class traits, class Allocator&gt;
1156       bool operator&gt;=(const charT* lhs,
1157                       const basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1158
1159     // _lib.string.special_:
1160 V   template&lt;class charT, class traits, class Allocator&gt;
1161        void swap(basic_string&lt;charT,traits,Allocator&gt;&amp; lhs,
1162                  basic_string&lt;charT,traits,Allocator&gt;&amp; rhs);
1163 V   template&lt;class charT, class traits, class Allocator&gt;
1164      basic_istream&lt;charT,traits&gt;&amp;
1165       operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp; is,
1166                  basic_string&lt;charT,traits,Allocator&gt;&amp; str);
1167 T   template&lt;class charT, class traits, class Allocator&gt;
1168      basic_ostream&lt;charT, traits&gt;&amp;
1169       operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os,
1170                  const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
1171 V   template&lt;class charT, class traits, class Allocator&gt;
1172      basic_istream&lt;charT,traits&gt;&amp;
1173        getline(basic_istream&lt;charT,traits&gt;&amp; is,
1174                basic_string&lt;charT,traits,Allocator&gt;&amp; str,
1175                charT delim);
1176 V   template&lt;class charT, class traits, class Allocator&gt;
1177      basic_istream&lt;charT,traits&gt;&amp;
1178        getline(basic_istream&lt;charT,traits&gt;&amp; is,
1179                basic_string&lt;charT,traits,Allocator&gt;&amp; str);
1180 V   typedef basic_string&lt;char&gt; string;
1181 T   typedef basic_string&lt;wchar_t&gt; wstring;
1182    }
1183
1184    21.3  Template class basic_string                   [lib.basic.string]
1185
1186 V  namespace std {
1187     template&lt;class charT, class traits = char_traits&lt;charT&gt;,
1188              class Allocator = allocator&lt;charT&gt; &gt;
1189     class basic_string {
1190     public:
1191       // types:
1192       typedef          traits                     traits_type;
1193       typedef typename traits::char_type          value_type;
1194       typedef          Allocator                  allocator_type;
1195       typedef typename Allocator::size_type       size_type;
1196       typedef typename Allocator::difference_type difference_type;
1197       typedef typename Allocator::reference       reference;
1198       typedef typename Allocator::const_reference const_reference;
1199       typedef typename Allocator::pointer         pointer;
1200       typedef typename Allocator::const_pointer   const_pointer;
1201       typedef implementation defined             iterator;
1202       typedef implementation defined             const_iterator;
1203       typedef std::reverse_iterator&lt;iterator&gt; reverse_iterator;
1204       typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
1205       static const size_type npos = -1;
1206
1207       // _lib.string.cons_ construct/copy/destroy:
1208 V     explicit basic_string(const Allocator&amp; a = Allocator());
1209 V     basic_string(const basic_string&amp; str, size_type pos = 0,
1210                    size_type n = npos, const Allocator&amp; a = Allocator());
1211 V     basic_string(const charT* s,
1212                    size_type n, const Allocator&amp; a = Allocator());
1213 V     basic_string(const charT* s, const Allocator&amp; a = Allocator());
1214 V     basic_string(size_type n, charT c, const Allocator&amp; a = Allocator());
1215 V     template&lt;class InputIterator&gt;
1216         basic_string(InputIterator begin, InputIterator end,
1217                      const Allocator&amp; a = Allocator());
1218 V    ~basic_string();
1219 V     basic_string&amp; operator=(const basic_string&amp; str);
1220 V     basic_string&amp; operator=(const charT* s);
1221 V     basic_string&amp; operator=(charT c);
1222       // _lib.string.iterators_ iterators:
1223 V     iterator       begin();
1224 V     const_iterator begin() const;
1225 V     iterator       end();
1226 V     const_iterator end() const;
1227
1228 V     reverse_iterator       rbegin();
1229 V     const_reverse_iterator rbegin() const;
1230 V     reverse_iterator       rend();
1231 V     const_reverse_iterator rend() const;
1232       // _lib.string.capacity_ capacity:
1233 V     size_type size() const;
1234 V     size_type length() const;
1235 V     size_type max_size() const;
1236 V     void resize(size_type n, charT c);
1237 V     void resize(size_type n);
1238 V     size_type capacity() const;
1239 V     void reserve(size_type res_arg = 0);
1240 V     void clear();
1241 V     bool empty() const;
1242       // _lib.string.access_ element access:
1243 V     const_reference operator[](size_type pos) const;
1244 V     reference       operator[](size_type pos);
1245 V     const_reference at(size_type n) const;
1246 V     reference       at(size_type n);
1247       // _lib.string.modifiers_ modifiers:
1248 V     basic_string&amp; operator+=(const basic_string&amp; str);
1249 V     basic_string&amp; operator+=(const charT* s);
1250 V     basic_string&amp; operator+=(charT c);
1251 V     basic_string&amp; append(const basic_string&amp; str);
1252 V     basic_string&amp; append(const basic_string&amp; str, size_type pos,
1253                            size_type n);
1254 V     basic_string&amp; append(const charT* s, size_type n);
1255 V     basic_string&amp; append(const charT* s);
1256 V     basic_string&amp; append(size_type n, charT c);
1257 V     template&lt;class InputIterator&gt;
1258         basic_string&amp; append(InputIterator first, InputIterator last);
1259 V     void push_back(const charT);
1260
1261 V     basic_string&amp; assign(const basic_string&amp;);
1262 V     basic_string&amp; assign(const basic_string&amp; str, size_type pos,
1263                            size_type n);
1264 V     basic_string&amp; assign(const charT* s, size_type n);
1265 V     basic_string&amp; assign(const charT* s);
1266 V     basic_string&amp; assign(size_type n, charT c);
1267 V     template&lt;class InputIterator&gt;
1268         basic_string&amp; assign(InputIterator first, InputIterator last);
1269 V     basic_string&amp; insert(size_type pos1, const basic_string&amp; str);
1270 V     basic_string&amp; insert(size_type pos1, const basic_string&amp; str,
1271                            size_type pos2, size_type n);
1272 V     basic_string&amp; insert(size_type pos, const charT* s, size_type n);
1273 V     basic_string&amp; insert(size_type pos, const charT* s);
1274 V     basic_string&amp; insert(size_type pos, size_type n, charT c);
1275 V     iterator insert(iterator p, charT c);
1276 V     void     insert(iterator p, size_type n, charT c);
1277 V     template&lt;class InputIterator&gt;
1278         void insert(iterator p, InputIterator first, InputIterator last);
1279 V     basic_string&amp; erase(size_type pos = 0, size_type n = npos);
1280 V     iterator erase(iterator position);
1281 V     iterator erase(iterator first, iterator last);
1282 V     basic_string&amp; replace(size_type pos1, size_type n1,
1283                             const basic_string&amp; str);
1284 V     basic_string&amp; replace(size_type pos1, size_type n1,
1285                             const basic_string&amp; str,
1286                             size_type pos2, size_type n2);
1287 V     basic_string&amp; replace(size_type pos, size_type n1, const charT* s,
1288                             size_type n2);
1289 V     basic_string&amp; replace(size_type pos, size_type n1, const charT* s);
1290 V     basic_string&amp; replace(size_type pos, size_type n1, size_type n2,
1291                             charT c);
1292 V     basic_string&amp; replace(iterator i1, iterator i2, const basic_string&amp; str);
1293 V     basic_string&amp; replace(iterator i1, iterator i2, const charT* s,
1294                             size_type n);
1295 V     basic_string&amp; replace(iterator i1, iterator i2, const charT* s);
1296 V     basic_string&amp; replace(iterator i1, iterator i2,
1297                             size_type n, charT c);
1298 V     template&lt;class InputIterator&gt;
1299         basic_string&amp; replace(iterator i1, iterator i2,
1300                               InputIterator j1, InputIterator j2);
1301 V     size_type copy(charT* s, size_type n, size_type pos = 0) const;
1302 V     void swap(basic_string&lt;charT,traits,Allocator&gt;&amp;);
1303       // _lib.string.ops_ string operations:
1304 V     const charT* c_str() const;         // explicit
1305 V     const charT* data() const;
1306 V     allocator_type get_allocator() const;
1307 V     size_type find (const basic_string&amp; str, size_type pos = 0) const;
1308 V     size_type find (const charT* s, size_type pos, size_type n) const;
1309 V     size_type find (const charT* s, size_type pos = 0) const;
1310 V     size_type find (charT c, size_type pos = 0) const;
1311 V     size_type rfind(const basic_string&amp; str, size_type pos = npos) const;
1312 V     size_type rfind(const charT* s, size_type pos, size_type n) const;
1313 V     size_type rfind(const charT* s, size_type pos = npos) const;
1314 V     size_type rfind(charT c, size_type pos = npos) const;
1315
1316 V     size_type find_first_of(const basic_string&amp; str,
1317                               size_type pos = 0) const;
1318 V     size_type find_first_of(const charT* s,
1319                               size_type pos, size_type n) const;
1320 V     size_type find_first_of(const charT* s, size_type pos = 0) const;
1321 V     size_type find_first_of(charT c, size_type pos = 0) const;
1322 V     size_type find_last_of (const basic_string&amp; str,
1323                               size_type pos = npos) const;
1324 V     size_type find_last_of (const charT* s,
1325                               size_type pos, size_type n) const;
1326 V     size_type find_last_of (const charT* s, size_type pos = npos) const;
1327 V     size_type find_last_of (charT c, size_type pos = npos) const;
1328 V     size_type find_first_not_of(const basic_string&amp; str,
1329                                   size_type pos = 0) const;
1330 V     size_type find_first_not_of(const charT* s, size_type pos,
1331                                   size_type n) const;
1332 V     size_type find_first_not_of(const charT* s, size_type pos = 0) const;
1333 V     size_type find_first_not_of(charT c, size_type pos = 0) const;
1334 V     size_type find_last_not_of (const basic_string&amp; str,
1335                                   size_type pos = npos) const;
1336 V     size_type find_last_not_of (const charT* s, size_type pos,
1337                                   size_type n) const;
1338 V     size_type find_last_not_of (const charT* s,
1339                                   size_type pos = npos) const;
1340 V     size_type find_last_not_of (charT c, size_type pos = npos) const;
1341 V     basic_string substr(size_type pos = 0, size_type n = npos) const;
1342 V     int compare(const basic_string&amp; str) const;
1343 V     int compare(size_type pos1, size_type n1,
1344                   const basic_string&amp; str) const;
1345 V     int compare(size_type pos1, size_type n1,
1346                   const basic_string&amp; str,
1347                   size_type pos2, size_type n2) const;
1348 V     int compare(const charT* s) const;
1349 V     int compare(size_type pos1, size_type n1,
1350                   const charT* s, size_type n2 = npos) const;
1351     };
1352    }
1353
1354    21.4  Null-terminated sequence utilities               [lib.c.strings]
1355
1356                     Table 10--Header &lt;cctype&gt; synopsis
1357
1358             isalnum   isdigit   isprint   isupper    tolower
1359 X           isalpha   isgraph   ispunct   isxdigit   toupper
1360             iscntrl   islower   isspace
1361
1362                    Table 11--Header &lt;cwctype&gt; synopsis
1363
1364 X  Macro:     WEOF &lt;cwctype&gt;
1365 X  Types:     wctrans_t   wctype_t   wint_t &lt;cwctype&gt;
1366    Functions:
1367 X  iswalnum   iswctype    iswlower   iswspace    towctrans   wctrans
1368 X  iswalpha   iswdigit    iswprint   iswupper    towlower    wctype
1369 X  iswcntrl   iswgraph    iswpunct   iswxdigit   towupper
1370
1371                    Table 12--Header &lt;cstring&gt; synopsis
1372
1373 X           Macro:    NULL &lt;cstring&gt;
1374 X           Type:     size_t &lt;cstring&gt;
1375             Functions:
1376 X           memchr    strcat    strcspn    strncpy   strtok
1377 X           memcmp    strchr    strerror   strpbrk   strxfrm
1378 X           memcpy    strcmp    strlen     strrchr
1379 X           memmove   strcoll   strncat    strspn
1380 X           memset    strcpy    strncmp    strstr
1381
1382                     Table 13--Header &lt;cwchar&gt; synopsis
1383    Macros:    NULL &lt;cwchar&gt;   WCHAR_MAX         WCHAR_MIN   WEOF &lt;cwchar&gt;
1384    Types:     mbstate_t       wint_t &lt;cwchar&gt;   size_t
1385    Functions:
1386 X  btowc      getwchar        ungetwc           wcscpy      wcsrtombs   wmemchr
1387 X  fgetwc     mbrlen          vfwprintf         wcscspn     wcsspn      wmemcmp
1388 X  fgetws     mbrtowc         vswprintf         wcsftime    wcsstr      wmemcpy
1389 X  fputwc     mbsinit         vwprintf          wcslen      wcstod      wmemmove
1390 X  fputws     mbsrtowcs       wcrtomb           wcsncat     wcstok      wmemset
1391 X  fwide      putwc           wcscat            wcsncmp     wcstol      wprintf
1392 X  fwprintf   putwchar        wcschr            wcsncpy     wcstoul     wscanf
1393 X  fwscanf    swprintf        wcscmp            wcspbrk     wcsxfrm
1394 X  getwc      swscanf         wcscoll           wcsrchr     wctob
1395
1396                    Table 14--Header &lt;cstdlib&gt; synopsis
1397
1398                Macros:   MB_CUR_MAX
1399                Functions:
1400 X              atol      mblen        strtod    wctomb
1401 X              atof      mbstowcs     strtol    wcstombs
1402 X              atoi      mbtowc       strtoul
1403
1404 X  const char* strchr(const char* s, int c);
1405 X       char* strchr(      char* s, int c);
1406
1407 X  const char* strpbrk(const char* s1, const char* s2);
1408 X       char* strpbrk(      char* s1, const char* s2);
1409
1410 X  const char* strrchr(const char* s, int c);
1411 X       char* strrchr(      char* s, int c);
1412
1413 X  const char* strstr(const char* s1, const char* s2);
1414 X       char* strstr(      char* s1, const char* s2);
1415
1416 X  const void* memchr(const void* s, int c, size_t n);
1417 X       void* memchr(      void* s, int c, size_t n);
1418
1419 X  const wchar_t* wcschr(const wchar_t* s, wchar_t c);
1420 X       wchar_t* wcschr(      wchar_t* s, wchar_t c);
1421
1422 X  const wchar_t* wcspbrk(const wchar_t* s1, const wchar_t* s2);
1423 X       wchar_t* wcspbrk(      wchar_t* s1, const wchar_t* s2);
1424
1425 X  const wchar_t* wcsrchr(const wchar_t* s, wchar_t c);
1426 X       wchar_t* wcsrchr(      wchar_t* s, wchar_t c);
1427
1428 X  const wchar_t* wcsstr(const wchar_t* s1, const wchar_t* s2);
1429 X       wchar_t* wcsstr(      wchar_t* s1, const wchar_t* s2);
1430
1431 X  const wchar_t* wmemchr(const wchar_t* s, wchar_t c, size_t n);
1432 X       wchar_t* wmemchr(      wchar_t* s, wchar_t c, size_t n);
1433
1434    [for initial efforts on the above, see shadow/string.h]
1435
1436    22.1  Locales                                            [lib.locales]
1437
1438    Header &lt;locale&gt; synopsis
1439
1440     // _lib.locale_, locale:
1441 T   class locale;
1442 T   template &lt;class Facet&gt; const Facet&amp; use_facet(const locale&amp;);
1443 T   template &lt;class Facet&gt; bool         has_facet(const locale&amp;) throw();
1444
1445     // _lib.locale.convenience_, convenience interfaces:
1446 T   template &lt;class charT&gt; bool isspace (charT c, const locale&amp; loc);
1447 T   template &lt;class charT&gt; bool isprint (charT c, const locale&amp; loc);
1448 T   template &lt;class charT&gt; bool iscntrl (charT c, const locale&amp; loc);
1449 T   template &lt;class charT&gt; bool isupper (charT c, const locale&amp; loc);
1450 T   template &lt;class charT&gt; bool islower (charT c, const locale&amp; loc);
1451 T   template &lt;class charT&gt; bool isalpha (charT c, const locale&amp; loc);
1452 T   template &lt;class charT&gt; bool isdigit (charT c, const locale&amp; loc);
1453 T   template &lt;class charT&gt; bool ispunct (charT c, const locale&amp; loc);
1454 T   template &lt;class charT&gt; bool isxdigit(charT c, const locale&amp; loc);
1455 T   template &lt;class charT&gt; bool isalnum (charT c, const locale&amp; loc);
1456 T   template &lt;class charT&gt; bool isgraph (charT c, const locale&amp; loc);
1457 T   template &lt;class charT&gt; charT toupper(charT c, const locale&amp; loc);
1458 T   template &lt;class charT&gt; charT tolower(charT c, const locale&amp; loc);
1459     // _lib.category.ctype_ and _lib.facet.ctype.special_, ctype:
1460     class ctype_base;
1461 T   template &lt;class charT&gt; class ctype;
1462 T   template &lt;&gt;            class ctype&lt;char&gt;;             // specialization
1463 S   template &lt;class charT&gt; class ctype_byname;
1464 S   template &lt;&gt;            class ctype_byname&lt;char&gt;;      // specialization
1465 T   class codecvt_base;
1466 X   template &lt;class internT, class externT, class stateT&gt; class codecvt;
1467 S   template &lt;class internT, class externT, class stateT&gt; class codecvt_byname;
1468     // _lib.category.numeric_ and _lib.facet.numpunct_, numeric:
1469 X   template &lt;class charT, class InputIterator&gt;  class num_get;
1470 X   template &lt;class charT, class OutputIterator&gt; class num_put;
1471 T   template &lt;class charT&gt; class numpunct;
1472 S   template &lt;class charT&gt; class numpunct_byname;
1473     // _lib.category.collate_, collation:
1474 T   template &lt;class charT&gt; class collate;
1475 S   template &lt;class charT&gt; class collate_byname;
1476     // _lib.category.time_, date and time:
1477 T   class time_base;
1478 S   template &lt;class charT, class InputIterator&gt;  class time_get;
1479 S   template &lt;class charT, class InputIterator&gt;  class time_get_byname;
1480 S   template &lt;class charT, class OutputIterator&gt; class time_put;
1481 S   template &lt;class charT, class OutputIterator&gt; class time_put_byname;
1482     // _lib.category.monetary_, money:
1483 T   class money_base;
1484 S   template &lt;class charT, class InputIterator&gt;  class money_get;
1485 S   template &lt;class charT, class OutputIterator&gt; class money_put;
1486 S   template &lt;class charT, bool Intl&gt; class moneypunct;
1487 S   template &lt;class charT, bool Intl&gt; class moneypunct_byname;
1488     // _lib.category.messages_, message retrieval:
1489 T   class messages_base;
1490 S   template &lt;class charT&gt; class messages;
1491 S   template &lt;class charT&gt; class messages_byname;
1492
1493
1494    22.1.1  Class locale                                      [lib.locale]
1495
1496 X   class locale {
1497     public:
1498       // types:
1499 T     class facet;
1500 T     class id;
1501 T     typedef int category;
1502 T     static const category   // values assigned here are for exposition only
1503 T       none     = 0,
1504 T       collate  = 0x010, ctype    = 0x020,
1505 T       monetary = 0x040, numeric  = 0x080,
1506 T       time     = 0x100, messages = 0x200,
1507 T       all = collate | ctype | monetary | numeric | time  | messages;
1508       // construct/copy/destroy:
1509 T     locale() throw()
1510 T     locale(const locale&amp; other) throw()
1511 X     explicit locale(const char* std_name);
1512 X     locale(const locale&amp; other, const char* std_name, category);
1513 T     template &lt;class Facet&gt; locale(const locale&amp; other, Facet* f);
1514 T     locale(const locale&amp; other, const locale&amp; one, category);
1515 T    ~locale() throw();           // non-virtual
1516 T     const locale&amp; operator=(const locale&amp; other) throw();
1517 T     template &lt;class Facet&gt; locale combine(const locale&amp; other) const;
1518       // locale operations:
1519 X     basic_string&lt;char&gt;                  name() const;
1520 T     bool operator==(const locale&amp; other) const;
1521 T     bool operator!=(const locale&amp; other) const;
1522 T     template &lt;class charT, class Traits, class Allocator&gt;
1523         bool operator()(const basic_string&lt;charT,Traits,Allocator&gt;&amp; s1,
1524                         const basic_string&lt;charT,Traits,Allocator&gt;&amp; s2) const;
1525       // global locale objects:
1526 T     static       locale  global(const locale&amp;);
1527 T     static const locale&amp; classic();
1528     };
1529
1530    22.1.1.1  locale types                              [lib.locale.types]
1531
1532    22.1.1.1.1  Type locale::category                [lib.locale.category]
1533
1534 T  typedef int category;
1535
1536 T   none, collate, ctype, monetary, numeric, time, and messages
1537
1538       [required locale members]
1539 T     collate&lt;char&gt;, collate&lt;wchar_t&gt;
1540 T     ctype&lt;char&gt;, ctype&lt;wchar_t&gt;
1541 T     codecvt&lt;char,char,mbstate_t&gt;,
1542 S     codecvt&lt;wchar_t,char,mbstate_t&gt;
1543 T     moneypunct&lt;char&gt;, moneypunct&lt;wchar_t&gt;
1544 T     moneypunct&lt;char,true&gt;, moneypunct&lt;wchar_t,true&gt;,
1545 S     money_get&lt;char&gt;, money_get&lt;wchar_t
1546 S     money_put&lt;char&gt;, money_put&lt;wchar_t&gt;
1547 T     numpunct&lt;char&gt;, numpunct&lt;wchar_t&gt;,
1548 X     num_get&lt;char&gt;, num_get&lt;wchar_t&gt;
1549 X     num_put&lt;char&gt;, num_put&lt;wchar_t&gt;
1550 S     time_get&lt;char&gt;, time_get&lt;wchar_t&gt;,
1551 S     time_put&lt;char&gt;, time_put&lt;wchar_t&gt;
1552 S     messages&lt;char&gt;, messages&lt;wchar_t&gt;
1553
1554       [required instantiations]
1555 S    collate_byname&lt;char&gt;, collate_byname&lt;wchar_t&gt;
1556 S    ctype_byname&lt;char&gt;, ctype_byname&lt;wchar_t&gt;
1557 S    codecvt_byname&lt;char,char,mbstate_t&gt;,
1558 S    codecvt_byname&lt;wchar_t,char,mbstate_t&gt;
1559 S    moneypunct_byname&lt;char,International&gt;,
1560 S    moneypunct_byname&lt;wchar_t,International&gt;,
1561 S    money_get&lt;C,InputIterator&gt;,
1562 S    money_put&lt;C,OutputIterator&gt;
1563 S    numpunct_byname&lt;char&gt;, numpunct_byname&lt;wchar_t&gt;
1564 X    num_get&lt;C,InputIterator&gt;, num_put&lt;C,OutputIterator&gt;
1565 S    time_get&lt;char,InputIterator&gt;,
1566 S    time_get_byname&lt;char,InputIterator&gt;,
1567 S    time_get&lt;wchar_t,OutputIterator&gt;,
1568 S    time_get_byname&lt;wchar_t,OutputIterator&gt;,
1569 S    time_put&lt;char,OutputIterator&gt;,
1570 S    time_put_byname&lt;char,OutputIterator&gt;,
1571 S    time_put&lt;wchar_t,OutputIterator&gt;
1572 S    time_put_byname&lt;wchar_t,OutputIterator&gt;
1573 S    messages_byname&lt;char&gt;, messages_byname&lt;wchar_t&gt;
1574
1575
1576    22.1.1.1.2  Class locale::facet                     [lib.locale.facet]
1577
1578 T   class locale::facet {
1579     protected:
1580 T     explicit facet(size_t refs = 0);
1581 T     virtual ~facet();
1582     private:
1583 T     facet(const facet&amp;);                // not defined
1584 T     void operator=(const facet&amp;);       // not defined
1585     };
1586    }
1587
1588
1589    22.1.1.1.3  Class locale::id                           [lib.locale.id]
1590
1591 T   class locale::id {
1592     public:
1593 T     id();
1594     private:
1595 T     void operator=(const id&amp;);  // not defined
1596 T     id(const id&amp;);              // not defined
1597     };
1598    }
1599
1600
1601    22.2.1  The ctype category                        [lib.category.ctype]
1602
1603 T   class ctype_base {
1604     public:
1605 T     enum mask {         // numeric values are for exposition only.
1606 T       space=, print=, cntrl=, upper=, lower=,
1607 T       alpha=, digit=, punct=, xdigit=,
1608 T       alnum=, graph=
1609       };
1610     };
1611
1612
1613    22.2.1.1  Template class ctype                      [lib.locale.ctype]
1614
1615 T   template &lt;class charT&gt;
1616     class ctype : public locale::facet, public ctype_base {
1617     public:
1618 T     typedef charT char_type;
1619 T     explicit ctype(size_t refs = 0);
1620 T     bool         is(mask m, charT c) const;
1621 T     const charT* is(const charT* low, const charT* high, mask* vec) const;
1622 T     const charT* scan_is(mask m,
1623                            const charT* low, const charT* high) const;
1624 T     const charT* scan_not(mask m,
1625                             const charT* low, const charT* high) const;
1626 T     charT        toupper(charT c) const;
1627 T     const charT* toupper(charT* low, const charT* high) const;
1628 T     charT        tolower(charT c) const;
1629 T     const charT* tolower(charT* low, const charT* high) const;
1630 T     charT        widen(char c) const;
1631 T     const char*  widen(const char* low, const char* high, charT* to) const;
1632 T     char         narrow(charT c, char dfault) const;
1633 T     const charT* narrow(const charT* low, const charT*, char dfault,
1634                           char* to) const;
1635 T     static locale::id id;
1636
1637     protected:
1638 T    ~ctype();                    // virtual
1639 T     virtual bool         do_is(mask m, charT c) const;
1640 T     virtual const charT* do_is(const charT* low, const charT* high,
1641                                  mask* vec) const;
1642 T     virtual const charT* do_scan_is(mask m,
1643                               const charT* low, const charT* high) const;
1644 T     virtual const charT* do_scan_not(mask m,
1645                               const charT* low, const charT* high) const;
1646 T     virtual charT        do_toupper(charT) const;
1647 T     virtual const charT* do_toupper(charT* low, const charT* high) const;
1648 T     virtual charT        do_tolower(charT) const;
1649 T     virtual const charT* do_tolower(charT* low, const charT* high) const;
1650 T     virtual charT        do_widen(char) const;
1651 T     virtual const char*  do_widen(const char* low, const char* high,
1652                                     charT* dest) const;
1653 T     virtual char         do_narrow(charT, char dfault) const;
1654 T     virtual const charT* do_narrow(const charT* low, const charT* high,
1655                                      char dfault, char* dest) const;
1656     };
1657
1658
1659    22.2.1.2  Template class ctype_byname        [lib.locale.ctype.byname]
1660
1661 X   template &lt;class charT&gt;
1662     class ctype_byname : public ctype&lt;charT&gt; {
1663     public:
1664 T     typedef ctype&lt;charT&gt;::mask mask;
1665 S     explicit ctype_byname(const char*, size_t refs = 0);
1666     protected:
1667 S    ~ctype_byname();             // virtual
1668 S     virtual bool         do_is(mask m, charT c) const;
1669 S     virtual const charT* do_is(const charT* low, const charT* high,
1670                                  mask* vec) const;
1671 S     virtual const char*  do_scan_is(mask m,
1672                                const charT* low, const charT* high) const;
1673 S     virtual const char*  do_scan_not(mask m,
1674                                const charT* low, const charT* high) const;
1675 S     virtual charT        do_toupper(charT) const;
1676 S     virtual const charT* do_toupper(charT* low, const charT* high) const;
1677 S     virtual charT        do_tolower(charT) const;
1678 S     virtual const charT* do_tolower(charT* low, const charT* high) const;
1679 S     virtual charT        do_widen(char) const;
1680 S     virtual const char*  do_widen(const char* low, const char* high,
1681                                     charT* dest) const;
1682 S     virtual char         do_narrow(charT, char dfault) const;
1683 S     virtual const charT* do_narrow(const charT* low, const charT* high,
1684                                      char dfault, char* dest) const;
1685     };
1686
1687    22.2.1.3  ctype specializations              [lib.facet.ctype.special]
1688
1689 T   template &lt;&gt; class ctype&lt;char&gt;
1690       : public locale::facet, public ctype_base {
1691     public:
1692 T     typedef char char_type;
1693 T     explicit ctype(const mask* tab = 0, bool del = false,
1694                      size_t refs = 0);
1695 T     bool is(mask m, char c) const;
1696 T     const char* is(const char* low, const char* high, mask* vec) const;
1697 T     const char* scan_is (mask m,
1698                            const char* low, const char* high) const;
1699 T     const char* scan_not(mask m,
1700                            const char* low, const char* high) const;
1701 T     char        toupper(char c) const;
1702 T     const char* toupper(char* low, const char* high) const;
1703 T     char        tolower(char c) const;
1704 T     const char* tolower(char* low, const char* high) const;
1705 T     char  widen(char c) const;
1706 T     const char* widen(const char* low, const char* high, char* to) const;
1707 T     char  narrow(char c, char dfault) const;
1708 T     const char* narrow(const char* low, const char* high, char dfault,
1709                          char* to) const;
1710 T     static locale::id id;
1711 T     static const size_t table_size = IMPLEMENTATION_DEFINED;
1712
1713     protected:
1714 T     const mask* table() const throw();
1715 T     static const mask* classic_table() throw();
1716 T    ~ctype();                    // virtual
1717 T     virtual char        do_toupper(char c) const;
1718 T     virtual const char* do_toupper(char* low, const char* high) const;
1719 T     virtual char        do_tolower(char c) const;
1720 T     virtual const char* do_tolower(char* low, const char* high) const;
1721
1722 T     virtual char        do_widen(char c) const;
1723 T     virtual const char* do_widen(const char* low,
1724                                    const char* high,
1725                                    char* to) const;
1726 T     virtual char        do_narrow(char c, char dfault) const;
1727 T     virtual const char* do_narrow(const char* low,
1728                                     const char* high,
1729                                     char dfault, char* to) const;
1730     };
1731
1732
1733    22.2.1.4  Class                      [lib.locale.ctype.byname.special]
1734        ctype_byname&lt;char&gt;
1735
1736 X   template &lt;&gt; class ctype_byname&lt;char&gt; : public ctype&lt;char&gt; {
1737     public:
1738 S     explicit ctype_byname(const char*, size_t refs = 0);
1739     protected:
1740 S    ~ctype_byname();             // virtual
1741 S     virtual char        do_toupper(char c) const;
1742 S     virtual const char* do_toupper(char* low, const char* high) const;
1743 S     virtual char        do_tolower(char c) const;
1744 S     virtual const char* do_tolower(char* low, const char* high) const;
1745
1746 S     virtual char        do_widen(char c) const;
1747 S     virtual const char* do_widen(char* low,
1748                                    const char* high,
1749                                    char* to) const;
1750 S     virtual char        do_widen(char c) const;
1751 S     virtual const char* do_widen(char* low, const char* high) const;
1752
1753     };
1754
1755
1756
1757    22.2.1.5  Template class codecvt                  [lib.locale.codecvt]
1758
1759 T  class codecvt_base {
1760    public:
1761 T   enum result { ok, partial, error, noconv };
1762    };
1763
1764 T  template &lt;class internT, class externT, class stateT&gt;
1765    class codecvt : public locale::facet, public codecvt_base {
1766    public:
1767 T   typedef internT  intern_type;
1768 T   typedef externT  extern_type;
1769 T   typedef stateT state_type;
1770 T   explicit codecvt(size_t refs = 0)
1771 T   result out(stateT&amp; state,
1772      const internT* from, const internT* from_end, const internT*&amp; from_next,
1773            externT*   to,       externT* to_limit, externT*&amp; to_next) const;
1774 T   result unshift(stateT&amp; state,
1775            externT*   to,        externT* to_limit, externT*&amp; to_next) const;
1776 T   result in(stateT&amp; state,
1777      const externT* from, const externT* from_end, const externT*&amp; from_next,
1778            internT*   to,       internT* to_limit, internT*&amp; to_next) const;
1779 T   int encoding() const throw();
1780 T   bool always_noconv() const throw();
1781 T   int length(const stateT&amp;, const externT* from, const externT* end,
1782                size_t max) const;
1783 T   int max_length() const throw();
1784 T   static locale::id id;
1785
1786    protected:
1787 T   ~codecvt();                   // virtual
1788 T   virtual result do_out(stateT&amp; state,
1789      const internT* from, const internT* from_end, const internT*&amp; from_next,
1790            externT* to,         externT* to_limit, externT*&amp; to_next) const;
1791 T   virtual result do_in(stateT&amp; state,
1792 T    const externT* from, const externT* from_end, const externT*&amp; from_next,
1793            internT* to,         internT* to_limit, internT*&amp; to_next) const;
1794 T   virtual result do_unshift(stateT&amp; state,
1795            externT* to,         externT* to_limit, externT*&amp; to_next) const;
1796 T   virtual int do_encoding() const throw();
1797 T   virtual bool do_always_noconv() const throw();
1798 T   virtual int do_length(const stateT&amp;, const externT* from,
1799                           const externT* end, size_t max) const;
1800 T   virtual int do_max_length() const throw();
1801    };
1802    }
1803
1804
1805    22.2.1.6  Template class                   [lib.locale.codecvt.byname]
1806        codecvt_byname
1807
1808 X  template &lt;class internT, class externT, class stateT&gt;
1809    class codecvt_byname : public codecvt&lt;internT, externT, stateT&gt; {
1810    public:
1811 S   explicit codecvt_byname(const char*, size_t refs = 0);
1812    protected:
1813 S  ~codecvt_byname();             // virtual
1814 S   virtual result do_out(stateT&amp; state,
1815       const internT* from, const internT* from_end, const internT*&amp; from_next,
1816             externT* to,         externT* to_limit, externT*&amp; to_next) const;
1817 S   virtual result do_in(stateT&amp; state,
1818       const externT* from, const externT* from_end, const externT*&amp; from_next,
1819             internT* to,         internT* to_limit, internT*&amp; to_next) const;
1820 S   virtual result do_unshift(stateT&amp; state,
1821             externT* to,         externT* to_limit, externT*&amp; to_next) const;
1822 S   virtual int do_encoding() const throw();
1823 S   virtual bool do_always_noconv() const throw();
1824 S   virtual int do_length(const stateT&amp;, const externT* from,
1825                           const externT* end, size_t max) const;
1826 S   virtual result do_unshift(stateT&amp; state,
1827            externT* to, externT* to_limit, externT*&amp; to_next) const;
1828 S   virtual int do_max_length() const throw();
1829     };
1830
1831
1832    22.2.2.1  Template class num_get                  [lib.locale.num.get]
1833
1834 X   template &lt;class charT, class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;
1835     class num_get : public locale::facet {
1836     public:
1837 T     typedef charT            char_type;
1838 T     typedef InputIterator    iter_type;
1839 T     explicit num_get(size_t refs = 0);
1840 T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
1841                     ios_base::iostate&amp; err, bool&amp; v)           const;
1842 T     iter_type get(iter_type in, iter_type end, ios_base&amp; ,
1843                     ios_base::iostate&amp; err, long&amp; v)           const;
1844 T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
1845                     ios_base::iostate&amp; err, unsigned short&amp; v) const;
1846 T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
1847                     ios_base::iostate&amp; err, unsigned int&amp; v)   const;
1848 T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
1849                     ios_base::iostate&amp; err, unsigned long&amp; v)  const;
1850 T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
1851                     ios_base::iostate&amp; err, float&amp; v)          const;
1852 T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
1853                     ios_base::iostate&amp; err, double&amp; v)         const;
1854 T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
1855                     ios_base::iostate&amp; err, long double&amp; v)    const;
1856 T     iter_type get(iter_type in, iter_type end, ios_base&amp;,
1857                     ios_base::iostate&amp; err, void*&amp; v)          const;
1858 T     static locale::id id;
1859
1860     protected:
1861 T    ~num_get();                  // virtual
1862 T     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
1863           ios_base::iostate&amp; err, bool&amp; v) const;
1864 S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
1865           ios_base::iostate&amp; err, long&amp; v) const;
1866 S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
1867           ios_base::iostate&amp; err, unsigned short&amp; v) const;
1868 S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
1869           ios_base::iostate&amp; err, unsigned int&amp; v) const;
1870 S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
1871           ios_base::iostate&amp; err, unsigned long&amp; v) const;
1872 S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
1873           ios_base::iostate&amp; err, float&amp; v) const;
1874 S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
1875           ios_base::iostate&amp; err, double&amp; v) const;
1876 S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
1877           ios_base::iostate&amp; err, long double&amp; v) const;
1878 S     virtual iter_type do_get(iter_type, iter_type, ios_base&amp;,
1879           ios_base::iostate&amp; err, void*&amp; v) const;
1880     };
1881
1882
1883
1884    22.2.2.2  Template class num_put                   [lib.locale.nm.put]
1885
1886 X   template &lt;class charT, class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;
1887     class num_put : public locale::facet {
1888     public:
1889 T     typedef charT            char_type;
1890 T     typedef OutputIterator   iter_type;
1891 T     explicit num_put(size_t refs = 0);
1892 T     iter_type put(iter_type s, ios_base&amp; f, char_type fill, bool v) const;
1893 T     iter_type put(iter_type s, ios_base&amp; f, char_type fill, long v) const;
1894 T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
1895                     unsigned long v) const;
1896 T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
1897                     double v) const;
1898 T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
1899                     long double v) const;
1900 T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
1901                     const void* v) const;
1902 T     static locale::id id;
1903     protected:
1904 T    ~num_put();                  // virtual
1905 T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
1906                                bool v) const;
1907 T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
1908                                long v) const;
1909 T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
1910                                unsigned long) const;
1911 S     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
1912                                double v) const;
1913 S     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
1914                                long double v) const;
1915 T     virtual iter_type do_put(iter_type, ios_base&amp;, char_type fill,
1916                                const void* v) const;
1917     };
1918    }
1919
1920    22.2.3.1  Template class numpunct                [lib.locale.numpunct]
1921
1922 T   template &lt;class charT&gt;
1923     class numpunct : public locale::facet {
1924     public:
1925 T     typedef charT               char_type;
1926 T     typedef basic_string&lt;charT&gt; string_type;
1927 T     explicit numpunct(size_t refs = 0);
1928 T     char_type    decimal_point()   const;
1929 T     char_type    thousands_sep()   const;
1930 T     string       grouping()        const;
1931 T     string_type  truename()        const;
1932 T     string_type  falsename()       const;
1933 T     static locale::id id;
1934     protected:
1935 T    ~numpunct();                 // virtual
1936 T     virtual char_type    do_decimal_point() const;
1937 T     virtual char_type    do_thousands_sep() const;
1938 T     virtual string       do_grouping()      const;
1939 T     virtual string_type  do_truename()      const;      // for bool
1940 T     virtual string_type  do_falsename()     const;      // for bool
1941     };
1942    }
1943
1944
1945
1946    22.2.3.2  Template class                  [lib.locale.numpunct.byname]
1947        numpunct_byname
1948
1949 X   template &lt;class charT&gt;
1950     class numpunct_byname : public numpunct&lt;charT&gt; {
1951    // this class is specialized for char and wchar_t.
1952     public:
1953 T     typedef charT                char_type;
1954 T     typedef basic_string&lt;charT&gt;  string_type;
1955 S     explicit numpunct_byname(const char*, size_t refs = 0);
1956     protected:
1957 S    ~numpunct_byname();          // virtual
1958 S     virtual char_type    do_decimal_point() const;
1959 S     virtual char_type    do_thousands_sep() const;
1960 S     virtual string       do_grouping()      const;
1961 S     virtual string_type  do_truename()      const;      // for bool
1962 S     virtual string_type  do_falsename()     const;      // for bool
1963     };
1964
1965
1966    22.2.4.1  Template class collate                  [lib.locale.collate]
1967
1968 T   template &lt;class charT&gt;
1969     class collate : public locale::facet {
1970     public:
1971 T     typedef charT               char_type;
1972 T     typedef basic_string&lt;charT&gt; string_type;
1973 T     explicit collate(size_t refs = 0);
1974 T     int compare(const charT* low1, const charT* high1,
1975                   const charT* low2, const charT* high2) const;
1976 T     string_type transform(const charT* low, const charT* high) const;
1977 T     long hash(const charT* low, const charT* high) const;
1978 T     static locale::id id;
1979     protected:
1980 T    ~collate();                  // virtual
1981 T     virtual int    do_compare(const charT* low1, const charT* high1,
1982                                 const charT* low2, const charT* high2) const;
1983 T     virtual string_type do_transform
1984                                (const charT* low, const charT* high) const;
1985 T     virtual long   do_hash   (const charT* low, const charT* high) const;
1986     };
1987
1988
1989    22.2.4.2  Template class                   [lib.locale.collate.byname]
1990        collate_byname
1991
1992 X   template &lt;class charT&gt;
1993     class collate_byname : public collate&lt;charT&gt; {
1994     public:
1995 T     typedef basic_string&lt;charT&gt; string_type;
1996 T     explicit collate_byname(const char*, size_t refs = 0);
1997     protected:
1998 S    ~collate_byname();           // virtual
1999 S     virtual int    do_compare(const charT* low1, const charT* high1,
2000                                 const charT* low2, const charT* high2) const;
2001 S     virtual string_type do_transform
2002                                (const charT* low, const charT* high) const;
2003 S     virtual long   do_hash   (const charT* low, const charT* high) const;
2004     };
2005
2006
2007    22.2.5.1  Template class time_get                [lib.locale.time.get]
2008
2009 T   class time_base {
2010     public:
2011 T     enum dateorder { no_order, dmy, mdy, ymd, ydm };
2012     };
2013
2014     [Note: semantics of time_get members are implementation-defined.
2015      To complete implementation requires documenting behavior.]
2016
2017 X   template &lt;class charT, class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;
2018     class time_get : public locale::facet, public time_base {
2019     public:
2020 T     typedef charT            char_type;
2021 T     typedef InputIterator    iter_type;
2022 T     explicit time_get(size_t refs = 0);
2023
2024 T     dateorder date_order()  const { return do_date_order(); }
2025 T     iter_type get_time(iter_type s, iter_type end, ios_base&amp; f,
2026                          ios_base::iostate&amp; err, tm* t)  const;
2027 T     iter_type get_date(iter_type s, iter_type end, ios_base&amp; f,
2028                          ios_base::iostate&amp; err, tm* t)  const;
2029 T     iter_type get_weekday(iter_type s, iter_type end, ios_base&amp; f,
2030                             ios_base::iostate&amp; err, tm* t) const;
2031 T     iter_type get_monthname(iter_type s, iter_type end, ios_base&amp; f,
2032                               ios_base::iostate&amp; err, tm* t) const;
2033 T     iter_type get_year(iter_type s, iter_type end, ios_base&amp; f,
2034                          ios_base::iostate&amp; err, tm* t) const;
2035 T     static locale::id id;
2036     protected:
2037      ~time_get();                 // virtual
2038 X     virtual dateorder do_date_order()  const;
2039 S     virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&amp;,
2040                                     ios_base::iostate&amp; err, tm* t) const;
2041 S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&amp;,
2042                                     ios_base::iostate&amp; err, tm* t) const;
2043 S     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&amp;,
2044                                        ios_base::iostate&amp; err, tm* t) const;
2045 S     virtual iter_type do_get_monthname(iter_type s, ios_base&amp;,
2046                                          ios_base::iostate&amp; err, tm* t) const;
2047 S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&amp;,
2048                                     ios_base::iostate&amp; err, tm* t) const;
2049     };
2050
2051
2052
2053    22.2.5.2  Template class                  [lib.locale.time.get.byname]
2054        time_get_byname
2055
2056 X   template &lt;class charT, class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;
2057     class time_get_byname : public time_get&lt;charT, InputIterator&gt; {
2058     public:
2059 T     typedef time_base::dateorder dateorder;
2060 T     typedef InputIterator        iter_type
2061
2062 S     explicit time_get_byname(const char*, size_t refs = 0);
2063     protected:
2064 S    ~time_get_byname();          // virtual
2065 S     virtual dateorder do_date_order()  const;
2066 S     virtual iter_type do_get_time(iter_type s, iter_type end, ios_base&amp;,
2067                                     ios_base::iostate&amp; err, tm* t) const;
2068 S     virtual iter_type do_get_date(iter_type s, iter_type end, ios_base&amp;,
2069                                     ios_base::iostate&amp; err, tm* t) const;
2070 T     virtual iter_type do_get_weekday(iter_type s, iter_type end, ios_base&amp;,
2071                                        ios_base::iostate&amp; err, tm* t) const;
2072 T     virtual iter_type do_get_monthname(iter_type s, iter_type end, ios_base&amp;,
2073                                          ios_base::iostate&amp; err, tm* t) const;
2074 S     virtual iter_type do_get_year(iter_type s, iter_type end, ios_base&amp;,
2075                                     ios_base::iostate&amp; err, tm* t) const;
2076     };
2077    }
2078
2079    22.2.5.3  Template class time_put                [lib.locale.time.put]
2080
2081 X   template &lt;class charT, class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;
2082     class time_put : public locale::facet {
2083     public:
2084 T     typedef charT            char_type;
2085 T     typedef OutputIterator   iter_type;
2086 T     explicit time_put(size_t refs = 0);
2087       // the following is implemented in terms of other member functions.
2088 S     iter_type put(iter_type s, ios_base&amp; f, char_type fill, const tm* tmb,
2089                     const charT* pattern, const charT* pat_end) const;
2090 T     iter_type put(iter_type s, ios_base&amp; f, char_type fill,
2091                     const tm* tmb, char format, char modifier = 0) const;
2092 T     static locale::id id;
2093     protected:
2094 T    ~time_put();                 // virtual
2095 S     virtual iter_type do_put(iter_type s, ios_base&amp;, char_type, const tm* t,
2096                                char format, char modifier) const;
2097     };
2098
2099
2100
2101    22.2.5.4  Template class                  [lib.locale.time.put.byname]
2102        time_put_byname
2103
2104 T   template &lt;class charT, class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;
2105     class time_put_byname : public time_put&lt;charT, OutputIterator&gt;
2106     {
2107     public:
2108 T     typedef charT          char_type;
2109 T     typedef OutputIterator iter_type;
2110
2111 T     explicit time_put_byname(const char*, size_t refs = 0);
2112     protected:
2113 T    ~time_put_byname();          // virtual
2114 S     virtual iter_type do_put(iter_type s, ios_base&amp;, char_type, const tm* t,
2115                                char format, char modifier) const;
2116     };
2117
2118
2119    22.2.6.1  Template class money_get              [lib.locale.money.get]
2120
2121 X   template &lt;class charT,
2122               class InputIterator = istreambuf_iterator&lt;charT&gt; &gt;
2123     class money_get : public locale::facet {
2124     public:
2125 T     typedef charT               char_type;
2126 T     typedef InputIterator       iter_type;
2127 T     typedef basic_string&lt;charT&gt; string_type;
2128 T     explicit money_get(size_t refs = 0);
2129 T     iter_type get(iter_type s, iter_type end, bool intl,
2130                     ios_base&amp; f, ios_base::iostate&amp; err,
2131                     long double&amp; units) const;
2132 T     iter_type get(iter_type s, iter_type end, bool intl,
2133                     ios_base&amp; f, ios_base::iostate&amp; err,
2134                     string_type&amp; digits) const;
2135 T     static locale::id id;
2136     protected:
2137 T    ~money_get();                // virtual
2138 S     virtual iter_type do_get(iter_type, iter_type, bool, ios_base&amp;,
2139                        ios_base::iostate&amp; err, long double&amp; units) const;
2140 S     virtual iter_type do_get(iter_type, iter_type, bool, ios_base&amp;,
2141                        ios_base::iostate&amp; err, string_type&amp; digits) const;
2142     };
2143
2144    22.2.6.2  Template class money_put              [lib.locale.money.put]
2145
2146 X   template &lt;class charT,
2147               class OutputIterator = ostreambuf_iterator&lt;charT&gt; &gt;
2148     class money_put : public locale::facet {
2149     public:
2150 T     typedef charT               char_type;
2151 T     typedef OutputIterator      iter_type;
2152 T     typedef basic_string&lt;charT&gt; string_type;
2153 T     explicit money_put(size_t refs = 0);
2154 T     iter_type put(iter_type s, bool intl, ios_base&amp; f,
2155                     char_type fill, long double units) const;
2156 T     iter_type put(iter_type s, bool intl, ios_base&amp; f,
2157                     char_type fill, const string_type&amp; digits) const;
2158 T     static locale::id id;
2159
2160     protected:
2161 T    ~money_put();                // virtual
2162 S     virtual iter_type
2163         do_put(iter_type, bool, ios_base&amp;, char_type fill,
2164                long double units) const;
2165 S     virtual iter_type
2166         do_put(iter_type, bool, ios_base&amp;, char_type fill,
2167                const string_type&amp; digits) const;
2168     };
2169
2170
2171    22.2.6.3  Template class moneypunct            [lib.locale.moneypunct]
2172
2173 T   class money_base {
2174     public:
2175 T     enum part { none, space, symbol, sign, value };
2176 T     struct pattern { char field[4]; };
2177     };
2178
2179 X   template &lt;class charT, bool International = false&gt;
2180     class moneypunct : public locale::facet, public money_base {
2181     public:
2182 T     typedef charT char_type;
2183 T     typedef basic_string&lt;charT&gt; string_type;
2184 T     explicit moneypunct(size_t refs = 0);
2185 T     charT        decimal_point() const;
2186 T     charT        thousands_sep() const;
2187 T     string       grouping()      const;
2188 T     string_type  curr_symbol()   const;
2189 T     string_type  positive_sign() const;
2190 T     string_type  negative_sign() const;
2191 T     int          frac_digits()   const;
2192 T     pattern      pos_format()    const;
2193 T     pattern      neg_format()    const;
2194 T     static locale::id id;
2195 T     static const bool intl = International;
2196     protected:
2197 T    ~moneypunct();               // virtual
2198 S     virtual charT        do_decimal_point() const;
2199 S     virtual charT        do_thousands_sep() const;
2200 S     virtual string       do_grouping()      const;
2201 S     virtual string_type  do_curr_symbol()   const;
2202 S     virtual string_type  do_positive_sign() const;
2203 S     virtual string_type  do_negative_sign() const;
2204 S     virtual int          do_frac_digits()   const;
2205 T     virtual pattern      do_pos_format()    const;
2206 T     virtual pattern      do_neg_format()    const;
2207     };
2208    }
2209
2210    22.2.6.4  Template class                [lib.locale.moneypunct.byname]
2211        moneypunct_byname
2212
2213 X   template &lt;class charT, bool Intl = false&gt;
2214     class moneypunct_byname : public moneypunct&lt;charT, Intl&gt; {
2215     public:
2216 T     typedef money_base::pattern pattern;
2217 T     typedef basic_string&lt;charT&gt; string_type;
2218
2219 T     explicit moneypunct_byname(const char*, size_t refs = 0);
2220     protected:
2221 T    ~moneypunct_byname();        // virtual
2222 S     virtual charT        do_decimal_point() const;
2223 S     virtual charT        do_thousands_sep() const;
2224 S     virtual string       do_grouping()      const;
2225 S     virtual string_type  do_curr_symbol()   const;
2226 S     virtual string_type  do_positive_sign() const;
2227 S     virtual string_type  do_negative_sign() const;
2228 S     virtual int          do_frac_digits()   const;
2229 S     virtual pattern      do_pos_format()    const;
2230 S     virtual pattern      do_neg_format()    const;
2231     };
2232
2233    22.2.7.1  Template class messages                [lib.locale.messages]
2234
2235 T   class messages_base {
2236     public:
2237 T     typedef int catalog;
2238     };
2239
2240 X   template &lt;class charT&gt;
2241     class messages : public locale::facet, public messages_base {
2242     public:
2243 T     typedef charT char_type;
2244 T     typedef basic_string&lt;charT&gt; string_type;
2245 T     explicit messages(size_t refs = 0);
2246 T     catalog open(const basic_string&lt;char&gt;&amp; fn, const locale&amp;) const;
2247 T     string_type  get(catalog c, int set, int msgid,
2248                        const string_type&amp; dfault) const;
2249 T     void    close(catalog c) const;
2250 T     static locale::id id;
2251     protected:
2252 T    ~messages();                 // virtual
2253 S     virtual catalog do_open(const basic_string&lt;char&gt;&amp;, const locale&amp;) const;
2254 S     virtual string_type  do_get(catalog, int set, int msgid,
2255                              const string_type&amp; dfault) const;
2256 S     virtual void    do_close(catalog) const;
2257     };
2258
2259    22.2.7.2  Template class                  [lib.locale.messages.byname]
2260        messages_byname
2261
2262
2263 X   template &lt;class charT&gt;
2264     class messages_byname : public messages&lt;charT&gt; {
2265     public:
2266 T     typedef messages_base::catalog catalog;
2267 T     typedef basic_string&lt;charT&gt;    string_type;
2268
2269 T     explicit messages_byname(const char*, size_t refs = 0);
2270     protected:
2271 T    ~messages_byname();          // virtual
2272 S     virtual catalog do_open(const basic_string&lt;char&gt;&amp;, const locale&amp;) const;
2273 S     virtual string_type  do_get(catalog, int set, int msgid,
2274                              const string_type&amp; dfault) const;
2275 S     virtual void    do_close(catalog) const;
2276     };
2277
2278
2279    22.3  C Library Locales                                [lib.c.locales]
2280
2281
2282                    Table 13--Header &lt;clocale&gt; synopsis
2283             Macros:
2284 X                        LC_ALL        LC_COLLATE   LC_CTYPE
2285 X                        LC_MONETARY   LC_NUMERIC   LC_TIME
2286 X                        NULL
2287 X           Struct:      lconv
2288 X           Functions:   localeconv    setlocale
2289
2290
2291    23.2  Sequences                                        [lib.sequences]
2292
2293    &lt;deque&gt;, &lt;list&gt;, &lt;queue&gt;, &lt;stack&gt;, and &lt;vector&gt;.
2294
2295    Header &lt;deque&gt; synopsis
2296
2297 T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt; class deque;
2298 T   template &lt;class T, class Allocator&gt;
2299       bool operator==(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
2300 T   template &lt;class T, class Allocator&gt;
2301       bool operator&lt; (const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
2302 T   template &lt;class T, class Allocator&gt;
2303       bool operator!=(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
2304 T   template &lt;class T, class Allocator&gt;
2305       bool operator&gt; (const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
2306 T   template &lt;class T, class Allocator&gt;
2307       bool operator&gt;=(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
2308 T   template &lt;class T, class Allocator&gt;
2309       bool operator&lt;=(const deque&lt;T,Allocator&gt;&amp; x, const deque&lt;T,Allocator&gt;&amp; y);
2310 T   template &lt;class T, class Allocator&gt;
2311       void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
2312    }
2313
2314    Header &lt;list&gt; synopsis
2315
2316 T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt; class list;
2317 T   template &lt;class T, class Allocator&gt;
2318       bool operator==(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2319 T   template &lt;class T, class Allocator&gt;
2320       bool operator&lt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2321 T   template &lt;class T, class Allocator&gt;
2322       bool operator!=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2323 T   template &lt;class T, class Allocator&gt;
2324       bool operator&gt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2325 T   template &lt;class T, class Allocator&gt;
2326       bool operator&gt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2327 T   template &lt;class T, class Allocator&gt;
2328       bool operator&lt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2329 T   template &lt;class T, class Allocator&gt;
2330       void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
2331    }
2332
2333    Header &lt;queue&gt; synopsis
2334
2335    namespace std {
2336 T   template &lt;class T, class Container = deque&lt;T&gt; &gt; class queue;
2337 T   template &lt;class T, class Container&gt;
2338       bool operator==(const queue&lt;T, Container&gt;&amp; x,
2339                       const queue&lt;T, Container&gt;&amp; y);
2340 T   template &lt;class T, class Container&gt;
2341       bool operator&lt; (const queue&lt;T, Container&gt;&amp; x,
2342                       const queue&lt;T, Container&gt;&amp; y);
2343 T   template &lt;class T, class Container&gt;
2344       bool operator!=(const queue&lt;T, Container&gt;&amp; x,
2345                       const queue&lt;T, Container&gt;&amp; y);
2346 T   template &lt;class T, class Container&gt;
2347       bool operator&gt; (const queue&lt;T, Container&gt;&amp; x,
2348                       const queue&lt;T, Container&gt;&amp; y);
2349 T   template &lt;class T, class Container&gt;
2350       bool operator&gt;=(const queue&lt;T, Container&gt;&amp; x,
2351                       const queue&lt;T, Container&gt;&amp; y);
2352 T   template &lt;class T, class Container&gt;
2353       bool operator&lt;=(const queue&lt;T, Container&gt;&amp; x,
2354                       const queue&lt;T, Container&gt;&amp; y);
2355 T   template &lt;class T, class Container = vector&lt;T&gt;,
2356               class Compare = less&lt;typename Container::value_type&gt; &gt;
2357 T   class priority_queue;
2358    }
2359
2360    Header &lt;stack&gt; synopsis
2361
2362    namespace std {
2363 T   template &lt;class T, class Container = deque&lt;T&gt; &gt; class stack;
2364 T   template &lt;class T, class Container&gt;
2365       bool operator==(const stack&lt;T, Container&gt;&amp; x,
2366                       const stack&lt;T, Container&gt;&amp; y);
2367 T   template &lt;class T, class Container&gt;
2368       bool operator&lt; (const stack&lt;T, Container&gt;&amp; x,
2369                       const stack&lt;T, Container&gt;&amp; y);
2370 T   template &lt;class T, class Container&gt;
2371       bool operator!=(const stack&lt;T, Container&gt;&amp; x,
2372                       const stack&lt;T, Container&gt;&amp; y);
2373 T   template &lt;class T, class Container&gt;
2374       bool operator&gt; (const stack&lt;T, Container&gt;&amp; x,
2375                       const stack&lt;T, Container&gt;&amp; y);
2376 T   template &lt;class T, class Container&gt;
2377       bool operator&gt;=(const stack&lt;T, Container&gt;&amp; x,
2378                       const stack&lt;T, Container&gt;&amp; y);
2379 T   template &lt;class T, class Container&gt;
2380       bool operator&lt;=(const stack&lt;T, Container&gt;&amp; x,
2381                       const stack&lt;T, Container&gt;&amp; y);
2382    }
2383
2384    Header &lt;vector&gt; synopsis
2385
2386 T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt; class vector;
2387
2388 T   template &lt;class T, class Allocator&gt;
2389       bool operator==(const vector&lt;T,Allocator&gt;&amp; x,
2390                       const vector&lt;T,Allocator&gt;&amp; y);
2391 T   template &lt;class T, class Allocator&gt;
2392       bool operator&lt; (const vector&lt;T,Allocator&gt;&amp; x,
2393                       const vector&lt;T,Allocator&gt;&amp; y);
2394 T   template &lt;class T, class Allocator&gt;
2395       bool operator!=(const vector&lt;T,Allocator&gt;&amp; x,
2396                       const vector&lt;T,Allocator&gt;&amp; y);
2397 T   template &lt;class T, class Allocator&gt;
2398       bool operator&gt; (const vector&lt;T,Allocator&gt;&amp; x,
2399                       const vector&lt;T,Allocator&gt;&amp; y);
2400 T   template &lt;class T, class Allocator&gt;
2401       bool operator&gt;=(const vector&lt;T,Allocator&gt;&amp; x,
2402                       const vector&lt;T,Allocator&gt;&amp; y);
2403 T   template &lt;class T, class Allocator&gt;
2404       bool operator&lt;=(const vector&lt;T,Allocator&gt;&amp; x,
2405                       const vector&lt;T,Allocator&gt;&amp; y);
2406 T   template &lt;class T, class Allocator&gt;
2407       void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
2408
2409 T   template &lt;class Allocator&gt; class vector&lt;bool,Allocator&gt;;
2410 T   template &lt;class Allocator&gt;
2411       bool operator==(const vector&lt;bool,Allocator&gt;&amp; x,
2412                       const vector&lt;bool,Allocator&gt;&amp; y);
2413 T   template &lt;class Allocator&gt;
2414       bool operator&lt; (const vector&lt;bool,Allocator&gt;&amp; x,
2415                       const vector&lt;bool,Allocator&gt;&amp; y);
2416 T   template &lt;class Allocator&gt;
2417       bool operator!=(const vector&lt;bool,Allocator&gt;&amp; x,
2418                       const vector&lt;bool,Allocator&gt;&amp; y);
2419 T   template &lt;class Allocator&gt;
2420       bool operator&gt; (const vector&lt;bool,Allocator&gt;&amp; x,
2421                       const vector&lt;bool,Allocator&gt;&amp; y);
2422 T   template &lt;class Allocator&gt;
2423       bool operator&gt;=(const vector&lt;bool,Allocator&gt;&amp; x,
2424                       const vector&lt;bool,Allocator&gt;&amp; y);
2425 T   template &lt;class Allocator&gt;
2426       bool operator&lt;=(const vector&lt;bool,Allocator&gt;&amp; x,
2427                       const vector&lt;bool,Allocator&gt;&amp; y);
2428 T   template &lt;class Allocator&gt;
2429       void swap(vector&lt;bool,Allocator&gt;&amp; x, vector&lt;bool,Allocator&gt;&amp; y);
2430    }
2431
2432    23.2.1  Template class deque                               [lib.deque]
2433
2434     template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
2435 T   class deque {
2436     public:
2437       // types:
2438 T     typedef typename Allocator::reference         reference;
2439 T     typedef typename Allocator::const_reference   const_reference;
2440 T     typedef implementation defined                iterator;
2441 T     typedef implementation defined                const_iterator;
2442 T     typedef implementation defined                size_type;
2443 T     typedef implementation defined                difference_type;
2444 T     typedef T                                     value_type;
2445 T     typedef Allocator                             allocator_type;
2446 T     typedef typename Allocator::pointer           pointer;
2447 T     typedef typename Allocator::const_pointer     const_pointer;
2448 T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
2449 T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
2450       // _lib.deque.cons_ construct/copy/destroy:
2451 T     explicit deque(const Allocator&amp; = Allocator());
2452 T     explicit deque(size_type n, const T&amp; value = T(),
2453           const Allocator&amp; = Allocator());
2454 T     template &lt;class InputIterator&gt;
2455         deque(InputIterator first, InputIterator last,
2456               const Allocator&amp; = Allocator());
2457 T     deque(const deque&lt;T,Allocator&gt;&amp; x);
2458 T    ~deque();
2459 T     deque&lt;T,Allocator&gt;&amp; operator=(const deque&lt;T,Allocator&gt;&amp; x);
2460 T     template &lt;class InputIterator&gt;
2461         void assign(InputIterator first, InputIterator last);
2462 T     void assign(size_type n, const T&amp; t);
2463 T     allocator_type get_allocator() const;
2464       // iterators:
2465 T     iterator               begin();
2466 T     const_iterator         begin() const;
2467 T     iterator               end();
2468 T     const_iterator         end() const;
2469 T     reverse_iterator       rbegin();
2470 T     const_reverse_iterator rbegin() const;
2471 T     reverse_iterator       rend();
2472 T     const_reverse_iterator rend() const;
2473       // _lib.deque.capacity_ capacity:
2474 T     size_type size() const;
2475 T     size_type max_size() const;
2476 T     void      resize(size_type sz, T c = T());
2477 T     bool      empty() const;
2478
2479       // element access:
2480 T     reference       operator[](size_type n);
2481 T     const_reference operator[](size_type n) const;
2482 T     reference       at(size_type n);
2483 T     const_reference at(size_type n) const;
2484 T     reference       front();
2485 T     const_reference front() const;
2486 T     reference       back();
2487 T     const_reference back() const;
2488       // _lib.deque.modifiers_ modifiers:
2489 T     void push_front(const T&amp; x);
2490 T     void push_back(const T&amp; x);
2491 T     iterator insert(iterator position, const T&amp; x);
2492 T     void     insert(iterator position, size_type n, const T&amp; x);
2493 T     template &lt;class InputIterator&gt;
2494         void insert (iterator position,
2495                      InputIterator first, InputIterator last);
2496 T     void pop_front();
2497 T     void pop_back();
2498 T     iterator erase(iterator position);
2499 T     iterator erase(iterator first, iterator last);
2500 T     void     swap(deque&lt;T,Allocator&gt;&amp;);
2501 T     void     clear();
2502     };
2503 T   template &lt;class T, class Allocator&gt;
2504       bool operator==(const deque&lt;T,Allocator&gt;&amp; x,
2505                       const deque&lt;T,Allocator&gt;&amp; y);
2506 T   template &lt;class T, class Allocator&gt;
2507       bool operator&lt; (const deque&lt;T,Allocator&gt;&amp; x,
2508                       const deque&lt;T,Allocator&gt;&amp; y);
2509 T   template &lt;class T, class Allocator&gt;
2510       bool operator!=(const deque&lt;T,Allocator&gt;&amp; x,
2511                       const deque&lt;T,Allocator&gt;&amp; y);
2512 T   template &lt;class T, class Allocator&gt;
2513       bool operator&gt; (const deque&lt;T,Allocator&gt;&amp; x,
2514                       const deque&lt;T,Allocator&gt;&amp; y);
2515 T   template &lt;class T, class Allocator&gt;
2516       bool operator&gt;=(const deque&lt;T,Allocator&gt;&amp; x,
2517                       const deque&lt;T,Allocator&gt;&amp; y);
2518 T   template &lt;class T, class Allocator&gt;
2519       bool operator&lt;=(const deque&lt;T,Allocator&gt;&amp; x,
2520                       const deque&lt;T,Allocator&gt;&amp; y);
2521     // specialized algorithms:
2522 T   template &lt;class T, class Allocator&gt;
2523       void swap(deque&lt;T,Allocator&gt;&amp; x, deque&lt;T,Allocator&gt;&amp; y);
2524
2525
2526    23.2.2  Template class list                                 [lib.list]
2527
2528 T   template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
2529     class list {
2530     public:
2531       // types:
2532 T     typedef typename Allocator::reference         reference;
2533 T     typedef typename Allocator::const_reference   const_reference;
2534 T     typedef implementation defined                iterator;
2535 T     typedef implementation defined                const_iterator;
2536 T     typedef implementation defined                size_type;
2537 T     typedef implementation defined                difference_type;
2538 T     typedef T                                     value_type;
2539 T     typedef Allocator                             allocator_type;
2540 T     typedef typename Allocator::pointer           pointer;
2541 T     typedef typename Allocator::const_pointer     const_pointer;
2542 T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
2543 T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
2544
2545       // _lib.list.cons_ construct/copy/destroy:
2546 T     explicit list(const Allocator&amp; = Allocator());
2547 T     explicit list(size_type n, const T&amp; value = T(),
2548                     const Allocator&amp; = Allocator());
2549 T     template &lt;class InputIterator&gt;
2550         list(InputIterator first, InputIterator last,
2551              const Allocator&amp; = Allocator());
2552 T     list(const list&lt;T,Allocator&gt;&amp; x);
2553 T    ~list();
2554 T     list&lt;T,Allocator&gt;&amp; operator=(const list&lt;T,Allocator&gt;&amp; x);
2555 T     template &lt;class InputIterator&gt;
2556         void assign(InputIterator first, InputIterator last);
2557 T     void assign(size_type n, const T&amp; t);
2558 T     allocator_type get_allocator() const;
2559       // iterators:
2560 T     iterator               begin();
2561 T     const_iterator         begin() const;
2562 T     iterator               end();
2563 T     const_iterator         end() const;
2564 T     reverse_iterator       rbegin();
2565 T     const_reverse_iterator rbegin() const;
2566 T     reverse_iterator       rend();
2567 T     const_reverse_iterator rend() const;
2568       // _lib.list.capacity_ capacity:
2569 T     bool      empty() const;
2570 T     size_type size() const;
2571 T     size_type max_size() const;
2572 T     void      resize(size_type sz, T c = T());
2573       // element access:
2574 T     reference       front();
2575 T     const_reference front() const;
2576 T     reference       back();
2577 T     const_reference back() const;
2578       // _lib.list.modifiers_ modifiers:
2579 T     void push_front(const T&amp; x);
2580 T     void pop_front();
2581 T     void push_back(const T&amp; x);
2582 T     void pop_back();
2583 T     iterator insert(iterator position, const T&amp; x);
2584 T     void     insert(iterator position, size_type n, const T&amp; x);
2585 T     template &lt;class InputIterator&gt;
2586         void insert(iterator position, InputIterator first,
2587                     InputIterator last);
2588 T     iterator erase(iterator position);
2589 T     iterator erase(iterator position, iterator last);
2590 T     void     swap(list&lt;T,Allocator&gt;&amp;);
2591 T     void     clear();
2592       // _lib.list.ops_ list operations:
2593 T     void splice(iterator position, list&lt;T,Allocator&gt;&amp; x);
2594 T     void splice(iterator position, list&lt;T,Allocator&gt;&amp; x, iterator i);
2595 T     void splice(iterator position, list&lt;T,Allocator&gt;&amp; x, iterator first,
2596                   iterator last);
2597 T     void remove(const T&amp; value);
2598 T     template &lt;class Predicate&gt; void remove_if(Predicate pred);
2599
2600 T     void unique();
2601 T     template &lt;class BinaryPredicate&gt;
2602         void unique(BinaryPredicate binary_pred);
2603 T     void merge(list&lt;T,Allocator&gt;&amp; x);
2604 T     template &lt;class Compare&gt; void merge(list&lt;T,Allocator&gt;&amp; x, Compare comp);
2605         void sort();
2606 T     template &lt;class Compare&gt; void sort(Compare comp);
2607         void reverse();
2608     };
2609 T   template &lt;class T, class Allocator&gt;
2610       bool operator==(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2611 T   template &lt;class T, class Allocator&gt;
2612       bool operator&lt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2613 T   template &lt;class T, class Allocator&gt;
2614       bool operator!=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2615 T   template &lt;class T, class Allocator&gt;
2616       bool operator&gt; (const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2617 T   template &lt;class T, class Allocator&gt;
2618       bool operator&gt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2619 T   template &lt;class T, class Allocator&gt;
2620       bool operator&lt;=(const list&lt;T,Allocator&gt;&amp; x, const list&lt;T,Allocator&gt;&amp; y);
2621     // specialized algorithms:
2622 T   template &lt;class T, class Allocator&gt;
2623       void swap(list&lt;T,Allocator&gt;&amp; x, list&lt;T,Allocator&gt;&amp; y);
2624
2625
2626    23.2.3.1  Template class queue                             [lib.queue]
2627
2628 T   template &lt;class T, class Container = deque&lt;T&gt; &gt;
2629     class queue {
2630     public:
2631 T     typedef typename Container::value_type            value_type;
2632 T     typedef typename Container::size_type             size_type;
2633 T     typedef          Container                        container_type;
2634     protected:
2635 T     Container c;
2636     public:
2637 T     explicit queue(const Container&amp; = Container());
2638
2639 T     bool      empty() const             { return c.empty(); }
2640 T     size_type size()  const             { return c.size(); }
2641 T     value_type&amp;       front()           { return c.front(); }
2642 T     const value_type&amp; front() const     { return c.front(); }
2643 T     value_type&amp;       back()            { return c.back(); }
2644 T     const value_type&amp; back() const      { return c.back(); }
2645 T     void push(const value_type&amp; x)      { c.push_back(x); }
2646 T     void pop()                          { c.pop_front(); }
2647     };
2648
2649 T   template &lt;class T, class Container&gt;
2650       bool operator==(const queue&lt;T, Container&gt;&amp; x,
2651                       const queue&lt;T, Container&gt;&amp; y);
2652 T   template &lt;class T, class Container&gt;
2653       bool operator&lt; (const queue&lt;T, Container&gt;&amp; x,
2654                       const queue&lt;T, Container&gt;&amp; y);
2655 T   template &lt;class T, class Container&gt;
2656       bool operator!=(const queue&lt;T, Container&gt;&amp; x,
2657                       const queue&lt;T, Container&gt;&amp; y);
2658 T   template &lt;class T, class Container&gt;
2659       bool operator&gt; (const queue&lt;T, Container&gt;&amp; x,
2660                       const queue&lt;T, Container&gt;&amp; y);
2661 T   template &lt;class T, class Container&gt;
2662       bool operator&gt;=(const queue&lt;T, Container&gt;&amp; x,
2663                       const queue&lt;T, Container&gt;&amp; y);
2664 T   template &lt;class T, class Container&gt;
2665       bool operator&lt;=(const queue&lt;T, Container&gt;&amp; x,
2666                       const queue&lt;T, Container&gt;&amp; y);
2667
2668    23.2.3.2  Template class priority_queue           [lib.priority.queue]
2669
2670 T   template &lt;class T, class Container = vector&lt;T&gt;,
2671               class Compare = less&lt;typename Container::value_type&gt; &gt;
2672     class priority_queue {
2673     public:
2674 T     typedef typename Container::value_type            value_type;
2675 T     typedef typename Container::size_type             size_type;
2676 T     typedef          Container                        container_type;
2677     protected:
2678 T     Container c;
2679 T     Compare comp;
2680     public:
2681 T     explicit priority_queue(const Compare&amp; x = Compare(),
2682                               const Container&amp; = Container());
2683 T     template &lt;class InputIterator&gt;
2684         priority_queue(InputIterator first, InputIterator last,
2685                        const Compare&amp; x = Compare(),
2686                        const Container&amp; = Container());
2687
2688 T     bool      empty() const       { return c.empty(); }
2689 T     size_type size()  const       { return c.size(); }
2690 T     const value_type&amp; top() const { return c.front(); }
2691 T     void push(const value_type&amp; x);
2692 T     void pop();
2693     };
2694
2695    23.2.3.3  Template class stack                             [lib.stack]
2696
2697 T   template &lt;class T, class Container = deque&lt;T&gt; &gt;
2698     class stack {
2699     public:
2700 T     typedef typename Container::value_type            value_type;
2701 T     typedef typename Container::size_type             size_type;
2702 T     typedef          Container                        container_type;
2703     protected:
2704 T     Container c;
2705     public:
2706 T     explicit stack(const Container&amp; = Container());
2707
2708 T     bool      empty() const             { return c.empty(); }
2709 T     size_type size()  const             { return c.size(); }
2710 T     value_type&amp;       top()             { return c.back(); }
2711 T     const value_type&amp; top() const       { return c.back(); }
2712 T     void push(const value_type&amp; x)      { c.push_back(x); }
2713 T     void pop()                          { c.pop_back(); }
2714     };
2715 T   template &lt;class T, class Container&gt;
2716       bool operator==(const stack&lt;T, Container&gt;&amp; x,
2717                       const stack&lt;T, Container&gt;&amp; y);
2718 T   template &lt;class T, class Container&gt;
2719       bool operator&lt; (const stack&lt;T, Container&gt;&amp; x,
2720                       const stack&lt;T, Container&gt;&amp; y);
2721 T   template &lt;class T, class Container&gt;
2722       bool operator!=(const stack&lt;T, Container&gt;&amp; x,
2723                       const stack&lt;T, Container&gt;&amp; y);
2724 T   template &lt;class T, class Container&gt;
2725       bool operator&gt; (const stack&lt;T, Container&gt;&amp; x,
2726                       const stack&lt;T, Container&gt;&amp; y);
2727 T   template &lt;class T, class Container&gt;
2728       bool operator&gt;=(const stack&lt;T, Container&gt;&amp; x,
2729                       const stack&lt;T, Container&gt;&amp; y);
2730 T   template &lt;class T, class Container&gt;
2731       bool operator&lt;=(const stack&lt;T, Container&gt;&amp; x,
2732                       const stack&lt;T, Container&gt;&amp; y);
2733
2734    23.2.4  Template class vector                             [lib.vector]
2735
2736     template &lt;class T, class Allocator = allocator&lt;T&gt; &gt;
2737 T   class vector {
2738     public:
2739       // types:
2740 T     typedef typename Allocator::reference         reference;
2741 T     typedef typename Allocator::const_reference   const_reference;
2742 T     typedef implementation defined                iterator;
2743 T     typedef implementation defined                const_iterator;
2744 T     typedef implementation defined                size_type;
2745 T     typedef implementation defined                difference_type;
2746 T     typedef T                                     value_type;
2747 T     typedef Allocator                             allocator_type;
2748 T     typedef typename Allocator::pointer           pointer;
2749 T     typedef typename Allocator::const_pointer     const_pointer
2750 T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
2751 T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
2752       // _lib.vector.cons_ construct/copy/destroy:
2753 T     explicit vector(const Allocator&amp; = Allocator());
2754 T     explicit vector(size_type n, const T&amp; value = T(),
2755           const Allocator&amp; = Allocator());
2756 T     template &lt;class InputIterator&gt;
2757         vector(InputIterator first, InputIterator last,
2758           const Allocator&amp; = Allocator());
2759 T     vector(const vector&lt;T,Allocator&gt;&amp; x);
2760 T    ~vector();
2761 T     vector&lt;T,Allocator&gt;&amp; operator=(const vector&lt;T,Allocator&gt;&amp; x);
2762 T     template &lt;class InputIterator&gt;
2763         void assign(InputIterator first, InputIterator last);
2764 T     void assign(size_type n, const T&amp; u);
2765 T     allocator_type get_allocator() const;
2766       // iterators:
2767 T     iterator               begin();
2768 T     const_iterator         begin() const;
2769 T     iterator               end();
2770 T     const_iterator         end() const;
2771 T     reverse_iterator       rbegin();
2772 T     const_reverse_iterator rbegin() const;
2773 T     reverse_iterator       rend();
2774 T     const_reverse_iterator rend() const;
2775       // _lib.vector.capacity_ capacity:
2776 T     size_type size() const;
2777 T     size_type max_size() const;
2778 T     void      resize(size_type sz, T c = T());
2779 T     size_type capacity() const;
2780 T     bool      empty() const;
2781 T     void      reserve(size_type n);
2782
2783       // element access:
2784 T     reference       operator[](size_type n);
2785 T     const_reference operator[](size_type n) const;
2786 T     const_reference at(size_type n) const;
2787 T     reference       at(size_type n);
2788 T     reference       front();
2789 T     const_reference front() const;
2790 T     reference       back();
2791 T     const_reference back() const;
2792       // _lib.vector.modifiers_ modifiers:
2793 T     void push_back(const T&amp; x);
2794 T     void pop_back();
2795 T     iterator insert(iterator position, const T&amp; x);
2796 T     void     insert(iterator position, size_type n, const T&amp; x);
2797 T     template &lt;class InputIterator&gt;
2798           void insert(iterator position,
2799                       InputIterator first, InputIterator last);
2800 T     iterator erase(iterator position);
2801 T     iterator erase(iterator first, iterator last);
2802 T     void     swap(vector&lt;T,Allocator&gt;&amp;);
2803 T     void     clear();
2804     };
2805
2806 T   template &lt;class T, class Allocator&gt;
2807       bool operator==(const vector&lt;T,Allocator&gt;&amp; x,
2808                       const vector&lt;T,Allocator&gt;&amp; y);
2809 T   template &lt;class T, class Allocator&gt;
2810       bool operator&lt; (const vector&lt;T,Allocator&gt;&amp; x,
2811                       const vector&lt;T,Allocator&gt;&amp; y);
2812 T   template &lt;class T, class Allocator&gt;
2813       bool operator!=(const vector&lt;T,Allocator&gt;&amp; x,
2814                       const vector&lt;T,Allocator&gt;&amp; y);
2815 T   template &lt;class T, class Allocator&gt;
2816       bool operator&gt; (const vector&lt;T,Allocator&gt;&amp; x,
2817                       const vector&lt;T,Allocator&gt;&amp; y);
2818 T   template &lt;class T, class Allocator&gt;
2819       bool operator&gt;=(const vector&lt;T,Allocator&gt;&amp; x,
2820                       const vector&lt;T,Allocator&gt;&amp; y);
2821 T   template &lt;class T, class Allocator&gt;
2822       bool operator&lt;=(const vector&lt;T,Allocator&gt;&amp; x,
2823                       const vector&lt;T,Allocator&gt;&amp; y);
2824     // specialized algorithms:
2825 T   template &lt;class T, class Allocator&gt;
2826       void swap(vector&lt;T,Allocator&gt;&amp; x, vector&lt;T,Allocator&gt;&amp; y);
2827
2828
2829    23.2.5  Class vector&lt;bool&gt;                           [lib.vector.bool]
2830
2831 T   template &lt;class Allocator&gt; class vector&lt;bool, Allocator&gt; {
2832     public:
2833       // types:
2834 T     typedef bool                                  const_reference;
2835 T     typedef implementation defined                iterator;
2836 T     typedef implementation defined                const_iterator;
2837 T     typedef implementation defined                size_type;
2838 T     typedef implementation defined                difference_type;
2839 T     typedef bool                                  value_type;
2840 T     typedef Allocator                             allocator_type;
2841 T     typedef implementation defined                pointer;
2842 T     typedef implementation defined                const_pointer
2843 T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
2844 T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
2845       // bit reference:
2846 T     class reference {
2847        friend class vector;
2848 T      reference();
2849       public:
2850 T      ~reference();
2851 T       operator bool() const;
2852 T       reference&amp; operator=(const bool x);
2853 T       reference&amp; operator=(const reference&amp; x);
2854 T       void flip();              // flips the bit
2855       };
2856
2857       // construct/copy/destroy:
2858 T     explicit vector(const Allocator&amp; = Allocator());
2859 T     explicit vector(size_type n, const bool&amp; value = bool(),
2860                       const Allocator&amp; = Allocator());
2861 T     template &lt;class InputIterator&gt;
2862         vector(InputIterator first, InputIterator last,
2863           const Allocator&amp; = Allocator());
2864 T     vector(const vector&lt;bool,Allocator&gt;&amp; x);
2865 T    ~vector();
2866 T     vector&lt;bool,Allocator&gt;&amp; operator=(const vector&lt;bool,Allocator&gt;&amp; x);
2867 T     template &lt;class InputIterator&gt;
2868         void assign(InputIterator first, InputIterator last);
2869 T     void assign(size_type n, const T&amp; t);
2870 T     allocator_type get_allocator() const;
2871       // iterators:
2872 T     iterator               begin();
2873 T     const_iterator         begin() const;
2874 T     iterator               end();
2875 T     const_iterator         end() const;
2876 T     reverse_iterator       rbegin();
2877 T     const_reverse_iterator rbegin() const;
2878 T     reverse_iterator       rend();
2879 T     const_reverse_iterator rend() const;
2880       // capacity:
2881 T     size_type size() const;
2882 T     size_type max_size() const;
2883 T     void      resize(size_type sz, bool c = false);
2884 T     size_type capacity() const;
2885 T     bool      empty() const;
2886 T     void      reserve(size_type n);
2887       // element access:
2888 T     reference       operator[](size_type n);
2889 T     const_reference operator[](size_type n) const;
2890 T     const_reference at(size_type n) const;
2891 T     reference       at(size_type n);
2892 T     reference       front();
2893 T     const_reference front() const;
2894 T     reference       back();
2895 T     const_reference back() const;
2896       // modifiers:
2897 T     void push_back(const bool&amp; x);
2898 T     void pop_back();
2899 T     iterator insert(iterator position, const bool&amp; x);
2900 T     void     insert (iterator position, size_type n, const bool&amp; x);
2901 T     template &lt;class InputIterator&gt;
2902           void insert(iterator position,
2903                       InputIterator first, InputIterator last);
2904 T     iterator erase(iterator position);
2905 T     iterator erase(iterator first, iterator last);
2906 T     void swap(vector&lt;bool,Allocator&gt;&amp;);
2907 T     static void swap(reference x, reference y);
2908 T     void flip();                // flips all bits
2909 T     void clear();
2910     };
2911
2912 T   template &lt;class Allocator&gt;
2913       bool operator==(const vector&lt;bool,Allocator&gt;&amp; x,
2914                       const vector&lt;bool,Allocator&gt;&amp; y);
2915 T   template &lt;class Allocator&gt;
2916       bool operator&lt; (const vector&lt;bool,Allocator&gt;&amp; x,
2917                       const vector&lt;bool,Allocator&gt;&amp; y);
2918 T   template &lt;class Allocator&gt;
2919       bool operator!=(const vector&lt;bool,Allocator&gt;&amp; x,
2920                       const vector&lt;bool,Allocator&gt;&amp; y);
2921 T   template &lt;class Allocator&gt;
2922       bool operator&gt; (const vector&lt;bool,Allocator&gt;&amp; x,
2923                       const vector&lt;bool,Allocator&gt;&amp; y);
2924 T   template &lt;class Allocator&gt;
2925       bool operator&gt;=(const vector&lt;bool,Allocator&gt;&amp; x,
2926                       const vector&lt;bool,Allocator&gt;&amp; y);
2927 T   template &lt;class Allocator&gt;
2928       bool operator&lt;=(const vector&lt;bool,Allocator&gt;&amp; x,
2929                       const vector&lt;bool,Allocator&gt;&amp; y);
2930     // specialized algorithms:
2931 T   template &lt;class Allocator&gt;
2932       void swap(vector&lt;bool,Allocator&gt;&amp; x, vector&lt;bool,Allocator&gt;&amp; y);
2933
2934    23.3  Associative containers                         [lib.associative]
2935
2936  &lt;map&gt; and &lt;set&gt;:
2937
2938    Header &lt;map&gt; synopsis
2939
2940     template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
2941               class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
2942 T     class map;
2943
2944 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2945       bool operator==(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
2946                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
2947 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2948       bool operator&lt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
2949                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
2950 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2951       bool operator!=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
2952                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
2953 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2954       bool operator&gt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
2955                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
2956 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2957       bool operator&gt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
2958                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
2959 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2960       bool operator&lt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
2961                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
2962 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2963       void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x,
2964                 map&lt;Key,T,Compare,Allocator&gt;&amp; y);
2965 T   template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
2966               class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
2967       class multimap;
2968 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2969       bool operator==(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
2970                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
2971 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2972       bool operator&lt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
2973                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
2974 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2975       bool operator!=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
2976                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
2977 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2978       bool operator&gt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
2979                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
2980 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2981       bool operator&gt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
2982                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
2983 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2984       bool operator&lt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
2985                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
2986 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
2987       void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
2988                 multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
2989    }
2990
2991    Header &lt;set&gt; synopsis
2992
2993     template &lt;class Key, class Compare = less&lt;Key&gt;,
2994               class Allocator = allocator&lt;Key&gt; &gt;
2995 T     class set;
2996
2997 T   template &lt;class Key, class Compare, class Allocator&gt;
2998       bool operator==(const set&lt;Key,Compare,Allocator&gt;&amp; x,
2999                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3000 T   template &lt;class Key, class Compare, class Allocator&gt;
3001       bool operator&lt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
3002                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3003 T   template &lt;class Key, class Compare, class Allocator&gt;
3004       bool operator!=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
3005                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3006 T   template &lt;class Key, class Compare, class Allocator&gt;
3007       bool operator&gt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
3008                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3009 T   template &lt;class Key, class Compare, class Allocator&gt;
3010       bool operator&gt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
3011                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3012 T   template &lt;class Key, class Compare, class Allocator&gt;
3013       bool operator&lt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
3014                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3015 T   template &lt;class Key, class Compare, class Allocator&gt;
3016       void swap(set&lt;Key,Compare,Allocator&gt;&amp; x,
3017                 set&lt;Key,Compare,Allocator&gt;&amp; y);
3018 T   template &lt;class Key, class Compare = less&lt;Key&gt;,
3019               class Allocator = allocator&lt;Key&gt; &gt;
3020       class multiset;
3021 T   template &lt;class Key, class Compare, class Allocator&gt;
3022       bool operator==(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3023                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3024 T   template &lt;class Key, class Compare, class Allocator&gt;
3025       bool operator&lt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3026                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3027 T   template &lt;class Key, class Compare, class Allocator&gt;
3028       bool operator!=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3029                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3030 T   template &lt;class Key, class Compare, class Allocator&gt;
3031       bool operator&gt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3032                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3033 T   template &lt;class Key, class Compare, class Allocator&gt;
3034       bool operator&gt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3035                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3036 T   template &lt;class Key, class Compare, class Allocator&gt;
3037       bool operator&lt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3038                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3039 T   template &lt;class Key, class Compare, class Allocator&gt;
3040       void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3041                 multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3042    }
3043
3044    23.3.1  Template class map                                   [lib.map]
3045
3046     template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
3047               class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
3048 T     class map {
3049     public:
3050       // types:
3051 T     typedef Key                                   key_type;
3052 T     typedef T                                     mapped_type;
3053 T     typedef pair&lt;const Key, T&gt;                    value_type;
3054 T     typedef Compare                               key_compare;
3055 T     typedef Allocator                             allocator_type;
3056 T     typedef typename Allocator::reference         reference;
3057 T     typedef typename Allocator::const_reference   const_reference;
3058 T     typedef implementation defined                iterator;
3059 T     typedef implementation defined                const_iterator;
3060 T     typedef implementation defined                size_type;
3061 T     typedef implementation defined                difference_type;
3062 T     typedef typename Allocator::pointer           pointer;
3063 T     typedef typename Allocator::const_pointer     const_pointer;
3064 T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
3065 T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
3066 T     class value_compare
3067         : public binary_function&lt;value_type,value_type,bool&gt; {
3068       friend class map;
3069       protected:
3070 T       Compare comp;
3071 T       value_compare(Compare c) : comp(c) {}
3072       public:
3073 T       bool operator()(const value_type&amp; x, const value_type&amp; y) const {
3074           return comp(x.first, y.first);
3075         }
3076       };
3077
3078       // _lib.map.cons_ construct/copy/destroy:
3079 T     explicit map(const Compare&amp; comp = Compare(),
3080                    const Allocator&amp; = Allocator());
3081 T     template &lt;class InputIterator&gt;
3082         map(InputIterator first, InputIterator last,
3083             const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());
3084 T     map(const map&lt;Key,T,Compare,Allocator&gt;&amp; x);
3085 T    ~map();
3086 T     map&lt;Key,T,Compare,Allocator&gt;&amp;
3087         operator=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x);
3088       // iterators:
3089 T     iterator               begin();
3090 T     const_iterator         begin() const;
3091 T     iterator               end();
3092 T     const_iterator         end() const;
3093 T     reverse_iterator       rbegin();
3094 T     const_reverse_iterator rbegin() const;
3095 T     reverse_iterator       rend();
3096 T     const_reverse_iterator rend() const;
3097       // capacity:
3098 T     bool      empty() const;
3099 T     size_type size() const;
3100 T     size_type max_size() const;
3101       // _lib.map.access_ element access:
3102 T     T&amp; operator[](const key_type&amp; x);
3103       // modifiers:
3104 T     pair&lt;iterator, bool&gt; insert(const value_type&amp; x);
3105 T     iterator             insert(iterator position, const value_type&amp; x);
3106 T     template &lt;class InputIterator&gt;
3107         void insert(InputIterator first, InputIterator last);
3108 T     void      erase(iterator position);
3109 T     size_type erase(const key_type&amp; x);
3110 T     void      erase(iterator first, iterator last);
3111 T     void swap(map&lt;Key,T,Compare,Allocator&gt;&amp;);
3112 T     void clear();
3113       // observers:
3114 T     key_compare   key_comp() const;
3115 T     value_compare value_comp() const;
3116       // _lib.map.ops_ map operations:
3117 T     iterator       find(const key_type&amp; x);
3118 T     const_iterator find(const key_type&amp; x) const;
3119 T     size_type      count(const key_type&amp; x) const;
3120 T     iterator       lower_bound(const key_type&amp; x);
3121 T     const_iterator lower_bound(const key_type&amp; x) const;
3122 T     iterator       upper_bound(const key_type&amp; x);
3123 T     const_iterator upper_bound(const key_type&amp; x) const;
3124 T     pair&lt;iterator,iterator&gt;
3125           equal_range(const key_type&amp; x);
3126 T     pair&lt;const_iterator,const_iterator&gt;
3127           equal_range(const key_type&amp; x) const;
3128     };
3129
3130 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3131       bool operator==(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
3132                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
3133 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3134       bool operator&lt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
3135                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
3136 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3137       bool operator!=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
3138                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
3139 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3140       bool operator&gt; (const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
3141                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
3142 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3143       bool operator&gt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
3144                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
3145 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3146       bool operator&lt;=(const map&lt;Key,T,Compare,Allocator&gt;&amp; x,
3147                       const map&lt;Key,T,Compare,Allocator&gt;&amp; y);
3148     // specialized algorithms:
3149 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3150       void swap(map&lt;Key,T,Compare,Allocator&gt;&amp; x,
3151                 map&lt;Key,T,Compare,Allocator&gt;&amp; y);
3152
3153    23.3.2  Template class multimap                         [lib.multimap]
3154
3155     template &lt;class Key, class T, class Compare = less&lt;Key&gt;,
3156               class Allocator = allocator&lt;pair&lt;const Key, T&gt; &gt; &gt;
3157 T   class multimap {
3158     public:
3159       // types:
3160 T     typedef Key                                   key_type;
3161 T     typedef T                                     mapped_type;
3162 T     typedef pair&lt;const Key,T&gt;                     value_type;
3163 T     typedef Compare                               key_compare;
3164 T     typedef Allocator                             allocator_type;
3165 T     typedef typename Allocator::reference         reference;
3166 T     typedef typename Allocator::const_reference   const_reference;
3167 T     typedef implementation defined                iterator;
3168 T     typedef implementation defined                const_iterator;
3169 T     typedef implementation defined                size_type;
3170 T     typedef implementation defined                difference_type
3171 T     typedef typename Allocator::pointer           pointer;
3172 T     typedef typename Allocator::const_pointer     const_pointer;
3173 T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
3174 T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
3175 T     class value_compare
3176         : public binary_function&lt;value_type,value_type,bool&gt; {
3177       friend class multimap;
3178       protected:
3179 T       Compare comp;
3180 T       value_compare(Compare c) : comp(c) {}
3181       public:
3182 T       bool operator()(const value_type&amp; x, const value_type&amp; y) const {
3183           return comp(x.first, y.first);
3184         }
3185       };
3186       // construct/copy/destroy:
3187 T     explicit multimap(const Compare&amp; comp = Compare(),
3188                         const Allocator&amp; = Allocator());
3189 T     template &lt;class InputIterator&gt;
3190         multimap(InputIterator first, InputIterator last,
3191                  const Compare&amp; comp = Compare(),
3192                  const Allocator&amp; = Allocator());
3193 T     multimap(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x);
3194 T    ~multimap();
3195 T     multimap&lt;Key,T,Compare,Allocator&gt;&amp;
3196         operator=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x);
3197 T     allocator_type get_allocator() const;
3198
3199       // iterators:
3200 T     iterator               begin();
3201 T     const_iterator         begin() const;
3202 T     iterator               end();
3203 T     const_iterator         end() const;
3204 T     reverse_iterator       rbegin();
3205 T     const_reverse_iterator rbegin() const;
3206 T     reverse_iterator       rend();
3207 T     const_reverse_iterator rend() const;
3208       // capacity:
3209 T     bool           empty() const;
3210 T     size_type      size() const;
3211 T     size_type      max_size() const;
3212       // modifiers:
3213 T     iterator insert(const value_type&amp; x);
3214 T     iterator insert(iterator position, const value_type&amp; x);
3215 T     template &lt;class InputIterator&gt;
3216         void insert(InputIterator first, InputIterator last);
3217 T     void      erase(iterator position);
3218 T     size_type erase(const key_type&amp; x);
3219 T     void      erase(iterator first, iterator last);
3220 T     void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp;);
3221 T     void clear();
3222       // observers:
3223 T     key_compare    key_comp() const;
3224 T     value_compare  value_comp() const;
3225       // map operations:
3226 T     iterator       find(const key_type&amp; x);
3227 T     const_iterator find(const key_type&amp; x) const;
3228 T     size_type      count(const key_type&amp; x) const;
3229 T     iterator       lower_bound(const key_type&amp; x);
3230 T     const_iterator lower_bound(const key_type&amp; x) const;
3231 T     iterator       upper_bound(const key_type&amp; x);
3232 T     const_iterator upper_bound(const key_type&amp; x) const;
3233 T     pair&lt;iterator,iterator&gt;             equal_range(const key_type&amp; x);
3234 T     pair&lt;const_iterator,const_iterator&gt; equal_range(const key_type&amp; x) const;
3235     };
3236
3237 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3238       bool operator==(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
3239                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
3240 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3241       bool operator&lt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
3242                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
3243 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3244       bool operator!=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
3245                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
3246 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3247       bool operator&gt; (const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
3248                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
3249 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3250       bool operator&gt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
3251                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
3252 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3253       bool operator&lt;=(const multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
3254                       const multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
3255     // specialized algorithms:
3256 T   template &lt;class Key, class T, class Compare, class Allocator&gt;
3257       void swap(multimap&lt;Key,T,Compare,Allocator&gt;&amp; x,
3258                 multimap&lt;Key,T,Compare,Allocator&gt;&amp; y);
3259
3260
3261    23.3.3  Template class set                                   [lib.set]
3262
3263     template &lt;class Key, class Compare = less&lt;Key&gt;,
3264               class Allocator = allocator&lt;Key&gt; &gt;
3265 T   class set {
3266     public:
3267       // types:
3268 T     typedef Key                                   key_type;
3269 T     typedef Key                                   value_type;
3270 T     typedef Compare                               key_compare;
3271 T     typedef Compare                               value_compare;
3272 T     typedef Allocator                             allocator_type;
3273 T     typedef typename Allocator::reference         reference;
3274 T     typedef typename Allocator::const_reference   const_reference;
3275 T     typedef implementation defined                iterator;
3276 T     typedef implementation defined                const_iterator;
3277 T     typedef implementation defined                size_type;
3278 T     typedef implementation defined                difference_type;
3279 T     typedef typename Allocator::pointer           pointer;
3280 T     typedef typename Allocator::const_pointer     const_pointer;
3281 T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
3282 T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
3283       // _lib.set.cons_ construct/copy/destroy:
3284 T     explicit set(const Compare&amp; comp = Compare(),
3285                    const Allocator&amp; = Allocator());
3286 T     template &lt;class InputIterator&gt;
3287         set(InputIterator first, InputIterator last,
3288             const Compare&amp; comp = Compare(), const Allocator&amp; = Allocator());
3289 T     set(const set&lt;Key,Compare,Allocator&gt;&amp; x);
3290 T    ~set();
3291 T     set&lt;Key,Compare,Allocator&gt;&amp;
3292         operator=(const set&lt;Key,Compare,Allocator&gt;&amp; x);
3293 T     allocator_type get_allocator() const;
3294       // iterators:
3295 T     iterator               begin();
3296 T     const_iterator         begin() const;
3297 T     iterator               end();
3298 T     const_iterator         end() const;
3299 T     reverse_iterator       rbegin();
3300 T     const_reverse_iterator rbegin() const;
3301 T     reverse_iterator       rend();
3302 T     const_reverse_iterator rend() const;
3303       // capacity:
3304 T     bool          empty() const;
3305 T     size_type     size() const;
3306 T     size_type     max_size() const;
3307       // modifiers:
3308 T     pair&lt;iterator,bool&gt; insert(const value_type&amp; x);
3309 T     iterator            insert(iterator position, const value_type&amp; x);
3310 T     template &lt;class InputIterator&gt;
3311 T         void insert(InputIterator first, InputIterator last);
3312 T     void      erase(iterator position);
3313 T     size_type erase(const key_type&amp; x);
3314 T     void      erase(iterator first, iterator last);
3315 T     void swap(set&lt;Key,Compare,Allocator&gt;&amp;);
3316 T     void clear();
3317
3318       // observers:
3319 T     key_compare   key_comp() const;
3320 T     value_compare value_comp() const;
3321       // set operations:
3322 T     iterator  find(const key_type&amp; x) const;
3323 T     size_type count(const key_type&amp; x) const;
3324 T     iterator  lower_bound(const key_type&amp; x) const;
3325 T     iterator  upper_bound(const key_type&amp; x) const;
3326 T     pair&lt;iterator,iterator&gt; equal_range(const key_type&amp; x) const;
3327     };
3328 T   template &lt;class Key, class Compare, class Allocator&gt;
3329       bool operator==(const set&lt;Key,Compare,Allocator&gt;&amp; x,
3330                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3331 T   template &lt;class Key, class Compare, class Allocator&gt;
3332       bool operator&lt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
3333                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3334 T   template &lt;class Key, class Compare, class Allocator&gt;
3335       bool operator!=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
3336                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3337 T   template &lt;class Key, class Compare, class Allocator&gt;
3338       bool operator&gt; (const set&lt;Key,Compare,Allocator&gt;&amp; x,
3339                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3340 T   template &lt;class Key, class Compare, class Allocator&gt;
3341       bool operator&gt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
3342                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3343 T   template &lt;class Key, class Compare, class Allocator&gt;
3344       bool operator&lt;=(const set&lt;Key,Compare,Allocator&gt;&amp; x,
3345                       const set&lt;Key,Compare,Allocator&gt;&amp; y);
3346     // specialized algorithms:
3347 T   template &lt;class Key, class Compare, class Allocator&gt;
3348       void swap(set&lt;Key,Compare,Allocator&gt;&amp; x,
3349                 set&lt;Key,Compare,Allocator&gt;&amp; y);
3350
3351    23.3.4  Template class multiset                         [lib.multiset]
3352
3353     template &lt;class Key, class Compare = less&lt;Key&gt;,
3354               class Allocator = allocator&lt;Key&gt; &gt;
3355 T   class multiset {
3356     public:
3357       // types:
3358 T     typedef Key                                   key_type;
3359 T     typedef Key                                   value_type;
3360 T     typedef Compare                               key_compare;
3361 T     typedef Compare                               value_compare;
3362 T     typedef Allocator                             allocator_type;
3363 T     typedef typename Allocator::reference         reference;
3364 T     typedef typename Allocator::const_reference   const_reference;
3365 T     typedef implementation defined                iterator;
3366 T     typedef implementation defined                const_iterator;
3367 T     typedef implementation defined                size_type;
3368 T     typedef implementation defined                difference_type
3369 T     typedef typename Allocator::pointer           pointer;
3370 T     typedef typename Allocator::const_pointer     const_pointer;
3371 T     typedef std::reverse_iterator&lt;iterator&gt;       reverse_iterator;
3372 T     typedef std::reverse_iterator&lt;const_iterator&gt; const_reverse_iterator;
3373
3374       // construct/copy/destroy:
3375 T     explicit multiset(const Compare&amp; comp = Compare(),
3376                         const Allocator&amp; = Allocator());
3377 T     template &lt;class InputIterator&gt;
3378         multiset(InputIterator first, InputIterator last,
3379                  const Compare&amp; comp = Compare(),
3380                  const Allocator&amp; = Allocator());
3381 T     multiset(const multiset&lt;Key,Compare,Allocator&gt;&amp; x);
3382 T    ~multiset();
3383 T     multiset&lt;Key,Compare,Allocator&gt;&amp;
3384           operator=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x);
3385 T     allocator_type get_allocator() const;
3386       // iterators:
3387 T     iterator               begin();
3388 T     const_iterator         begin() const;
3389 T     iterator               end();
3390 T     const_iterator         end() const;
3391 T     reverse_iterator       rbegin();
3392 T     const_reverse_iterator rbegin() const;
3393 T     reverse_iterator       rend();
3394 T     const_reverse_iterator rend() const;
3395       // capacity:
3396 T     bool          empty() const;
3397 T     size_type     size() const;
3398 T     size_type     max_size() const;
3399       // modifiers:
3400 T     iterator insert(const value_type&amp; x);
3401 T     iterator insert(iterator position, const value_type&amp; x);
3402 T     template &lt;class InputIterator&gt;
3403         void insert(InputIterator first, InputIterator last);
3404 T     void      erase(iterator position);
3405 T     size_type erase(const key_type&amp; x);
3406 T     void      erase(iterator first, iterator last);
3407 T     void swap(multiset&lt;Key,Compare,Allocator&gt;&amp;);
3408 T     void clear();
3409       // observers:
3410 T     key_compare   key_comp() const;
3411 T     value_compare value_comp() const;
3412       // set operations:
3413 T     iterator  find(const key_type&amp; x) const;
3414 T     size_type count(const key_type&amp; x) const;
3415 T     iterator  lower_bound(const key_type&amp; x) const;
3416 T     iterator  upper_bound(const key_type&amp; x) const;
3417 T     pair&lt;iterator,iterator&gt; equal_range(const key_type&amp; x) const;
3418     };
3419
3420 T   template &lt;class Key, class Compare, class Allocator&gt;
3421       bool operator==(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3422                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3423 T   template &lt;class Key, class Compare, class Allocator&gt;
3424       bool operator&lt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3425                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3426 T   template &lt;class Key, class Compare, class Allocator&gt;
3427       bool operator!=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3428                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3429 T   template &lt;class Key, class Compare, class Allocator&gt;
3430       bool operator&gt; (const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3431                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3432 T   template &lt;class Key, class Compare, class Allocator&gt;
3433       bool operator&gt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3434                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3435 T   template &lt;class Key, class Compare, class Allocator&gt;
3436       bool operator&lt;=(const multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3437                       const multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3438     // specialized algorithms:
3439 T   template &lt;class Key, class Compare, class Allocator&gt;
3440       void swap(multiset&lt;Key,Compare,Allocator&gt;&amp; x,
3441                 multiset&lt;Key,Compare,Allocator&gt;&amp; y);
3442
3443    23.3.5  Template class bitset                    [lib.template.bitset]
3444
3445    Header &lt;bitset&gt; synopsis
3446
3447 T   template &lt;size_t N&gt; class bitset;
3448     // _lib.bitset.operators_ bitset operations:
3449 T   template &lt;size_t N&gt;
3450       bitset&lt;N&gt; operator&amp;(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;);
3451 T   template &lt;size_t N&gt;
3452       bitset&lt;N&gt; operator|(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;);
3453 T   template &lt;size_t N&gt;
3454       bitset&lt;N&gt; operator^(const bitset&lt;N&gt;&amp;, const bitset&lt;N&gt;&amp;);
3455 T   template &lt;class charT, class traits, size_t N&gt;
3456       basic_istream&lt;charT, traits&gt;&amp;
3457       operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp; is, bitset&lt;N&gt;&amp; x);
3458 T   template &lt;class charT, class traits, size_t N&gt;
3459       basic_ostream&lt;charT, traits&gt;&amp;
3460       operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp; os, const bitset&lt;N&gt;&amp; x);
3461
3462 T   template&lt;size_t N&gt; class bitset {
3463     public:
3464       // bit reference:
3465 T     class reference {
3466         friend class bitset;
3467 T       reference();
3468       public:
3469 T      ~reference();
3470 T       reference&amp; operator=(bool x);             // for b[i] = x;
3471 T       reference&amp; operator=(const reference&amp;);   // for b[i] = b[j];
3472 T       bool operator~() const;                   // flips the bit
3473 T       operator bool() const;                    // for x = b[i];
3474 T       reference&amp; flip();                        // for b[i].flip();
3475       };
3476
3477       // _lib.bitset.cons_ constructors:
3478 T     bitset();
3479 T     bitset(unsigned long val);
3480 T     template&lt;class charT, class traits, class Allocator&gt;
3481         explicit bitset(
3482           const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
3483           typename basic_string&lt;charT,traits,Allocator&gt;::size_type pos = 0,
3484           typename basic_string&lt;charT,traits,Allocator&gt;::size_type n =
3485             basic_string&lt;charT,traits,Allocator&gt;::npos);
3486       // _lib.bitset.members_ bitset operations:
3487 T     bitset&lt;N&gt;&amp; operator&amp;=(const bitset&lt;N&gt;&amp; rhs);
3488 T     bitset&lt;N&gt;&amp; operator|=(const bitset&lt;N&gt;&amp; rhs);
3489 T     bitset&lt;N&gt;&amp; operator^=(const bitset&lt;N&gt;&amp; rhs);
3490 T     bitset&lt;N&gt;&amp; operator&lt;&lt;=(size_t pos);
3491 T     bitset&lt;N&gt;&amp; operator&gt;&gt;=(size_t pos);
3492 T     bitset&lt;N&gt;&amp; set();
3493 T     bitset&lt;N&gt;&amp; set(size_t pos, int val = true);
3494 T     bitset&lt;N&gt;&amp; reset();
3495 T     bitset&lt;N&gt;&amp; reset(size_t pos);
3496 T     bitset&lt;N&gt;  operator~() const;
3497 T     bitset&lt;N&gt;&amp; flip();
3498 T     bitset&lt;N&gt;&amp; flip(size_t pos);
3499       // element access:
3500 T     reference operator[](size_t pos);         // for b[i];
3501 T     unsigned long  to_ulong() const;
3502 T     template &lt;class charT, class traits, class Allocator&gt;
3503         basic_string&lt;charT, traits, Allocator&gt; to_string() const;
3504 T     size_t count() const;
3505 T     size_t size()  const;
3506 T     bool operator==(const bitset&lt;N&gt;&amp; rhs) const;
3507 T     bool operator!=(const bitset&lt;N&gt;&amp; rhs) const;
3508 T     bool test(size_t pos) const;
3509 T     bool any() const;
3510 T     bool none() const;
3511 T     bitset&lt;N&gt; operator&lt;&lt;(size_t pos) const;
3512 T     bitset&lt;N&gt; operator&gt;&gt;(size_t pos) const;
3513     };
3514
3515
3516
3517
3518    24.2  Header &lt;iterator&gt; synopsis               [lib.iterator.synopsis]
3519
3520     // _lib.iterator.primitives_, primitives:
3521 T   template&lt;class Iterator&gt; struct iterator_traits;
3522 T   template&lt;class T&gt; struct iterator_traits&lt;T*&gt;;
3523
3524 X   template&lt;class Category, class T, class Distance = ptrdiff_t,
3525              class Pointer = T*, class Reference = T&amp;&gt; struct iterator;
3526 T   struct input_iterator_tag {};
3527 T   struct output_iterator_tag {};
3528 T   struct forward_iterator_tag: public input_iterator_tag {};
3529 T   struct bidirectional_iterator_tag: public forward_iterator_tag {};
3530 T   struct random_access_iterator_tag: public bidirectional_iterator_tag {};
3531     // _lib.iterator.operations_, iterator operations:
3532 T   template &lt;class InputIterator, class Distance&gt;
3533       void advance(InputIterator&amp; i, Distance n);
3534 T   template &lt;class InputIterator&gt;
3535       typename iterator_traits&lt;InputIterator&gt;::difference_type
3536       distance(InputIterator first, InputIterator last);
3537     // _lib.predef.iterators_, predefined iterators:
3538 X   template &lt;class Iterator&gt; class reverse_iterator;
3539 T   template &lt;class Iterator&gt;
3540       bool operator==(
3541         const reverse_iterator&lt;Iterator&gt;&amp; x,
3542         const reverse_iterator&lt;Iterator&gt;&amp; y);
3543 T   template &lt;class Iterator&gt;
3544       bool operator&lt;(
3545         const reverse_iterator&lt;Iterator&gt;&amp; x,
3546         const reverse_iterator&lt;Iterator&gt;&amp; y);
3547 T   template &lt;class Iterator&gt;
3548       bool operator!=(
3549         const reverse_iterator&lt;Iterator&gt;&amp; x,
3550         const reverse_iterator&lt;Iterator&gt;&amp; y);
3551 T   template &lt;class Iterator&gt;
3552       bool operator&gt;(
3553         const reverse_iterator&lt;Iterator&gt;&amp; x,
3554         const reverse_iterator&lt;Iterator&gt;&amp; y);
3555 T   template &lt;class Iterator&gt;
3556       bool operator&gt;=(
3557         const reverse_iterator&lt;Iterator&gt;&amp; x,
3558         const reverse_iterator&lt;Iterator&gt;&amp; y);
3559 T   template &lt;class Iterator&gt;
3560       bool operator&lt;=(
3561         const reverse_iterator&lt;Iterator&gt;&amp; x,
3562         const reverse_iterator&lt;Iterator&gt;&amp; y);
3563 T   template &lt;class Iterator&gt;
3564       typename reverse_iterator&lt;Iterator&gt;::difference_type operator-(
3565         const reverse_iterator&lt;Iterator&gt;&amp; x,
3566         const reverse_iterator&lt;Iterator&gt;&amp; y);
3567 T   template &lt;class Iterator&gt;
3568       reverse_iterator&lt;Iterator&gt;
3569         operator+(
3570           typename reverse_iterator&lt;Iterator&gt;::difference_type n,
3571           const reverse_iterator&lt;Iterator&gt;&amp; x);
3572
3573 X   template &lt;class Container&gt; class back_insert_iterator;
3574 T   template &lt;class Container&gt;
3575       back_insert_iterator&lt;Container&gt; back_inserter(Container&amp; x);
3576 X   template &lt;class Container&gt; class front_insert_iterator;
3577 T   template &lt;class Container&gt;
3578       front_insert_iterator&lt;Container&gt; front_inserter(Container&amp; x);
3579 X   template &lt;class Container&gt; class insert_iterator;
3580 T   template &lt;class Container, class Iterator&gt;
3581       insert_iterator&lt;Container&gt; inserter(Container&amp; x, Iterator i);
3582     // _lib.stream.iterators_, stream iterators:
3583 X   template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;,
3584               class Distance = ptrdiff_t&gt;
3585       class istream_iterator;
3586     template &lt;class T, class charT, class traits, class Distance&gt;
3587 X     bool operator==(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
3588                       const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
3589     template &lt;class T, class charT, class traits, class Distance&gt;
3590 X     bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
3591                       const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
3592 X   template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt; &gt;
3593         class ostream_iterator;
3594 X   template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
3595       class istreambuf_iterator;
3596 X   template &lt;class charT, class traits&gt;
3597       bool operator==(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
3598                       const istreambuf_iterator&lt;charT,traits&gt;&amp; b);
3599 X   template &lt;class charT, class traits&gt;
3600       bool operator!=(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
3601                       const istreambuf_iterator&lt;charT,traits&gt;&amp; b);
3602 T   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
3603       class ostreambuf_iterator;
3604
3605    24.3  Iterator primitives                    [lib.iterator.primitives]
3606
3607 T   template&lt;class Iterator&gt; struct iterator_traits {
3608 T     typedef typename Iterator::difference_type difference_type;
3609 T     typedef typename Iterator::value_type value_type;
3610 T     typedef typename Iterator::pointer pointer;
3611 T     typedef typename Iterator::reference reference;
3612 T     typedef typename Iterator::iterator_category iterator_category;
3613     };
3614
3615 T   template&lt;class T&gt; struct iterator_traits&lt;T*&gt; {
3616 T     typedef ptrdiff_t difference_type;
3617 T     typedef T value_type;
3618 T     typedef T* pointer;
3619 T     typedef T&amp; reference;
3620 T     typedef random_access_iterator_tag iterator_category;
3621     };
3622
3623 T   template&lt;class T&gt; struct iterator_traits&lt;const T*&gt; {
3624 T     typedef ptrdiff_t difference_type;
3625 T     typedef T value_type;
3626 T     typedef const T* pointer;
3627 T     typedef const T&amp; reference;
3628 T     typedef random_access_iterator_tag iterator_category;
3629     };
3630
3631    24.3.2  Basic iterator                            [lib.iterator.basic]
3632
3633     template&lt;class Category, class T, class Distance = ptrdiff_t,
3634              class Pointer = T*, class Reference = T&amp;&gt;
3635 X     struct iterator {
3636 T         typedef T         value_type;
3637 T         typedef Distance  difference_type;
3638 T         typedef Pointer   pointer;
3639 T         typedef Reference reference;
3640 T         typedef Category  iterator_category;
3641     };
3642
3643    24.3.3  Standard iterator tags                 [lib.std.iterator.tags]
3644
3645 T   struct input_iterator_tag {};
3646 T   struct output_iterator_tag {};
3647 T   struct forward_iterator_tag: public input_iterator_tag {};
3648 T   struct bidirectional_iterator_tag: public forward_iterator_tag {};
3649 T   struct random_access_iterator_tag: public bidirectional_iterator_tag {};
3650
3651
3652    24.4.1  Reverse iterators                      [lib.reverse.iterators]
3653
3654     template &lt;class Iterator&gt;
3655 X   class reverse_iterator : public
3656           iterator&lt;typename iterator_traits&lt;Iterator&gt;::iterator_category,
3657                    typename iterator_traits&lt;Iterator&gt;::value_type,
3658                    typename iterator_traits&lt;Iterator&gt;::difference_type,
3659                    typename iterator_traits&lt;Iterator&gt;::pointer,
3660                    typename iterator_traits&lt;Iterator&gt;::reference&gt; {
3661     protected:
3662 T     Iterator current;
3663     public:
3664 T     typedef Iterator
3665           iterator_type;
3666 T     typedef typename iterator_traits&lt;Iterator&gt;::difference_type
3667           difference_type;
3668 T     typedef typename iterator_traits&lt;Iterator&gt;::reference
3669           reference;
3670 T     typedef typename iterator_traits&lt;Iterator&gt;::pointer
3671           pointer;
3672
3673 T     reverse_iterator();
3674 T     explicit reverse_iterator(Iterator x);
3675 T     template &lt;class U&gt; reverse_iterator(const reverse_iterator&lt;U&gt;&amp; u);
3676 T     Iterator base() const;      // explicit
3677 T     reference operator*() const;
3678 T     pointer   operator-&gt;() const;
3679 T     reverse_iterator&amp; operator++();
3680 T     reverse_iterator  operator++(int);
3681 T     reverse_iterator&amp; operator--();
3682 T     reverse_iterator  operator--(int);
3683
3684 T     reverse_iterator  operator+ (difference_type n) const;
3685 T     reverse_iterator&amp; operator+=(difference_type n);
3686 T     reverse_iterator  operator- (difference_type n) const;
3687 T     reverse_iterator&amp; operator-=(difference_type n);
3688 T     reference operator[](difference_type n) const;
3689     };
3690 T   template &lt;class Iterator&gt;
3691       bool operator==(
3692         const reverse_iterator&lt;Iterator&gt;&amp; x,
3693         const reverse_iterator&lt;Iterator&gt;&amp; y);
3694 T   template &lt;class Iterator&gt;
3695       bool operator&lt;(
3696         const reverse_iterator&lt;Iterator&gt;&amp; x,
3697         const reverse_iterator&lt;Iterator&gt;&amp; y);
3698 T   template &lt;class Iterator&gt;
3699       bool operator!=(
3700         const reverse_iterator&lt;Iterator&gt;&amp; x,
3701         const reverse_iterator&lt;Iterator&gt;&amp; y);
3702 T   template &lt;class Iterator&gt;
3703       bool operator&gt;(
3704         const reverse_iterator&lt;Iterator&gt;&amp; x,
3705         const reverse_iterator&lt;Iterator&gt;&amp; y);
3706 T   template &lt;class Iterator&gt;
3707       bool operator&gt;=(
3708         const reverse_iterator&lt;Iterator&gt;&amp; x,
3709         const reverse_iterator&lt;Iterator&gt;&amp; y);
3710 T   template &lt;class Iterator&gt;
3711       bool operator&lt;=(
3712         const reverse_iterator&lt;Iterator&gt;&amp; x,
3713         const reverse_iterator&lt;Iterator&gt;&amp; y);
3714 T   template &lt;class Iterator&gt;
3715       typename reverse_iterator&lt;Iterator&gt;::difference_type operator-(
3716         const reverse_iterator&lt;Iterator&gt;&amp; x,
3717         const reverse_iterator&lt;Iterator&gt;&amp; y);
3718 T   template &lt;class Iterator&gt;
3719       reverse_iterator&lt;Iterator&gt; operator+(
3720         typename reverse_iterator&lt;Iterator&gt;::difference_type n,
3721         const reverse_iterator&lt;Iterator&gt;&amp; x);
3722
3723
3724    24.4.2.1  Template class                    [lib.back.insert.iterator]
3725        back_insert_iterator
3726
3727     template &lt;class Container&gt;
3728 X   class back_insert_iterator :
3729           public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
3730     protected:
3731 T     Container* container;
3732     public:
3733 T     typedef Container container_type;
3734 T     explicit back_insert_iterator(Container&amp; x);
3735 T     back_insert_iterator&lt;Container&gt;&amp;
3736         operator=(typename Container::const_reference value);
3737
3738 T     back_insert_iterator&lt;Container&gt;&amp; operator*();
3739 T     back_insert_iterator&lt;Container&gt;&amp; operator++();
3740 T     back_insert_iterator&lt;Container&gt;  operator++(int);
3741     };
3742 T   template &lt;class Container&gt;
3743       back_insert_iterator&lt;Container&gt; back_inserter(Container&amp; x);
3744
3745
3746
3747    24.4.2.3  Template class                   [lib.front.insert.iterator]
3748        front_insert_iterator
3749
3750     template &lt;class Container&gt;
3751 X   class front_insert_iterator :
3752           public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
3753     protected:
3754 T     Container* container;
3755     public:
3756 T     typedef Container container_type;
3757 T     explicit front_insert_iterator(Container&amp; x);
3758 T     front_insert_iterator&lt;Container&gt;&amp;
3759         operator=(typename Container::const_reference value);
3760 T     front_insert_iterator&lt;Container&gt;&amp; operator*();
3761 T     front_insert_iterator&lt;Container&gt;&amp; operator++();
3762 T     front_insert_iterator&lt;Container&gt;  operator++(int);
3763     };
3764 T   template &lt;class Container&gt;
3765       front_insert_iterator&lt;Container&gt; front_inserter(Container&amp; x);
3766
3767
3768    24.4.2.5  Template class insert_iterator         [lib.insert.iterator]
3769
3770     template &lt;class Container&gt;
3771 X   class insert_iterator :
3772           public iterator&lt;output_iterator_tag,void,void,void,void&gt; {
3773     protected:
3774 T     Container* container;
3775 T     typename Container::iterator iter;
3776     public:
3777 T     typedef Container container_type;
3778 T     insert_iterator(Container&amp; x, typename Container::iterator i);
3779 T     insert_iterator&lt;Container&gt;&amp;
3780         operator=(typename Container::const_reference value);
3781 T     insert_iterator&lt;Container&gt;&amp; operator*();
3782 T     insert_iterator&lt;Container&gt;&amp; operator++();
3783 T     insert_iterator&lt;Container&gt;&amp; operator++(int);
3784     };
3785 T   template &lt;class Container, class Iterator&gt;
3786       insert_iterator&lt;Container&gt; inserter(Container&amp; x, Iterator i);
3787
3788    24.5.1  Template class istream_iterator         [lib.istream.iterator]
3789
3790     template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt;,
3791         class Distance = ptrdiff_t&gt;
3792 X   class istream_iterator:
3793       public iterator&lt;input_iterator_tag, T, Distance, const T*, const T&amp;&gt; {
3794     public:
3795 T     typedef charT char_type
3796 T     typedef traits traits_type;
3797 T     typedef basic_istream&lt;charT,traits&gt; istream_type;
3798 T     istream_iterator();
3799 T     istream_iterator(istream_type&amp; s);
3800 T     istream_iterator(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x);
3801 T    ~istream_iterator();
3802
3803 T     const T&amp; operator*() const;
3804 T     const T* operator-&gt;() const;
3805 T     istream_iterator&lt;T,charT,traits,Distance&gt;&amp; operator++();
3806 T     istream_iterator&lt;T,charT,traits,Distance&gt;  operator++(int);
3807     };
3808
3809 T   template &lt;class T, class charT, class traits, class Distance&gt;
3810       bool operator==(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
3811                       const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
3812 T   template &lt;class T, class charT, class traits, class Distance&gt;
3813       bool operator!=(const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; x,
3814                       const istream_iterator&lt;T,charT,traits,Distance&gt;&amp; y);
3815
3816
3817    24.5.2  Template class ostream_iterator         [lib.ostream.iterator]
3818
3819     template &lt;class T, class charT = char, class traits = char_traits&lt;charT&gt; &gt;
3820 X   class ostream_iterator:
3821       public iterator&lt;output_iterator_tag, void, void, void, void&gt; {
3822     public:
3823 T     typedef charT char_type;
3824 T     typedef traits traits_type;
3825 T     typedef basic_ostream&lt;charT,traits&gt; ostream_type;
3826 T     ostream_iterator(ostream_type&amp; s);
3827 T     ostream_iterator(ostream_type&amp; s, const charT* delimiter);
3828 T     ostream_iterator(const ostream_iterator&lt;T,charT,traits&gt;&amp; x);
3829 T    ~ostream_iterator();
3830 T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator=(const T&amp; value);
3831
3832 T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator*();
3833 T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator++();
3834 T     ostream_iterator&lt;T,charT,traits&gt;&amp; operator++(int);
3835     };
3836
3837
3838    24.5.3  Template class                       [lib.istreambuf.iterator]
3839        istreambuf_iterator
3840
3841     template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
3842 X   class istreambuf_iterator
3843        : public iterator&lt;input_iterator_tag, charT,
3844                          typename traits::off_type, charT*, charT&amp;&gt; {
3845     public:
3846 T     typedef charT                         char_type;
3847 T     typedef traits                        traits_type;
3848 T     typedef typename traits::int_type     int_type;
3849 T     typedef basic_streambuf&lt;charT,traits&gt; streambuf_type;
3850 T     typedef basic_istream&lt;charT,traits&gt;   istream_type;
3851 T     class proxy;                        // exposition only
3852 T     istreambuf_iterator() throw();
3853 T     istreambuf_iterator(istream_type&amp; s) throw();
3854 T     istreambuf_iterator(streambuf_type* s) throw();
3855 T     istreambuf_iterator(const proxy&amp; p) throw();
3856 T     charT operator*() const;
3857 T     istreambuf_iterator&lt;charT,traits&gt;&amp; operator++();
3858 T     proxy operator++(int);
3859 X     bool equal(istreambuf_iterator&amp; b);
3860     };
3861
3862 T   template &lt;class charT, class traits&gt;
3863       bool operator==(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
3864                       const istreambuf_iterator&lt;charT,traits&gt;&amp; b);
3865
3866 T   template &lt;class charT, class traits&gt;
3867       bool operator!=(const istreambuf_iterator&lt;charT,traits&gt;&amp; a,
3868                       const istreambuf_iterator&lt;charT,traits&gt;&amp; b);
3869
3870    24.5.3.1  Template class              [lib.istreambuf.iterator::proxy]
3871        istreambuf_iterator::proxy
3872
3873     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
3874 T     class istreambuf_iterator&lt;charT, traits&gt;::proxy
3875     {
3876 T     charT keep_;
3877 T     basic_streambuf&lt;charT,traits&gt;* sbuf_;
3878 T     proxy(charT c,
3879             basic_streambuf&lt;charT,traits&gt;* sbuf);
3880         : keep_(c), sbuf_(sbuf) {}
3881     public:
3882 T     charT operator*() { return keep_; }
3883     };
3884
3885
3886
3887    24.5.4  Template class                       [lib.ostreambuf.iterator]
3888        ostreambuf_iterator
3889
3890     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
3891 T   class ostreambuf_iterator:
3892       public iterator&lt;output_iterator_tag, void, void, void, void&gt; {
3893     public:
3894 T     typedef charT                         char_type;
3895 T     typedef traits                        traits_type;
3896 T     typedef basic_streambuf&lt;charT,traits&gt; streambuf_type;
3897 T     typedef basic_ostream&lt;charT,traits&gt;   ostream_type;
3898     public:
3899 T     ostreambuf_iterator(ostream_type&amp; s) throw();
3900 T     ostreambuf_iterator(streambuf_type* s) throw();
3901 T     ostreambuf_iterator&amp; operator=(charT c);
3902 T     ostreambuf_iterator&amp; operator*();
3903 T     ostreambuf_iterator&amp; operator++();
3904 T     ostreambuf_iterator&amp; operator++(int);
3905 T     bool failed() const throw();
3906     };
3907
3908
3909    Header &lt;algorithm&gt; synopsis
3910
3911
3912     // _lib.alg.nonmodifying_, non-modifying sequence operations:
3913 T   template&lt;class InputIterator, class Function&gt;
3914       Function for_each(InputIterator first, InputIterator last, Function f);
3915 T   template&lt;class InputIterator, class T&gt;
3916       InputIterator find(InputIterator first, InputIterator last,
3917                          const T&amp; value);
3918 T   template&lt;class InputIterator, class Predicate&gt;
3919       InputIterator find_if(InputIterator first, InputIterator last,
3920                             Predicate pred);
3921 T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
3922       ForwardIterator1
3923         find_end(ForwardIterator1 first1, ForwardIterator1 last1,
3924                  ForwardIterator2 first2, ForwardIterator2 last2);
3925 T   template&lt;class ForwardIterator1, class ForwardIterator2,
3926              class BinaryPredicate&gt;
3927       ForwardIterator1
3928         find_end(ForwardIterator1 first1, ForwardIterator1 last1,
3929                  ForwardIterator2 first2, ForwardIterator2 last2,
3930                  BinaryPredicate pred);
3931 T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
3932       ForwardIterator1
3933         find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
3934                       ForwardIterator2 first2, ForwardIterator2 last2);
3935 T   template&lt;class ForwardIterator1, class ForwardIterator2,
3936              class BinaryPredicate&gt;
3937       ForwardIterator1
3938         find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
3939                  ForwardIterator2 first2, ForwardIterator2 last2,
3940                  BinaryPredicate pred);
3941 T   template&lt;class ForwardIterator&gt;
3942       ForwardIterator adjacent_find(ForwardIterator first,
3943                                     ForwardIterator last);
3944 T   template&lt;class ForwardIterator, class BinaryPredicate&gt;
3945       ForwardIterator adjacent_find(ForwardIterator first,
3946           ForwardIterator last, BinaryPredicate pred);
3947 T   template&lt;class InputIterator, class T&gt;
3948       typename iterator_traits&lt;InputIterator&gt;::difference_type
3949         count(InputIterator first, InputIterator last, const T&amp; value);
3950 T   template&lt;class InputIterator, class Predicate&gt;
3951       typename iterator_traits&lt;InputIterator&gt;::difference_type
3952         count_if(InputIterator first, InputIterator last, Predicate pred);
3953 T   template&lt;class InputIterator1, class InputIterator2&gt;
3954       pair&lt;InputIterator1, InputIterator2&gt;
3955         mismatch(InputIterator1 first1, InputIterator1 last1,
3956                  InputIterator2 first2);
3957 T   template&lt;class InputIterator1, class InputIterator2, class BinaryPredicate&gt;
3958       pair&lt;InputIterator1, InputIterator2&gt;
3959         mismatch(InputIterator1 first1, InputIterator1 last1,
3960                  InputIterator2 first2, BinaryPredicate pred);
3961
3962 T   template&lt;class InputIterator1, class InputIterator2&gt;
3963       bool equal(InputIterator1 first1, InputIterator1 last1,
3964                  InputIterator2 first2);
3965 T   template&lt;class InputIterator1, class InputIterator2, class BinaryPredicate&gt;
3966       bool equal(InputIterator1 first1, InputIterator1 last1,
3967                  InputIterator2 first2, BinaryPredicate pred);
3968 T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
3969       ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
3970                               ForwardIterator2 first2, ForwardIterator2 last2);
3971 T   template&lt;class ForwardIterator1, class ForwardIterator2,
3972              class BinaryPredicate&gt;
3973       ForwardIterator1 search(ForwardIterator1 first1, ForwardIterator1 last1,
3974                               ForwardIterator2 first2, ForwardIterator2 last2,
3975                               BinaryPredicate pred);
3976 T   template&lt;class ForwardIterator, class Size, class T&gt;
3977       ForwardIterator  search_n(ForwardIterator first, ForwardIterator last,
3978                               Size count, const T&amp; value);
3979 T   template&lt;class ForwardIterator, class Size, class T, class BinaryPredicate&gt;
3980       ForwardIterator1 search_n(ForwardIterator first, ForwardIterator last,
3981                               Size count, const T&amp; value,
3982                               BinaryPredicate pred);
3983     // _lib.alg.modifying.operations_, modifying sequence operations:
3984     // _lib.alg.copy_, copy:
3985 T   template&lt;class InputIterator, class OutputIterator&gt;
3986       OutputIterator copy(InputIterator first, InputIterator last,
3987                           OutputIterator result);
3988 T   template&lt;class BidirectionalIterator1, class BidirectionalIterator2&gt;
3989       BidirectionalIterator2
3990         copy_backward(BidirectionalIterator1 first, BidirectionalIterator1 last,
3991                       BidirectionalIterator2 result);
3992     // _lib.alg.swap_, swap:
3993 T   template&lt;class T&gt; void swap(T&amp; a, T&amp; b);
3994 T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
3995       ForwardIterator2 swap_ranges(ForwardIterator1 first1,
3996           ForwardIterator1 last1, ForwardIterator2 first2);
3997 T   template&lt;class ForwardIterator1, class ForwardIterator2&gt;
3998       void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
3999 T   template&lt;class InputIterator, class OutputIterator, class UnaryOperation&gt;
4000       OutputIterator transform(InputIterator first, InputIterator last,
4001                                OutputIterator result, UnaryOperation op);
4002 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
4003              class BinaryOperation&gt;
4004       OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
4005                                InputIterator2 first2, OutputIterator result,
4006                                BinaryOperation binary_op);
4007
4008 T   template&lt;class ForwardIterator, class T&gt;
4009       void replace(ForwardIterator first, ForwardIterator last,
4010                    const T&amp; old_value, const T&amp; new_value);
4011 T   template&lt;class ForwardIterator, class Predicate, class T&gt;
4012       void replace_if(ForwardIterator first, ForwardIterator last,
4013                       Predicate pred, const T&amp; new_value);
4014 T   template&lt;class InputIterator, class OutputIterator, class T&gt;
4015       OutputIterator replace_copy(InputIterator first, InputIterator last,
4016                                   OutputIterator result,
4017                                   const T&amp; old_value, const T&amp; new_value);
4018 T   template&lt;class Iterator, class OutputIterator, class Predicate, class T&gt;
4019       OutputIterator replace_copy_if(Iterator first, Iterator last,
4020                                      OutputIterator result,
4021                                      Predicate pred, const T&amp; new_value);
4022 T   template&lt;class ForwardIterator, class T&gt;
4023       void fill(ForwardIterator first, ForwardIterator last, const T&amp; value);
4024 T   template&lt;class OutputIterator, class Size, class T&gt;
4025       void fill_n(OutputIterator first, Size n, const T&amp; value);
4026 T   template&lt;class ForwardIterator, class Generator&gt;
4027       void generate(ForwardIterator first, ForwardIterator last, Generator gen);
4028 T   template&lt;class OutputIterator, class Size, class Generator&gt;
4029       void generate_n(OutputIterator first, Size n, Generator gen);
4030 T   template&lt;class ForwardIterator, class T&gt;
4031       ForwardIterator remove(ForwardIterator first, ForwardIterator last,
4032                              const T&amp; value);
4033 T   template&lt;class ForwardIterator, class Predicate&gt;
4034       ForwardIterator remove_if(ForwardIterator first, ForwardIterator last,
4035                                 Predicate pred);
4036 T   template&lt;class InputIterator, class OutputIterator, class T&gt;
4037       OutputIterator remove_copy(InputIterator first, InputIterator last,
4038                                  OutputIterator result, const T&amp; value);
4039 T   template&lt;class InputIterator, class OutputIterator, class Predicate&gt;
4040       OutputIterator remove_copy_if(InputIterator first, InputIterator last,
4041                                     OutputIterator result, Predicate pred);
4042 T   template&lt;class ForwardIterator&gt;
4043       ForwardIterator unique(ForwardIterator first, ForwardIterator last);
4044 T   template&lt;class ForwardIterator, class BinaryPredicate&gt;
4045       ForwardIterator unique(ForwardIterator first, ForwardIterator last,
4046                              BinaryPredicate pred);
4047 T   template&lt;class InputIterator, class OutputIterator&gt;
4048       OutputIterator unique_copy(InputIterator first, InputIterator last,
4049                                  OutputIterator result);
4050 T   template&lt;class InputIterator, class OutputIterator, class BinaryPredicate&gt;
4051       OutputIterator unique_copy(InputIterator first, InputIterator last,
4052                                  OutputIterator result, BinaryPredicate pred);
4053 T   template&lt;class BidirectionalIterator&gt;
4054       void reverse(BidirectionalIterator first, BidirectionalIterator last);
4055 T   template&lt;class BidirectionalIterator, class OutputIterator&gt;
4056       OutputIterator reverse_copy(BidirectionalIterator first,
4057                                   BidirectionalIterator last,
4058                                   OutputIterator result);
4059
4060 T   template&lt;class ForwardIterator&gt;
4061       void rotate(ForwardIterator first, ForwardIterator middle,
4062                   ForwardIterator last);
4063 T   template&lt;class ForwardIterator, class OutputIterator&gt;
4064       OutputIterator rotate_copy(ForwardIterator first, ForwardIterator middle,
4065                                  ForwardIterator last, OutputIterator result);
4066 T   template&lt;class RandomAccessIterator&gt;
4067       void random_shuffle(RandomAccessIterator first,
4068                           RandomAccessIterator last);
4069 T   template&lt;class RandomAccessIterator, class RandomNumberGenerator&gt;
4070       void random_shuffle(RandomAccessIterator first,
4071                           RandomAccessIterator last,
4072                           RandomNumberGenerator&amp; rand);
4073     // _lib.alg.partitions_, partitions:
4074 T   template&lt;class BidirectionalIterator, class Predicate&gt;
4075       BidirectionalIterator partition(BidirectionalIterator first,
4076                                       BidirectionalIterator last,
4077                                       Predicate pred);
4078 T   template&lt;class BidirectionalIterator, class Predicate&gt;
4079       BidirectionalIterator stable_partition(BidirectionalIterator first,
4080                                              BidirectionalIterator last,
4081                                              Predicate pred);
4082     // _lib.alg.sorting_, sorting and related operations:
4083     // _lib.alg.sort_, sorting:
4084 T   template&lt;class RandomAccessIterator&gt;
4085       void sort(RandomAccessIterator first, RandomAccessIterator last);
4086 T   template&lt;class RandomAccessIterator, class Compare&gt;
4087       void sort(RandomAccessIterator first, RandomAccessIterator last,
4088                 Compare comp);
4089 T   template&lt;class RandomAccessIterator&gt;
4090       void stable_sort(RandomAccessIterator first, RandomAccessIterator last);
4091 T   template&lt;class RandomAccessIterator, class Compare&gt;
4092       void stable_sort(RandomAccessIterator first, RandomAccessIterator last,
4093                        Compare comp);
4094 T   template&lt;class RandomAccessIterator&gt;
4095       void partial_sort(RandomAccessIterator first,
4096                         RandomAccessIterator middle,
4097                         RandomAccessIterator last);
4098 T   template&lt;class RandomAccessIterator, class Compare&gt;
4099       void partial_sort(RandomAccessIterator first,
4100                         RandomAccessIterator middle,
4101                         RandomAccessIterator last, Compare comp);
4102 T   template&lt;class InputIterator, class RandomAccessIterator&gt;
4103       RandomAccessIterator
4104         partial_sort_copy(InputIterator first, InputIterator last,
4105                           RandomAccessIterator result_first,
4106                           RandomAccessIterator result_last);
4107 T   template&lt;class InputIterator, class RandomAccessIterator, class Compare&gt;
4108       RandomAccessIterator
4109         partial_sort_copy(InputIterator first, InputIterator last,
4110                           RandomAccessIterator result_first,
4111                           RandomAccessIterator result_last,
4112                           Compare comp);
4113
4114 T   template&lt;class RandomAccessIterator&gt;
4115       void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
4116                        RandomAccessIterator last);
4117 T   template&lt;class RandomAccessIterator, class Compare&gt;
4118       void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
4119                        RandomAccessIterator last, Compare comp);
4120     // _lib.alg.binary.search_, binary search:
4121 T   template&lt;class ForwardIterator, class T&gt;
4122       ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
4123                                   const T&amp; value);
4124 T   template&lt;class ForwardIterator, class T, class Compare&gt;
4125       ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last,
4126                                   const T&amp; value, Compare comp);
4127 T   template&lt;class ForwardIterator, class T&gt;
4128       ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
4129                                   const T&amp; value);
4130 T   template&lt;class ForwardIterator, class T, class Compare&gt;
4131       ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
4132                                   const T&amp; value, Compare comp);
4133 T   template&lt;class ForwardIterator, class T&gt;
4134       pair&lt;ForwardIterator, ForwardIterator&gt;
4135         equal_range(ForwardIterator first, ForwardIterator last,
4136                     const T&amp; value);
4137 T   template&lt;class ForwardIterator, class T, class Compare&gt;
4138       pair&lt;ForwardIterator, ForwardIterator&gt;
4139         equal_range(ForwardIterator first, ForwardIterator last,
4140                     const T&amp; value, Compare comp);
4141 T   template&lt;class ForwardIterator, class T&gt;
4142       bool binary_search(ForwardIterator first, ForwardIterator last,
4143                          const T&amp; value);
4144 T   template&lt;class ForwardIterator, class T, class Compare&gt;
4145       bool binary_search(ForwardIterator first, ForwardIterator last,
4146                          const T&amp; value, Compare comp);
4147     // _lib.alg.merge_, merge:
4148 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
4149       OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
4150                            InputIterator2 first2, InputIterator2 last2,
4151                            OutputIterator result);
4152 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
4153              class Compare&gt;
4154       OutputIterator merge(InputIterator1 first1, InputIterator1 last1,
4155                            InputIterator2 first2, InputIterator2 last2,
4156                            OutputIterator result, Compare comp);
4157 T   template&lt;class BidirectionalIterator&gt;
4158       void inplace_merge(BidirectionalIterator first,
4159                          BidirectionalIterator middle,
4160                          BidirectionalIterator last);
4161 T   template&lt;class BidirectionalIterator, class Compare&gt;
4162       void inplace_merge(BidirectionalIterator first,
4163                          BidirectionalIterator middle,
4164                          BidirectionalIterator last, Compare comp);
4165
4166     // _lib.alg.set.operations_, set operations:
4167 T   template&lt;class InputIterator1, class InputIterator2&gt;
4168       bool includes(InputIterator1 first1, InputIterator1 last1,
4169                     InputIterator2 first2, InputIterator2 last2);
4170 T   template&lt;class InputIterator1, class InputIterator2, class Compare&gt;
4171       bool includes(InputIterator1 first1, InputIterator1 last1,
4172                     InputIterator2 first2, InputIterator2 last2, Compare comp);
4173 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
4174       OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
4175                                InputIterator2 first2, InputIterator2 last2,
4176                                OutputIterator result);
4177 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
4178              class Compare&gt;
4179       OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
4180                                InputIterator2 first2, InputIterator2 last2,
4181                                OutputIterator result, Compare comp);
4182 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
4183       OutputIterator set_intersection
4184           (InputIterator1 first1, InputIterator1 last1,
4185            InputIterator2 first2, InputIterator2 last2,
4186            OutputIterator result);
4187 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
4188              class Compare&gt;
4189       OutputIterator set_intersection
4190           (InputIterator1 first1, InputIterator1 last1,
4191            InputIterator2 first2, InputIterator2 last2,
4192            OutputIterator result, Compare comp);
4193 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
4194       OutputIterator set_difference
4195           (InputIterator1 first1, InputIterator1 last1,
4196            InputIterator2 first2, InputIterator2 last2,
4197            OutputIterator result);
4198 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
4199              class Compare&gt;
4200       OutputIterator set_difference(InputIterator1 first1, InputIterator1 last1,
4201                                     InputIterator2 first2, InputIterator2 last2,
4202                                     OutputIterator result, Compare comp);
4203 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator&gt;
4204       OutputIterator
4205         set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
4206                                  InputIterator2 first2, InputIterator2 last2,
4207                                  OutputIterator result);
4208 T   template&lt;class InputIterator1, class InputIterator2, class OutputIterator,
4209               class Compare&gt;
4210       OutputIterator
4211         set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
4212                                  InputIterator2 first2, InputIterator2 last2,
4213                                  OutputIterator result, Compare comp);
4214     // _lib.alg.heap.operations_, heap operations:
4215 T   template&lt;class RandomAccessIterator&gt;
4216       void push_heap(RandomAccessIterator first, RandomAccessIterator last);
4217 T   template&lt;class RandomAccessIterator, class Compare&gt;
4218       void push_heap(RandomAccessIterator first, RandomAccessIterator last,
4219                      Compare comp);
4220
4221 T   template&lt;class RandomAccessIterator&gt;
4222       void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
4223 T   template&lt;class RandomAccessIterator, class Compare&gt;
4224       void pop_heap(RandomAccessIterator first, RandomAccessIterator last,
4225                     Compare comp);
4226 T   template&lt;class RandomAccessIterator&gt;
4227       void make_heap(RandomAccessIterator first, RandomAccessIterator last);
4228 T   template&lt;class RandomAccessIterator, class Compare&gt;
4229       void make_heap(RandomAccessIterator first, RandomAccessIterator last,
4230                      Compare comp);
4231 T   template&lt;class RandomAccessIterator&gt;
4232       void sort_heap(RandomAccessIterator first, RandomAccessIterator last);
4233 T   template&lt;class RandomAccessIterator, class Compare&gt;
4234       void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
4235                      Compare comp);
4236     // _lib.alg.min.max_, minimum and maximum:
4237 T   template&lt;class T&gt; const T&amp; min(const T&amp; a, const T&amp; b);
4238 T   template&lt;class T, class Compare&gt;
4239       const T&amp; min(const T&amp; a, const T&amp; b, Compare comp);
4240 T   template&lt;class T&gt; const T&amp; max(const T&amp; a, const T&amp; b);
4241 T   template&lt;class T, class Compare&gt;
4242       const T&amp; max(const T&amp; a, const T&amp; b, Compare comp);
4243 T   template&lt;class ForwardIterator&gt;
4244       ForwardIterator min_element(ForwardIterator first, ForwardIterator last);
4245 T   template&lt;class ForwardIterator, class Compare&gt;
4246       ForwardIterator min_element(ForwardIterator first, ForwardIterator last,
4247                                 Compare comp);
4248 T   template&lt;class ForwardIterator&gt;
4249       ForwardIterator max_element(ForwardIterator first, ForwardIterator last);
4250 T   template&lt;class ForwardIterator, class Compare&gt;
4251       ForwardIterator max_element(ForwardIterator first, ForwardIterator last,
4252                                 Compare comp);
4253 T   template&lt;class InputIterator1, class InputIterator2&gt;
4254       bool lexicographical_compare
4255           (InputIterator1 first1, InputIterator1 last1,
4256            InputIterator2 first2, InputIterator2 last2);
4257 T   template&lt;class InputIterator1, class InputIterator2, class Compare&gt;
4258       bool lexicographical_compare
4259           (InputIterator1 first1, InputIterator1 last1,
4260            InputIterator2 first2, InputIterator2 last2,
4261            Compare comp);
4262
4263     // _lib.alg.permutation.generators_, permutations
4264 T   template&lt;class BidirectionalIterator&gt;
4265       bool next_permutation(BidirectionalIterator first,
4266                             BidirectionalIterator last);
4267 T   template&lt;class BidirectionalIterator, class Compare&gt;
4268       bool next_permutation(BidirectionalIterator first,
4269                             BidirectionalIterator last, Compare comp);
4270 T   template&lt;class BidirectionalIterator&gt;
4271       bool prev_permutation(BidirectionalIterator first,
4272                             BidirectionalIterator last);
4273 T   template&lt;class BidirectionalIterator, class Compare&gt;
4274       bool prev_permutation(BidirectionalIterator first,
4275                             BidirectionalIterator last, Compare comp);
4276
4277
4278    25.4  C library algorithms                         [lib.alg.c.library]
4279
4280    1 Header &lt;cstdlib&gt; (partial, Table 2):
4281
4282                     Table 2--Header &lt;cstdlib&gt; synopsis
4283
4284                       Functions:   bsearch   qsort
4285
4286
4287 X  extern "C" void *bsearch(const void *key, const void *base,
4288                           size_t nmemb, size_t size,
4289                           int (*compar)(const void *, const void *));
4290 X  extern "C++" void *bsearch(const void *key, const void *base,
4291                           size_t nmemb, size_t size,
4292                           int (*compar)(const void *, const void *));
4293
4294 X  extern "C" void qsort(void* base, size_t nmemb, size_t size,
4295                   int (*compar)(const void*, const void*));
4296 X  extern "C++" void qsort(void* base, size_t nmemb, size_t size,
4297                   int (*compar)(const void*, const void*));
4298
4299
4300
4301    26.2  Complex numbers                            [lib.complex.numbers]
4302
4303
4304    26.2.1  Header &lt;complex&gt; synopsis               [lib.complex.synopsis]
4305
4306 T   template&lt;class T&gt; class complex;
4307 T   template&lt;&gt; class complex&lt;float&gt;;
4308 T   template&lt;&gt; class complex&lt;double&gt;;
4309 T   template&lt;&gt; class complex&lt;long double&gt;;
4310     // _lib.complex.ops_ operators:
4311 T   template&lt;class T&gt;
4312       complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4313 T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const T&amp;);
4314 T   template&lt;class T&gt; complex&lt;T&gt; operator+(const T&amp;, const complex&lt;T&gt;&amp;);
4315 T   template&lt;class T&gt; complex&lt;T&gt; operator-
4316       (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4317 T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;, const T&amp;);
4318 T   template&lt;class T&gt; complex&lt;T&gt; operator-(const T&amp;, const complex&lt;T&gt;&amp;);
4319 T   template&lt;class T&gt; complex&lt;T&gt; operator*
4320       (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4321 T   template&lt;class T&gt; complex&lt;T&gt; operator*(const complex&lt;T&gt;&amp;, const T&amp;);
4322 T   template&lt;class T&gt; complex&lt;T&gt; operator*(const T&amp;, const complex&lt;T&gt;&amp;);
4323 T   template&lt;class T&gt; complex&lt;T&gt; operator/
4324       (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4325 T   template&lt;class T&gt; complex&lt;T&gt; operator/(const complex&lt;T&gt;&amp;, const T&amp;);
4326 T   template&lt;class T&gt; complex&lt;T&gt; operator/(const T&amp;, const complex&lt;T&gt;&amp;);
4327 T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;);
4328 T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;);
4329 T   template&lt;class T&gt; bool operator==
4330       (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4331 T   template&lt;class T&gt; bool operator==(const complex&lt;T&gt;&amp;, const T&amp;);
4332 T   template&lt;class T&gt; bool operator==(const T&amp;, const complex&lt;T&gt;&amp;);
4333 T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4334 T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const T&amp;);
4335 T   template&lt;class T&gt; bool operator!=(const T&amp;, const complex&lt;T&gt;&amp;);
4336 T   template&lt;class T, class charT, class traits&gt;
4337       basic_istream&lt;charT, traits&gt;&amp;
4338       operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;, complex&lt;T&gt;&amp;);
4339
4340 T   template&lt;class T, class charT, class traits&gt;
4341       basic_ostream&lt;charT, traits&gt;&amp;
4342       operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;, const complex&lt;T&gt;&amp;);
4343     // _lib.complex.value.ops_ values:
4344 T   template&lt;class T&gt; T real(const complex&lt;T&gt;&amp;);
4345 T   template&lt;class T&gt; T imag(const complex&lt;T&gt;&amp;);
4346
4347 T   template&lt;class T&gt; T abs(const complex&lt;T&gt;&amp;);
4348 T   template&lt;class T&gt; T arg(const complex&lt;T&gt;&amp;);
4349 T   template&lt;class T&gt; T norm(const complex&lt;T&gt;&amp;);
4350 T   template&lt;class T&gt; complex&lt;T&gt; conj(const complex&lt;T&gt;&amp;);
4351 T   template&lt;class T&gt; complex&lt;T&gt; polar(const T&amp;, const T&amp;);
4352     // _lib.complex.transcendentals_ transcendentals:
4353 T   template&lt;class T&gt; complex&lt;T&gt; cos  (const complex&lt;T&gt;&amp;);
4354 T   template&lt;class T&gt; complex&lt;T&gt; cosh (const complex&lt;T&gt;&amp;);
4355 T   template&lt;class T&gt; complex&lt;T&gt; exp  (const complex&lt;T&gt;&amp;);
4356 T   template&lt;class T&gt; complex&lt;T&gt; log  (const complex&lt;T&gt;&amp;);
4357 T   template&lt;class T&gt; complex&lt;T&gt; log10(const complex&lt;T&gt;&amp;);
4358 T   template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, int);
4359 T   template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, const T&amp;);
4360 T   template&lt;class T&gt; complex&lt;T&gt; pow(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4361 T   template&lt;class T&gt; complex&lt;T&gt; pow(const T&amp;, const complex&lt;T&gt;&amp;);
4362 T   template&lt;class T&gt; complex&lt;T&gt; sin  (const complex&lt;T&gt;&amp;);
4363 T   template&lt;class T&gt; complex&lt;T&gt; sinh (const complex&lt;T&gt;&amp;);
4364 T   template&lt;class T&gt; complex&lt;T&gt; sqrt (const complex&lt;T&gt;&amp;);
4365 T   template&lt;class T&gt; complex&lt;T&gt; tan  (const complex&lt;T&gt;&amp;);
4366 T   template&lt;class T&gt; complex&lt;T&gt; tanh (const complex&lt;T&gt;&amp;);
4367    }
4368
4369    26.2.2  Template class complex                           [lib.complex]
4370
4371     template&lt;class T&gt;
4372 T   class complex {
4373     public:
4374 T     typedef T value_type;
4375
4376 T     complex(const T&amp; re = T(), const T&amp; im = T());
4377 T     complex(const complex&amp;);
4378 T     template&lt;class X&gt; complex(const complex&lt;X&gt;&amp;);
4379
4380 T     T real() const;
4381 T     T imag() const;
4382
4383 T     complex&lt;T&gt;&amp; operator= (const T&amp;);
4384 T     complex&lt;T&gt;&amp; operator+=(const T&amp;);
4385 T     complex&lt;T&gt;&amp; operator-=(const T&amp;);
4386 T     complex&lt;T&gt;&amp; operator*=(const T&amp;);
4387 T     complex&lt;T&gt;&amp; operator/=(const T&amp;);
4388
4389 T     complex&amp; operator=(const complex&amp;);
4390 T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator= (const complex&lt;X&gt;&amp;);
4391 T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);
4392 T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);
4393 T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);
4394 T     template&lt;class X&gt; complex&lt;T&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);
4395     };
4396
4397 T   template&lt;class T&gt; complex&lt;T&gt; operator+
4398       (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4399 T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;, const T&amp;);
4400 T   template&lt;class T&gt; complex&lt;T&gt; operator+(const T&amp;, const complex&lt;T&gt;&amp;);
4401
4402 T   template&lt;class T&gt; complex&lt;T&gt; operator-
4403       (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4404 T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;, const T&amp;);
4405 T   template&lt;class T&gt; complex&lt;T&gt; operator-(const T&amp;, const complex&lt;T&gt;&amp;);
4406
4407 T   template&lt;class T&gt; complex&lt;T&gt; operator*
4408       (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4409 T   template&lt;class T&gt; complex&lt;T&gt; operator*(const complex&lt;T&gt;&amp;, const T&amp;);
4410 T   template&lt;class T&gt; complex&lt;T&gt; operator*(const T&amp;, const complex&lt;T&gt;&amp;);
4411
4412 T   template&lt;class T&gt; complex&lt;T&gt; operator/
4413       (const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4414 T   template&lt;class T&gt; complex&lt;T&gt; operator/(const complex&lt;T&gt;&amp;, const T&amp;);
4415 T   template&lt;class T&gt; complex&lt;T&gt; operator/(const T&amp;, const complex&lt;T&gt;&amp;);
4416
4417 T   template&lt;class T&gt; complex&lt;T&gt; operator+(const complex&lt;T&gt;&amp;);
4418 T   template&lt;class T&gt; complex&lt;T&gt; operator-(const complex&lt;T&gt;&amp;);
4419
4420 T   template&lt;class T&gt; bool operator==(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4421 T   template&lt;class T&gt; bool operator==(const complex&lt;T&gt;&amp;, const T&amp;);
4422 T   template&lt;class T&gt; bool operator==(const T&amp;, const complex&lt;T&gt;&amp;);
4423
4424 T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const complex&lt;T&gt;&amp;);
4425 T   template&lt;class T&gt; bool operator!=(const complex&lt;T&gt;&amp;, const T&amp;);
4426 T   template&lt;class T&gt; bool operator!=(const T&amp;, const complex&lt;T&gt;&amp;);
4427
4428 T   template&lt;class T, class charT, class traits&gt;
4429       basic_istream&lt;charT, traits&gt;&amp;
4430       operator&gt;&gt;(basic_istream&lt;charT, traits&gt;&amp;, complex&lt;T&gt;&amp;);
4431
4432 T   template&lt;class T, class charT, class traits&gt;
4433       basic_ostream&lt;charT, traits&gt;&amp;
4434       operator&lt;&lt;(basic_ostream&lt;charT, traits&gt;&amp;, const complex&lt;T&gt;&amp;);
4435
4436
4437    26.2.3  complex specializations                  [lib.complex.special]
4438
4439 T   template&lt;&gt; class complex&lt;float&gt; {
4440     public:
4441 T     typedef float value_type;
4442
4443 T     complex(float re = 0.0f, float im = 0.0f);
4444 T     explicit complex(const complex&lt;double&gt;&amp;);
4445 T     explicit complex(const complex&lt;long double&gt;&amp;);
4446 T     float real() const;
4447 T     float imag() const;
4448
4449 T     complex&lt;float&gt;&amp; operator= (float);
4450 T     complex&lt;float&gt;&amp; operator+=(float);
4451 T     complex&lt;float&gt;&amp; operator-=(float);
4452 T     complex&lt;float&gt;&amp; operator*=(float);
4453 T     complex&lt;float&gt;&amp; operator/=(float);
4454
4455 T     complex&lt;float&gt;&amp; operator=(const complex&lt;float&gt;&amp;);
4456 T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator= (const complex&lt;X&gt;&amp;);
4457 T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);
4458 T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);
4459 T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);
4460 T     template&lt;class X&gt; complex&lt;float&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);
4461     };
4462 T   template&lt;&gt; class complex&lt;double&gt; {
4463     public:
4464 T     typedef double value_type;
4465
4466 T     complex(double re = 0.0, double im = 0.0);
4467 T     complex(const complex&lt;float&gt;&amp;);
4468 T     explicit complex(const complex&lt;long double&gt;&amp;);
4469 T     double real() const;
4470 T     double imag() const;
4471
4472 T     complex&lt;double&gt;&amp; operator= (double);
4473 T     complex&lt;double&gt;&amp; operator+=(double);
4474 T     complex&lt;double&gt;&amp; operator-=(double);
4475 T     complex&lt;double&gt;&amp; operator*=(double);
4476 T     complex&lt;double&gt;&amp; operator/=(double);
4477
4478 T     complex&lt;double&gt;&amp; operator=(const complex&lt;double&gt;&amp;);
4479 T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator= (const complex&lt;X&gt;&amp;);
4480 T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);
4481 T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);
4482 T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);
4483 T     template&lt;class X&gt; complex&lt;double&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);
4484     };
4485
4486 T   template&lt;&gt; class complex&lt;long double&gt; {
4487     public:
4488 T     typedef long double value_type;
4489
4490 T     complex(long double re = 0.0L, long double im = 0.0L);
4491 T     complex(const complex&lt;float&gt;&amp;);
4492 T     complex(const complex&lt;double&gt;&amp;);
4493 T     long double real() const;
4494 T     long double imag() const;
4495
4496 T     complex&lt;long double&gt;&amp; operator=(const complex&lt;long double&gt;&amp;);
4497 T     complex&lt;long double&gt;&amp; operator= (long double);
4498 T     complex&lt;long double&gt;&amp; operator+=(long double);
4499 T     complex&lt;long double&gt;&amp; operator-=(long double);
4500 T     complex&lt;long double&gt;&amp; operator*=(long double);
4501 T     complex&lt;long double&gt;&amp; operator/=(long double);
4502
4503 T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator= (const complex&lt;X&gt;&amp;);
4504 T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator+=(const complex&lt;X&gt;&amp;);
4505 T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator-=(const complex&lt;X&gt;&amp;);
4506 T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator*=(const complex&lt;X&gt;&amp;);
4507 T     template&lt;class X&gt; complex&lt;long double&gt;&amp; operator/=(const complex&lt;X&gt;&amp;);
4508     };
4509
4510    26.3  Numeric arrays                                    [lib.numarray]
4511
4512    26.3.1  Header &lt;valarray&gt; synopsis             [lib.valarray.synopsis]
4513
4514 T   template&lt;class T&gt; class valarray;         // An array of type T
4515 T   class slice;
4516 T   template&lt;class T&gt; class slice_array;
4517 T   class gslice;
4518 T   template&lt;class T&gt; class gslice_array;
4519 T   template&lt;class T&gt; class mask_array;       // a masked array
4520 T   template&lt;class T&gt; class indirect_array;   // an indirected array
4521
4522 T   template&lt;class T&gt; valarray&lt;T&gt; operator*
4523       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4524 T   template&lt;class T&gt; valarray&lt;T&gt; operator* (const valarray&lt;T&gt;&amp;, const T&amp;);
4525 T   template&lt;class T&gt; valarray&lt;T&gt; operator* (const T&amp;, const valarray&lt;T&gt;&amp;);
4526 T   template&lt;class T&gt; valarray&lt;T&gt; operator/
4527       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4528 T   template&lt;class T&gt; valarray&lt;T&gt; operator/ (const valarray&lt;T&gt;&amp;, const T&amp;);
4529 T   template&lt;class T&gt; valarray&lt;T&gt; operator/ (const T&amp;, const valarray&lt;T&gt;&amp;);
4530 T   template&lt;class T&gt; valarray&lt;T&gt; operator%
4531       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4532 T   template&lt;class T&gt; valarray&lt;T&gt; operator% (const valarray&lt;T&gt;&amp;, const T&amp;);
4533 T   template&lt;class T&gt; valarray&lt;T&gt; operator% (const T&amp;, const valarray&lt;T&gt;&amp;);
4534 T   template&lt;class T&gt; valarray&lt;T&gt; operator+
4535       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4536 T   template&lt;class T&gt; valarray&lt;T&gt; operator+ (const valarray&lt;T&gt;&amp;, const T&amp;);
4537 T   template&lt;class T&gt; valarray&lt;T&gt; operator+ (const T&amp;, const valarray&lt;T&gt;&amp;);
4538 T   template&lt;class T&gt; valarray&lt;T&gt; operator-
4539       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4540 T   template&lt;class T&gt; valarray&lt;T&gt; operator- (const valarray&lt;T&gt;&amp;, const T&amp;);
4541 T   template&lt;class T&gt; valarray&lt;T&gt; operator- (const T&amp;, const valarray&lt;T&gt;&amp;);
4542 T   template&lt;class T&gt; valarray&lt;T&gt; operator^
4543       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4544 T   template&lt;class T&gt; valarray&lt;T&gt; operator^ (const valarray&lt;T&gt;&amp;, const T&amp;);
4545 T   template&lt;class T&gt; valarray&lt;T&gt; operator^ (const T&amp;, const valarray&lt;T&gt;&amp;);
4546 T   template&lt;class T&gt; valarray&lt;T&gt; operator&amp;
4547       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4548 T   template&lt;class T&gt; valarray&lt;T&gt; operator&amp; (const valarray&lt;T&gt;&amp;, const T&amp;);
4549 T   template&lt;class T&gt; valarray&lt;T&gt; operator&amp; (const T&amp;, const valarray&lt;T&gt;&amp;);
4550 T   template&lt;class T&gt; valarray&lt;T&gt; operator|
4551       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4552 T   template&lt;class T&gt; valarray&lt;T&gt; operator| (const valarray&lt;T&gt;&amp;, const T&amp;);
4553 T   template&lt;class T&gt; valarray&lt;T&gt; operator| (const T&amp;, const valarray&lt;T&gt;&amp;);
4554 T   template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;
4555       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4556 T   template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;(const valarray&lt;T&gt;&amp;, const T&amp;);
4557 T   template&lt;class T&gt; valarray&lt;T&gt; operator&lt;&lt;(const T&amp;, const valarray&lt;T&gt;&amp;);
4558 T   template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;
4559       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4560 T   template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;(const valarray&lt;T&gt;&amp;, const T&amp;);
4561 T   template&lt;class T&gt; valarray&lt;T&gt; operator&gt;&gt;(const T&amp;, const valarray&lt;T&gt;&amp;);
4562 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;
4563       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4564 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;(const valarray&lt;T&gt;&amp;, const T&amp;);
4565 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&amp;&amp;(const T&amp;, const valarray&lt;T&gt;&amp;);
4566 T   template&lt;class T&gt; valarray&lt;bool&gt; operator||
4567       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4568 T   template&lt;class T&gt; valarray&lt;bool&gt; operator||(const valarray&lt;T&gt;&amp;, const T&amp;);
4569 T   template&lt;class T&gt; valarray&lt;bool&gt; operator||(const T&amp;, const valarray&lt;T&gt;&amp;);
4570
4571 T   template&lt;class T&gt;
4572       valarray&lt;bool&gt; operator==(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4573 T   template&lt;class T&gt; valarray&lt;bool&gt; operator==(const valarray&lt;T&gt;&amp;, const T&amp;);
4574 T   template&lt;class T&gt; valarray&lt;bool&gt; operator==(const T&amp;, const valarray&lt;T&gt;&amp;);
4575 T   template&lt;class T&gt;
4576       valarray&lt;bool&gt; operator!=(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4577 T   template&lt;class T&gt; valarray&lt;bool&gt; operator!=(const valarray&lt;T&gt;&amp;, const T&amp;);
4578 T   template&lt;class T&gt; valarray&lt;bool&gt; operator!=(const T&amp;, const valarray&lt;T&gt;&amp;);
4579 T   template&lt;class T&gt;
4580       valarray&lt;bool&gt; operator&lt; (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4581 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt; (const valarray&lt;T&gt;&amp;, const T&amp;);
4582 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt; (const T&amp;, const valarray&lt;T&gt;&amp;);
4583 T   template&lt;class T&gt;
4584       valarray&lt;bool&gt; operator&gt; (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4585 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt; (const valarray&lt;T&gt;&amp;, const T&amp;);
4586 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt; (const T&amp;, const valarray&lt;T&gt;&amp;);
4587 T   template&lt;class T&gt;
4588       valarray&lt;bool&gt; operator&lt;=(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4589 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt;=(const valarray&lt;T&gt;&amp;, const T&amp;);
4590 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&lt;=(const T&amp;, const valarray&lt;T&gt;&amp;);
4591 T   template&lt;class T&gt;
4592       valarray&lt;bool&gt; operator&gt;=(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4593 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt;=(const valarray&lt;T&gt;&amp;, const T&amp;);
4594 T   template&lt;class T&gt; valarray&lt;bool&gt; operator&gt;=(const T&amp;, const valarray&lt;T&gt;&amp;);
4595 T   template&lt;class T&gt; valarray&lt;T&gt; abs  (const valarray&lt;T&gt;&amp;);
4596 T   template&lt;class T&gt; valarray&lt;T&gt; acos (const valarray&lt;T&gt;&amp;);
4597 T   template&lt;class T&gt; valarray&lt;T&gt; asin (const valarray&lt;T&gt;&amp;);
4598 T   template&lt;class T&gt; valarray&lt;T&gt; atan (const valarray&lt;T&gt;&amp;);
4599 T   template&lt;class T&gt; valarray&lt;T&gt; atan2
4600       (const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4601 T   template&lt;class T&gt; valarray&lt;T&gt; atan2(const valarray&lt;T&gt;&amp;, const T&amp;);
4602 T   template&lt;class T&gt; valarray&lt;T&gt; atan2(const T&amp;, const valarray&lt;T&gt;&amp;);
4603 T   template&lt;class T&gt; valarray&lt;T&gt; cos  (const valarray&lt;T&gt;&amp;);
4604 T   template&lt;class T&gt; valarray&lt;T&gt; cosh (const valarray&lt;T&gt;&amp;);
4605 T   template&lt;class T&gt; valarray&lt;T&gt; exp  (const valarray&lt;T&gt;&amp;);
4606 T   template&lt;class T&gt; valarray&lt;T&gt; log  (const valarray&lt;T&gt;&amp;);
4607 T   template&lt;class T&gt; valarray&lt;T&gt; log10(const valarray&lt;T&gt;&amp;);
4608 T   template&lt;class T&gt; valarray&lt;T&gt; pow(const valarray&lt;T&gt;&amp;, const valarray&lt;T&gt;&amp;);
4609 T   template&lt;class T&gt; valarray&lt;T&gt; pow(const valarray&lt;T&gt;&amp;, const T&amp;);
4610 T   template&lt;class T&gt; valarray&lt;T&gt; pow(const T&amp;, const valarray&lt;T&gt;&amp;);
4611 T   template&lt;class T&gt; valarray&lt;T&gt; sin  (const valarray&lt;T&gt;&amp;);
4612 T   template&lt;class T&gt; valarray&lt;T&gt; sinh (const valarray&lt;T&gt;&amp;);
4613 T   template&lt;class T&gt; valarray&lt;T&gt; sqrt (const valarray&lt;T&gt;&amp;);
4614 T   template&lt;class T&gt; valarray&lt;T&gt; tan  (const valarray&lt;T&gt;&amp;);
4615 T   template&lt;class T&gt; valarray&lt;T&gt; tanh (const valarray&lt;T&gt;&amp;);
4616    }
4617
4618
4619    26.3.2  Template class valarray                [lib.template.valarray]
4620
4621 T   template&lt;class T&gt; class valarray {
4622     public:
4623 T     typedef T value_type;
4624
4625       // _lib.valarray.cons_ construct/destroy:
4626 T     valarray();
4627 T     explicit valarray(size_t);
4628 T     valarray(const T&amp;, size_t);
4629 T     valarray(const T*, size_t);
4630 T     valarray(const valarray&amp;);
4631 T     valarray(const slice_array&lt;T&gt;&amp;);
4632 T     valarray(const gslice_array&lt;T&gt;&amp;);
4633 T     valarray(const mask_array&lt;T&gt;&amp;);
4634 T     valarray(const indirect_array&lt;T&gt;&amp;);
4635 T    ~valarray();
4636
4637       // _lib.valarray.assign_ assignment:
4638 T     valarray&lt;T&gt;&amp; operator=(const valarray&lt;T&gt;&amp;);
4639 T     valarray&lt;T&gt;&amp; operator=(const T&amp;);
4640 T     valarray&lt;T&gt;&amp; operator=(const slice_array&lt;T&gt;&amp;);
4641 T     valarray&lt;T&gt;&amp; operator=(const gslice_array&lt;T&gt;&amp;);
4642 T     valarray&lt;T&gt;&amp; operator=(const mask_array&lt;T&gt;&amp;);
4643 T     valarray&lt;T&gt;&amp; operator=(const indirect_array&lt;T&gt;&amp;);
4644       // _lib.valarray.access_ element access:
4645 T     T                 operator[](size_t) const;
4646 T     T&amp;                operator[](size_t);
4647       // _lib.valarray.sub_ subset operations:
4648 T     valarray&lt;T&gt;       operator[](slice) const;
4649 T     slice_array&lt;T&gt;    operator[](slice);
4650 T     valarray&lt;T&gt;       operator[](const gslice&amp;) const;
4651 T     gslice_array&lt;T&gt;   operator[](const gslice&amp;);
4652 T     valarray&lt;T&gt;       operator[](const valarray&lt;bool&gt;&amp;) const;
4653 T     mask_array&lt;T&gt;     operator[](const valarray&lt;bool&gt;&amp;);
4654 T     valarray&lt;T&gt;       operator[](const valarray&lt;size_t&gt;&amp;) const;
4655 T     indirect_array&lt;T&gt; operator[](const valarray&lt;size_t&gt;&amp;);
4656       // _lib.valarray.unary_ unary operators:
4657 T     valarray&lt;T&gt; operator+() const;
4658 T     valarray&lt;T&gt; operator-() const;
4659 T     valarray&lt;T&gt; operator~() const;
4660 T     valarray&lt;T&gt; operator!() const;
4661       // _lib.valarray.cassign_ computed assignment:
4662 T     valarray&lt;T&gt;&amp; operator*= (const T&amp;);
4663 T     valarray&lt;T&gt;&amp; operator/= (const T&amp;);
4664 T     valarray&lt;T&gt;&amp; operator%= (const T&amp;);
4665 T     valarray&lt;T&gt;&amp; operator+= (const T&amp;);
4666 T     valarray&lt;T&gt;&amp; operator-= (const T&amp;);
4667 T     valarray&lt;T&gt;&amp; operator^= (const T&amp;);
4668 T     valarray&lt;T&gt;&amp; operator&amp;= (const T&amp;);
4669 T     valarray&lt;T&gt;&amp; operator|= (const T&amp;);
4670 T     valarray&lt;T&gt;&amp; operator&lt;&lt;=(const T&amp;);
4671 T     valarray&lt;T&gt;&amp; operator&gt;&gt;=(const T&amp;);
4672 T     valarray&lt;T&gt;&amp; operator*= (const valarray&lt;T&gt;&amp;);
4673 T     valarray&lt;T&gt;&amp; operator/= (const valarray&lt;T&gt;&amp;);
4674 T     valarray&lt;T&gt;&amp; operator%= (const valarray&lt;T&gt;&amp;);
4675 T     valarray&lt;T&gt;&amp; operator+= (const valarray&lt;T&gt;&amp;);
4676 T     valarray&lt;T&gt;&amp; operator-= (const valarray&lt;T&gt;&amp;);
4677 T     valarray&lt;T&gt;&amp; operator^= (const valarray&lt;T&gt;&amp;);
4678 T     valarray&lt;T&gt;&amp; operator|= (const valarray&lt;T&gt;&amp;);
4679 T     valarray&lt;T&gt;&amp; operator&amp;= (const valarray&lt;T&gt;&amp;);
4680 T     valarray&lt;T&gt;&amp; operator&lt;&lt;=(const valarray&lt;T&gt;&amp;);
4681 T     valarray&lt;T&gt;&amp; operator&gt;&gt;=(const valarray&lt;T&gt;&amp;);
4682       // _lib.valarray.members_ member functions:
4683 T     size_t size() const;
4684 T     T    sum() const;
4685 T     T    min() const;
4686 T     T    max() const;
4687
4688 T     valarray&lt;T&gt; shift (int) const;
4689 T     valarray&lt;T&gt; cshift(int) const;
4690 T     valarray&lt;T&gt; apply(T func(T)) const;
4691 T     valarray&lt;T&gt; apply(T func(const T&amp;)) const;
4692 T     void resize(size_t sz, T c = T());
4693     };
4694    }
4695
4696
4697
4698    26.3.4  Class slice                                  [lib.class.slice]
4699
4700 T   class slice {
4701     public:
4702 T     slice();
4703 T     slice(size_t, size_t, size_t);
4704
4705 T     size_t start() const;
4706 T     size_t size() const;
4707 T     size_t stride() const;
4708     };
4709    }
4710
4711
4712
4713    26.3.5  Template class slice_array          [lib.template.slice.array]
4714
4715 T   template &lt;class T&gt; class slice_array {
4716     public:
4717 T     typedef T value_type;
4718
4719 T     void operator=  (const valarray&lt;T&gt;&amp;) const;
4720 T     void operator*= (const valarray&lt;T&gt;&amp;) const;
4721 T     void operator/= (const valarray&lt;T&gt;&amp;) const;
4722 T     void operator%= (const valarray&lt;T&gt;&amp;) const;
4723 T     void operator+= (const valarray&lt;T&gt;&amp;) const;
4724 T     void operator-= (const valarray&lt;T&gt;&amp;) const;
4725 T     void operator^= (const valarray&lt;T&gt;&amp;) const;
4726 T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;
4727 T     void operator|= (const valarray&lt;T&gt;&amp;) const;
4728 T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;
4729 T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;
4730 T     void operator=(const T&amp;);
4731 T    ~slice_array();
4732     private:
4733 T     slice_array();
4734 T     slice_array(const slice_array&amp;);
4735 T     slice_array&amp; operator=(const slice_array&amp;);
4736     };
4737    }
4738
4739
4740
4741    26.3.6  The gslice class                            [lib.class.gslice]
4742
4743 T   class gslice {
4744     public:
4745 T     gslice();
4746 T     gslice(size_t s, const valarray&lt;size_t&gt;&amp; l, const valarray&lt;size_t&gt;&amp; d);
4747
4748 T     size_t           start() const;
4749 T     valarray&lt;size_t&gt; size() const;
4750 T     valarray&lt;size_t&gt; stride() const;
4751     };
4752
4753
4754    26.3.7  Template class gslice_array        [lib.template.gslice.array]
4755
4756 T   template &lt;class T&gt; class gslice_array {
4757     public:
4758 T     typedef T value_type;
4759
4760 T     void operator=  (const valarray&lt;T&gt;&amp;) const;
4761 T     void operator*= (const valarray&lt;T&gt;&amp;) const;
4762 T     void operator/= (const valarray&lt;T&gt;&amp;) const;
4763 T     void operator%= (const valarray&lt;T&gt;&amp;) const;
4764 T     void operator+= (const valarray&lt;T&gt;&amp;) const;
4765 T     void operator-= (const valarray&lt;T&gt;&amp;) const;
4766 T     void operator^= (const valarray&lt;T&gt;&amp;) const;
4767 T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;
4768 T     void operator|= (const valarray&lt;T&gt;&amp;) const;
4769 T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;
4770 T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;
4771 T     void operator=(const T&amp;);
4772 T    ~gslice_array();
4773     private:
4774 T     gslice_array();
4775 T     gslice_array(const gslice_array&amp;);
4776 T     gslice_array&amp; operator=(const gslice_array&amp;);
4777     };
4778
4779
4780    26.3.8  Template class mask_array            [lib.template.mask.array]
4781
4782 T   template &lt;class T&gt; class mask_array {
4783     public:
4784 T     typedef T value_type;
4785
4786 T     void operator=  (const valarray&lt;T&gt;&amp;) const;
4787 T     void operator*= (const valarray&lt;T&gt;&amp;) const;
4788 T     void operator/= (const valarray&lt;T&gt;&amp;) const;
4789 T     void operator%= (const valarray&lt;T&gt;&amp;) const;
4790 T     void operator+= (const valarray&lt;T&gt;&amp;) const;
4791 T     void operator-= (const valarray&lt;T&gt;&amp;) const;
4792 T     void operator^= (const valarray&lt;T&gt;&amp;) const;
4793 T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;
4794 T     void operator|= (const valarray&lt;T&gt;&amp;) const;
4795 T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;
4796 T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;
4797 T     void operator=(const T&amp;);
4798 T    ~mask_array();
4799     private:
4800 T     mask_array();
4801 T     mask_array(const mask_array&amp;);
4802 T     mask_array&amp; operator=(const mask_array&amp;);
4803       //  remainder implementation defined
4804     };
4805
4806
4807    26.3.9  Template class                   [lib.template.indirect.array]
4808        indirect_array
4809
4810 T   template &lt;class T&gt; class indirect_array {
4811     public:
4812 T     typedef T value_type;
4813
4814 T     void operator=  (const valarray&lt;T&gt;&amp;) const;
4815 T     void operator*= (const valarray&lt;T&gt;&amp;) const;
4816 T     void operator/= (const valarray&lt;T&gt;&amp;) const;
4817 T     void operator%= (const valarray&lt;T&gt;&amp;) const;
4818 T     void operator+= (const valarray&lt;T&gt;&amp;) const;
4819 T     void operator-= (const valarray&lt;T&gt;&amp;) const;
4820 T     void operator^= (const valarray&lt;T&gt;&amp;) const;
4821 T     void operator&amp;= (const valarray&lt;T&gt;&amp;) const;
4822 T     void operator|= (const valarray&lt;T&gt;&amp;) const;
4823 T     void operator&lt;&lt;=(const valarray&lt;T&gt;&amp;) const;
4824 T     void operator&gt;&gt;=(const valarray&lt;T&gt;&amp;) const;
4825 T     void operator=(const T&amp;);
4826 T    ~indirect_array();
4827     private:
4828 T     indirect_array();
4829 T     indirect_array(const indirect_array&amp;);
4830 T     indirect_array&amp; operator=(const indirect_array&amp;);
4831       //  remainder implementation defined
4832     };
4833
4834    26.4  Generalized numeric operations                 [lib.numeric.ops]
4835
4836    Header &lt;numeric&gt; synopsis
4837
4838 T   template &lt;class InputIterator, class T&gt;
4839       T accumulate(InputIterator first, InputIterator last, T init);
4840
4841 T   template &lt;class InputIterator, class T, class BinaryOperation&gt;
4842       T accumulate(InputIterator first, InputIterator last, T init,
4843                    BinaryOperation binary_op);
4844
4845 T   template &lt;class InputIterator1, class InputIterator2, class T&gt;
4846       T inner_product(InputIterator1 first1, InputIterator1 last1,
4847                       InputIterator2 first2, T init);
4848
4849 T   template &lt;class InputIterator1, class InputIterator2, class T,
4850               class BinaryOperation1, class BinaryOperation2&gt;
4851       T inner_product(InputIterator1 first1, InputIterator1 last1,
4852                       InputIterator2 first2, T init,
4853                       BinaryOperation1 binary_op1,
4854                       BinaryOperation2 binary_op2);
4855
4856 T   template &lt;class InputIterator, class OutputIterator&gt;
4857       OutputIterator partial_sum(InputIterator first,
4858                                  InputIterator last,
4859                                  OutputIterator result);
4860
4861 T   template &lt;class InputIterator, class OutputIterator,
4862               class BinaryOperation&gt;
4863       OutputIterator partial_sum(InputIterator first,
4864                                  InputIterator last,
4865                                  OutputIterator result,
4866                                  BinaryOperation binary_op);
4867
4868 T   template &lt;class InputIterator, class OutputIterator&gt;
4869       OutputIterator adjacent_difference(InputIterator first,
4870                                          InputIterator last,
4871                                          OutputIterator result);
4872
4873 T   template &lt;class InputIterator, class OutputIterator,
4874               class BinaryOperation&gt;
4875       OutputIterator adjacent_difference(InputIterator first,
4876                                          InputIterator last,
4877                                          OutputIterator result,
4878                                          BinaryOperation binary_op);
4879
4880
4881    26.5  C Library                                           [lib.c.math]
4882
4883                      Table 2--Header &lt;cmath&gt; synopsis
4884 X               Macro:   HUGE_VAL
4885                 Functions:
4886 X               acos     cos        fmod    modf   tan
4887 X               asin     cosh       frexp   pow    tanh
4888 X               atan     exp        ldexp   sin
4889 X               atan2    fabs       log     sinh
4890 X               ceil     floor      log10   sqrt
4891
4892                     Table 3--Header &lt;cstdlib&gt; synopsis
4893 X                     Macros:   RAND_MAX
4894 X                     Types:    div_t      ldiv_t
4895                       Functions:
4896 X                     abs       labs       srand
4897 X                     div       ldiv       rand
4898
4899 X  long   abs(long);               // labs()
4900 X  ldiv_t div(long, long);         // ldiv()
4901
4902 X  float abs  (float);
4903 X  float acos (float);
4904 X  float asin (float);
4905 X  float atan (float);
4906 X  float atan2(float, float);
4907 X  float ceil (float);
4908 X  float cos  (float);
4909 X  float cosh (float);
4910 X  float exp  (float);
4911 X  float fabs (float);
4912 X  float floor(float);
4913 X  float fmod (float, float);
4914 X  float frexp(float, int*);
4915 X  float ldexp(float, int);
4916 X  float log  (float);
4917 X  float log10(float);
4918 X  float modf (float, float*);
4919 X  float pow  (float, float);
4920 X  float pow  (float, int);
4921 X  float sin  (float);
4922 X  float sinh (float);
4923 X  float sqrt (float);
4924 X  float tan  (float);
4925 X  float tanh (float);
4926
4927 X  double abs(double);            // fabs()
4928 X  double pow(double, int);
4929
4930 X  long double abs  (long double);
4931 X  long double acos (long double);
4932 X  long double asin (long double);
4933 X  long double atan (long double);
4934 X  long double atan2(long double, long double);
4935 X  long double ceil (long double);
4936 X  long double cos  (long double);
4937 X  long double cosh (long double);
4938 X  long double exp  (long double);
4939 X  long double fabs (long double);
4940 X  long double floor(long double);
4941 X  long double fmod (long double, long double);
4942 X  long double frexp(long double, int*);
4943 X  long double ldexp(long double, int);
4944 X  long double log  (long double);
4945 X  long double log10(long double);
4946 X  long double modf (long double, long double*);
4947 X  long double pow  (long double, long double);
4948 X  long double pow  (long double, int);
4949 X  long double sin  (long double);
4950 X  long double sinh (long double);
4951 X  long double sqrt (long double);
4952 X  long double tan  (long double);
4953 X  long double tanh (long double);
4954
4955    Header &lt;iosfwd&gt; synopsis
4956
4957 X   template&lt;class charT&gt; class char_traits;
4958 X   template&lt;&gt; class char_traits&lt;char&gt;;
4959 X   template&lt;&gt; class char_traits&lt;wchar_t&gt;;
4960 X   template&lt;class T&gt; class allocator;
4961 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
4962       class basic_ios;
4963
4964 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
4965       class basic_streambuf;
4966
4967 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
4968       class basic_istream;
4969
4970 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
4971       class basic_ostream;
4972
4973 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
4974       class basic_iostream;
4975
4976 X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
4977               class Allocator = allocator&lt;charT&gt; &gt;
4978       class basic_stringbuf;
4979
4980 X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
4981               class Allocator = allocator&lt;charT&gt; &gt;
4982       class basic_istringstream;
4983
4984 X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
4985               class Allocator = allocator&lt;charT&gt; &gt;
4986       class basic_ostringstream;
4987
4988 X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
4989               class Allocator = allocator&lt;charT&gt; &gt;
4990       class basic_stringstream;
4991
4992 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
4993       class basic_filebuf;
4994
4995 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
4996       class basic_ifstream;
4997
4998 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
4999       class basic_ofstream;
5000
5001 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5002       class basic_fstream;
5003 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5004       class istreambuf_iterator;
5005
5006 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5007       class ostreambuf_iterator;
5008 X   typedef basic_ios&lt;char&gt;       ios;
5009 X   typedef basic_ios&lt;wchar_t&gt;    wios;
5010 X   typedef basic_streambuf&lt;char&gt; streambuf;
5011 X   typedef basic_istream&lt;char&gt;   istream;
5012 X   typedef basic_ostream&lt;char&gt;   ostream;
5013 X   typedef basic_iostream&lt;char&gt;  iostream;
5014 X   typedef basic_stringbuf&lt;char&gt;     stringbuf;
5015 X   typedef basic_istringstream&lt;char&gt; istringstream;
5016 X   typedef basic_ostringstream&lt;char&gt; ostringstream;
5017 X   typedef basic_stringstream&lt;char&gt;  stringstream;
5018 X   typedef basic_filebuf&lt;char&gt;  filebuf;
5019 X   typedef basic_ifstream&lt;char&gt; ifstream;
5020 X   typedef basic_ofstream&lt;char&gt; ofstream;
5021 X   typedef basic_fstream&lt;char&gt;  fstream;
5022 X   typedef basic_streambuf&lt;wchar_t&gt; wstreambuf;
5023 X   typedef basic_istream&lt;wchar_t&gt;   wistream;
5024 X   typedef basic_ostream&lt;wchar_t&gt;   wostream;
5025 X   typedef basic_iostream&lt;wchar_t&gt;  wiostream;
5026 X   typedef basic_stringbuf&lt;wchar_t&gt;     wstringbuf;
5027 X   typedef basic_istringstream&lt;wchar_t&gt; wistringstream;
5028 X   typedef basic_ostringstream&lt;wchar_t&gt; wostringstream;
5029 X   typedef basic_stringstream&lt;wchar_t&gt;  wstringstream;
5030
5031 X   typedef basic_filebuf&lt;wchar_t&gt;  wfilebuf;
5032 X   typedef basic_ifstream&lt;wchar_t&gt; wifstream;
5033 X   typedef basic_ofstream&lt;wchar_t&gt; wofstream;
5034 X   typedef basic_fstream&lt;wchar_t&gt;  wfstream;
5035 X   template &lt;class state&gt; class fpos;
5036 X   typedef fpos&lt;char_traits&lt;char&gt;::state_type&gt;    streampos;
5037 X   typedef fpos&lt;char_traits&lt;wchar_t&gt;::state_type&gt; wstreampos;
5038
5039    27.3  Standard iostream objects                 [lib.iostream.objects]
5040
5041    Header &lt;iostream&gt; synopsis
5042
5043 T  [must also include &lt;istream&gt; and &lt;ostream&gt;]
5044 T   extern istream cin;
5045 T   extern ostream cout;
5046 T   extern ostream cerr;
5047 T   extern ostream clog;
5048
5049 T   extern wistream wcin;
5050 T   extern wostream wcout;
5051 T   extern wostream wcerr;
5052 T   extern wostream wclog;
5053
5054    27.4  Iostreams base classes                      [lib.iostreams.base]
5055
5056    Header &lt;ios&gt; synopsis
5057
5058    #include &lt;iosfwd&gt;
5059
5060 T   typedef OFF_T  streamoff;
5061 T   typedef SZ_T streamsize;
5062 T   template &lt;class stateT&gt; class fpos;
5063
5064     class ios_base;
5065     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5066       class basic_ios;
5067    // _lib.std.ios.manip_, manipulators:
5068 T   ios_base&amp; boolalpha  (ios_base&amp; str);
5069 T   ios_base&amp; noboolalpha(ios_base&amp; str);
5070 T   ios_base&amp; showbase   (ios_base&amp; str);
5071 T   ios_base&amp; noshowbase (ios_base&amp; str);
5072 T   ios_base&amp; showpoint  (ios_base&amp; str);
5073 T   ios_base&amp; noshowpoint(ios_base&amp; str);
5074 T   ios_base&amp; showpos    (ios_base&amp; str);
5075 T   ios_base&amp; noshowpos  (ios_base&amp; str);
5076 T   ios_base&amp; skipws     (ios_base&amp; str);
5077 T   ios_base&amp; noskipws   (ios_base&amp; str);
5078 T   ios_base&amp; nouppercase(ios_base&amp; str);
5079 T   ios_base&amp; uppercase  (ios_base&amp; str);
5080 M   ios_base&amp; unitbuf    (ios_base&amp; str);
5081 M   ios_base&amp; nounitbuf  (ios_base&amp; str);
5082    // _lib.adjustfield.manip_ adjustfield:
5083 T   ios_base&amp; internal   (ios_base&amp; str);
5084 T   ios_base&amp; left       (ios_base&amp; str);
5085 T   ios_base&amp; right      (ios_base&amp; str);
5086    // _lib.basefield.manip_ basefield:
5087 T   ios_base&amp; dec        (ios_base&amp; str);
5088 T   ios_base&amp; hex        (ios_base&amp; str);
5089 T   ios_base&amp; oct        (ios_base&amp; str);
5090
5091    // _lib.floatfield.manip_ floatfield:
5092 T   ios_base&amp; fixed      (ios_base&amp; str);
5093 T   ios_base&amp; scientific (ios_base&amp; str);
5094
5095
5096    27.4.2  Class ios_base                                  [lib.ios.base]
5097
5098 T   class ios_base {
5099     public:
5100       class failure;
5101 T     typedef T1 fmtflags;
5102 T     static const fmtflags boolalpha;
5103 T     static const fmtflags dec;
5104 T     static const fmtflags fixed;
5105 T     static const fmtflags hex;
5106 T     static const fmtflags internal;
5107 T     static const fmtflags left;
5108 T     static const fmtflags oct;
5109 T     static const fmtflags right;
5110 T     static const fmtflags scientific;
5111 T     static const fmtflags showbase;
5112 T     static const fmtflags showpoint;
5113 T     static const fmtflags showpos;
5114 T     static const fmtflags skipws;
5115 X     static const fmtflags unitbuf;
5116 T     static const fmtflags uppercase;
5117 T     static const fmtflags adjustfield;
5118 T     static const fmtflags basefield;
5119 T     static const fmtflags floatfield;
5120
5121       typedef T2 iostate;
5122 T     static const iostate badbit;
5123 T     static const iostate eofbit;
5124 T     static const iostate failbit;
5125 T     static const iostate goodbit;
5126 T     typedef T3 openmode;
5127 T     static const openmode app;
5128 T     static const openmode ate;
5129 T     static const openmode binary;
5130 T     static const openmode in;
5131 T     static const openmode out;
5132 T     static const openmode trunc;
5133 T     typedef T4 seekdir;
5134 T     static const seekdir beg;
5135 T     static const seekdir cur;
5136 T     static const seekdir end;
5137 T     class Init;
5138       // _lib.fmtflags.state_ fmtflags state:
5139 T     fmtflags flags() const;
5140 T     fmtflags flags(fmtflags fmtfl);
5141 T     fmtflags setf(fmtflags fmtfl);
5142 T     fmtflags setf(fmtflags fmtfl, fmtflags mask);
5143 T     void unsetf(fmtflags mask);
5144 T     streamsize precision() const;
5145 T     streamsize precision(streamsize prec);
5146 T     streamsize width() const;
5147 T     streamsize width(streamsize wide);
5148       // _lib.ios.base.locales_ locales:
5149 T     locale imbue(const locale&amp; loc);
5150 T     locale getloc() const;
5151       // _lib.ios.base.storage_ storage:
5152 T     static int xalloc();
5153 T     long&amp;  iword(int index);
5154 T     void*&amp; pword(int index);
5155       // destructor
5156 T     virtual ~ios_base();
5157       // _lib.ios.base.callback_ callbacks;
5158 T     enum event { erase_event, imbue_event, copyfmt_event };
5159 T     typedef void (*event_callback)(event, ios_base&amp;, int index);
5160 T     void register_callback(event_call_back fn, int index);
5161 T     static bool sync_with_stdio(bool sync = true);
5162     protected:
5163 T     ios_base();
5164     };
5165
5166    27.4.2.1.1  Class ios_base::failure                 [lib.ios::failure]
5167
5168 T   class ios_base::failure : public exception {
5169     public:
5170 T     explicit failure(const string&amp; msg);
5171 T     virtual ~failure();
5172 T     virtual const char* what() const throw();
5173     };
5174
5175
5176    27.4.2.1.6  Class ios_base::Init                       [lib.ios::Init]
5177
5178 T   class ios_base::Init {
5179     public:
5180 T     Init();
5181 T    ~Init();
5182     };
5183
5184
5185    27.4.3  Template class fpos                                 [lib.fpos]
5186
5187 X   template &lt;class stateT&gt; class fpos {
5188     public:
5189       // _lib.fpos.members_ Members
5190 T     stateT state() const;
5191 T     void state(stateT);
5192     private;
5193 T     stateT st; // exposition only
5194     };
5195
5196
5197    27.4.5  Template class basic_ios                             [lib.ios]
5198
5199     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5200 X   class basic_ios : public ios_base {
5201     public:
5202
5203       // Types:
5204 T     typedef charT                     char_type;
5205 T     typedef typename traits::int_type int_type;
5206 T     typedef typename traits::pos_type pos_type;
5207 T     typedef typename traits::off_type off_type;
5208 T     typedef traits                    traits_type;
5209 T     operator void*() const
5210 T     bool operator!() const
5211 T     iostate rdstate() const;
5212 T     void clear(iostate state = goodbit);
5213 T     void setstate(iostate state);
5214 T     bool good() const;
5215 T     bool eof()  const;
5216 T     bool fail() const;
5217 T     bool bad()  const;
5218 T     iostate exceptions() const;
5219 T     void exceptions(iostate except);
5220       // _lib.basic.ios.cons_ Constructor/destructor:
5221 T     explicit basic_ios(basic_streambuf&lt;charT,traits&gt;* sb);
5222 T     virtual ~basic_ios();
5223       // _lib.basic.ios.members_ Members:
5224 T     basic_ostream&lt;charT,traits&gt;* tie() const;
5225 T     basic_ostream&lt;charT,traits&gt;* tie(basic_ostream&lt;charT,traits&gt;* tiestr);
5226 T     basic_streambuf&lt;charT,traits&gt;* rdbuf() const;
5227 T     basic_streambuf&lt;charT,traits&gt;* rdbuf(basic_streambuf&lt;charT,traits&gt;* sb);
5228 X     basic_ios&amp; copyfmt(const basic_ios&amp; rhs);
5229 T     char_type fill() const;
5230 T     char_type fill(char_type ch);
5231       // _lib.ios.base.locales_ locales:
5232 T     locale imbue(const locale&amp; loc);
5233 X     char     narrow(char_type c, char dfault) const;
5234 X     char_type widen(char c) const;
5235     protected:
5236       basic_ios();
5237 T     void init(basic_streambuf&lt;charT,traits&gt;* sb);
5238    private:
5239 T     basic_ios(const basic_ios&amp; );       // not defined
5240 T     basic_ios&amp; operator=(const basic_ios&amp;);     // not defined
5241     };
5242
5243
5244    27.5  Stream buffers                              [lib.stream.buffers]
5245
5246    Header &lt;streambuf&gt; synopsis
5247
5248 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5249       class basic_streambuf;
5250 T   typedef basic_streambuf&lt;char&gt;     streambuf;
5251 T   typedef basic_streambuf&lt;wchar_t&gt; wstreambuf;
5252
5253    27.5.2  Template class                                 [lib.streambuf]
5254        basic_streambuf&lt;charT,traits&gt;
5255
5256     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5257 X   class basic_streambuf {
5258     public:
5259
5260       // Types:
5261 T     typedef charT                     char_type;
5262 T     typedef typename traits::int_type int_type;
5263 T     typedef typename traits::pos_type pos_type;
5264 T     typedef typename traits::off_type off_type;
5265 T     typedef traits                    traits_type;
5266 T     virtual ~basic_streambuf();
5267       // _lib.streambuf.locales_ locales:
5268 T     locale   pubimbue(const locale &amp;loc);
5269 T     locale   getloc() const;
5270       // _lib.streambuf.buffer_ buffer and positioning:
5271 T     basic_streambuf&lt;char_type,traits&gt;*
5272                pubsetbuf(char_type* s, streamsize n);
5273 T     pos_type pubseekoff(off_type off, ios_base::seekdir way,
5274                           ios_base::openmode which =
5275                               ios_base::in | ios_base::out);
5276 T     pos_type pubseekpos(pos_type sp,
5277                           ios_base::openmode which =
5278                               ios_base::in | ios_base::out);
5279 T     int      pubsync();
5280
5281       // Get and put areas:
5282       // _lib.streambuf.pub.get_ Get area:
5283 T     streamsize in_avail();
5284 T     int_type snextc();
5285 T     int_type sbumpc();
5286 T     int_type sgetc();
5287 T     streamsize sgetn(char_type* s, streamsize n);
5288       // _lib.streambuf.pub.pback_ Putback:
5289 X     int_type sputbackc(char_type c);
5290 X     int_type sungetc();
5291       // _lib.streambuf.pub.put_ Put area:
5292 T     int_type   sputc(char_type c);
5293 X     streamsize sputn(const char_type* s, streamsize n);
5294     protected:
5295 T     basic_streambuf();
5296       // _lib.streambuf.get.area_ Get area:
5297 T     char_type* eback() const;
5298 T     char_type* gptr()  const;
5299 T     char_type* egptr() const;
5300 T     void       gbump(int n);
5301 T     void       setg(char_type* gbeg, char_type* gnext, char_type* gend);
5302       // _lib.streambuf.put.area_ Put area:
5303 T     char_type* pbase() const;
5304 T     char_type* pptr() const;
5305 T     char_type* epptr() const;
5306 T     void       pbump(int n);
5307 T     void       setp(char_type* pbeg, char_type* pend);
5308       // _lib.streambuf.virtuals_ virtual functions:
5309       // _lib.streambuf.virt.locales_ Locales:
5310 T     virtual void imbue(const locale &amp;loc);
5311       // _lib.streambuf.virt.buffer_ Buffer management and positioning:
5312 T     virtual basic_streambuf&lt;char_type,traits&gt;*
5313                        setbuf(char_type* s, streamsize n);
5314 T     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
5315                 ios_base::openmode which = ios_base::in | ios_base::out);
5316 T     virtual pos_type seekpos(pos_type sp,
5317                 ios_base::openmode which = ios_base::in | ios_base::out);
5318 T     virtual int      sync();
5319       // _lib.streambuf.virt.get_ Get area:
5320 T     virtual int        showmanyc();
5321 T     virtual streamsize xsgetn(char_type* s, streamsize n);
5322 T     virtual int_type   underflow();
5323 T     virtual int_type   uflow();
5324       // _lib.streambuf.virt.pback_ Putback:
5325 T     virtual int_type   pbackfail(int_type c = traits::eof());
5326       // _lib.streambuf.virt.put_ Put area:
5327 X     virtual streamsize xsputn(const char_type* s, streamsize n);
5328 T     virtual int_type   overflow (int_type c = traits::eof());
5329     };
5330
5331    27.6  Formatting and manipulators                [lib.iostream.format]
5332
5333    Header &lt;istream&gt; synopsis
5334
5335 T   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5336       class basic_istream;
5337 T   typedef basic_istream&lt;char&gt;     istream;
5338 T   typedef basic_istream&lt;wchar_t&gt; wistream;
5339
5340 T   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5341       class basic_iostream;
5342 T   typedef basic_iostream&lt;char&gt;    iostream;
5343 T   typedef basic_iostream&lt;wchar_t&gt; wiostream;
5344
5345 X   template &lt;class charT, class traits&gt;
5346       basic_istream&lt;charT,traits&gt;&amp; ws(basic_istream&lt;charT,traits&gt;&amp; is);
5347
5348    Header &lt;ostream&gt; synopsis
5349
5350 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5351       class basic_ostream;
5352 T   typedef basic_ostream&lt;char&gt;     ostream;
5353 T   typedef basic_ostream&lt;wchar_t&gt; wostream;
5354
5355 T   template &lt;class charT, class traits&gt;
5356       basic_ostream&lt;charT,traits&gt;&amp; endl(basic_ostream&lt;charT,traits&gt;&amp; os);
5357 T   template &lt;class charT, class traits&gt;
5358       basic_ostream&lt;charT,traits&gt;&amp; ends(basic_ostream&lt;charT,traits&gt;&amp; os);
5359 T   template &lt;class charT, class traits&gt;
5360       basic_ostream&lt;charT,traits&gt;&amp; flush(basic_ostream&lt;charT,traits&gt;&amp; os);
5361
5362    Header &lt;iomanip&gt; synopsis
5363
5364       // Types T1, T2, ... are unspecified implementation types
5365 T     T1 resetiosflags(ios_base::fmtflags mask);
5366 T     T2 setiosflags  (ios_base::fmtflags mask);
5367 T     T3 setbase(int base);
5368 T     template&lt;charT&gt; T4 setfill(charT c);
5369 T     T5 setprecision(int n);
5370 T     T6 setw(int n);
5371
5372
5373    27.6.1.1  Template class basic_istream                   [lib.istream]
5374
5375     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5376 T   class basic_istream : virtual public basic_ios&lt;charT,traits&gt; {
5377     public:
5378     // Types (inherited from basic_ios (_lib.ios_)):
5379 T     typedef charT                     char_type;
5380 T     typedef typename traits::int_type int_type;
5381 T     typedef typename traits::pos_type pos_type;
5382 T     typedef typename traits::off_type off_type;
5383 T     typedef traits                    traits_type;
5384       // _lib.istream.cons_ Constructor/destructor:
5385 T     explicit basic_istream(basic_streambuf&lt;charT,traits&gt;* sb);
5386 T     virtual ~basic_istream();
5387       // _lib.istream::sentry_ Prefix/suffix:
5388 T     class sentry;
5389
5390       // _lib.istream.formatted_ Formatted input:
5391 T     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;
5392           (basic_istream&lt;charT,traits&gt;&amp; (*pf)(basic_istream&lt;charT,traits&gt;&amp;))
5393 T     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;
5394           (basic_ios&lt;charT,traits&gt;&amp; (*pf)(basic_ios&lt;charT,traits&gt;&amp;))
5395 T     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;
5396           (ios_base&amp; (*pf)(ios_base&amp;))
5397 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(bool&amp; n);
5398 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(short&amp; n);
5399 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned short&amp; n);
5400 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(int&amp; n);
5401 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned int&amp; n);
5402 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(long&amp; n);
5403 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(unsigned long&amp; n);
5404 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(float&amp; f);
5405 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(double&amp; f);
5406 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(long double&amp; f);
5407 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(void*&amp; p);
5408 S     basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;
5409           (basic_streambuf&lt;char_type,traits&gt;* sb);
5410       // _lib.istream.unformatted_ Unformatted input:
5411 T     streamsize gcount() const;
5412 S     int_type get();
5413 S     basic_istream&lt;charT,traits&gt;&amp; get(char_type&amp; c);
5414 S     basic_istream&lt;charT,traits&gt;&amp; get(char_type* s, streamsize n);
5415 S     basic_istream&lt;charT,traits&gt;&amp; get(char_type* s, streamsize n,
5416                         char_type delim);
5417 S     basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp; sb);
5418 S     basic_istream&lt;charT,traits&gt;&amp; get(basic_streambuf&lt;char_type,traits&gt;&amp; sb,
5419                         char_type delim);
5420 S     basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n);
5421 S     basic_istream&lt;charT,traits&gt;&amp; getline(char_type* s, streamsize n,
5422                         char_type delim);
5423 S     basic_istream&lt;charT,traits&gt;&amp; ignore
5424           (streamsize n = 1, int_type delim = traits::eof());
5425 S     int_type                     peek();
5426 S     basic_istream&lt;charT,traits&gt;&amp; read    (char_type* s, streamsize n);
5427 S     streamsize                   readsome(char_type* s, streamsize n);
5428 S     basic_istream&lt;charT,traits&gt;&amp; putback(char_type c);
5429 S     basic_istream&lt;charT,traits&gt;&amp; unget();
5430 S     int sync();
5431
5432 S     pos_type tellg();
5433 S     basic_istream&lt;charT,traits&gt;&amp; seekg(pos_type);
5434 S     basic_istream&lt;charT,traits&gt;&amp; seekg(off_type, ios_base::seekdir);
5435     };
5436
5437     // _lib.istream::extractors_ character extraction templates:
5438 S   template&lt;class charT, class traits&gt;
5439       basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;,
5440                                               charT&amp;);
5441 S   template&lt;class traits&gt;
5442       basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
5443                                              unsigned char&amp;);
5444 S   template&lt;class traits&gt;
5445       basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
5446                                              signed char&amp;);
5447
5448 S   template&lt;class charT, class traits&gt;
5449       basic_istream&lt;charT,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;charT,traits&gt;&amp;,
5450                                               charT*);
5451 S   template&lt;class traits&gt;
5452       basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
5453                                              unsigned char*);
5454 S   template&lt;class traits&gt;
5455       basic_istream&lt;char,traits&gt;&amp; operator&gt;&gt;(basic_istream&lt;char,traits&gt;&amp;,
5456                                              signed char*);
5457
5458    27.6.1.1.2  Class basic_istream::sentry          [lib.istream::sentry]
5459
5460
5461     template &lt;class charT,class traits = char_traits&lt;charT&gt; &gt;
5462 S   class basic_istream&lt;charT,traits&gt;::sentry {
5463       typedef traits traits_type;
5464 S     bool ok_; // exposition only
5465      public:
5466 S     explicit sentry(basic_istream&lt;charT,traits&gt;&amp; is, bool noskipws = false);
5467 S     ~sentry();
5468 S     operator bool() const { return ok_; }
5469      private:
5470 T     sentry(const sentry&amp;); //   not defined
5471 T     sentry&amp; operator=(const sentry&amp;); //   not defined
5472     };
5473
5474
5475    27.6.1.5  Template class basic_iostream            [lib.iostreamclass]
5476
5477     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5478 T   class basic_iostream :
5479       public basic_istream&lt;charT,traits&gt;,
5480       public basic_ostream&lt;charT,traits&gt; {
5481     public:
5482       // constructor/destructor
5483 T     explicit basic_iostream(basic_streambuf&lt;charT,traits&gt;* sb);
5484 T     virtual ~basic_iostream();
5485     };
5486
5487
5488    27.6.2.1  Template class basic_ostream                   [lib.ostream]
5489
5490     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5491 X   class basic_ostream : virtual public basic_ios&lt;charT,traits&gt; {
5492     public:
5493     // Types (inherited from basic_ios (_lib.ios_)):
5494 T     typedef charT                     char_type;
5495 T     typedef typename traits::int_type int_type;
5496 T     typedef typename traits::pos_type pos_type;
5497 T     typedef typename traits::off_type off_type;
5498 T     typedef traits                    traits_type;
5499       // _lib.ostream.cons_ Constructor/destructor:
5500 T     explicit basic_ostream(basic_streambuf&lt;char_type,traits&gt;* sb);
5501 T     virtual ~basic_ostream();
5502       // _lib.ostream::sentry_ Prefix/suffix:
5503 T     class sentry;
5504       // _lib.ostream.formatted_ Formatted output:
5505 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;
5506           (basic_ostream&lt;charT,traits&gt;&amp; (*pf)(basic_ostream&lt;charT,traits&gt;&amp;));
5507 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;
5508           (basic_ios&lt;charT,traits&gt;&amp; (*pf)(basic_ios&lt;charT,traits&gt;&amp;));
5509 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;
5510           (ios_base&amp; (*pf)(ios_base&amp;));
5511 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(bool n);
5512 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(short n);
5513 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned short n);
5514 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(int n);
5515 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned int n);
5516 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(long n);
5517 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(unsigned long n);
5518 S     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(float f);
5519 S     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(double f);
5520 S     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(long double f);
5521 T     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(const void* p);
5522 X     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;
5523           (basic_streambuf&lt;char_type,traits&gt;* sb);
5524       // _lib.ostream.unformatted_ Unformatted output:
5525 T     basic_ostream&lt;charT,traits&gt;&amp; put(char_type c);
5526 T     basic_ostream&lt;charT,traits&gt;&amp; write(const char_type* s, streamsize n);
5527 X     basic_ostream&lt;charT,traits&gt;&amp; flush();
5528
5529       // _lib.ostream.seeks_ seeks:
5530 S     pos_type tellp();
5531 S     basic_ostream&lt;charT,traits&gt;&amp; seekp(pos_type);
5532 S     basic_ostream&lt;charT,traits&gt;&amp; seekp(off_type, ios_base::seekdir);
5533     };
5534     // _lib.ostream.inserters.character_ character inserters
5535 X   template&lt;class charT, class traits&gt;
5536     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
5537                                             charT);
5538 X   template&lt;class charT, class traits&gt;
5539     basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
5540                                             char);
5541     // specialization
5542 X   template&lt;class traits&gt;
5543       basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
5544                                              char);
5545     // signed and unsigned
5546 X   template&lt;class traits&gt;
5547       basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
5548                                              signed char);
5549 X   template&lt;class traits&gt;
5550       basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
5551                                              unsigned char)
5552 X   template&lt;class charT, class traits&gt;
5553       basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
5554                                               const charT*);
5555 X   template&lt;class charT, class traits&gt;
5556       basic_ostream&lt;charT,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;charT,traits&gt;&amp;,
5557                                               const char*);
5558     // partial specializationss
5559 X   template&lt;class traits&gt;
5560       basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
5561                                              const char*);
5562     //  signed and unsigned
5563 X   template&lt;class traits&gt;
5564       basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
5565                                              const signed char*);
5566 X   template&lt;class traits&gt;
5567       basic_ostream&lt;char,traits&gt;&amp; operator&lt;&lt;(basic_ostream&lt;char,traits&gt;&amp;,
5568                                              const unsigned char*);
5569
5570
5571    27.6.2.3  Class basic_ostream::sentry            [lib.ostream::sentry]
5572
5573     template &lt;class charT,class traits = char_traits&lt;charT&gt; &gt;
5574 X   class basic_ostream&lt;charT,traits&gt;::sentry {
5575       bool ok_; // exposition only
5576      public:
5577 X     explicit sentry(basic_ostream&lt;charT,traits&gt;&amp; os);
5578 X     ~sentry();
5579 X     operator bool() const { return ok_; }
5580      private
5581 X     sentry(const sentry&amp;); //   not defined
5582 X     sentry&amp; operator=(const sentry&amp;); //   not defined
5583     };
5584
5585    27.7  String-based streams                        [lib.string.streams]
5586
5587    Header &lt;sstream&gt; synopsis
5588
5589 X   template &lt;class charT, class traits = char_traits&lt;charT&gt;,
5590                       class Allocator = allocator&lt;charT&gt; &gt;
5591       class basic_stringbuf;
5592
5593 T   typedef basic_stringbuf&lt;char&gt;     stringbuf;
5594 T   typedef basic_stringbuf&lt;wchar_t&gt; wstringbuf;
5595
5596     template &lt;class charT, class traits = char_traits&lt;charT&gt;,
5597                       class Allocator = allocator&lt;charT&gt; &gt;
5598 X     class basic_istringstream;
5599
5600 T   typedef basic_istringstream&lt;char&gt;     istringstream;
5601 T   typedef basic_istringstream&lt;wchar_t&gt; wistringstream;
5602
5603     template &lt;class charT, class traits = char_traits&lt;charT&gt;,
5604                       class Allocator = allocator&lt;charT&gt; &gt;
5605 X     class basic_ostringstream;
5606 T   typedef basic_ostringstream&lt;char&gt;     ostringstream;
5607 T   typedef basic_ostringstream&lt;wchar_t&gt; wostringstream;
5608
5609     template &lt;class charT, class traits = char_traits&lt;charT&gt;,
5610                       class Allocator = allocator&lt;charT&gt; &gt;
5611 X     class basic_stringstream;
5612 T   typedef basic_stringstream&lt;char&gt;     stringstream;
5613 T   typedef basic_stringstream&lt;wchar_t&gt; wstringstream;
5614
5615    27.7.1  Template class basic_stringbuf                 [lib.stringbuf]
5616
5617     template &lt;class charT, class traits = char_traits&lt;charT&gt;,
5618               class Allocator = allocator&lt;charT&gt; &gt;
5619 X   class basic_stringbuf : public basic_streambuf&lt;charT,traits&gt; {
5620     public:
5621 T     typedef charT                     char_type;
5622 T     typedef typename traits::int_type int_type;
5623 T     typedef typename traits::pos_type pos_type;
5624 T     typedef typename traits::off_type off_type;
5625 T     typedef traits                    traits_type;
5626       // _lib.stringbuf.cons_ Constructors:
5627 S     explicit basic_stringbuf(ios_base::openmode which
5628                                 = ios_base::in | ios_base::out);
5629 S     explicit basic_stringbuf
5630           (const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
5631            ios_base::openmode which = ios_base::in | ios_base::out);
5632       // _lib.stringbuf.members_ Get and set:
5633 S     basic_string&lt;charT,traits,Allocator&gt; str() const;
5634 S     void               str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);
5635
5636     protected:
5637       // _lib.stringbuf.virtuals_ Overridden virtual functions:
5638 S     virtual int_type   underflow();
5639 S     virtual int_type   pbackfail(int_type c = traits::eof());
5640 S     virtual int_type   overflow (int_type c = traits::eof());
5641 S     virtual  basic_streambuf&lt;charT,traits&gt;* setbuf(charT*, streamsize);
5642
5643 S     virtual pos_type   seekoff(off_type off, ios_base::seekdir way,
5644                                  ios_base::openmode which
5645                                   = ios_base::in | ios_base::out);
5646 S     virtual pos_type   seekpos(pos_type sp,
5647                                  ios_base::openmode which
5648                                   = ios_base::in | ios_base::out);
5649     };
5650
5651
5652    27.7.2  Template class basic_istringstream         [lib.istringstream]
5653
5654     template &lt;class charT, class traits = char_traits&lt;charT&gt;,
5655               class Allocator = allocator&lt;charT&gt; &gt;
5656 X   class basic_istringstream : public basic_istream&lt;charT,traits&gt; {
5657     public:
5658 T     typedef charT                     char_type;
5659 T     typedef typename traits::int_type int_type;
5660 T     typedef typename traits::pos_type pos_type;
5661 T     typedef typename traits::off_type off_type;
5662 T     typedef traits                    traits_type;
5663       // _lib.istringstream.cons_ Constructors:
5664 S     explicit basic_istringstream(ios_base::openmode which = ios_base::in);
5665 S     explicit basic_istringstream(
5666                          const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
5667                          ios_base::openmode which = ios_base::in);
5668
5669       // _lib.istringstream.members_ Members:
5670 S     basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
5671 S     basic_string&lt;charT,traits,Allocator&gt; str() const;
5672 S     void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);
5673    private:
5674    //  basic_stringbuf&lt;charT,traits,Allocator&gt; sb;   exposition only
5675     };
5676
5677    27.7.3  Class basic_ostringstream                  [lib.ostringstream]
5678
5679     template &lt;class charT, class traits = char_traits&lt;charT&gt;,
5680               class Allocator = allocator&lt;charT&gt; &gt;
5681 X   class basic_ostringstream : public basic_ostream&lt;charT,traits&gt; {
5682     public:
5683
5684       // Types:
5685 T     typedef charT            char_type;
5686 T     typedef typename traits::int_type int_type;
5687 T     typedef typename traits::pos_type pos_type;
5688 T     typedef typename traits::off_type off_type;
5689       // _lib.ostringstream.cons_ Constructors/destructor:
5690 S     explicit basic_ostringstream(ios_base::openmode which = ios_base::out);
5691 S     explicit basic_ostringstream(
5692                            const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
5693                            ios_base::openmode which = ios_base::out);
5694       // _lib.ostringstream.members_ Members:
5695 S     basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
5696 S     basic_string&lt;charT,traits,Allocator&gt; str() const;
5697 S     void    str(const basic_string&lt;charT,traits,Allocator&gt;&amp; s);
5698     };
5699
5700
5701    27.7.4  Template class basic_stringstream           [lib.stringstream]
5702
5703     template &lt;class charT, class traits = char_traits&lt;charT&gt;,
5704               class Allocator = allocator&lt;charT&gt; &gt;
5705 X   class basic_stringstream
5706       : public basic_iostream&lt;charT,traits&gt; {
5707     public:
5708       // Types
5709 T     typedef charT                     char_type;
5710 T     typedef typename traits::int_type int_type;
5711 T     typedef typename traits::pos_type pos_type;
5712 T     typedef typename traits::off_type off_type;
5713       // constructors/destructors
5714 S     explicit basic_stringstream(
5715           ios_base::openmode which = ios_base::out|ios_base::in);
5716 S     explicit basic_stringstream(
5717           const basic_string&lt;charT,traits,Allocator&gt;&amp; str,
5718           ios_base::openmode which = ios_base::out|ios_base::in);
5719       // Members:
5720 S     basic_stringbuf&lt;charT,traits,Allocator&gt;* rdbuf() const;
5721 S     basic_string&lt;charT,traits,Allocator&gt; str() const;
5722 S     void str(const basic_string&lt;charT,traits,Allocator&gt;&amp; str);
5723     };
5724
5725
5726
5727    27.8.1  File streams                                    [lib.fstreams]
5728
5729
5730    Header &lt;fstream&gt; synopsis
5731
5732 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5733       class basic_filebuf;
5734 T   typedef basic_filebuf&lt;char&gt;    filebuf;
5735 T   typedef basic_filebuf&lt;wchar_t&gt; wfilebuf;
5736
5737 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5738       class basic_ifstream;
5739 T   typedef basic_ifstream&lt;char&gt;    ifstream;
5740 T   typedef basic_ifstream&lt;wchar_t&gt; wifstream;
5741
5742 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5743       class basic_ofstream;
5744 T   typedef basic_ofstream&lt;char&gt;    ofstream;
5745 T   typedef basic_ofstream&lt;wchar_t&gt; wofstream;
5746
5747 X   template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5748       class basic_fstream;
5749 T   typedef basic_fstream&lt;char&gt;     fstream;
5750 T   typedef basic_fstream&lt;wchar_t&gt; wfstream;
5751
5752    27.8.1.1  Template class basic_filebuf                   [lib.filebuf]
5753
5754     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5755 X   class basic_filebuf : public basic_streambuf&lt;charT,traits&gt; {
5756     public:
5757 T     typedef charT                     char_type;
5758 T     typedef typename traits::int_type int_type;
5759 T     typedef typename traits::pos_type pos_type;
5760 T     typedef typename traits::off_type off_type;
5761 T     typedef traits                    traits_type;
5762       // _lib.filebuf.cons_ Constructors/destructor:
5763 X     basic_filebuf();
5764 X     virtual ~basic_filebuf();
5765        // _lib.filebuf.members_ Members:
5766 T     bool is_open() const;
5767 X     basic_filebuf&lt;charT,traits&gt;* open
5768           (const char* s, ios_base::openmode mode);
5769 X     basic_filebuf&lt;charT,traits&gt;* close();
5770     protected:
5771       // _lib.filebuf.virtuals_ Overridden virtual functions:
5772 X     virtual streamsize showmanyc();
5773 X     virtual int_type underflow();
5774 X     virtual int_type uflow();
5775 X     virtual int_type pbackfail(int_type c = traits::eof());
5776 X     virtual int_type overflow (int_type c = traits::eof());
5777 S     virtual basic_streambuf&lt;charT,traits&gt;*
5778                        setbuf(char_type* s, streamsize n);
5779 S     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
5780                                ios_base::openmode which
5781                                  = ios_base::in | ios_base::out);
5782 S     virtual pos_type seekpos(pos_type sp, ios_base::openmode which
5783                                  = ios_base::in | ios_base::out);
5784 S     virtual int      sync();
5785 S     virtual void     imbue(const locale&amp; loc);
5786     };
5787
5788
5789
5790    27.8.1.5  Template class basic_ifstream                 [lib.ifstream]
5791
5792     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5793 X   class basic_ifstream : public basic_istream&lt;charT,traits&gt; {
5794     public:
5795 T     typedef charT                     char_type;
5796 T     typedef typename traits::int_type int_type;
5797 T     typedef typename traits::pos_type pos_type;
5798 T     typedef typename traits::off_type off_type;
5799 T     typedef traits                    traits_type;
5800       // _lib.ifstream.cons_ Constructors:
5801 S     basic_ifstream();
5802 S     explicit basic_ifstream(const char* s,
5803                               ios_base::openmode mode = ios_base::in);
5804       // _lib.ifstream.members_ Members:
5805 S     basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
5806 S     bool is_open();
5807 S     void open(const char* s, ios_base::openmode mode = ios_base::in);
5808 S     void close();
5809     };
5810
5811
5812    27.8.1.8  Template class basic_ofstream                 [lib.ofstream]
5813
5814     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5815 X   class basic_ofstream : public basic_ostream&lt;charT,traits&gt; {
5816     public:
5817 T     typedef charT                     char_type;
5818 T     typedef typename traits::int_type int_type;
5819 T     typedef typename traits::pos_type pos_type;
5820 T     typedef typename traits::off_type off_type;
5821 T     typedef traits                    traits_type;
5822       // _lib.ofstream.cons_ Constructors:
5823 X     basic_ofstream();
5824 X     explicit basic_ofstream(const char* s,
5825                               ios_base::openmode mode
5826                                 = ios_base::out);
5827       // _lib.ofstream.members_ Members:
5828 X     basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
5829 T     bool is_open();
5830 X     void open(const char* s, ios_base::openmode mode = ios_base::out);
5831 X     void close();
5832     };
5833
5834
5835    27.8.1.11  Template class basic_fstream                  [lib.fstream]
5836
5837     template &lt;class charT, class traits=char_traits&lt;charT&gt; &gt;
5838 X   class basic_fstream
5839       : public basic_iostream&lt;charT,traits&gt; {
5840     public:
5841 T     typedef charT                     char_type;
5842 T     typedef typename traits::int_type int_type;
5843 T     typedef typename traits::pos_type pos_type;
5844 T     typedef typename traits::off_type off_type;
5845 T     typedef traits                    traits_type;
5846       // constructors/destructor
5847 S     basic_fstream();
5848 S     explicit basic_fstream(
5849           const char* s,
5850           ios_base::openmode mode = ios_base::in|ios_base::out);
5851
5852       // Members:
5853 S     basic_filebuf&lt;charT,traits&gt;* rdbuf() const;
5854 S     bool is_open();
5855 S     void open(
5856           const char* s,
5857           ios_base::openmode mode = ios_base::in|ios_base::out);
5858 S     void close();
5859     };
5860
5861
5862
5863    27.8.2  C Library files                                  [lib.c.files]
5864
5865
5866                     Table 13--Header &lt;cstdio&gt; synopsis
5867     Macros:
5868 X   BUFSIZ         L_tmpnam        SEEK_SET   TMP_MAX
5869 X   EOF            NULL &lt;cstdio&gt;   stderr     _IOFBF
5870 X   FILENAME_MAX   SEEK_CUR        stdin      _IOLBF
5871 X   FOPEN_MAX      SEEK_END        stdout     _IONBF
5872
5873 X   Types:         FILE            fpos_t     size_t &lt;cstdio&gt;
5874     Functions:
5875 X   clearerr       fgets           fscanf     gets     rewind
5876 X   fclose         fopen           fseek      perror   scanf     tmpnam
5877 X   feof           fprintf         fsetpos    printf   setbuf    ungetc
5878 X   ferror         fputc           ftell      putc     setvbuf   vprintf
5879 X   fflush         fputs           fwrite     puts     sprintf   vfprintf
5880 X   fgetc          fread           getc       remove   sscanf    vsprintf
5881 X   fgetpos        freopen         getchar    putchar  rename    tmpfile
5882
5883
5884
5885
5886    1.5  Standard C library headers                       [depr.c.headers]
5887
5888 X     &lt;assert.h&gt;   &lt;iso646.h&gt;   &lt;setjmp.h&gt;   &lt;stdio.h&gt;    &lt;wchar.h&gt;
5889       &lt;ctype.h&gt;    &lt;limits.h&gt;   &lt;signal.h&gt;   &lt;stdlib.h&gt;   &lt;wctype.h&gt;
5890       &lt;errno.h&gt;    &lt;locale.h&gt;   &lt;stdarg.h&gt;   &lt;string.h&gt;
5891       &lt;float.h&gt;    &lt;math.h&gt;     &lt;stddef.h&gt;   &lt;time.h&gt;
5892
5893    1.6  Old iostreams members                          [depr.ios.members]
5894
5895    [Note: these should be #ifdef'd to permit diagnostics if used.]
5896    namespace std {
5897     class ios_base {
5898     public:
5899 T     typedef T1  io_state;
5900 T     typedef T2 open_mode;
5901 T     typedef T3  seek_dir;
5902 T     typedef OFF_T  streamoff;
5903 T     typedef OFF_T  streampos;
5904       // remainder unchanged
5905     };
5906    }
5907
5908    [Note: these should be #ifdef'd to permit diagnostics if used.]
5909    namespace std {
5910     template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5911     class basic_streambuf {
5912     public:
5913 T     void stossc();
5914       // remainder unchanged
5915     };
5916    }
5917
5918    8 An implementation may provide  the  following  member  functions  that
5919    overload signatures specified in clause _lib.iostreams_:
5920
5921    [Note: the following overloads should be #ifdef'd to permit
5922     diagnostics to be emitted, by default, if used.]
5923
5924     template&lt;class charT, class Traits&gt; class basic_ios {
5925     public:
5926 M     void clear(io_state state);
5927 M     void setstate(io_state state);
5928       // remainder unchanged
5929     };
5930     class ios_base {
5931     public:
5932 M     void exceptions(io_state);
5933       // remainder unchanged
5934     };
5935     template&lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5936     class basic_streambuf {
5937     public:
5938 M     pos_type pubseekoff(off_type off, ios_base::seek_dir way,
5939                 ios_base::open_mode which = ios_base::in | ios_base::out);
5940 M     pos_type pubseekpos(pos_type sp,
5941                 ios_base::open_mode which = ios_base::in | ios_base::out);
5942       // remainder unchanged
5943     };
5944     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5945     class basic_filebuf : public basic_streambuf&lt;charT,traits&gt; {
5946     public:
5947 M     basic_filebuf&lt;charT,traits&gt;* open
5948           (const char* s, ios_base::open_mode mode);
5949       // remainder unchanged
5950     };
5951     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5952     class basic_ifstream : public basic_istream&lt;charT,traits&gt; {
5953     public:
5954 M     void open(const char* s, ios_base::open_mode mode = in);
5955       // remainder unchanged
5956     };
5957     template &lt;class charT, class traits = char_traits&lt;charT&gt; &gt;
5958     class basic_ofstream : public basic_ostream&lt;charT,traits&gt; {
5959     public:
5960 M     void open(const char* s, ios_base::open_mode mode = out | trunc);
5961       // remainder unchanged
5962     };
5963    }
5964
5965
5966
5967    1.7.1  Class strstreambuf                          [depr.strstreambuf]
5968
5969    [Note: It should be possible to adopt these components with only
5970     minor changes from the 2.8 version of the library.]
5971
5972 M   class strstreambuf : public basic_streambuf&lt;char&gt; {
5973     public:
5974 M     explicit strstreambuf(streamsize alsize_arg = 0);
5975 M     strstreambuf(void* (*palloc_arg)(size_t), void (*pfree_arg)(void*));
5976 M     strstreambuf(char* gnext_arg, streamsize n, char* pbeg_arg = 0);
5977 M     strstreambuf(const char* gnext_arg, streamsize n);
5978 M     strstreambuf(signed char* gnext_arg, streamsize n,
5979                    signed char* pbeg_arg = 0);
5980 M     strstreambuf(const signed char* gnext_arg, streamsize n);
5981 M     strstreambuf(unsigned char* gnext_arg, streamsize n,
5982                    unsigned char* pbeg_arg = 0);
5983 M     strstreambuf(const unsigned char* gnext_arg, streamsize n);
5984 M     virtual ~strstreambuf();
5985 M     void  freeze(bool freezefl = true);
5986 M     char* str();
5987 M     int   pcount();
5988     protected:
5989 M     virtual int_type overflow (int_type c = EOF);
5990 M     virtual int_type pbackfail(int_type c = EOF);
5991 M     virtual int_type underflow();
5992 M     virtual pos_type seekoff(off_type off, ios_base::seekdir way,
5993                                ios_base::openmode which
5994                                 = ios_base::in | ios_base::out);
5995 M     virtual pos_type seekpos(pos_type sp, ios_base::openmode which
5996                                 = ios_base::in | ios_base::out);
5997 M     virtual streambuf&lt;char&gt;* setbuf(char* s, streamsize n);
5998    }
5999
6000    1.7.4  Class strstream                                [depr.strstream]
6001
6002 M   class strstream
6003       : public basic_iostream&lt;char&gt; {
6004     public:
6005       // Types
6006 M     typedef char                                char_type;
6007 M     typedef typename char_traits&lt;char&gt;::int_type int_type
6008 M     typedef typename char_traits&lt;char&gt;::pos_type pos_type;
6009 M     typedef typename char_traits&lt;char&gt;::off_type off_type;
6010       // consturctors/destructor
6011 M     strstream();
6012 M     strstream(char* s, int n,
6013                 ios_base::openmode mode = ios_base::in|ios_base::out);
6014 M     virtual ~strstream();
6015       // Members:
6016 M     strstreambuf* rdbuf() const;
6017 M     void freeze(bool freezefl = true);
6018 M     int pcount() const;
6019 M     char* str();
6020     };
6021 </literallayout>
6022
6023 </sect3>
6024
6025
6026 <sect3 id="standard.1998.specific" xreflabel="Implementation Specific">
6027   <title>Implementation Specific Behavior</title>
6028
6029    <para>
6030      The ISO standard defines the following phrase:
6031    </para>
6032    <blockquote>
6033      <variablelist>
6034      <varlistentry>
6035        <term>
6036          <code>[1.3.5] implementation-defined behavior</code>
6037        </term>
6038        <listitem>
6039          <para>
6040          Behavior, for a well-formed program construct and correct data, that
6041          depends on the implementation <emphasis>and that each implementation
6042          shall document</emphasis>.
6043          </para>
6044        </listitem>
6045      </varlistentry>
6046      </variablelist>
6047    </blockquote>
6048    <para>
6049      We do so here, for the C++ library only.  Behavior of the
6050      compiler, linker, runtime loader, and other elements of &quot;the
6051      implementation&quot; are documented elsewhere.  Everything listed
6052      in Annex B, Implementation Qualities, are also part of the
6053      compiler, not the library.
6054    </para>
6055    <para>
6056      For each entry, we give the section number of the standard, when
6057      applicable.  This list is probably incomplet and inkorrekt.
6058    </para>
6059    <para>
6060      <emphasis>[1.9]/11 #3</emphasis> If <code>isatty(3)</code> is true, then
6061       interactive stream support is implied.
6062    </para>
6063    <para>
6064      <emphasis>[17.4.4.5]</emphasis> Non-reentrant functions are probably best
6065       discussed in the various sections on multithreading (see above).
6066    </para>
6067    <!-- [17.4.4.8]/3 says any function that doesn't have an exception-spec
6068         can throw whatever we want; see also its footnote.  Let's list those
6069         in the sections where the function itself occurs.
6070    -->
6071    <para><emphasis>[18.1]/4</emphasis> The type of <code>NULL</code> is described
6072       <ulink url="../18_support/howto.html#1">here</ulink>.
6073    </para>
6074    <para><emphasis>[18.3]/8</emphasis> Even though it's listed in the library
6075       sections, libstdc++ has zero control over what the cleanup code hands
6076       back to the runtime loader.  Talk to the compiler people.  :-)
6077    </para>
6078    <para><emphasis>[18.4.2.1]/5</emphasis> (bad_alloc),
6079       <emphasis>[18.5.2]/5</emphasis> (bad_cast),
6080       <emphasis>[18.5.3]/5</emphasis> (bad_typeid),
6081       <emphasis>[18.6.1]/8</emphasis> (exception),
6082       <emphasis>[18.6.2.1]/5</emphasis> (bad_exception):  The <code>what()</code>
6083       member function of class <code>std::exception</code>, and these other
6084       classes publicly derived from it, simply returns the name of the
6085       class.  But they are the <emphasis>mangled</emphasis> names; you will need to call
6086       <code>c++filt</code> and pass the names as command-line parameters to
6087       demangle them, or call a
6088       <ulink url="../18_support/howto.html#5">runtime demangler function</ulink>.
6089       (The classes in <code>&lt;stdexcept&gt;</code> have constructors which
6090       require an argument to use later for <code>what()</code> calls, so the
6091       problem of <code>what()</code>'s value does not arise in most
6092       user-defined exceptions.)
6093    </para>
6094    <para><emphasis>[18.5.1]/7</emphasis> The return value of
6095       <code>std::type_info::name()</code> is the mangled type name (see the
6096       previous entry for more).
6097    </para>
6098    <para><emphasis>[20.1.5]/5</emphasis> <emphasis>&quot;Implementors are encouraged to
6099       supply libraries that can accept allocators that encapsulate more
6100       general memory models and that support non-equal instances.  In such
6101       implementations, any requirements imposed on allocators by containers
6102       beyond those requirements that appear in Table 32, and the semantics
6103       of containers and algorithms when allocator instances compare
6104       non-equal, are implementation-defined.&quot;</emphasis>  As yet we don't
6105       have any allocators which compare non-equal, so we can't describe how
6106       they behave.
6107    </para>
6108    <para><emphasis>[21.1.3.1]/3,4</emphasis>,
6109       <emphasis>[21.1.3.2]/2</emphasis>,
6110       <emphasis>[23.*]'s foo::iterator</emphasis>,
6111       <emphasis>[27.*]'s foo::*_type</emphasis>,
6112       <emphasis>others...</emphasis>
6113       Nope, these types are called implementation-defined because you
6114       shouldn't be taking advantage of their underlying types.  Listing them
6115       here would defeat the purpose.  :-)
6116    </para>
6117    <para><emphasis>[21.1.3.1]/5</emphasis> I don't really know about the mbstate_t
6118       stuff... see the <ulink url="../22_locale/howto.html">chapter 22 notes</ulink>
6119       for what does exist.
6120    </para>
6121    <para><emphasis>[22.*]</emphasis> Anything and everything we have on locale
6122       implementation will be described
6123       <ulink url="../22_locale/howto.html">over here</ulink>.
6124    </para>
6125    <para><emphasis>[26.2.8]/9</emphasis> I have no idea what
6126       <code>complex&lt;T&gt;</code>'s pow(0,0) returns.
6127    </para>
6128    <para><emphasis>[27.4.2.4]/2</emphasis> Calling
6129       <code>std::ios_base::sync_with_stdio</code> after I/O has already been
6130       performed on the standard stream objects will
6131       flush the buffers, and <!-- this line might go away -->
6132       destroy and recreate the underlying buffer instances.  Whether or not
6133       the previously-written I/O is destroyed in this process depends mostly
6134       on the --enable-libio choice:  for stdio, if the written data is
6135       already in the stdio buffer, the data may be completely safe!
6136    </para>
6137    <para><emphasis>[27.6.1.1.2]</emphasis>,
6138       <emphasis>[27.6.2.3]</emphasis> The I/O sentry ctor and dtor can perform
6139       additional work than the minimum required.  We are not currently taking
6140       advantage of this yet.
6141    </para>
6142    <para><emphasis>[27.7.1.3]/16</emphasis>,
6143       <emphasis>[27.8.1.4]/10</emphasis>
6144       The effects of <code>pubsetbuf/setbuf</code> are described
6145       <ulink url="../27_io/howto.html#2">in this chapter</ulink>.
6146    </para>
6147    <para><emphasis>[27.8.1.4]/16</emphasis> Calling <code>fstream::sync</code> when
6148       a get area exists will... whatever <code>fflush()</code> does, I think.
6149    </para>
6150
6151 </sect3>
6152
6153 </sect2>