1 This clause lists the complete set of hexadecimal code values that are valid in universal-character-names in C++ identifiers (2.10).
2 This table is reproduced unchanged from ISO/IEC PDTR 10176, produced by ISO/IEC JTC1/SC22/WG20, except that the ranges 0041 005a and 0061 007a designate the upper and lower case English alphabets, which are part of the basic source character set, and are not repeated in the table below. Latin: 00c0 00d6, 00d8 00f6, 00f8 01f5, 01fa 0217, 0250 02a8, 1e00 1e9a, 1ea0 1ef9 Greek: 0384, 0388 038a, 038c, 038e 03a1, 03a3 03ce, 03d0 03d6, 03da, 03dc, 03de, 03e0, 03e2 03f3, 1f00 1f15, 1f18 1f1d, 1f20 1f45, 1f48 1f4d, 1f50 1f57, 1f59, 1f5b, 1f5d, 1f5f 1f7d, 1f80 1fb4, 1fb6 1fbc, 1fc2 1fc4, 1fc6 1fcc, 1fd0 1fd3, 1fd6 1fdb, 1fe0 1fec, 1ff2 1ff4, 1ff6 1ffc Cyrillic: 0401 040d, 040f 044f, 0451 045c, 045e 0481, 0490 04c4, 04c7 04c8, 04cb 04cc, 04d0 04eb, 04ee 04f5, 04f8 04f9 Armenian: 0531 0556, 0561 0587 Hebrew: 05d0 05ea, 05f0 05f4 Arabic: 0621 063a, 0640 0652, 0670 06b7, 06ba 06be, 06c0 06ce, 06e5 06e7 Devanagari: 0905 0939, 0958 0962 Bengali: 0985 098c, 098f 0990, 0993 09a8, 09aa 09b0, 09b2, 09b6 09b9, 09dc 09dd, 09df 09e1, 09f0 09f1 Gurmukhi: 0a05 0a0a, 0a0f 0a10, 0a13 0a28, 0a2a 0a30, 0a32 0a33, 0a35 0a36, 0a38 0a39, 0a59 0a5c, 0a5e Gujarati: 0a85 0a8b, 0a8d, 0a8f 0a91, 0a93 0aa8, 0aaa 0ab0, 0ab2 0ab3, 0ab5 0ab9, 0ae0 Oriya: 0b05 0b0c, 0b0f 0b10, 0b13 0b28, 0b2a 0b30, 0b32 0b33, 0b36 0b39, 0b5c 0b5d, 0b5f 0b61 Tamil: 0b85 0b8a, 0b8e 0b90, 0b92 0b95, 0b99 0b9a, 0b9c, 0b9e 0b9f, 0ba3 0ba4, 0ba8 0baa, 0bae 0bb5, 0bb7 0bb9 Telugu: 0c05 0c0c, 0c0e 0c10, 0c12 0c28, 0c2a 0c33, 0c35 0c39, 0c60 0c61 Kannada: 0c85 0c8c, 0c8e 0c90, 0c92 0ca8, 0caa 0cb3, 0cb5 0cb9, 0ce0 0ce1 Malayalam: 0d05 0d0c, 0d0e 0d10, 0d12 0d28, 0d2a 0d39, 0d60 0d61 Thai: 0e01 0e30, 0e32 0e33, 0e40 0e46, 0e4f 0e5b Lao: 0e81 0e82, 0e84, 0e87, 0e88, 0e8a, 0e0d, 0e94 0e97, 0e99 0e9f, 0ea1 0ea3, 0ea5, 0ea7, 0eaa, 0eab, 0ead 0eb0, 0eb2, 0eb3, 0ebd, 0ec0 0ec4, 0ec6 Georgian: 10a0 10c5, 10d0 10f6 Hiragana: 3041 3094, 309b 309e Katakana: 30a1 30fe Bopmofo: 3105 312c Hangul: 1100 1159, 1161 11a2, 11a8 11f9 CJK Unified Ideographs: f900 fa2d, fb1f fb36, fb38 fb3c, fb3e, fb40 fb41, fb42 fb44, fb46 fbb1, fbd3 fd3f, fd50 fd8f, fd92 fdc7, fdf0 fdfb, fe70 fe72, fe74, fe76 fefc, ff21 ff3a, ff41 ff5a, ff66 ffbe, ffc2 ffc7, ffca ffcf, ffd2 ffd7, ffda ffdc, 4e00 9fa5 Index , ---see comma operator 90 [] ! ---see logical negation operator 76 ---see subscripting operator 66 != ---see inequality operator 86 array declarator 133 # operator 305 \ ---see backslash 17 ## operator 306 ^ ---see bitwise exclusive OR operator 87 % ---see modulus operator 83 ^= operator 89 %= operator 89 _, underscore in identifier 14 & {} ---see address-of operator 76 block statement 93 ---see bitwise AND operator 87 class declaration 149 reference declarator 132 class definition 149 && ---see logical AND operator 87 enum declaration 110 &= operator 89 initializer list 144 () | ---see bitwise inclusive OR operator 87 ---see function call operator 66 |= operator 89 function declarator 135 || ---see logical OR operator 88 * ~ ---see indirection operator 76 ---see destructor 191 ---see multiplication operator 83 ---see one's complement operator 76 pointer declarator 131 0 *= operator 89 ---see also zero, null 19 + null character 19 ---see addition operator 84 string terminator 19 ---see unary plus operator 76 ++ ---see increment operator 69 += operator 77, 89 A - abort 45, 97, 320, 336, 341, 345 ---see subtraction operator 84 abs 585, 596 597 ---see unary minus operator 76 complex 572 -- ---see decrement operator 69 abstract -= operator 89 class 172 -> ---see class member access operator 68 class, constructor and 173 ->* ---see pointer to member operator 83 class, pointer to 172 . ---see class member access operator 68 abstract-declarator 128 .* ---see pointer to member operator 83 access ... ---see ellipsis 135 adjusting base class member 178 / ---see division operator 83 /* */ comment 12 ambiguity, member 165 and friend, class 180 // comment 12 and friend function 179 /= operator 89 base class 177 : base class member 163 field declaration 159 class member 68 label specifier 93 control 175 :: control, anonymous union 158 ---see scope resolution operator 65 control default 175 scope resolution operator 34 control, member function and 185 ::*, pointer to member declarator 133 control, overloading resolution and 166 < declaration 178 ---see less than operator 85 example, member name 179 template and 238 239 member name 175 << ---see left shift operator 85 overloading and 212 <<= operator 89 specifier 176 177 <= ---see less than or equal to operator 85 specifier and friend 181 = ---see assignment operator 89 specifier and object layout 177 == ---see equality operator 86 struct default member 149 > ---see greater than operator 85 union default member 149 >= ---see greater than or equal operator 85 virtual function 183 >> ---see right shift operator 85 access-specifier 163 >>= operator 89 ?: ---see conditional expression operator 88 accumulate 594 acos 585, 597 addition operator 84 conversion 135 additive operator 84 declaration, default 137 additive-expression 84 evaluation of default 138 139 address evaluation, order of 68 of bit-field 159 evaluation, unspecified order of 68 of bit-field restriction 159 example of default 137 138 of constructor 186 list, empty 135 of cv-qualified name 76 list, variable 135 of member function, unspecified 325 matching ---see overload resolution 212 of overloaded function 76, 226 overloaded operator and default 228 address-of operator 76 passing 67 adjacent_find 547 passing, reference and 147 adjusting base class member access 178 reference 67 adjustment scope of default 139 array parameter 135 specification, template 278 function parameter 135 substitution 305 advance 519 template 239 aggregate 144 to constructor, unspecified 81 alert 17 type checking 67 <algorithm> 537 type checking of default 138 alias 115 type, unknown 135 alignment argument-dependent lookup 32 of bit-field 159 arguments, implementation-defined order of evaluation of of bit-field, implementation defined 159 function 139 requirement, implementation-defined 51 argv[] 43 storage allocation 79 arithmetic allocation conversions, usual 64 alignment storage 79 exception 63 function 47, 79 exception, undefined 63 implementation defined bit-field 159 pointer 84 new, storage 78 type 54 unspecified 153, 177 unsigned 53 Allocator requirements 354 array allocator 368 bound 133 allowing an exception 297 const 55 altermate definition 322 declaration 133 always_noconv, codecvt 426 declarator [] 133 ambiguity declarator, multidimensional 134 base class member 165 delete 81 class conversion 168 example 134 declaration type 102 initialization 144 declaration versus cast 128 member 152 declaration versus expression 99 multidimensional 134 detection, overloaded function 212 new 78 function declaration 142 of class objects and constructor 196 member access 165 of class objects and new 80 parentheses and 78 of class objects initialization 146, 196 resolution, scoping 167 order of execution, constructor and 195 ambiguous conversion sequence 222 order of execution, destructor and 192 Amendment 1 322 overloading and pointer versus 210 AND parameter adjustment 135 operator, bitwise 87 pointer conversion 58 operator, logical 87 size, default 134 operator, side effects and logical 88 sizeof 77 and pointer to member type, multi-level mixed pointer 59 storage of 135 anonymous type 54, 135 union 158 array-to-pointer conversion 58 union access control 158 arrow operator ---see class member access operator 68 union at namespace scope 158 as-if rule 5 union, global 158 asin 585, 597 union restriction 158 asm any, bitset 506 declaration 123 append, basic_string 392 implementation-defined 123 apply, valarray 582 assembler 123 arbitrary-positional stream 311 <assert.h> 320, 701 arg, complex 572 assign argc 43 basic_string 393 argument 1, 324 325, 351 deque 472 and name hiding, default 139 list 476 and virtual function, default 140 vector 484 binding of default 138 Assignable requirements 459 assignment operator= 343 and initialization, overloaded 196 what 343 and lvalue 89 bad_typeid::what, implementation-defined 343 conversion by 89 base expression 89 class 322, 325 operator 89, 318 class 163 164 operator, copy 205 class access 177 operator, overloaded 229 class cast 73 operator restriction, copy 206 class constructor order of execution 186 reference 147 class destructor order of execution 192 to class object 89 class, direct 163 to reference 90 class, indirect 163 assignment-expression 89 class initialization 197 assignment-operator 89 class initialization, order of 198 at, basic_string 391 class initializer 141 atan 585, 597 class member access 163 atan2 585, 597 class member access, adjusting 178 atexit 45, 320, 336 class member ambiguity 165 auto 103 class, private 177 destruction of 97 98 class, public 177 initialization 99 class virtual ---see virtual base class 163 object initialization 141 of integer literal 16 restriction 103 base-specifier 163 specifier 103 base-specifier-list 163 storage duration 46 basic automatic initialization 98 99 execution character set 4 auto_ptr 372 source character set 10 auto_ptr 373 basic_filebuf 601, 657 auto_ptr 373 basic_filebuf 658 get 373 basic_filebuf 658 operator* 373 close 659, 666 operator-> 373 imbue 662 operator= 373 is_open 659, 666 release 374 open 659, 666 ~auto_ptr 373 overflow 661 ~auto_ptr, auto_ptr 373 pbackfail 660 rdbuf 666 seekoff 661 B seekpos 662 setbuf 661 back_inserter 526 showmanyc 660 back_insert_iterator 525 sync 662 back_insert_iterator 525 uflow 660 back_insert_iterator 525 underflow 660 operator* 525 ~basic_filebuf 658 operator++ 525 ~basic_filebuf, basic_filebuf 658 operator= 525 basic_filebuf<char> 657 backslash character 17 backspace 17 basic_filebuf<wchar_t> 657 basic_fstream 601, 665 bad, basic_ios 617 basic_fstream 666 bad_alloc 79, 337, 340 basic_fstream 666 bad_alloc 340 basic_ifstream 601, 662 bad_alloc 340 basic_ifstream 663 operator= 340 basic_ifstream 663 what 340 close 663 bad_alloc::what, implementation-defined 340 is_open 663 bad_cast 71, 342 open 663 bad_cast 342 rdbuf 663 bad_cast 342 basic_ifstream<char> 657 operator= 342 basic_ifstream<wchar_t> 657 what 342 basic_ios 601, 613 bad_cast::what, implementation-defined 342 bad 617 bad_exception 299, 344 basic_ios 614 bad_exception 344 basic_ios 614 bad_exception 344 clear 616 operator= 344 copyfmt 616 what 344 eof 617 bad_exception::what, implementation-defined 344 exceptions 617 bad_typeid 71, 342 fail 617 bad_typeid 342 343 bad_typeid 342 343 fill 616 good 617 imbue 615 basic_ostreambuf_iterator 601 init 632, 642 basic_ostream<char> 629 narrow 615 basic_ostream<wchar_t> 629 operator bool 616 basic_ostringstream 601, 654 operator! 616 basic_ostringstream 655 rdbuf 615 basic_ostringstream 655 rdstate 616 rdbuf 655 setstate 616 str 655 tie 615 basic_ostringstream<char> 649 widen 615 basic_ostringstream<wchar_t> 649 basic_ios<char> 604 basic_streambuf 601, 620 basic_ios::failure argument, implementation-defined basic_streambuf 622 616 basic_streambuf 622 basic_iostream 639 eback 624 basic_iostream 639 egptr 624 basic_iostream 639 epptr 625 ~basic_iostream 640 gbump 624 ~basic_iostream, basic_iostream 640 getloc 623 basic_ios<wchar_t> 604 gptr 624 basic_istream 601, 630 imbue 625 basic_istream 632 in_avail 623 basic_istream 632 overflow 628 gcount 635 pbackfail 627 get 636 pbase 625 getline 637 pbump 625 ignore 638 pptr 625 operator bool() 633 pubimbue 623 operator>> 634 pubseekoff 623 peek 638 pubseekpos 623 putback 638 pubsetbuf 623 read 638 pubsync 623 readsome 638 sbumpc 623 seekg 639 seekoff 625 sentry 632 seekpos 625 sync 639 setbuf 625 tellg 639 setg 624 unget 638 setp 625 ~sentry 633 sgetc 623 basic_istreambuf_iterator 601 sgetn 624 basic_istream<char> 629 showmanyc 626, 660 basic_istream<wchar_t> 629 snextc 623 basic_istringstream 601, 653 sputbackc 624 basic_istringstream 653 sputc 624 basic_istringstream 653 sputn 624 rdbuf 654 sungetc 624 str 654 sync 626 basic_istringstream<char> 649 uflow 627 basic_istringstream<wchar_t> 649 underflow 626 basic_ofstream 601, 664 xsgetn 626 basic_ofstream 664 xsputn 628 basic_ofstream 664 basic_streambuf<char> 619 close 665 basic_streambuf<wchar_t> 619 is_open 665 basic_string 383, 401, 648 open 665 append 392 rdbuf 665 assign 393 basic_ofstream<char> 657 at 391 basic_ofstream<wchar_t> 657 basic_string 387 basic_ostream 601 basic_string 387 basic_ostream 642 begin 390 basic_ostream 642 c_str 397 flush 646 capacity 391 operator bool() 642 clear 391 operator<< 643 644 compare 400 put 645 copy 396 seekp 643 data 397 sentry 642 empty 391 tellp 643 end 390 write 646 erase 394 ~basic_ostream 642 find 397 ~sentry 642 find_first_not_of 399 ~basic_ostream, basic_ostream 642 find_first_of 398 find_last_not_of 400 allocation, implementation defined 159 find_last_of 399 declaration 159 getline 404 implementation defined alignment of 159 insert 393 implementation-defined sign of 159 max_size 390 layout 159 operator!= 402 restriction 159 operator+ 401 restriction, address of 159 operator+= 392 restriction, pointer to 159 operator< 403 type of 159 operator<< 404 unnamed 159 operator<= 403 zero width of 159 operator= 389 bit-fields, Boolean 159 operator== 402 bitmask type 316 317 operator> 403 <bitset> 502 operator>= 404 bitset 502 operator>> 404 any 506 operator[] 391 bitset 503 rbegin 390 bitset 503 rend 390 count 506 replace 395 flip 505 reserve 391 none 506 resize 391 operator!= 506 rfind 398 operator& 506 size 390 operator&= 504 substr 400 operator<< 506 507 swap 397, 404 operator<<= 504 basic_stringbuf 601, 649 operator== 506 basic_stringbuf 650 operator>> 506 507 basic_stringbuf 650 operator>>= 505 overflow 651 operator^ 506 pbackfail 651 operator^= 504 seekoff 651 operator| 506 seekpos 652 operator|= 504 str 650 operator~ 505 underflow 651 reset 505 basic_stringbuf<char> 649 set 505 basic_stringbuf<wchar_t> 649 size 506 basic_stringstream 601, 655 test 506 basic_stringstream 656 to_string 505 basic_stringstream 656 to_ulong 505 rdbuf 656 bitwise str 656 AND operator 87 before, type_info 341 exclusive OR operator 87 begin, basic_string 390 inclusive OR operator 87 behavior operator 87 default 312, 315 block implementation-defined 2, 445 initialization in 98 locale-specific 2 scope ---see local scope 26 reentrancy, implementation-defined 325 statement {} 93 required 312, 315 structure 98 undefined 2 body, function 140 unspecified 3 bool promotion to int 59 Ben 211 bool bidirectional_iterator_tag 518 increment 69, 77 binary type-specifier 108 operator, interpretation of 229 bool() operator, overloaded 229 basic_istream operator 633 binary_function 361 basic_ostream operator 642 binary_negate 363 boolalpha 617 binary_search 557 Boolean bind1st 364 bit-fields 159 bind2nd 365 conversion 61 binder1st 364 literal 19 binder2nd 364 type 53 binding type 53 ---see virtual function, dynamic 168 boolean-literal 19 of default argument 138 bound array 133 reference 147 bound, of array 133 bit-field 159 break statement 97 address of 159 built-in type ---see fundamental type 53 alignment of 159 byte 77 string, null-terminated 317 literal 17 literal, type of 17 multibyte 2 C set, basic execution 4 set, basic source 10 C signed 53 header 321 322, 324, 701 string 19 library, Standard 311, 317, 319, 321, 696, 698, 701 type 53 linkage to 124 type string, null-terminated 312 summary, compatibility with ISO 687 underscore 321 322 call character-literal 16 ---see also function call, member function call, overloaded char_traits function call, virtual function call 66 eq 397 400 by reference 67 length 389 390, 392 395, 397 403 by value 67 checking operator function 228 point of error 259 pseudo destructor 68 syntax 259 calloc 374, 699 cin 602 candidate functions 266 <ciso646> 699 capacity class 54, 149 basic_string 391 abstract 172 vector 485 access and friend 180 carriage return 17 and type 149 case label 93, 95 base 322, 325 <cassert> 320, 352 base ---see base class 164 cast cast to incomplete 82 ambiguity, declaration versus 128 constructor and abstract 173 base class 73 conversion 188 const 74 conversion ambiguity 168 derived class 73 declaration, forward 150 dynamic 70, 342 declaration {} 149 integer to pointer 73 definition 149, 152 lvalue 72 73 definition 22 operator 76, 82, 128 definition, empty 149 pointer to function 73 definition example 152 pointer to integer 73 definition name hiding 150 pointer to member 73 74 definition, scope of 150 reference 72, 74 definition {} 149 reinterpret 73 derived 325 reinterpret_cast, lvalue 73 derived ---see derived class 163 reinterpret_cast, reference 74 gslice 587 static 72 linkage of 41 static_cast, lvalue 72 linkage specification 124 static_cast, reference 72 local ---see local class 160 to incomplete class 82 member ---see also member 151 undefined pointer to function 73 member access 68 cast-expression 82 member access operator 68 casting 68, 82 catch 291 member declaration 151 member function 153 category, locale 412 member initialization 142 c-char 16 member semantics 68 c-char-sequence 16 member, static 46 <cctype> 405 member storage duration 48 ceil 597 member syntax 68 cerr 603 name 128 <cerrno> 322, 352 name as type definition 149 <cfloat> 335 name declaration 21 change name, elaborated 109, 150 151 to const object, undefined 107 name, point of declaration 151 to string literal, undefined 19 name, scope of 150 char name, typedef 106, 151 implementation-defined sign of 53 nested ---see nested class 160 literal, implementation-defined value of 18 object, assignment to 89 type 53 object, const 55 type, signed 53 object copy 203 type specifier 108 object copy ---see also copy constructor 187 type, unsigned 53 object initialization 144, 195 196 character 311 object initialization ---see also constructor 144 array initialization 146 object layout 153, 164 container type 311 decimal-point 317 object, member 152 object, operations on 149 object, sizeof 77 comparison objects and constructor, array of 196 function 311 objects and new, array of 80 pointer 86 objects initialization, array of 146, 196 pointer to function 86 pointer to abstract 172 undefined pointer 84, 86 polymorphic 168 unspecified pointer 86 scope 27 void* pointer 86 scope of enumerator 111 compatibility with ISO C summary 687 sizeof, empty 149 compilation, separate 9 template 503 compiler control line ---see preprocessing directive 301 template partial specializations 250 complete object 5 template specialization 239 completely defined object type 152 unnamed 106 <complex> 566 class complex 567 type specifier 149 abs 572 versus struct 149 arg 572 versus union 149 complex 570 classes complex 570 narrow-oriented iostream 312 conj 572 wide-oriented iostream 313 cos 573 classic, locale 417 cosh 573 classic_table, ctype<char> 424 exp 573 class-key 149 imag 572 class-name 149 log 573 class-specifier 149 log10 573 clear norm 572 basic_ios 616 operator!= 571 basic_string 391 operator* 571 <climits> 335, 504, 705 operator*= 570 <clocale> 317, 457, 699 operator+ 571 clog 603 operator+= 570 close operator- 571 basic_filebuf 659, 666 operator-= 570 basic_ifstream 663 operator/= 570 571 basic_ofstream 665 operator<< 572 messages 452 operator== 571 <cmath> 596 operator>> 572 codecvt 425 polar 573 always_noconv 426 pow 573 do_always_noconv 428 real 572 do_encoding 428 sin 573 do_in 427 sinh 573 do_length 428 sqrt 573 do_max_length 428 tan 573 do_out 427 tanh 574 do_unshift 427 component 312 encoding 426 compound in 426 statement 93 length 427 type 54 max_length 427 compound-statement 93 out 426 concatenation unshift 426 string 19 codecvt_byname 429 undefined string literal 19 collate 439 condition 94 compare 440 conditional do_compare 440 expression operator 88 do_hash 440 inclusion 302 do_transform 440 conditional-expression, throw-expression in 88 hash 440 conditions, rules for 94 transform 440 conj, complex 572 collate_byname 441 consistency combine, locale 416 example, linkage 103 comma linkage 103 operator 90 linkage specification 125 operator, side effects and 90 type declaration 43 comment 11 const /* */ 12 cast 74 // 12 member initialization 198 compare *const example 131 basic_string 400 const 55 collate 440 array 55 class object 55 argument 135 constructor and 156, 185 array pointer 58 destructor and 156, 191 array-to-pointer 58 example 131 by assignment 89 initialization 107, 143 by constructor 189 linkage of 41, 103 class 188 member function 155 derived-to-base 222 object, undefined change to 107 explicit type ---see casting 68 overloading and 210 floating point 60 reference 148 floating-integral 60 type 106 function 190 constant 15, 64 function ---see also user-defined conversion 188 enumeration 110 function-to-pointer 58 expression 90 implementation defined pointer integer 73 expression, pointer to member 76 implementation-defined floating point 60 initializer 152 implicit 57, 188 null pointer 60 61 implicit user-defined 188 pointer declaration 131 inheritance of user-defined 191 pointer example 131 integer 60 constant-expression 90 lvalue-to-rvalue 57 constant-initializer 152 operator ---see conversion function 190 const_mem_fun1_ref_t 367 overload resolution and 219 const_mem_fun1_t 367 overload resolution and pointer 227 const_mem_fun_ref_t 367 pointer 60 const_mem_fun_t 367 pointer to function 58 constructor 185 pointer to member 61 address of 186 pointer to member void* 61 and abstract class 173 rank 223 and array order of execution 195 return type 98 and const 156, 185 reverse_iterator 521 and initialization 195 196 sequence, ambiguous 222 and initialization example 196 sequence, implicit 221 and member function 186 sequence, standard 57 and new 80 signed unsigned integer 60 and new, unspecified 81 standard 57 and return 98 to enumeration type 73 and static objects order of execution 197 to enumeration type, static_cast, 73 and virtual function call 201 to rvalue, lvalue 57 and volatile 156, 185 type of 190 array of class objects and 196 undefined floating point 60 call, explicit 186 user-defined 188 190 conversion by 189 virtual user-defined 191 conversion by ---see also user-defined conversion 188 conversion-function-id 190 copy 186 187, 203, 318 conversions default ---see default constructor 80 qualification 58 definition 141 usual arithmetic 64 example 186 copy exception handling 294 assignment operator 205 for temporary 187 assignment operator 203 inheritance of 186 assignment operator, implicitly-declared 205 non-trivial 186 assignment operator restriction 206 order of execution, base class 186 class object 203 order of execution, member 186 constructor 186 187, 203, 318 restriction 185 186 constructor, implicitly-declared 204 restriction, copy 205 constructor restriction 205 type of 186 initialization 142 union 158 copy 549 unspecified argument to 81 basic_string 396 container copy_backward 549 requirements 459 CopyConstructible requirements 354 type, character 311 copyfmt, basic_ios 616 context, nondeduced 284 cos 585, 597 continue complex 573 in for statement 97 cosh 585, 597 statement 97 98 complex 573 control line ---see preprocessing directive 301 count 547 convention 315 bitset 506 conversion count_if 547 Boolean 61 cout 602 ambiguity, class 168 __cplusplus 309 and name hiding, user-defined 189 <csetjmp> 322, 346 cshift, valarray 582 decimal-literal 15 <csignal> 346 decimal-point character 317 <cstdarg> 135, 322, 346 decimal_point, numpunct 438 <cstddef> 77, 84, 327, 698 699 declaration 21, 101 <cstdio> 602 603, 657, 659 660, 666, 699 :, field 159 <cstdlib> 43, 45, 320, 336, 346, 374, 406, 563, 596, access 178 698 699, 701 ambiguity, function 142 c_str, basic_string 397 array 133 <cstring> 317, 375, 406, 699, 705, 710 as definition 102 <ctime> 346, 375, 410, 699 asm 123 ctor-initializer 197 bit-field 159 ctype 418 class member 151 do_is 420 class name 21 do_narrow 421 class name, point of 151 do_scan_is 420 consistency, type 43 do_scan_not 420 constant pointer 131 do_tolower 420 default argument 137 do_toupper 420 definition versus 21 do_widen 420 ellipsis in function 67, 135 is 419 enumerator point of 25 narrow 420 example 22, 137 scan_is 419 example, function 136 scan_not 419 extern 21 tolower 419 extern reference 147 toupper 419 forward 104 widen 419 forward class 150 ctype_byname 421 function 21, 135 ctype_byname<char> 425 hiding ---see name hiding 98 ctype<char> in for, scope of 97 classic_table 424 in for statement 97 ctype<char> 423 in switch statement 95 ctype<char> 423 matching, overloaded function 211 is 423 member 151 narrow 424 multiple 43 scan_is 423 name 21 scan_not 423 name, point of 25 table 424 overloaded 209 tolower 424 overloaded name and friend 180 toupper 424 parameter 135 widen 424 parentheses in 128, 131 ~ctype<char> 423 pointer 131 ~ctype<char>, ctype<char> 423 reference 132 <ctype.h> 701 register 103 C++ specifier 102 Standard Library 311, 322, 324 325 statement 98 Standard Library exception specifications 326 static member 21 Standard library 322 storage class 103 headers 319 type 130 cv-qualified name, address of 76 type ambiguity 102 cv-qualifier 55 typedef 21 cv-qualifier 128 typedef as type 105 <cwchar> 318, 322, 406, 698 699 versus cast ambiguity 128 <cwctype> 322, 405 versus expression ambiguity 99 {}, class 149 {}, enum 110 D declaration 101 declaration-statement 98 DAG declarative region 21, 24 multiple inheritance 165 declarator 101, 127 nonvirtual base class 165 &, reference 132 virtual base class 165 (), function 135 data *, pointer 131 member ---see member 151 ::*, pointer to member 133 member, static 156 [], array 133 data, basic_string 397 example 128 date_order, time_get 442 initializer, temporary and 187 deallocation meaning of 130 ---see delete 81 multidimensional array 134 function 47, 81, 194 declarator 127 dec 619, 644 decimal literal 16 declarator-id 128 decl-specifier 102 decrement delete[], operator 323, 339 operator 69, 76 77 deleted object, undefined 48 operator, overloaded 230 delete-expression 81 default dependent name 262, 265 access control 175 deprecated features 69, 77 argument and name hiding 139 <deque> 467 argument and virtual function 140 deque 470 argument, binding of 138 assign 472 argument declaration 137 erase 473 argument, evaluation of 138 139 insert 473 argument, example of 137 138 resize 473 argument, overload resolution and 219 dereferencing ---see also indirection 76 argument, overloaded operator and 228 derivation ---see inheritance 163 argument, scope of 139 derived argument, type checking of 138 class 325 array size 134 class 163 behavior 312, 315 class cast 73 constructor 186 class example 163 constructor and initialization 195 class, most 5 constructor and new 80 class, overloading and 211 destructor 191 object, most 5 initialization 141 derived-to-base conversion 222 initializers, overloading and 211 destination type 143 member access, struct 149 destruction member access, union 149 of auto 97 98 default label 93, 95 of local static 99 default-initialization 142 of local variable 97 98 #define 305 of temporary 187 definition 21, 311 of temporary, order of 187 altermate 322 destructor 191, 318 and initialization 102 and array order of execution 192 class 22 and const 156, 191 class 149, 152 and delete 81, 192 class name as type 149 and delete example 195 constructor 141 and exception, explicit 194 declaration as 102 and exit from scope 97 empty class 149 and fundamental type 193 enumerator 22 and member function 192 enumerator point of 110 and placement of object 193 example 22 and virtual function call 201 example, function 140 and volatile 156, 191 example, nested class 160, 184 call example, explicit 193 function 22 call, explicit 192 function 140 call, implicit 192 local class 161 call, pseudo 68 member function 153 default 191 name hiding, class 150 exception handling 294 namespace 112 for temporary 187 nested class 160 non-trivial 191 object 22 order of execution 192 of template 235 order of execution, base class 192 pure virtual function 172 order of execution, member 192 scope, macro 306 program termination and 192 scope of class 150 pure virtual 192 static member 157 restriction 191 192 versus declaration 21 static object 45 virtual function 170 union 158 {}, class 149 virtual 192 definitions, implementation-generated 22 diagnostic message 1 delete digit 14 array 81 digit-sequence 18 object 81 digraph 12 delete 46, 81, 194 direct destructor and 81, 192 base class 163 example 194 binding of reference 147 example, destructor and 195 initialization 142 example, scope of 195 direct-abstract-declarator 128 operator 323, 338, 374 direct-declarator 127 overloading and 48 directed acyclic graph ---see DAG 164 type of 194 directive undefined 81 error 308 null 308 type 53 pragma 308 type specifier 108 preprocessing 301 do_unshift, codecvt 427 direct-new-declarator 78 dowiden 424 distance 519 do_widen, ctype 420 distinct string 19 dynamic div 596 binding ---see virtual function 168 divides 361 cast 70, 342 division initialization 44 by zero, undefined 63, 84 storage duration 46, 78 implementation defined 84 type 2 operator 83 djacent_difference 595 do statement 95 96 E do_always_noconv, codecvt 428 E suffix 18 do_close, messages 453 eback, basic_streambuf 624 do_compare, collate 440 effect, side 6 do_curr_symbol, moneypunct 451 egptr, basic_streambuf 624 do_date_order, time_get 443 elaborated do_decimal_point class name 109, 150 151 moneypunct 450 enum name 109 numpunct 439 type specifier ---see elaborated class name 151 do_encoding, codecvt 428 elaborated-type-specifier 109 do_falsename, numpunct do_truename 439 #elif 302 do_frac_digits, moneypunct 451 elimination of temporary 187 do_get ellipsis messages 452 453 example 135 money_get 446 in function declaration 67, 135 num_get 431 overload resolution and 219 do_get_date, time_get 443 #else 303 do_get_monthname, time_get 443 else 94 do_get_time, time_get 443 empty do_get_weekday, time_get 443 argument list 135 do_get_year, time_get 443 class definition 149 do_grouping class sizeof 149 moneypunct 451 statement 93 numpunct 439 empty 518 do_hash, collate 440 basic_string 391 do_in, codecvt 427 encoding, multibyte 19 do_is, ctype 420 encoding, codecvt 426 do_length, codecvt 428 end, basic_string 390 domain_error 350 #endif 303 domain_error 350 endl 644, 646 domain_error 350 end-of-file 507 do_max_length, codecvt 428 ends 646 dominance, virtual base class 167 entity 21 donarrow 424 do_narrow, ctype 421 enum name, typedef 106 do_negative_sign, moneypunct 451 enum 54 declaration {} 110 do_neg_format, moneypunct 451 name, elaborated 109 do_open, messages 453 overloading and 210 do_out, codecvt 427 type of 110 do_pos_format, moneypunct 451 type specifier 109 do_positive_sign, moneypunct 451 enumerated type 54, 316 do_put enumeration 110 money_put 448 constant 110 num_put 434 example 111 time_put 445 linkage of 41 do_scan_is, ctype 420 type, conversion to 73 do_scan_not, ctype 420 type, static_cast, conversion to 73 dot operator ---see class member access operator 68 underlying type 111 do_thousands_sep enumerator moneypunct 450 class, scope of 111 numpunct 439 definition 22 do_tolower, ctype 420 member 111 do_toupper, ctype 420 point of declaration 25 do_transform, collate 440 point of definition 110 do_truename do_falsename, numpunct 439 redefinition 110 double quote 17 double restriction 110 literal 18 value of 110 enumerator 110 of default argument 137 138 environment, program 43 of incomplete type 52 eof, basic_ios 617 of overloading 209 epptr, basic_streambuf 625 pointer to member 133 eq, char_traits 397 400 pure virtual function 172 equal 548 scope of delete 195 istreambuf_iterator 533 scope resolution operator 167 equality operator 86 static member 157 EqualityComparable requirements 353 subscripting 134 equality-expression 86 type name 128 equal_range 557 typedef 105 equal_to 362 unnamed parameter 141 equivalence variable parameter list 135 template type 244 virtual function 169 170 type 105, 149 exception equivalent allowing an 297 parameter declarations 209 and new 80 parameter declarations, overloading and 209 arithmetic 63 erase declaration scope 26 basic_string 394 explicit destructor and 194 deque 473 handler 294, 325 list 477 handler, incomplete type in 294 vector 485 handling 291 <errno.h> 701 handling constructor 294 error handling destructor 294 checking, point of 259 specifications, C++ Standard Library 326 directive 308 specifications, Standard C library 326 #error 308 specifications, implementation-defined 326 escape throwing 292 character ---see backslash 17 types, implementation-defined 326 sequence 17 undefined arithmetic 63 sequence, undefined 17 <exception> 343 escape-sequence 16 exception evaluation exception 343 new, unspecified order of 81 exception 343 of default argument 138 139 operator= 344 of expression, order of 7 what 344 order of argument 68 ~exception 344 unspecified order of 44, 63 ~exception, exception 344 unspecified order of argument 68 exception-declaration 291 unspecified order of function call 68 exceptions, basic_ios 617 example exception-specification 296 *const 131 exception::what message, implementation-defined 344 array 134 execution character set, basic 4 class definition 152 exit from scope, destructor and 97 const 131 exit 43, 45, 97, 320, 336, 341 constant pointer 131 exp 585, 597 constructor 186 complex 573 constructor and initialization 196 explanation, subscripting 134 declaration 22, 137 explicit declarator 128 constructor call 186 definition 22 destructor and exception 194 delete 194 destructor call 192 derived class 163 destructor call example 193 destructor and delete 195 instantiation 271 ellipsis 135 qualification 33 enumeration 111 qualification example 167 explicit destructor call 193 specialization, template 272 explicit qualification 167 type conversion ---see casting 68 friend 150 explicit specifier 105 friend function 179 explicit-specialization 273 function declaration 136 exponent-part 18 function definition 140 export 235 linkage consistency 103 expression 63 local class 161 ambiguity, declaration versus 99 member function 155, 179 assignment 89 member name access 179 constant 90 nested class 160 order of evaluation of 7 nested class definition 160, 184 parenthesized 65 nested class forward declaration 160 pointer to member constant 76 nested type name 161 postfix 66 primary 64 floating-suffix 18 reference 63 float_round_style 333 statement 93 floor 597 unary 76 flush 610, 632, 642, 646 expression 90 basic_ostream 646 expression-list 66 fmtflags expression-statement 93 ios 647 extern 103 ios_base 607 "C" 321 322 fopen 659 "C++" 321 322 for declaration 21 scope of declaration in 97 linkage of 103 statement 95, 97 linkage specification 123 statement, continue in 97 reference declaration 147 statement, declaration in 97 restriction 103 for_each 545 external linkage 41, 321 322 form feed 17 formal argument ---see parameter 67 forward F class declaration 150 declaration 104 F suffix 18 declaration example, nested class 160 f suffix 18 forward_iterator_tag 518 facet, locale 414 fpos 604, 612 fail, basic_ios 617 state 612 failed, ostreambuf_iterator 535 fractional-constant 18 failure, ios_base::failure 607 free store ---see also new, delete 78 falsename, numpunct truename 438 free 374 fclose 660 freestanding implementation 320 field declaration : 159 freeze file 9 ostrstream 710 source 9, 320, 322 strstreambuf 706 filebuf 601, 657 frexp 597 implementation-defined 662 friend fill 551 local class 181 basic_ios 616 specifier 325 gslice_array 590 friend indirect_array 593 access specifier and 181 mask_array 592 class access and 180 slice_array 587 declaration, overloaded name and 180 fill_n 551 example 150 final overrider 168 function, access and 179 find 546 function example 179 basic_string 397 function, inline 181 find_end 546 function, linkage of 180 find_first_not_of, basic_string 399 function, member function and 179 find_first_of 546 function, nested class 161 basic_string 398 inheritance and 181 find_if 546 find_last_not_of, basic_string 400 local class and 181 member function 180 find_last_of, basic_string 399 specifier 106 fIoctal-digit 15 template and 248 fixed 619 virtual and 170 flags, ios_base 418, 610 front_inserter 527 flip, bitset 505 front_insert_iterator 526 float front_insert_iterator 526 literal 18 front_insert_iterator 526 type 53 operator* 526 type specifier 108 operator++ 527 <float.h> 701 operator= 526 floating fseek 659 point conversion 60 <fstream> 657 point conversion, implementation-defined 60 fstream 601 point conversion, undefined 60 full-expression 6 point literal 18 function point literal, type of 18 ---see also friend function, member function, inline point promotion 59 function, virtual function 104 point type 53 allocation 47, 79 point type 53 argument ---see argument 67 point type, implementation-defined 54 arguments, implementation-defined order of evaluation of floating-integral conversion 60 floating-literal 18 139 body 140 call 67 generate_n 551 call evaluation, unspecified order of 68 get call operator 66, 228 auto_ptr 373 call operator, overloaded 229 basic_istream 636 call, recursive 68 money_get 446 call, undefined 73 num_get 431 cast, pointer to 73 get_date, time_get 442 cast, undefined pointer to 73 getline comparison 311 basic_istream 637 comparison, pointer to 86 basic_string 404 conversion 190 getloc conversion, pointer to 58 basic_streambuf 623 deallocation 47, 81, 194 ios_base 611 declaration 21, 135 get_monthname, time_get 442 declaration ambiguity 142 get_temporary_buffer 371 declaration, ellipsis in 67, 135 get_time, time_get 442 declaration example 136 get_weekday, time_get 442 declaration matching, overloaded 211 get_year, time_get 443 declarator () 135 global definition 140 anonymous union 158 definition 22 function 322, 324 325 definition example 140 name 27 global 322, 324 325 namespace 322 handler 312 namespace scope 27 linkage specification overloaded 125 scope 27 modifier 312 global, locale 416 name hiding 211 good, basic_ios 617 name, overloaded 209 goto observer 312 initialization and 98 operator 227 statement 93, 97 98 overloaded ---see also overloading 209 gptr, basic_streambuf 624 parameter ---see parameter 67 grammar 667 parameter adjustment 135 greater plain old 347 than operator 85 pointer to member 83 than or equal to operator 85 prototype scope 26 greater 362 replacement 312 greater_equal 362 reserved 313 grouping, numpunct 438 return ---see return 98 gslice return type ---see return type 136 class 587 scope 27 gslice 588 specifier 104 gslice 588 template 277 size 589 template overload resolution 288 start 589 template partial ordering 256 stride 589 type 54, 135 gslice_array 589 typedef 136 fill 590 viable 213 gslice_array 589 virtual ---see virtual function 168 gslice_array 589 virtual member 322, 325 operator%= 590 <functional> 359 operator&= 590 function-body 140 operator*= 590 function-definition 140 operator+= 590 function-like macro 304 operator-= 590 functions, candidate 266 operator/= 590 function-specifier 104 operator<<= 590 function-to-pointer conversion 58 operator= 590 function-try-block 291 operator>>= 590 fundamental operator^= 590 type 53 operator|= 590 type conversion ---see conversion, user-defined conversion 190 type, destructor and 193 H handler G exception 294, 325 function 312 gbump, basic_streambuf 624 incomplete type in exception 294 gcount, basic_istream 635 handler 291 generate 551 handler-seq 291 generated destructor ---see default destructor 191 hasfacet, locale 417 hash, collate 440 generation of temporary 187 header, C 321 322, 324, 701 linkage of main() 43 header-name 13 linkage specification 124 headers, C++ 319 object linkage 126 hex number 18 order of evaluation of function arguments 139 hex 619 parameters to main() 43 hexadecimal literal 16 sign of bit-field 159 hexadecimal-digit 15 sign of char 53 hexadecimal-escape-sequence 17 sizeof integral type 53 hexadecimal-literal 15 sizeof type 53 hex-quad 10 streambuf 599 hiding ---see name hiding 28 streamoff 604, 702 horizontal tab 17 streampos 702 hosted implementation 320 string literal 19 type of integer literal 16 type_info::name 342 I types 316 value of char literal 18 id, qualified 65 value of multicharacter literal 17 id, locale 414 volatile 108 identifier 14, 65, 101 wchar_t 53 _, underscore in 14 implementation-dependent 632, 642 identifier 13 implementation-generated definitions 22 identities and overloading, operator 228 implementation-specifiedsmanip 647 id-expression 65 implicit id-expression 64 conversion 57, 188 #if 302, 324 conversion sequence 221 if statement 94 95 conversion sequences implied object parameter 213 #ifdef 303 destructor call 192 #ifndef 303 instantiation, template 268 ifstream 601, 657 object argument 213 ignore, basic_istream 638 user-defined conversion 188 ill-formed program 2 implicitly-declared imag 571 copy assignment operator 205 complex 572 copy constructor 204 imbue default constructor 186 basic_filebuf 662 default constructor ---see default constructor 186 basic_ios 615 implied basic_streambuf 625 object parameter 213 ios_base 611 object parameter, implicit conversion sequences 213 immolation, self 274 in, codecvt 426 implementation in_avail, basic_streambuf 623 defined alignment of bit-field 159 #include 303, 320 defined bit-field allocation 159 includes 559 defined division 84 inclusion defined modulus 84 conditional 302 defined pointer integer conversion 73 source file 303 defined pointer subtraction 84 defined right shift 85 incomplete class, cast to 82 defined type of ptrdiff_t 84 type 22 23, 26, 52, 57, 66 68, 70 71, 76 78, 81, 84, 89, freestanding 320 163 hosted 320 type, example of 52 limits 2 type in exception handler 294 implementation-defined 60, 148, 320, 322, 327, 336, 340, increment 342 344, 611, 653, 661, 699 bool 69, 77 __STDC__ 309 operator 69, 76 77 alignment requirement 51 operator, overloaded 230 asm 123 indeterminate uninitialized variable 141 bad_alloc::what 340 indirect base class 163 bad_cast::what 342 indirect_array 592 bad_exception::what 344 fill 593 bad_typeid::what 343 indirect_array 592 basic_ios::failure argument 616 indirect_array 592 behavior 2, 445 operator%= 593 behavior reentrancy 325 operator&= 593 exception specifications 326 operator*= 593 exception types 326 operator+= 593 exception::what message 344 operator-= 593 filebuf 662 operator/= 593 floating point conversion 60 floating point type 54 operator<<= 593 operator= 593 operator>>= 593 function 104 operator^= 593 member function 153 operator|= 593 inline indirection 76 linkage of 41 operator 76 specifier 104 inequality operator 86 inner_product 595 inheritance 163 inplace_merge 558 ---see also multiple inheritance 163 input_iterator_tag 518 and friend 181 insert of constructor 186 basic_string 393 of overloaded operator 228 deque 473 of user-defined conversion 191 list 477 Init, ios_base::Init 609 vector 485 init, basic_ios 632, 642 inserter 528 ~Init, ios_base::Init 610 insert_iterator 527 init-declarator 127 insert_iterator 527 init-declarator-list 127 insert_iterator 527 initialization 141 operator* 528 and goto 98 operator++ 528 and new 80 operator= 527 array 144 instantiation array of class objects 146, 196 explicit 271 auto 99 point of 265 auto object 141 template implicit 268 automatic 98 99 unit 10 base class 197 int, bool promotion to 59 character array 146 int class member 142 type 53 class object 144, 195 196 type specifier 108 class object ---see also constructor 144 type, unsigned 53 const 107, 143 integer const member 198 cast, pointer to 73 constructor and 195 196 conversion 60 copy 142 conversion, implementation defined pointer 73 default 141 conversion, signed unsigned 60 default constructor and 195 literal 16 definition and 102 literal, base of 16 direct 142 literal, implementation-defined type of 16 dynamic 44 literal, type of 16 example, constructor and 196 to pointer cast 73 in block 98 type 53 jump past 95, 98 integer-literal 15 local static 99 integer-suffix 16 member 197 integral member object 197 promotion 59 order of 44, 164 type 53 order of base class 198 type 53 order of member 198 type, implementation-defined sizeof 53 order of virtual base class 198 value, undefined unrepresentable 60 overloaded assignment and 196 internal linkage 41 parameter 67 internal 618 reference 133, 147 interpretation reference member 198 of binary operator 229 run-time 44 of unary operator 228 static member 157 invalid_argument 350, 503 504 static object 44, 141 invalid_argument 350 struct 144 invalid_argument 350 union 146, 158 invocation, macro 305 virtual base class 198, 205 <iomanip> 629 initializer 141 <ios> 604 base class 141 ios 601, 604 constant 152 fmtflags 647 list {} 144 ios_base 605 member 141 flags 418, 610 scope of member 199 fmtflags 607 temporary and declarator 187 getloc 611 initializer 141 imbue 611 initializer-clause 141 ios_base 612 initializer-list 141 ios_base 612 inline 324 iostate 608 friend function 181 iword 611 openmode 609 J precision 418, 610 Jessie 189 pword 611 jump register_callback 612 past initialization 95, 98 seekdir 609 setf 610 statement 97 sync_with_stdio 611 jump-statement 97 unsetf 610 width 418, 610 K xalloc 611 ios_base::failure 607 keyword 667 failure 607 list 14 what 607 ios_base::Init 609 Init 609 L ~Init 610 L <iosfwd> 599 prefix 17, 19 iostate, ios_base 608 suffix 16, 18 iostream l suffix 16, 18 classes, narrow-oriented 312 label 98 classes, wide-oriented 313 case 93, 95 <iostream> 602 default 93, 95 is name space 93 ctype 419 scope of 27, 93 ctype<char> 423 specifier : 93 isalnum 417 labeled statement 93 isalpha 417 lattice ---see DAG, sub-object 164 iscntrl 417 layout isdigit 417 access specifier and object 177 isgraph 417 bit-field 159 islower 417 class object 153, 164 ISO C summary, compatibility with 687 layout-compatible type 52 <iso646.h> 699, 701 left is_open shift operator 85 basic_filebuf 659, 666 shift, undefined 85 basic_ifstream 663 left 618 basic_ofstream 665 length of name 14 isprint 417 length ispunct 417 char_traits 389 390, 392 395, 397 403 isspace 417 codecvt 427 <istream> 629 valarray 581 istream 601, 629 length_error 350, 384 operator>> 633 length_error 350 istreambuf_iterator 531 length_error 350 equal 533 less istreambuf_iterator 533 than operator 85 istreambuf_iterator 533 operator!= 534 than or equal to operator 85 operator* 533 less 362 less_equal 362 operator++ 533 LessThanComparable requirements 353 operator== 533 lexical conventions 9 proxy 532 lexicographical_compare 562 istream_iterator 528 Library, C++ Standard 311, 322, 324 325 operator== 530 library istringstream 601, 649 C++ Standard 322 istrstream 709 Standard C 311, 317, 319, 321, 696, 698, 701 istrstream 709 limits, implementation 2 istrstream 709 <limits> 328 rdbuf 709 <limits.h> 701 str 709 #line 308 isupper 417 linkage 21, 41 isxdigit 417 consistency 103 iteration statement 95 consistency example 103 iteration-statement 95, 97 98 external 41, 321 322 scope 96 implementation-defined object 126 iterator requirements 509 internal 41 <iterator> 514 of class 41 iter_swap 549 iword, ios_base 611 of const 41, 103 of enumeration 41 of extern 103 of friend function 180 classic 417 of inline 41 combine 416 of main(), implementation-defined 43 facet 414 of static 41, 103 global 416 specification 123 hasfacet 417 specification class 124 id 414 specification consistency 125 locale() 415 specification, extern 123 name 416 specification, implementation-defined 124 operator!= 416 specification object 126 operator() 416 specification overloaded function 125 operator== 416 to C 124 usefacet 417 linkage-specification 123 ~locale() 415 list locale(), locale 415 keyword 14 ~locale(), locale 415 operator 15, 227 <locale.h> 701 {}, initializer 144 locale-specific behavior 2 <list> 468 log 585, 597 list 474 complex 573 assign 476 log10 585, 597 erase 477 complex 573 insert 477 logical merge 478 AND operator 87 remove 478 AND operator, side effects and 88 resize 477 OR operator 88 reverse 478 OR operator, side effects and 88 sort 478 negation operator 76 77 splice 477 logical_and 363 unique 478 logical_not 363 literal 15, 64 logical_or 363 base of integer 16 logic_error 349 character 17 logic_error 349 decimal 16 logic_error 349 double 18 long float 18 double literal 18 floating point 18 double type 53 hexadecimal 16 literal 16 implementation-defined type of integer 16 type 53 implementation-defined value of char 18 type specifier 108 implementation-defined value of multicharacter 17 type, unsigned 53 integer 16 typedef and 102 long 16 longjmp 347 long double 18 long-suffix 16 multicharacter 17 lookup narrow-character 17 argument-dependent 32 octal 16 member name 165 type of character 17 name 21, 29 type of floating point 18 template name 257 type of integer 16 lower_bound 556 unsigned 16 lowercase 317 literal 15 lvalue 55 local assignment and 89 class and friend 181 cast 72 73 class definition 161 cast, reinterpret_cast, 73 class example 161 cast, static_cast, 72 class, friend 181 conversion to rvalue 57 class member function 161 modifiable 55 class, member function in 154 lvalue-to-rvalue conversion 57 class nested class 161 class restriction 161 class restriction, static member 158 M class, scope of 161 macro object, static 46 definition scope 306 object storage duration 46 function-like 304 scope 26 invocation 305 static, destruction of 99 masking 324 static initialization 99 name 304 variable, destruction of 97 98 object-like 304 <locale> 409 locale parameters 305 category 412 preprocessor 301 replacement 304 function, static 156 157 main() 43 function template 245 implementation-defined linkage of 43 function, union 158 implementation-defined parameters to 43 function, virtual 322, 325 parameters to 43 function, volatile 155 return from 43, 45 initialization 197 make_heap 561 initialization, const 198 make_pair 359 initialization, order of 198 malloc 374, 699 initialization, reference 198 <map> 488 initialization, static 157 map 490 initializer 141 operator< 492 initializer, scope of 199 operator== 492 local class restriction, static 158 operator[] 493 name access 175 mask_array 590 name access example 179 fill 592 name lookup 165 mask_array 591 name, overloaded 152 mask_array 591 object initialization 197 operator%= 591 pointer to ---see pointer to member 54 operator&= 591 pointer value, null 61 operator*= 591 static 156 operator+= 591 static class 46 operator-= 591 storage duration, class 48 operator/= 591 template and static 246 operator<<= 591 type of static 76 operator= 591 use, static 156 operator>>= 591 member-declaration 151 operator^= 591 member-declarator 151 operator|= 591 member-specification 151 masking macro 324 memchr 407 <math.h> 701 mem_fun 366 367 max 562 mem_fun1_ref_t 366 valarray 582 mem_fun1_t 366 max_element 562 mem_fun_ref 366 367 max_length, codecvt 427 mem_fun_ref_t 366 max_size, basic_string 390 mem_fun_t 366 meaning of declarator 130 mem-initializer 197 member mem-initializer-id 197 ---see also base class member 151 memory access operator, overloaded 230 management ---see also new, delete 78 access ambiguity 165 model 4 access, base class 163 <memory> 368 access, class 68 merge 558 access, struct default 149 list 478 access, union default 149 message, diagnostic 1 array 152 messages 452 cast, pointer to 73 74 close 452 class object 152 do_close 453 constructor order of execution 186 do_get 452 453 declaration 151 do_open 453 declaration, class 151 open 452 declaration, static 21 messages_byname 453 definition, static 157 min 562 destructor order of execution 192 valarray 581 enumerator 111 min_element 562 example, static 157 minus 361 function and access control 185 mismatch 547 function and friend function 179 missing storage class specifier 103 function call, undefined 154 mixed pointer and pointer to member type, multi-level 59 function, class 153 mod 597 function, const 155 modf 597 function, constructor and 186 modifiable lvalue 55 function definition 153 modifier function 312 function, destructor and 192 modulus function example 155, 179 implementation defined 84 function, friend 180 operator 83 function in local class 154 zero, undefined 63 function, inline 153 modulus 362 function, local class 161 money_get 446 function, nested class 184 do_get 446 function, overload resolution and 213 get 446 moneypunct 449 reserved 321 do_curr_symbol 451 resolution, template 257 do_decimal_point 450 scope of 24 do_frac_digits 451 space, label 93 do_grouping 451 unqualified 29 do_neg_format 451 name do_negative_sign 451 locale 416 do_pos_format 451 type_info 341 do_positive_sign 451 namespace 319, 701 do_thousands_sep 450 definition 112 moneypunct_byname 451 global 322 money_put 448 scope 27 do_put 448 scope, anonymous union at 158 put 448 scope, global 27 most namespaces 112 derived class 5 narrow string literal 19 derived object 5 narrow multibyte basic_ios 615 character 2 ctype 420 encoding 19 ctype<char> 424 string, null-terminated 318 narrow-character literal 17 multicharacter narrow-oriented iostream classes 312 literal 17 NDEBUG 320 literal, implementation-defined value of 17 negate 362 multidimensional negation operator, logical 76 77 array 134 nested array declarator 134 class definition 160 multi-level class definition example 160, 184 mixed pointer and pointer to member type 59 class example 160 pointer to member type 59 class forward declaration example 160 multimap 493 class friend function 161 operator< 496 class, local class 161 operator== 496 class member function 184 multiple class, scope of 160 declaration 43 type name 161 inheritance 163 164 type name example 161 inheritance DAG 165 type name, scope of 161 inheritance, virtual and 170 nested-name-specifier 65 multiplication operator 83 <new> 323, 337 multiplicative operator 83 new 46, 78 79 multiplicative-expression 83 array 78 multiset 499 array of class objects and 80 operator< 501 constructor and 80 operator== 501 default constructor and 80 mutable 103 exception and 80 initialization and 80 operator 322, 337, 339 340, 374 N placement syntax 79 scoping and 78 name 14, 21, 65 storage allocation 78 address of cv-qualified 76 type of 194 and translation unit 21 unspecified constructor and 81 class ---see class name 149 unspecified order of evaluation 81 declaration 21 new[], operator 322, 338 340 dependent 262, 265 new-declarator 78 elaborated enum 109 new-expression 78 global 27 new_handler 47, 340 hiding 25, 28, 64 65, 98 new-initializer 78 hiding, class definition 150 new-line 17 hiding, function 211 new-placement 78 hiding, overloading versus 211 new-type-id 78 hiding, user-defined conversion and 189 next_permutation 563 length of 14 noboolalpha 617 lookup 21, 29 nondeduced context 284 lookup, member 165 nondigit 13 lookup, template 257 none, bitset 506 macro 304 non-trivial overloaded function 209 constructor 186 overloaded member 152 destructor 191 point of declaration 25 qualified 33 nonvirtual base class DAG 165 nonzero-digit 15 norm, complex 572 linkage specification 126 noshowbase 617 representation 51 noshowpoint 618 state 312 noshowpos 618 static local 46 noskipws 618 storage duration, local 46 not1 363 temporary ---see temporary 187 not2 364 type 4 notation, syntax 4 type 52 not_equal_to 362 type, completely defined 152 nounitbuf 618 undefined deleted 48 nouppercase 618 unnamed 186 NTBS 317 318, 659, 709 710 object-expression 63 static 317 object-like macro 304 NTCTS 312 observer function 312 nth_element 556 oct 619 NTMBS 318 octal static 318 literal 16 NTWCS 318 number 18 static 318 octal-escape-sequence 17 null octal-literal 15 character 0 19 of directive 308 overloading, example 209 member pointer value 61 reference, direct binding 147 pointer constant 60 61 offsetof 328, 699 pointer value 60 ofstream 601, 657 reference 133 old function, plain 347 statement 93 one-definition rule 22 NULL 327 one's complement operator 76 77 null-terminated open byte string 317 basic_filebuf 659, 666 character type string 312 basic_ifstream 663 multibyte string 318 basic_ofstream 665 wide-character string 318 messages 452 number openmode, ios_base 609 hex 18 operations on class object 149 octal 18 operator numeric type requirements 565 ---see conversion function, conversion 190 <numeric> 593 %= 89 numeric_limits 54, 328 &= 89 num_get 429 *= 89 do_get 431 += 77, 89 get 431 -= 89 numpunct 437 /= 89 decimal_point 438 <<= 89 do_decimal_point 439 >>= 89 do_grouping 439 ^= 89 do_thousands_sep 439 additive 84 do_truename do_falsename 439 address-of 76 grouping 438 assignment 89, 318 thousands_sep 438 bitwise 87 truename falsename 438 bitwise AND 87 numpunct_byname 439 bitwise exclusive OR 87 num_put 433 bitwise inclusive OR 87 do_put 434 cast 76, 82, 128 put 434 class member access 68 comma 90 conditional expression 88 O copy assignment 203 decrement 69, 76 77 object 4, 21, 55 division 83 class ---see also class object 149 equality 86 complete 5 example, scope resolution 167 definition 22 function call 66, 228 delete 81 function call 228 destructor and placement of 193 greater than 85 destructor static 45 greater than or equal to 85 initialization, auto 141 identities and overloading 228 initialization, static 44, 141 increment 69, 76 77 layout, access specifier and 177 indirection 76 lifetime 48 linkage, implementation-defined 126 inequality 86 left shift ---see left shift operator 85 less than 85 indirect_array 593 less than or equal to 85 mask_array 591 list 15, 227 slice_array 587 logical AND 87 valarray 581 logical OR 88 operator(), locale 416 logical negation 76 77 operator* modulus 83 auto_ptr 373 multiplication 83 back_insert_iterator 525 multiplicative 83 complex 571 new ---see new 78 front_insert_iterator 526 one's complement 76 77 insert_iterator 528 overloaded 63 istreambuf_iterator 533 overloading ---see also overloaded operator 227 ostreambuf_iterator 534 overloading restrictions 228 reverse_iterator 521 pointer to member 83 valarray 583 precedence of 7 operator*= relational 85 complex 570 right shift; right shift operator 85 gslice_array 590 scope resolution 64 65, 79, 154, 163, 172 indirect_array 593 shift ---see left shift operator, right shift operator 85 mask_array 591 side effects and comma 90 slice_array 587 side effects and logical AND 88 valarray 581 side effects and logical OR 88 operator+ sizeof 76 77 basic_string 401 subscripting 66, 228 complex 571 unary 76 reverse_iterator 522, 524 unary minus 76 77 valarray 580, 583 unary plus 76 operator++ use, scope resolution 157 back_insert_iterator 525 |= 89 front_insert_iterator 527 operator insert_iterator 528 bool, basic_ios 616 istreambuf_iterator 533 bool(), basic_istream 633 ostreambuf_iterator 535 bool(), basic_ostream 642 reverse_iterator 522 delete 323, 338, 374 operator+= delete 79, 81, 194 basic_string 392 delete ---see delete 81 complex 570 delete[] 323, 339 gslice_array 590 delete[] 79, 81, 194 indirect_array 593 function 227 mask_array 591 new 322, 337, 339 340, 374 reverse_iterator 522 new 79 slice_array 587 new[] 322, 338 340 valarray 581 new[] 79 operator- overloaded 227 complex 571 operator! reverse_iterator 523 524 basic_ios 616 valarray 580, 583 valarray 580 operator--, reverse_iterator 522 operator!= 357 operator-= basic_string 402 complex 570 bitset 506 gslice_array 590 complex 571 indirect_array 593 istreambuf_iterator 534 mask_array 591 locale 416 reverse_iterator 523 reverse_iterator 523 slice_array 587 type_info 341 valarray 581 valarray 584 operator-> operator%, valarray 583 auto_ptr 373 operator%= reverse_iterator 522 gslice_array 590 operator/, valarray 583 indirect_array 593 operator/= mask_array 591 complex 570 571 slice_array 587 gslice_array 590 valarray 581 indirect_array 593 operator& mask_array 591 bitset 506 slice_array 587 valarray 583 valarray 581 operator&&, valarray 583 584 operator< operator&= basic_string 403 bitset 504 map 492 gslice_array 590 multimap 496 multiset 501 basic_string 404 pair 358 bitset 506 507 queue 480 complex 572 reverse_iterator 523 istream 633 set 498 valarray 583 valarray 584 operator>>= vector 484 bitset 505 vector<bool> 488 gslice_array 590 operator<< 619 indirect_array 593 basic_ostream 643 644 mask_array 591 basic_string 404 slice_array 587 bitset 506 507 valarray 581 complex 572 operator[] valarray 583 basic_string 391 operator<<= map 493 bitset 504 reverse_iterator 523 gslice_array 590 valarray 580 indirect_array 593 operator^ mask_array 591 bitset 506 slice_array 587 valarray 583 valarray 581 operator^= operator<= 358 bitset 504 basic_string 403 gslice_array 590 reverse_iterator 524 indirect_array 593 valarray 584 mask_array 591 operator= slice_array 587 auto_ptr 373 valarray 581 back_insert_iterator 525 operator| bad_alloc 340 bitset 506 bad_cast 342 valarray 583 bad_exception 344 operator|= bad_typeid 343 bitset 504 basic_string 389 gslice_array 590 exception 344 indirect_array 593 front_insert_iterator 526 mask_array 591 gslice_array 590 slice_array 587 indirect_array 593 valarray 581 insert_iterator 527 operator||, valarray 583 584 mask_array 591 operator~ ostreambuf_iterator 534 bitset 505 slice_array 587 valarray 580 type_info 342 operator 228 valarray 579 operator-function-id 227 operator== optimization of temporary ---see elimination of temporary 187 basic_string 402 OR bitset 506 operator, bitwise exclusive 87 complex 571 operator, bitwise inclusive 87 istream_iterator 530 operator, logical 88 istreambuf_iterator 533 operator, side effects and logical 88 locale 416 order map 492 of argument evaluation 68 multimap 496 of argument evaluation, unspecified 68 multiset 501 of base class initialization 198 pair 358 of destruction of temporary 187 queue 480 of evaluation new, unspecified 81 reverse_iterator 523 of evaluation of expression 7 set 498 of evaluation of function arguments, implementation-defined type_info 341 139 valarray 584 of evaluation, unspecified 44, 63 vector 484 of execution, base class constructor 186 vector<bool> 488 of execution, base class destructor 192 operator> 358 of execution, constructor and array 195 basic_string 403 of execution, constructor and static objects 197 reverse_iterator 523 of execution, destructor 192 valarray 584 of execution, destructor and array 192 operator>= 358 of execution, member constructor 186 basic_string 404 of execution, member destructor 192 reverse_iterator 524 of function call evaluation, unspecified 68 valarray 584 of initialization 44, 164 operator>> of member initialization 198 basic_istream 634 of virtual base class initialization 198 ordering, function template partial 256 and const 210 <ostream> 629 and default initializers 211 ostream 601, 629 and delete 48 ostreambuf_iterator 534 and derived class 211 failed 535 and enum 210 operator* 534 and equivalent parameter declarations 209 operator++ 535 and pointer versus array 210 operator= 534 and return type 209 ostreambuf_iterator 534 and scope 211 ostreambuf_iterator 534 and static 209 ostream_iterator 530 and typedef 210 ostringstream 601, 649 and volatile 210 ostrstream 710 operator identities and 228 :pcount 711 postfix ++ and -- 230 freeze 710 prefix ++ and -- 230 ostrstream 710 resolution and access control 166 ostrstream 710 restriction 228 rdbuf 710 subsequence rule 225 str 710 versus name hiding 211 out, codecvt 426 overrider, final 168 out_of_range 351, 384, 503 506 out_of_range 351 out_of_range 351 P output_iterator_tag 518 pair 358 overflow 63 operator< 358 undefined 63 operator== 358 overflow parameter 2 basic_filebuf 661 adjustment, array 135 basic_streambuf 628 adjustment, function 135 basic_stringbuf 651 declaration 135 strstreambuf 706 example, unnamed 141 overflow_error 351 352, 503, 505 initialization 67 overflow_error 352 list example, variable 135 overflow_error 352 list, variable 67, 135 overload reference 132 resolution 212 scope of 26 resolution and conversion 219 void 135 resolution and default argument 219 parameter type list 136 resolution and ellipsis 219 parameter-declaration 135 resolution and member function 213 parameterized type ---see template 235 resolution and pointer conversion 227 parameters resolution contexts 212 macro 305 resolution, function template 288 to main() 43 resolution, template 256 to main(), implementation-defined 43 overloaded parentheses assignment and initialization 196 and ambiguity 78 assignment operator 229 binary operator 229 in declaration 128, 131 declaration 209 parenthesized expression 65 partial decrement operator 230 ordering, function template 256 function, address of 76, 226 specializations, class template 250 function ambiguity detection 212 partial_sort 555 function call operator 229 partial_sort_copy 556 function call resolution ---see also argument matching, partial_sum 595 overload resolution 212 partition 554 function declaration matching 211 pbackfail function, linkage specification 125 basic_filebuf 660 function name 209 basic_streambuf 627 increment operator 230 basic_stringbuf 651 member access operator 230 strstreambuf 707 member name 152 pbase, basic_streambuf 625 name and friend declaration 180 pbump, basic_streambuf 625 operator 227 :pcount, ostrstream 711 operator 63 pcount operator 227 strstream 712 operator and default argument 228 strstreambuf 706 operator, inheritance of 228 peek, basic_istream 638 subscripting operator 230 period 317 unary operator 228 overloading 135, 150, 209, 254 phases, translation 9 and access 212 placement of object, destructor and 193 ++ and -- 69 syntax, new 79 ++ and --, overloading 230 plain old function 347 expression 66 plus 361 potential scope 24 pm-expression 83 pow 585, 597 POD complex 573 class type 80 pp-number 13 type 52 pptr, basic_streambuf 625 type 80 pragma directive 308 POD-struct 149 #pragma 308 POF 347 precedence of operator 7 point precision, ios_base 418, 610 of declaration class name 151 prefix of declaration, enumerator 25 ++ and -- 77 of declaration name 25 ++ and --, overloading 230 of definition, enumerator 110 L 17, 19 of error checking 259 preprocessing 301 of instantiation 265 directive 301 promotion, floating 59 preprocessing-op-or-punc 15 type, floating 53 preprocessing-token 11 pointer preprocessor, macro 301 ---see also void* 54 prev_permutation 563 and pointer to member type, multi-level mixed 59 primary arithmetic 84 expression 64 cast, integer to 73 template 250 comparison 86 priority_queue 480 comparison, undefined 84, 86 pop 481 comparison, unspecified 86 priority_queue 481 comparison, void* 86 priority_queue 481 constant, null 60 61 push 481 conversion 60 private 175 conversion, array 58 base class 177 conversion, overload resolution and 227 program 41 declaration 131 environment 43 declarator * 131 ill-formed 2 example, constant 131 start 43 44 integer conversion, implementation defined 73 startup 321, 323 subtraction, implementation defined 84 termination 43, 45 terminology 54 termination and destructor 192 to abstract class 172 well-formed 3 to bit-field restriction 159 promotion to function cast 73 floating point 59 to function cast, undefined 73 integral 59 to function comparison 86 to int, bool 59 to function conversion 58 protected 175 to integer cast 73 protection 325 to member 54, 83 ---see access control 175 to member cast 73 74 proxy, istreambuf_iterator 532 to member constant expression 76 pseudo destructor call 68 to member conversion 61 pseudo-destructor-name 68 to member declarator ::* 133 pseudo-destructor-name 66 to member example 133 ptrdiff_t 84 to member function 83 implementation defined type of 84 to member operator 83 ptr_fun 365 to member type, multi-level 59 ptr-operator 127 to member type, multi-level mixed pointer and 59 pubimbue, basic_streambuf 623 to member void* conversion 61 public 175 type 54 base class 177 value, null 60 pubseekoff, basic_streambuf 623 value, null member 61 pubseekpos, basic_streambuf 623 versus array, overloading and 210 pubsetbuf, basic_streambuf 623 zero 60 pubsync, basic_streambuf 623 pointer_to_binary_function 365 punctuators 15 pointer_to_unary_function 365 pure polar, complex 573 specifier 151 polymorphic virtual destructor 192 class 168 virtual function 172 type 168 virtual function call, undefined 173 pop, priority_queue 481 virtual function definition 172 pop_heap 561 virtual function example 172 postfix pure-specifier 151 push, priority_queue 481 cast, static_cast, 72 push_heap 561 const 148 put declaration 132 basic_ostream 645 declaration, extern 147 money_put 448 declarator & 132 num_put 434 direct binding of 147 time_put 445 expression 63 putback, basic_istream 638 initialization 133, 147 pword, ios_base 611 member initialization 198 null 133 parameter 132 Q restriction 133 sizeof 77 qualification reference-compatible 147 conversions 58 reference-related 147 explicit 33 region, declarative 21, 24 qualified register 103 id 65 declaration 103 name 33 restriction 103 qualified-id 65 register_callback, ios_base 612 question mark 17 reinterpret cast 73 <queue> 468 reinterpret_cast queue 479 lvalue cast 73 operator< 480 reference cast 74 operator== 480 relational operator 85 quote relational-expression 85 double 17 single 17 release, auto_ptr 374 rel_ops 357 remainder operator ---see modulus operator 83 R remove 551 list 478 random_access_iterator_tag 518 remove_copy 551 random_shuffle 553 remove_copy_if 551 range_error 351 remove_if 551 range_error 351 rend, basic_string 390 range_error 351 replace 550 rank, conversion 223 basic_string 395 rbegin, basic_string 390 replace_copy 550 rdbuf replace_copy_if 550 basic_filebuf 666 replace_if 550 basic_ifstream 663 replacement basic_ios 615 function 312 basic_istringstream 654 macro 304 basic_ofstream 665 repositional stream 313 basic_ostringstream 655 representation basic_stringstream 656 object 51 istrstream 709 value 51 ostrstream 710 required behavior 312, 315 strstream 712 requirements 314 rdstate, basic_ios 616 Allocator 354 read, basic_istream 638 Assignable 459 readsome, basic_istream 638 CopyConstructible 354 real 571 EqualityComparable 353 complex 572 LessThanComparable 353 realloc 374 container 459 recursive function call 68 iterator 509 redefinition numeric type 565 enumerator 110 reraise 293 typedef 105 rescanning and replacement 306 reentrancy 325 reserve implementation-defined behavior 325 basic_string 391 reference 54 vector 485 and argument passing 147 reserved and return 147 function 313 argument 67 identifier 14 assignment 147 name 321 assignment to 90 word ---see keyword 14 binding 147 reset, bitset 505 call by 67 resetiosflags 647 cast 72, 74 resize cast, reinterpret_cast, 74 basic_string 391 deque 473 reverse_iterator 521 list 477 rfind, basic_string 398 valarray 582 right vector 485 shift, implementation defined 85 resolution shift operator 85 and conversion, overload 219 right 619 and default argument, overload 219 rotate 553 and ellipsis, overload 219 rotate_copy 553 and member function, overload 213 rounding 60 and pointer conversion, overload 227 rule argument matching ---see overload 212 as-if 5 function template overload 288 one-definition 22 overload 212 rules overloaded function call resolution ---see also argument for conditions 94 matching, overload 212 summary, scope 29 overloading ---see overload resolution 212 run-time initialization 44 resolution overloading ---see overload 212 runtime_error 351 scoping ambiguity 167 runtime_error 351 template name 257 runtime_error 351 template overload 256 rvalue 55 restriction 324 325 lvalue conversion to 57 address of bit-field 159 anonymous union 158 auto 103 S bit-field 159 sbumpc, basic_streambuf 623 constructor 185 186 scalar type 52 copy assignment operator 206 scan_is copy constructor 205 ctype 419 destructor 191 192 ctype<char> 423 enumerator 110 scan_not extern 103 ctype 419 local class 161 ctype<char> 423 overloading 228 s-char 19 pointer to bit-field 159 s-char-sequence 19 reference 133 scientific 619 register 103 scope 21, 24 static 103 anonymous union at namespace 158 static member local class 158 class 27 union 158, 186 destructor and exit from 97 restrictions, operator overloading 228 exception declaration 26 rethrow 293 function 27 return function prototype 26 type 136 global 27 type conversion 98 global namespace 27 type, overloading and 209 iteration-statement 96 return 97 98 local 26 constructor and 98 from main() 43, 45 macro definition 306 reference and 147 namespace 27 of class definition 150 statement ---see also return 97 of class name 150 reverse 552 of declaration in for 97 list 478 of default argument 139 reverse_copy 552 of delete example 195 reverse_iterator 520 of enumerator class 111 conversion 521 of label 27, 93 operator!= 523 of local class 161 operator* 521 of member initializer 199 operator+ 522, 524 of name 24 operator++ 522 of nested class 160 operator+= 522 of nested type name 161 operator- 523 524 of parameter 26 operator-- 522 overloading and 211 operator-= 523 potential 24 operator-> 522 resolution operator 64 65, 79, 154, 163, 172 operator< 523 resolution operator :: 34 operator<= 524 resolution operator example 167 operator== 523 resolution operator use 157 operator> 523 rules summary 29 operator>= 524 operator[] 523 selection-statement 94 reverse_iterator 521 scoping ambiguity resolution 167 shift-expression 85 and new 78 short search 548 type 53 seekdir, ios_base 609 type specifier 108 seekg, basic_istream 639 type, unsigned 53 seekoff typedef and 102 basic_filebuf 661 showbase 617 basic_streambuf 625 showmanyc basic_stringbuf 651 basic_filebuf 660 strstreambuf 707 basic_streambuf 626, 660 seekp, basic_ostream 643 showpoint 617 seekpos showpos 618 basic_filebuf 662 side basic_streambuf 625 effect 6 basic_stringbuf 652 effects 63 strstreambuf 708 effects and comma operator 90 selection statement 94 effects and logical AND operator 88 selection-statement 94 effects and logical OR operator 88 scope 94 sign self immolation 274 of bit-field, implementation-defined 159 semantics, class member 68 of char, implementation-defined 53 sentry sign 18 basic_istream 632 <signal.h> 701 basic_ostream 642 signature 2 ~sentry signed basic_istream 633 char type 53 basic_ostream 642 character 53 separate typedef and 102 compilation 9 unsigned integer conversion 60 translation 9 simple-escape-sequence 17 sequence simple-type-specifier 108 ambiguous conversion 222 sin 585, 597 implicit conversion 221 complex 573 point 6, 63 single quote 17 standard conversion 57 sinh 585, 597 statement 93 complex 573 sequencing operator ---see comma operator 90 size set, basic source character 10 basic_string 390 <set> 489 bitset 506 set 496 gslice 589 bitset 505 slice 586 operator< 498 sizeof operator== 498 array 77 setbase 647 class object 77 setbuf empty class 149 basic_filebuf 661 integral type, implementation-defined 53 basic_streambuf 625 operator 76 77 streambuf 709 reference 77 strstreambuf 709 string 19 set_difference 560 type, implementation-defined 53 setf, ios_base 610 size_t 77 setfill 647 skipws 618 setg, basic_streambuf 624 slice 585 set_intersection 559 size 586 setiosflags 647 slice 585 setjmp 322 slice 585 <setjmp.h> 701 start 586 setlocale 317 stride 586 set_new_handler 323, 341 slice_array 586 setp, basic_streambuf 625 fill 587 setprecision 648 operator%= 587 setstate, basic_ios 616 operator&= 587 set_symmetric_difference 560 operator*= 587 set_terminate 323, 345 operator+= 587 set_unexpected 323, 345 operator-= 587 set_union 559 operator/= 587 setw 648 operator<<= 587 sgetc, basic_streambuf 623 operator= 587 sgetn, basic_streambuf 624 operator>>= 587 shift operator ---see left shift operator, right shift operator 85 operator^= 587 shift, valarray 582 operator|= 587 slice_array 587 compound 93 slice_array 587 continue 97 98 smanip, implementation-specified 647 continue in for 97 snextc, basic_streambuf 623 declaration 98 sort 555 declaration in for 97 list 478 declaration in switch 95 sort_heap 561 do 95 96 source empty 93 character set, basic 10 expression 93 file 9, 320, 322 for 95, 97 file inclusion 303 goto 93, 97 98 space, white 11 if 94 95 special member function ---see also constructor, destructor, iteration 95 inline function, user-defined conversion, virtual function jump 97 185 labeled 93 specialization null 93 class template 239 selection 94 template 267 sequence 93 template explicit 272 switch 94 95, 97 specializations, class template partial 250 while 95 96 specification, template argument 278 {}, block 93 specifications statement 93 C++ Standard Library exception 326 static Standard C library exception 326 NTBS 317 implementation-defined exception 326 NTMBS 318 specifier NTWCS 318 access ---see access specifier 163 cast 72 auto 103 type 2 declaration 102 static 103 explicit 105 class member 46 friend 106 data member 156 friend 325 destruction of local 99 function 104 initialization, local 99 inline 104 linkage of 41, 103 missing storage class 103 local object 46 static 103 member 156 storage class 103 member declaration 21 type ---see type specifier 106 member definition 157 typedef 105 member example 157 virtual 105 member function 156 157 splice, list 477 member initialization 157 sputbackc, basic_streambuf 624 member local class restriction 158 sputc, basic_streambuf 624 member, template and 246 sputn, basic_streambuf 624 member, type of 76 sqrt 585, 597 member use 156 complex 573 object, destructor 45 <sstream> 649 object initialization 44, 141 stable_partition 554 objects order of execution, constructor and 197 stable_sort 555 overloading and 209 stack unwinding 294 restriction 103 <stack> 469 specifier 103 stack 481 static_cast Standard conversion to enumeration type 73 C library 311, 317, 319, 321, 696, 698, 701 lvalue cast 72 C library exception specifications 326 reference cast 72 Library, C++ 311, 322, 324 325 <stdarg.h> 701 library, C++ 322 __STDC__ 309 standard implementation-defined 309 conversion 57 <stddef.h> 17, 19, 701 conversion sequence 57 <stdexcept> 349 structure of 4 <stdio.h> 701 start, program 43 44 <stdlib.h> 701 start storage gslice 589 allocation new 78 slice 586 class 21 startup, program 321, 323 class declaration 103 state, object 312 class specifier 103 state, fpos 612 class specifier, missing 103 statement 93 duration 45 ---see also return, return 97 duration, auto 46 break 97 duration, class member 48 duration, dynamic 46, 78 str 706 duration, local object 46 strstreambuf 705 management ---see new, delete 78 strstreambuf 705 of array 135 underflow 707 str ~strstreambuf 706 basic_istringstream 654 ~strstreambuf, strstreambuf 706 basic_ostringstream 655 struct basic_stringbuf 650 class versus 149 basic_stringstream 656 default member access 149 istrstream 709 initialization 144 ostrstream 710 type specifier 149 strstream 712 structure 149 strstreambuf 706 of standard 4 strchr 407 tag ---see class name 149 stream sub-object 5 arbitrary-positional 311 lattice ---see DAG 164 repositional 313 subscripting <streambuf> 619 example 134 streambuf 601, 619 explanation 134 implementation-defined 599 operator 66, 228 setbuf 709 operator, overloaded 230 streamoff 612, 702 subsequence rule, overloading 225 implementation-defined 604, 702 substr, basic_string 400 streampos, implementation-defined 702 subtraction streamsize 604 implementation defined pointer 84 strftime 445 operator 84 stride suffix gslice 589 E 18 slice 586 F 18 string L 16, 18 concatenation 19 U 16 distinct 19 f 18 literal 19 l 16, 18 literal concatenation, undefined 19 u 16 literal, implementation-defined 19 sum, valarray 581 literal, narrow 19 summary literal, type of 19 compatibility with ISO C 687 literal, undefined change to 19 scope rules 29 literal, wide 19 syntax 667 null-terminated byte 317 sungetc, basic_streambuf 624 null-terminated character type 312 swap 549 null-terminated multibyte 318 basic_string 397, 404 null-terminated wide-character 318 swap_ranges 549 sizeof 19 switch terminator 0 19 statement 94 95, 97 type of 19 statement, declaration in 95 <string> 381 sync stringbuf 601, 649 basic_filebuf 662 <string.h> 701 basic_istream 639 string-literal 19 basic_streambuf 626 stringstream 601 sync_with_stdio, ios_base 611 strlen 705, 710 synonym 115 strpbrk 407 type name as 105 strrchr 407 syntax strstr 407 checking 259 strstream 711 class member 68 pcount 712 notation 4 rdbuf 712 summary 667 str 712 strstream 711 strstream 711 T ~strstream 711 table, ctype<char> 424 ~strstream, strstream 711 tan 585, 597 strstreambuf 703 complex 573 freeze 706 tanh 585, 597 overflow 706 complex 574 pbackfail 707 tellg, basic_istream 639 pcount 706 tellp, basic_ostream 643 seekoff 707 seekpos 708 template 235 setbuf 709 and < 238 239 and friend 248 put 445 and static member 246 time_put_byname 445 argument 239 times 361 argument specification 278 to class 503 int, bool promotion 59 definition of 235 rvalue, lvalue conversion 57 explicit specialization 272 token 12, 15 function 277 token 12 implicit instantiation 268 tolower 417 member function 245 ctype 419 name lookup 257 ctype<char> 424 name resolution 257 to_string, bitset 505 overload resolution 256 to_ulong, bitset 505 overload resolution, function 288 toupper 417 partial ordering, function 256 ctype 419 partial specializations, class 250 ctype<char> 424 primary 250 traits 313 specialization 267 transform 550 specialization, class 239 collate 440 type equivalence 244 translation template 235 phases 9 template-argument 238 separate 9 template-argument-list 238 unit 320 321 template-declaration 235 unit 9, 41 template-id 238 unit, name and 21 template-name 238 trigraph 9, 11 template-parameter 236 truename falsename, numpunct 438 template-parameter-list 235 truncation 60 temporary 187 try 291 and declarator initializer 187 try-block 291 constructor for 187 type 21 destruction of 187 Boolean 53 destructor for 187 POD 52 elimination of 187 ambiguity, declaration 102 implementation-defined generation of 187 arithmetic 54 order of destruction of 187 array 54, 135 terminate 45, 299, 336, 345 bitmask 316 317 terminate() 298 char 53 terminate_handler 323, 345 character 53 termination character container 311 and destructor, program 192 checking, argument 67 program 43, 45 checking of default argument 138 terminator 0, string 19 class and 149 terminology, pointer 54 completely defined object 152 test, bitset 506 compound 54 this 64 const 106 pointer ---see this 155 conversion, explicit ---see casting 68 type of 155 declaration 130 thousands_sep, numpunct 438 declaration consistency 43 throw 291 declaration, typedef as 105 throw-expression in conditional-expression 88 definition, class name as 149 throw-expression 291 destination 143 throwing, exception 292 double 53 tie, basic_ios 615 dynamic 2 time_get 441 enumerated 54, 316 date_order 442 enumeration underlying 111 do_date_order 443 equivalence 105, 149 do_get_date 443 equivalence, template 244 do_get_monthname 443 example of incomplete 52 do_get_time 443 float 53 do_get_weekday 443 floating point 53 do_get_year 443 function 54, 135 get_date 442 fundamental 53 get_monthname 442 generator ---see template 235 get_time 442 implementation-defined sizeof 53 get_weekday 442 incomplete 22 23, 26, 52, 57, 66 68, 70 71, 76 78, 81, get_year 443 84, 89, 163 time_get_byname 444 int 53 <time.h> 701 integral 53 time_put 444 long 53 do_put 445 long double 53 multi-level mixed pointer and pointer to member 59 type-id-list 296 multi-level pointer to member 59 <typeinfo> 341 name 128 type_info 71, 341 name as synonym 105 before 341 name example 128 name 341 name example, nested 161 operator!= 341 name, nested 161 operator= 342 name, scope of nested 161 operator== 341 object 4 type_info 342 of bit-field 159 type_info 342 of character literal 17 type_info::name, implementation-defined 342 of constructor 186 typename 109 of conversion 190 type-name 108 of delete 194 type-parameter 236 of enum 110 types of floating point literal 18 implementation-defined 316 of integer literal 16 implementation-defined exception 326 of integer literal, implementation-defined 16 type-specifier of new 194 bool 108 of ptrdiff_t, implementation defined 84 wchart 108 of static member 76 type-specifier 106 of string 19 of string literal 19 of this 155 U pointer 54 U suffix 16 polymorphic 168 u suffix 16 pun 74 uflow requirements, numeric 565 basic_filebuf 660 short 53 basic_streambuf 627 signed char 53 unary specifier, char 108 expression 76 specifier, class 149 minus operator 76 77 specifier, double 108 operator 76 specifier, enum 109 operator, interpretation of 228 specifier, float 108 operator, overloaded 228 specifier, int 108 plus operator 76 specifier, long 108 unary-expression 76 specifier, short 108 unary_function 361 specifier, struct 149 unary_negate 363 specifier, union 149 unary-operator 76 specifier, unsigned 108 uncaught\xception 346 specifier, void 108 #undef 306, 321 specifier, volatile 108 undefined 312 313, 321 322, 324, 347, 391, 532, 579 581, static 2 583 584, 588, 593, 613 unsigned 53 arithmetic exception 63 unsigned char 53 behavior 2 unsigned int 53 unsigned long 53 change to const object 107 unsigned short 53 change to string literal 19 delete 81 void 54 deleted object 48 void* 54 division by zero 63, 84 volatile 106 escape sequence 17 wchar_t 53 floating point conversion 60 wchar_t underlying 53 function call 73 typedef, function 136 left shift 85 typedef member function call 154 and long 102 modulus zero 63 and short 102 overflow 63 and signed 102 pointer comparison 84, 86 and unsigned 102 pointer to function cast 73 as type declaration 105 pure virtual function call 173 class name 106, 151 string literal concatenation 19 declaration 21 unrepresentable integral value 60 enum name 106 underflow example 105 basic_filebuf 660 overloading and 210 basic_streambuf 626 redefinition 105 basic_stringbuf 651 specifier 105 strstreambuf 707 typedef-name 105 typeid 71 underflow_error type-id 128 underflow_error 352 underflow_error 352 pointer comparison 86 underlying unwinding, stack 294 type, enumeration 111 upper_bound 557 type, wchar_t 53 uppercase 317, 321 underscore uppercase 618 character 321 322 usefacet, locale 417 in identifier _ 14 user-defined unexpected 345 conversion 188 190 unexpected() 299 conversion and name hiding 189 unexpected_handler 323, 345 conversion, implicit 188 unget, basic_istream 638 conversion, inheritance of 191 uninitialized variable, indeterminate 141 conversion, virtual 191 uninitialized_copy 371 using-declaration 115 uninitialized_fill 372 using-directive 120 uninitialized_fill_n 372 usual arithmetic conversions 64 union 54, 158 <utility> 357 access control, anonymous 158 anonymous 158 at namespace scope, anonymous 158 V class versus 149 va_end 322 constructor 158 <valarray> 574 default member access 149 valarray 577, 589 destructor 158 apply 582 global anonymous 158 cshift 582 initialization 146, 158 length 581 member function 158 max 582 restriction 158, 186 min 581 restriction, anonymous 158 operator! 580 type specifier 149 operator!= 584 unique 552 operator% 583 list 478 operator%= 581 unique_copy 552 operator& 583 unit operator&& 583 584 instantiation 10 operator&= 581 translation 320 321 operator* 583 unitbuf 618 operator*= 581 universal-character-name 10 operator+ 580, 583 universal-character-name 10 operator+= 581 unknown argument type 135 operator- 580, 583 unnamed operator-= 581 bit-field 159 operator/ 583 class 106 operator/= 581 object 186 operator< 584 parameter example 141 operator<< 583 unqualified name 29 operator<<= 581 unqualified-id 64 operator<= 584 unrepresentable integral value, undefined 60 unsetf, ios_base 610 operator= 579 unshift, codecvt 426 operator== 584 operator> 584 unsigned operator>= 584 arithmetic 53 operator>> 583 char type 53 operator>>= 581 int type 53 operator[] 580 integer conversion, signed 60 operator^ 583 literal 16 operator^= 581 long type 53 operator| 583 short type 53 operator|= 581 type 53 operator|| 583 584 type specifier 108 operator~ 580 typedef and 102 resize 582 unsigned-suffix 16 shift 582 unspecified 337 339, 341, 388, 555, 581, 651, 705 707 sum 581 address of member function 325 valarray 578 allocation 153, 177 valarray 578 argument to constructor 81 ~valarray 579 behavior 3 ~valarray, valarray 579 constructor and new 81 va_list 322 order of argument evaluation 68 value order of evaluation 44, 63 order of evaluation new 81 call by 67 order of function call evaluation 68 null member pointer 61 null pointer 60 W of char literal, implementation-defined 18 wcerr 603 of enumerator 110 <wchar.h> 701 of multicharacter literal, implementation-defined 17 wchart type-specifier 108 representation 51 wchar_t 17, 19, 318, 407 undefined unrepresentable integral 60 implementation-defined 53 variable type 53 argument list 135 underlying type 53 indeterminate uninitialized 141 wcin 603 parameter list 67, 135 wclog 603 parameter list example 135 wcout 603 <vector> 469 wcschr 407 vector 482 wcspbrk 408 assign 484 wcsrchr 408 capacity 485 wcsstr 408 erase 485 <wctype.h> 701 insert 485 well-formed program 3 operator< 484 wfilebuf 601, 657 operator== 484 wfstream 601 reserve 485 what resize 485 bad_alloc 340 vector 484 bad_cast 342 vector 484 bad_exception 344 vector<bool> 486 bad_typeid 343 operator< 488 exception 344 operator== 488 ios_base::failure 607 vertical tab 17 while statement 95 96 viable function 213 white virtual space 11 base class 164 space 12 base class DAG 165 wide string literal 19 base class dominance 167 wide-character 17 base class initialization 198, 205 string, null-terminated 318 base class initialization, order of 198 widen destructor 192 basic_ios 615 destructor, pure 192 ctype 419 function 168 ctype<char> 424 function access 183 wide-oriented iostream classes 313 function call 172 width, ios_base 418, 610 function call, constructor and 201 wifstream 601, 657 function call, destructor and 201 wios 604 function call, undefined pure 173 wistream 601, 629 function definition 170 wistringstream 601, 649 function definition, pure 172 wmemchr 408 function example 169 170 wofstream 601, 657 function example, pure 172 wostream 601, 629 function, pure 172 member function 322, 325 wostringstream 601, 649 user-defined conversion 191 write, basic_ostream 646 ws 634, 639 virtual wstreambuf 601, 619 and friend 170 wstreamoff 604 and multiple inheritance 170 specifier 105 wstringbuf 601, 649 visibility 29 wstringstream 601 void parameter 135 X type 54 type specifier 108 xalloc, ios_base 611 void& 132 xsgetn, basic_streambuf 626 void* xsputn, basic_streambuf 628 conversion, pointer to member 61 X(X&) ---see copy constructor 186, 203 pointer comparison 86 type 54 volatile 55 Z constructor and 156, 185 zero destructor and 156, 191 pointer 60 implementation-defined 108 undefined division by 63, 84 member function 155 undefined modulus 63 overloading and 210 type 106 width of bit-field 159 type specifier 108 zero-initialization 141 ICS 35.060 Descriptors: data processing, computer software, artificial languages, programming languages, C (programming language), implementation. Price based on 732 pages