ILE C/C++ Language Reference


Index

Special characters
A B C D E F G H I K L M N O P Q R S T U V W
Special characters
  • ! (logical negation operator) (2827)
  • != (not equal to operator) (2911)
  • # preprocessor directive character (3180)
  • # preprocessor operator (3206)
  • ## (macro concatenation) (3211)
  • $ (2428)
  • % (remainder) (2882)
  • . (dot operator) (2790)
  • :: (scope resolution operator) (2767)
  • & (address operator) (2834)
  • & (bitwise AND operator) (2917)
  • & (reference declarator) (2729)
  • && (logical AND operator) (2926)
  • &= (compound assignment operator) (2960)
  • > (greater than operator) (2898)
  • >> (right-shift operator) (2891)
  • >>= (compound assignment operator) (2958)
  • >= (greater than or equal to operator) (2900)
  • < (less than operator) (2897)
  • << (left-shift operator) (2890)
  • <<= (compound assignment operator) (2959)
  • <= (less than or equal to operator) (2899)
  • * (indirection operator) (2838)
  • * (multiplication operator) (2873)
  • *= (compound assignment operator) (2956)
  • + (addition operator) (2884)
  • + (unary plus operator) (2822)
  • ++ (increment operator) (2811)
  • += (compound assignment operator) (2955)
  • , (comma operator) (2965)
  • - (subtraction operator) (2888)
  • - (unary minus operator) (2825)
  • -- (decrement operator) (2816)
  • -> (arrow operator) (2793)
  • / (division operator) (2876)
  • /= (compound assignment operator) (2957)
  • = (simple assignment operator) (2950)
  • == (equal to operator) (2910)
  • ? : (conditional operators) (2941)
  • [ ] (array subscript operator) (2784)
  • \ continuation character (2512), (3186)
  • \ escape character (2432)
  • ^ (bitwise exclusive OR operator) (2920)
  • ^= (compound assignment operator) (2961)
  • _Decimal (2475), (2595)
  • _Packed (2476)
  • __align (2471), (2518)
  • __alignof (2470)
  • __cdecl (3123)
  • __ptr128 (2472), (2685)
  • __ptr64 (2473), (2687)
  • __VA_ARGS__ identifier (3197)
  • | (bitwise inclusive OR operator) (2924)
  • || (logical OR operator) (2932)
  • ~ (bitwise negation operator) (2832)
  • A
  • aborting functions (3704)
  • abstract classes (3512), (3523)
  • access rules
  • base classes (3452)
  • class types (3304), (3411)
  • friends (3424)
  • members (3405)
  • multiple access (3479)
  • protected members (3449)
  • virtual functions (3520)
  • access specifiers (3354), (3410), (3439), (3440), (3464)
  • in class derivations (3454)
  • accessibility (3409), (3482)
  • addition operator (+) (2885)
  • address operator (&) (2704), (2835)
  • lvalue cast (2869)
  • aggregate types (2553), (3537)
  • initialization (2636), (3538)
  • alias (2731)
  • alignment
  • bit fields (2643), (2644)
  • structure members (2634)
  • structures and unions (2516)
  • allocation
  • expressions (2850)
  • functions (3119)
  • ambiguities
  • base and derived member names (3484)
  • base classes (3474)
  • resolving (3136), (3489)
  • virtual function calls (3513)
  • AND operator, bitwise (&) (2918)
  • AND operator, logical (&&) (2927)
  • argc (argument count) (3086)
  • example (3090)
  • arguments
  • default (3105)
  • evaluation (3109)
  • macro (3196)
  • main function (3085)
  • of catch blocks (3670)
  • passing (3034), (3092)
  • passing by reference (3101)
  • passing by value (3099)
  • trailing (3199)
  • argv (argument vector) (3087)
  • example (3091)
  • arithmetic conversions (3017)
  • arithmetic types (2575)
  • type compatibility (2567)
  • arrays
  • array-to-pointer conversions (3002)
  • as function parameter (2714)
  • declaration (2715), (3359)
  • description (2707)
  • initializing (2722)
  • multidimensional (2717)
  • subscripting operator (2783)
  • type compatibility (2712)
  • ASCII character codes (2444)
  • asm (2461), (2688)
  • assignment operator (=)
  • compound (2954)
  • pointers (2701)
  • simple (2949)
  • associativity of operators (2741)
  • atexit function (3703)
  • auto storage class specifier (2524)
  • B
  • base classes
  • abstract (3524)
  • access rules (3453)
  • ambiguities (3475), (3483)
  • direct (3469)
  • indirect (3432), (3473)
  • initialization (3541)
  • multiple access (3481)
  • pointers to (3446)
  • virtual (3476), (3495)
  • base list (3471)
  • best viable function (3290)
  • binary expressions and operators (2870)
  • binding (2734)
  • direct (2735)
  • dynamic (3502)
  • static (3501)
  • virtual functions (3500)
  • bit fields (2640)
  • as structure member (2626)
  • bitwise negation operator (~) (2831)
  • block statement (3141)
  • block visibility (2385)
  • boolean
  • conversions (2982)
  • literals (2482)
  • variables (2577)
  • break statement (3162)
  • C
  • candidate functions (3273), (3289)
  • case label (3151)
  • cast expressions (2863)
  • catch blocks (3068), (3646), (3661)
  • argument matching (3672)
  • order of catching (3677)
  • char type specifier (2580)
  • character
  • data types (2586)
  • literals (2500)
  • multibyte (2449)
  • character set
  • extended (2451)
  • source (2425)
  • class members
  • access operators (2788)
  • access rules (3407)
  • class member list (3349)
  • declaration (3355)
  • initialization (3542)
  • order of allocation (3356)
  • class templates
  • declaration and definition (3589)
  • distinction from template class (3587)
  • explicit specialization (3627)
  • member functions (3594)
  • static data members (3591)
  • classes (3320)
  • abstract (3522)
  • access rules (3406)
  • aggregate (3316)
  • base (3437)
  • base list (3438)
  • class objects (2520), (2521)
  • class specifiers (3310)
  • class templates (3586)
  • declarations (3308)
  • incomplete (3330), (3360)
  • derived (3436)
  • friends (3415)
  • inheritance (3426)
  • keywords (3301)
  • local (3340)
  • member functions (3363)
  • member lists (3350)
  • member scope (3383)
  • nested (3332), (3421)
  • overview (3300)
  • polymorphic (3306)
  • scope of names (3322)
  • static members (3398)
  • this pointer (3394)
  • using declaration (3460)
  • virtual (3478), (3499)
  • Classic C (2371)
  • comma (2967)
  • comments (2452)
  • compatible types
  • across source files (2568)
  • arithmetic types (2566)
  • arrays (2711)
  • in conditional expressions (2945)
  • composite types (2564)
  • across source files (2572)
  • compound
  • assignment (2953)
  • expression (2963)
  • statement (3142)
  • types (2616)
  • concatenation
  • macros (3214)
  • conditional compilation directives (3234)
  • elif preprocessor directive (3237)
  • else preprocessor directive (3247)
  • endif preprocessor directive (3249)
  • examples (3250)
  • if preprocessor directive (3238)
  • ifdef preprocessor directive (3243)
  • ifndef preprocessor directive (3245)
  • conditional expression (? :) (2942), (2964)
  • const (2675)
  • casting away constness (3102)
  • member functions (3372)
  • object (2748)
  • placement in type name (2561)
  • qualifier (2673)
  • vs. #define (3190)
  • constant expressions (2654), (2760)
  • constant initializers (3352)
  • constructors (3531)
  • converting (3019), (3561)
  • copy (3566)
  • default (3532)
  • exception handling (3685)
  • initialization
  • explicit (3536)
  • initializer list (3072)
  • nontrivial (3535), (3547)
  • overview (3529)
  • trivial (3534), (3546)
  • const_cast (2803), (3103)
  • continuation character (2511), (3185)
  • continue statement (3164)
  • conversion
  • constructors (3560)
  • function (3564)
  • implicit conversion sequences (3292)
  • conversion sequence
  • ellipsis (3298)
  • implicit (3291)
  • standard (3293)
  • user-defined (3296)
  • conversions
  • argument expressions (3095)
  • arithmetic (3016)
  • array-to-pointer (3003)
  • boolean (2984)
  • cast (2865)
  • derived-to-base (3000)
  • explicit keyword (3020)
  • floating-point (2989)
  • function arguments (3014)
  • function-to-pointer (3005)
  • integral (2987)
  • lvalue-to-rvalue (2752), (2981), (3295)
  • pointer (2991)
  • pointer to derived class (3492)
  • pointer to member (3010)
  • qualification (3012)
  • references (3007)
  • standard (2979)
  • user-defined (3559)
  • void pointer (2999)
  • copy assignment operators (3568)
  • copy constructors (3567)
  • covariant virtual functions (3506)
  • CPLUSPLUS macro (3230)
  • cv-qualifier (2628), (2668), (2691)
  • in function definition (3064)
  • syntax (2674)
  • D
  • data members
  • description (3357)
  • scope (3384)
  • static (3400)
  • DATE macro (3218)
  • deallocation
  • expressions (2861)
  • functions (3120)
  • decimal integer literals (2488)
  • declarations
  • classes (3309), (3329)
  • description (2513)
  • friend specifier in member list (3416)
  • friends (3425)
  • pointers to members (3387)
  • resolving ambiguous statements (3138)
  • syntax (2515), (2556)
  • unsubscripted arrays (2721)
  • declarative region (2380)
  • declarators
  • description (2690)
  • reference (2728)
  • decrement operator (--) (2817)
  • default
  • clause (3150), (3154)
  • constructors (3533)
  • label (3153)
  • define preprocessor directive (3187)
  • defined unary operator (3240)
  • definitions
  • description (2514)
  • macro (3188)
  • member function (3367)
  • delete operator (2860)
  • dependent names (3634)
  • dereferencing operator (2840)
  • derivation (3435)
  • array type (2710)
  • public, protected, private (3451)
  • derived classes
  • catch block (3676)
  • construction order (3544)
  • pointers to (3445)
  • destructors (3545)
  • exception handling (3686)
  • overview (3530)
  • pseudo (2791), (3548)
  • digraph (2479)
  • direct base class (3470)
  • division operator (/) (2877)
  • do statement (3158)
  • dollar sign (2429)
  • dot operator (2786)
  • double type specifier (2590)
  • downcast (2806)
  • dynamic binding (3504)
  • dynamic_cast (2805)
  • E
  • EBCDIC character codes (2445)
  • elaborated type specifier (3328)
  • elif preprocessor directive (3236)
  • ellipsis
  • conversion sequence (3297)
  • in function declaration (3046)
  • in function definition (3078)
  • in macro argument list (3200)
  • else
  • preprocessor directive (3246)
  • statement (3146)
  • enclosing class (3365), (3419)
  • endif preprocessor directive (3248)
  • entry point
  • program (3083)
  • enum
  • keyword (2660), (2665)
  • enumerations (2653)
  • compatibility (2571), (2658)
  • declaration (2659)
  • initialization (2664)
  • enumerator (2662)
  • equal to operator (==) (2912)
  • error preprocessor directive (3215)
  • escape character \ (2431)
  • escape sequence (2430)
  • alarm \a (2433)
  • backslash \\ (2443)
  • backspace \b (2434)
  • carriage return \r (2437)
  • double quotation mark \" (2441)
  • form feed \f (2435)
  • horizontal tab \t (2438)
  • new-line \n (2436)
  • question mark \? (2442)
  • single quotation mark \' (2440)
  • vertical tab \v (2439)
  • exception handling (3642)
  • argument matching (3674)
  • catch blocks (3664)
  • arguments (3669)
  • constructors (3687)
  • destructors (3688)
  • example, C++ (3711)
  • exception objects (3650)
  • function try blocks (3653)
  • handlers (3651), (3663)
  • order of catching (3675)
  • rethrowing exceptions (3682)
  • set_terminate (3705)
  • set_unexpected (3706)
  • special functions (3693)
  • stack unwinding (3689)
  • terminate function (3700)
  • throw expressions (3659), (3680)
  • try blocks (3652)
  • try exceptions (3666)
  • unexpected function (3697)
  • exceptions
  • declaration (3665)
  • function try block handlers (3667)
  • specification (3065), (3692)
  • exclusive OR operator, bitwise (^) (2921)
  • explicit
  • function specifier (2726)
  • instantiation, templates (3613)
  • keyword (3018), (3562)
  • specializations, templates (3617), (3619)
  • type conversions (2867)
  • exponent (2498)
  • expressions
  • allocation (2851)
  • assignment (2947)
  • binary (2872)
  • cast (2864)
  • comma (2968)
  • conditional (2944)
  • deallocation (2862)
  • description (2736)
  • full (2739)
  • integer constant (2762)
  • new initializer (2854)
  • parenthesized (2763)
  • pointer to member (2937)
  • primary (2756)
  • resolving ambiguous statements (3139)
  • statement (3134)
  • throw (2971), (3679)
  • unary (2809)
  • extern storage class specifier (2408), (2417), (2529)
  • implicit declaration (2781)
  • with function pointers (3125)
  • F
  • file inclusion (3217)
  • FILE macro (3220)
  • file scope data declarations
  • unsubscripted arrays (2720)
  • float type specifier (2589)
  • floating-point
  • conversion (2988)
  • literal (2496)
  • promotion (2976)
  • for statement (3160)
  • free store (3549)
  • delete operator (2859)
  • new operator (2848)
  • friend
  • access rules (3423)
  • implicit conversion of pointers (3458)
  • member functions (3364)
  • nested classes (3420)
  • relationships with classes when templates are involved (3596)
  • scope (3418)
  • specifier (3413)
  • virtual functions (3508)
  • function designator (2753)
  • function specifier
  • explicit (3021), (3563)
  • function templates
  • explicit specialization (3625)
  • function try blocks (3067), (3648), (3656)
  • handlers (3668)
  • function-like macro (3194)
  • functions (3022)
  • allocation (3117)
  • arguments (2778), (3031), (3041)
  • conversions (3013)
  • block (3029)
  • body (3028)
  • C++ enhancements (3036)
  • calling (3093)
  • calls (2777)
  • as lvalue (2754)
  • class templates (3593)
  • conversion function (3565)
  • deallocation (3118)
  • declaration (3026), (3037), (3038)
  • C++ (3047)
  • examples (3051)
  • exception specification (3045)
  • multiple (3048)
  • parameter names (3050)
  • default arguments (3104)
  • evaluation (3108)
  • restrictions (3106)
  • definition (3030), (3039), (3052)
  • constructor initializer list (3073)
  • declarator (3053)
  • examples (3081)
  • exception specification (3066)
  • return type (3059)
  • scope (3055)
  • storage class specifier (3056)
  • try block (3070)
  • type specifiers (3060)
  • exception handling (3694)
  • exception specification (3691)
  • friends (3414)
  • function call operator (3032)
  • function templates (3597)
  • function-to-pointer conversions (3004)
  • inline (3126), (3368)
  • library functions (3023)
  • main (3084)
  • name (3040), (3061)
  • overloading (3272)
  • parameters (2779), (3042), (3094)
  • pointers to (3121)
  • polymorphic (3434)
  • prototype (3027), (3044)
  • return statements (3167)
  • return type (3025), (3076), (3111), (3116)
  • return value (3024), (3110)
  • signature (3035)
  • specifiers (2723), (3129)
  • template function
  • template argument deduction (3599)
  • type name (2560)
  • virtual (3374), (3498), (3515)
  • fundamental type (2576)
  • G
  • global variable (2393), (2410)
  • uninitialized (2532)
  • goto statement (3169)
  • restrictions (3171)
  • greater than operator (>) (2902)
  • greater than or equal to operator (>=) (2904)
  • H
  • handlers (3662)
  • hexadecimal integer literals (2490)
  • hidden names (3319), (3325)
  • I
  • identifiers (2454), (2757)
  • case sensitivity (2458)
  • id-expression (2693), (2759)
  • labels (3133)
  • linkage (2407)
  • name space (2398)
  • reserved (2457), (2462), (2467)
  • special characters (2427), (2459)
  • if
  • preprocessor directive (3239)
  • statement (3145)
  • ifdef preprocessor directive (3242)
  • ifndef preprocessor directive (3244)
  • implementation dependency
  • allocation of floating-point types (2592)
  • allocation of integral types (2614)
  • implicit conversion (2974)
  • boolean (2983)
  • lvalue (2750)
  • pointer to derived class (3444), (3457)
  • pointers to base class (3447)
  • types (2972)
  • implicit instantiation
  • templates (3611)
  • include preprocessor directive (3216)
  • inclusive OR operator, bitwise (|) (2923)
  • incomplete type (2689), (2709)
  • as structure member (2627)
  • class declaration (3331)
  • increment operator (++) (2812)
  • indentation of code (3183)
  • indirect base class (3431), (3472)
  • indirection operator (*) (2705), (2839)
  • information hiding (2381), (2388), (3348), (3448)
  • inheritance
  • multiple (3430), (3467)
  • overview (3427), (3428)
  • initialization
  • aggregate types (2639)
  • auto object (2526)
  • base classes (3539)
  • class members (3540)
  • extern object (2531)
  • references (3008)
  • register object (2539)
  • static data members (3402)
  • static object (2546)
  • union member (2647)
  • initializer lists (3071)
  • initializers (2694)
  • aggregate types (2638)
  • enumerations (2663)
  • initializer list (2695), (3543)
  • unions (2648)
  • inline
  • function specifier (2724)
  • functions (3127), (3369)
  • integer
  • constant expressions (2655), (2761)
  • conversion (2986)
  • conversions (2985)
  • data types (2611)
  • implicit int (3075)
  • literals (2484)
  • promotion (2975)
  • K
  • K&R C (2372)
  • keywords (2460)
  • exception handling (3649)
  • language extension (2463)
  • template (3573), (3638), (3641)
  • underscore characters (2464)
  • L
  • label
  • implicit declaration (2390)
  • in switch statement (3152)
  • statement (3131)
  • language extension (2466)
  • iSeries (2683)
  • left-shift operator (<<) (2892)
  • less than operator (<) (2901)
  • less than or equal to operator (<=) (2903)
  • LINE macro (3222)
  • line preprocessor directive (3251)
  • linkage (2377), (2404)
  • auto storage class specifier (2528)
  • const cv-qualifier (2677)
  • extern storage class specifier (2416), (2534)
  • external (2406), (2780)
  • in function definition (3058), (3074)
  • inline member functions (3370)
  • internal (2405), (2544)
  • language (2414)
  • multiple function declarations (3049)
  • none (2411)
  • register storage class specifier (2541)
  • specifications (2412)
  • static storage class specifier (2547)
  • with function pointers (3124)
  • linking to non-C++ programs (2413)
  • literals (2480)
  • boolean (2481)
  • character (2504)
  • floating-point (2495)
  • integer (2483)
  • data types (2486)
  • decimal (2487)
  • hexadecimal (2489)
  • octal (2492)
  • string (2507)
  • local
  • classes (3341)
  • type names (3344)
  • logical operators
  • ! (logical negation) (2828)
  • && (logical AND) (2928)
  • || (logical OR) (2931)
  • long double type specifier (2591)
  • long long type specifier (2613)
  • long type specifier (2603)
  • lvalues (2669), (2745), (2758)
  • casting (2868)
  • conversions (2751), (2980), (3294)
  • M
  • macro
  • definition (3189)
  • function-like (3193)
  • invocation (3195)
  • object-like (3192)
  • variable argument (3198)
  • main function (3082)
  • arguments (3088)
  • example (3089)
  • member functions
  • const and volatile (3371)
  • definition (3366)
  • friend (3361)
  • special (3380)
  • static (3403)
  • this pointer (3395), (3519)
  • member lists (3313), (3351)
  • members
  • access (3408)
  • access control (3466)
  • class member access operators (2789)
  • data (3358)
  • pointers to (2940), (3388)
  • protected (3450)
  • scope (3382)
  • static (3339), (3396)
  • virtual functions (3376)
  • modifiable lvalue (2749), (2948), (2952)
  • modulo operator (%) (2881)
  • multibyte character (2450)
  • multicharacter literal (2503)
  • multidimensional arrays (2718)
  • multiple
  • access (3480)
  • inheritance (3429), (3468)
  • multiplication operator (*) (2874)
  • mutable storage class specifier (2535)
  • N
  • name binding (3632)
  • name hiding (2402), (2768)
  • accessible base class (3493)
  • ambiguities (3487)
  • name space
  • class names (3324)
  • context (2401)
  • of identifiers (2397)
  • names
  • conflicts (2396)
  • hidden (2769), (3318), (3326)
  • local type (3343)
  • mangling (2415)
  • resolution (2386), (3461), (3490)
  • namespaces (3254)
  • alias (3257), (3258)
  • declaring (3256)
  • defining (3255)
  • explicit access (3269)
  • extending (3259)
  • friends (3264)
  • member definitions (3263)
  • overloading (3260)
  • unnamed (3261)
  • user-defined (2382)
  • using declaration (3267)
  • using directive (3265)
  • narrow character literal (2502)
  • nested classes
  • friend scope (3422)
  • scope (3333)
  • new operator
  • default arguments (3107)
  • description (2849)
  • initializer expression (2855)
  • placement syntax (2853), (3552), (3554)
  • set_new_handler function (2856)
  • not equal to operator (!=) (2913)
  • null
  • character \0 (2510)
  • pointer (2702)
  • pointer constants (3001)
  • preprocessor directive (3252)
  • statement (3173)
  • number sign (#)
  • preprocessor directive character (3178)
  • preprocessor operator (3204)
  • O
  • object-like macro (3191)
  • objects (2747)
  • class
  • declarations (3317)
  • description (2519)
  • lifetime (2376)
  • octal integer literals (2493)
  • one's complement operator (~) (2830)
  • operator functions (3277)
  • operators (2421)
  • ! (logical negation) (2829)
  • != (not equal to) (2916)
  • % (remainder) (2883)
  • . (dot) (2787)
  • .* (pointer to member) (2934)
  • :: (scope resolution) (2766)
  • & (address) (2836)
  • & (bitwise AND) (2919)
  • && (logical AND) (2929)
  • > (greater than) (2906)
  • >> (right- shift) (2896)
  • >= (greater than or equal to) (2908)
  • < (less than) (2905)
  • << (left- shift) (2895)
  • <= (less than or equal to) (2907)
  • () (function call) (2776), (3033)
  • * (indirection) (2841)
  • * (multiplication) (2875)
  • + (addition) (2886)
  • ++ (increment) (2813)
  • , (comma) (2966)
  • - (subtraction) (2889)
  • - (unary minus) (2826)
  • -- (decrement) (2818)
  • -> (arrow) (2794)
  • ->* (pointer to member) (2935)
  • / (division) (2878)
  • = (simple assignment) (2951)
  • == (equal to) (2915)
  • ? : (conditional) (2943)
  • alignof (2469)
  • alternative representations (2422), (2478)
  • assignment (2946)
  • copy assignment (3569)
  • associativity (2742)
  • binary (2871)
  • bitwise negation operator (~) (2833)
  • compound assignment (2962)
  • const_cast (2802)
  • defined (3241)
  • delete (2858), (3556)
  • dynamic_cast (2804)
  • equality (2914)
  • expressions (2774)
  • new (2847), (3551)
  • operators (2775)
  • overloading (3276), (3362)
  • binary (3283)
  • unary (3279)
  • pointer to member (2938), (3391)
  • precedence (2743)
  • examples (2744)
  • type names (2558)
  • preprocessor
  • # (3207)
  • ## (3210)
  • reinterpret_cast (2800)
  • relational (2909)
  • scope resolution (3443), (3486), (3510)
  • sizeof (2845)
  • static_cast (2798)
  • typeid (2795)
  • unary (2810)
  • unary plus operator (+) (2823)
  • [] (array subscripting) (2785)
  • ^ (bitwise exclusive OR) (2922)
  • | (bitwise inclusive OR) (2925)
  • || (logical OR) (2933)
  • OR operator, logical (||) (2930)
  • overload resolution (3288), (3496)
  • resolving addresses of overloaded functions (3299)
  • overloading
  • delete operator (3555)
  • description (3270)
  • function templates (3606)
  • functions (3271), (3463)
  • restrictions (3274)
  • new operator (3550)
  • operators (3275), (3307)
  • assignment (3284)
  • binary (3282)
  • class member access (3287)
  • decrement (3280)
  • function call (3285)
  • increment (3281)
  • subscripting (3286)
  • unary (3278)
  • overriding virtual functions (3516)
  • covariant virtual function (3507)
  • P
  • packed
  • structure member (2642)
  • packed decimal
  • data type (2474), (2593)
  • literal (2499)
  • parenthesized expressions (2557), (2764)
  • pass by reference (2730), (3100)
  • pass by value (3098)
  • placement syntax (2852), (3553)
  • pointer to member
  • conversions (3009)
  • declarations (3385)
  • operators (2936), (3390)
  • pointers
  • compatible (2698)
  • const (2678)
  • conversions (2990), (2995), (3491)
  • cv-qualified (2700)
  • description (2696)
  • generic (2996)
  • iSeries (2994), (3015)
  • null (2703)
  • pointer arithmetic (2706)
  • this (3393)
  • to functions (3122)
  • to members (2939), (3386)
  • type-qualified (2699)
  • void* (2992)
  • polymorphism
  • polymorphic classes (3305), (3505)
  • polymorphic functions (3433)
  • postfix
  • ++ and -- (2814), (2819)
  • expression (2772)
  • operator (2773)
  • pound sign (#)
  • preprocessor directive character (3179)
  • preprocessor operator (3205)
  • pragmas
  • preprocessor directive (3253)
  • precedence of operators (2740)
  • predefined macros
  • CPLUSPLUS (3231)
  • DATE (3219)
  • FILE (3221)
  • LINE (3223)
  • STDC (3225)
  • STDC_VERSION (3227)
  • TIME (3229)
  • __IBMCPP__ (3233)
  • __IBMC__ (3232)
  • prefix
  • ++ and -- (2815), (2820)
  • hexadecimal integer literals (2491)
  • octal integer literals (2494)
  • preprocessor directives (3174)
  • conditional compilation (3235)
  • preprocessing overview (3175)
  • special character (3181)
  • preprocessor operator
  • # (3203)
  • ## (3212)
  • primary expressions (2755)
  • promotions
  • function argument values (3096)
  • integral and floating-point (2977)
  • prototype (3043)
  • pseudo-destructors (2792)
  • punctuators (2420)
  • alternative representations (2423), (2477)
  • pure specifier (3353), (3377), (3511), (3526), (3528)
  • pure virtual functions (3527)
  • Q
  • qualification conversions (3011)
  • qualified name (2770), (3336)
  • qualifiers
  • const (2672), (3062)
  • iSeries (2468), (2684), (2686)
  • volatile (2670), (2680), (3063)
  • R
  • references
  • as return types (3114)
  • binding (2733)
  • conversions (3006)
  • declarator (2837)
  • description (2727)
  • initialization (2732)
  • register storage class specifier (2537)
  • reinterpret_cast (2801)
  • remainder operator (%) (2880)
  • return statement (3113), (3166)
  • value (3168)
  • return type
  • reference as (3115)
  • size_t (2844)
  • right-shift operator (>>) (2893)
  • RTTI support (2797)
  • rvalues (2746)
  • S
  • scalar types (2551), (2697)
  • scope (2373)
  • class (2395)
  • class names (3323)
  • description (2379)
  • enclosing and nested (2387)
  • friends (3417)
  • function (2389)
  • function prototype (2391)
  • global (2392)
  • global namespace (2394)
  • identifiers (2399)
  • local (block) (2383)
  • local classes (3342)
  • macro names (3202)
  • member (3381)
  • nested classes (3334)
  • scope resolution operator
  • ambiguous base classes (3485)
  • description (2765)
  • inheritance (3442)
  • virtual functions (3509)
  • sequence point (2738), (2969)
  • set_new_handler function (2857)
  • set_terminate function (3710)
  • set_unexpected function (3699), (3709)
  • shift operators << and >> (2894)
  • short type specifier (2602)
  • side effect (2682), (2737)
  • signed type specifiers
  • char (2585)
  • int (2608)
  • long (2609)
  • long long (2610)
  • simple type specifiers (2573)
  • char (2578)
  • wchar_t (2579)
  • sizeof operator (2842)
  • size_t (2843)
  • space character (3184)
  • special characters (2426)
  • special member functions (3379)
  • specifiers
  • access control (3455)
  • inline (3128)
  • pure (3378)
  • storage class (2523)
  • splice preprocessor directive ## (3213)
  • stack unwinding (3690)
  • Standard C (2370)
  • Standard C++ (2369)
  • standard type conversions (2973), (2978)
  • statements (3130)
  • block (3140)
  • break (3161)
  • continue (3163)
  • do (3157)
  • expressions (3135)
  • for (3159)
  • goto (3170)
  • if (3143)
  • labels (3132)
  • null (3172)
  • resolving ambiguities (3137)
  • return (3112), (3165)
  • selection (3144), (3149)
  • switch (3148)
  • while (3155)
  • static
  • binding (3503)
  • data members (3399)
  • initialization of data members (3401)
  • member functions (3404)
  • members (3338), (3397)
  • storage class specifier (2542)
  • linkage (2548)
  • static storage class specifier (2409)
  • static_cast (2799)
  • STDC macro (3224)
  • STDC_VERSION macro (3226)
  • storage class specifiers (2522), (3057)
  • auto (2525)
  • extern (2530)
  • mutable (2536)
  • register (2538)
  • static (2543)
  • storage duration (2375)
  • auto storage class specifier (2527)
  • extern storage class specifier (2533)
  • register storage class specifier (2540)
  • static (2545)
  • string
  • literal (2508)
  • terminator (2509)
  • stringize preprocessor directive # (3208)
  • struct type specifier (2623)
  • structures (2618), (3321)
  • alignment (2517)
  • as base class (3456)
  • as class type (3303), (3314)
  • compatibility (2569), (2619)
  • identifier (tag) (2621)
  • initialization (2637)
  • members (2625)
  • alignment (2633)
  • layout in memory (2630), (2635)
  • packed (2641)
  • padding (2631)
  • name spaces within (2400)
  • packed (2632)
  • subscript declarator
  • in arrays (2716)
  • subscripting operator (2708), (2782)
  • in type name (2559)
  • subtraction operator (-) (2887)
  • suffix
  • floating-point literals (2497)
  • integer literal constants (2485)
  • switch statement (3147)
  • T
  • tags
  • enumeration (2657), (2661)
  • structure (2620), (2622), (2624)
  • union (2651)
  • template arguments (3579)
  • deduction (3600)
  • deduction, non-type (3604)
  • deduction, type (3602)
  • non-type (3583)
  • template (3584)
  • type (3581)
  • template keyword (3640)
  • templates
  • arguments
  • non-type (3582)
  • type (3580)
  • class
  • declaration and definition (3588)
  • distinction from template class (3585)
  • explicit specialization (3626)
  • member functions (3592)
  • static data members (3590)
  • declaration (3570)
  • dependent names (3633)
  • explicit specializations (3616), (3621)
  • class members (3623)
  • declaration (3618)
  • definition and declaration (3620)
  • function templates (3624)
  • function
  • argument deduction (3603)
  • overloading (3605)
  • partial ordering (3607)
  • function templates (3598)
  • type template argument deduction (3601)
  • instantiation (3571), (3608), (3615)
  • explicit (3612)
  • implicit (3610)
  • name binding (3631)
  • parameters (3574)
  • default arguments (3578)
  • non-type (3576)
  • template (3577)
  • type (3575)
  • partial specialization (3628)
  • matching (3630)
  • parameter and argument lists (3629)
  • point of definition (3635)
  • point of instantiation (3636)
  • relationship between classes and their friends (3595)
  • scope (3622)
  • specialization (3572), (3609), (3614)
  • temporary objects (3557), (3671)
  • terminate function (3643), (3660), (3678), (3684), (3696) , (3701)
  • set_terminate (3707)
  • this pointer (2679), (3392), (3518)
  • throw expressions (2970), (3647), (3681)
  • argument matching (3673)
  • rethrowing exceptions (3683)
  • within nested try blocks (3657)
  • TIME macro (3228)
  • tokens (2418), (3176)
  • alternative representations for operators and punctuators (2424)
  • translation unit (2378)
  • trigraph sequences (2448)
  • truncation
  • integer division (2879)
  • try blocks (3645), (3655)
  • in function definition (3069)
  • nested (3658)
  • try keyword (3654)
  • type name (2555)
  • local (3345)
  • qualified (2771), (3337)
  • typename keyword (3639)
  • type qualifiers
  • const (2667), (2676)
  • const and volatile (2692)
  • in structure member definition (2629)
  • volatile (2666)
  • type specifier (2550)
  • (long) double (2588)
  • char (2582)
  • class types (3311)
  • elaborated (3327)
  • enumeration (2652)
  • float (2587)
  • in function definition (3054)
  • int (2596)
  • long (2598)
  • long long (2600)
  • short (2597)
  • simple (2574)
  • unsigned (2599)
  • wchar_t (2583), (2601)
  • typedef specifier (2549)
  • and type compatibility (2565)
  • class declaration (3346)
  • local type names (3347)
  • pointers to members (3389)
  • qualified type name (3335)
  • typeid operator (2796)
  • typename keyword (3637)
  • types
  • aggregates (2554)
  • class (3312)
  • compatible (2562)
  • composite (2563)
  • compound (2617)
  • conversions (2866)
  • enumerated (2656)
  • packed decimal (2594)
  • scalar (2552)
  • U
  • unary expressions (2807)
  • unary operators (2808)
  • minus (-) (2824)
  • plus (+) (2821)
  • undef preprocessor directive (3201)
  • underscore character (2456), (2465)
  • unexpected function (3644), (3695), (3698), (3702)
  • set_unexpected (3708)
  • Unicode (2446)
  • unions (2645)
  • as class type (3302), (3315)
  • compatibility (2570), (2649)
  • initialization (2646)
  • specifier (2650)
  • universal character name (2447), (2455), (2505)
  • unnamed namespaces (3262)
  • unsigned type specifiers
  • char (2584)
  • int (2604)
  • long (2606)
  • long long (2607)
  • short (2605)
  • unsubscripted arrays
  • description (2713), (2719)
  • user-defined conversions (3558)
  • using declarations (3268), (3459), (3488)
  • changing member access (3465)
  • overloading member functions (3462)
  • using directive (3266)
  • V
  • variable length array
  • sizeof (2846)
  • variably modified types
  • size evaluation (3097)
  • virtual
  • base classes (3441), (3477), (3494)
  • function specifier (2725)
  • virtual functions (3375), (3497)
  • access (3521)
  • ambiguous calls (3514)
  • overriding (3517)
  • pure specifier (3525)
  • visibility (2374), (2403)
  • block (2384)
  • class members (3412)
  • void (2615)
  • argument type (3080)
  • in function definition (3077), (3079)
  • pointer (2993), (2997), (2998)
  • volatile
  • member functions (3373)
  • qualifier (2671), (2681)
  • W
  • wchar_t type specifier (2506), (2581), (2612)
  • while statement (3156)
  • white space (2419), (2453), (3177), (3182), (3209)
  • wide characters
  • literals (2501)

  • [ Top of Page | Previous Page | Table of Contents | Index ]