Table of Contents
v
14.3 Implicit conversions ............................................................................................................................ 65
1
14.3.1 Implicit constant expression conversions ..................................................................................... 65 2
14.3.2 User-defined implicit conversions ................................................................................................ 65 3
14.3.3 Boolean Equivalence .................................................................................................................... 65 4
14.4 Explicit conversions ............................................................................................................................ 66 5
14.5 User-defined conversions .................................................................................................................... 66 6
14.5.1 Constructors.................................................................................................................................. 66 7
14.5.2 Explicit conversion functions ....................................................................................................... 66 8
14.5.3 Static conversion functions........................................................................................................... 66 9
14.6 Parameter array conversions................................................................................................................ 67 10
14.7 Naming conventions............................................................................................................................ 67 11
15. Expressions .............................................................................................................................................. 69 12
15.1 Function members ............................................................................................................................... 69 13
15.2 Primary expressions............................................................................................................................. 70 14
15.3 Postfix expressions .............................................................................................................................. 70 15
15.3.1 Subscripting and indexed access................................................................................................... 71 16
15.3.2 Function call ................................................................................................................................. 71 17
15.3.3 Explicit type conversion (functional notation).............................................................................. 71 18
15.3.4 Class member access..................................................................................................................... 72 19
15.3.5 Increment and decrement.............................................................................................................. 72 20
15.3.6 Dynamic cast................................................................................................................................. 72 21
15.3.7 Type identification........................................................................................................................ 73 22
15.3.8 Static cast ...................................................................................................................................... 74 23
15.3.9 Reinterpret cast ............................................................................................................................. 75 24
15.3.10 Const cast.................................................................................................................................... 75 25
15.3.11 Safe cast ...................................................................................................................................... 75 26
15.4 Unary expressions ............................................................................................................................... 76 27
15.4.1 Unary operators............................................................................................................................. 76 28
15.4.2 Increment and decrement.............................................................................................................. 79 29
15.4.3 Sizeof ............................................................................................................................................ 79 30
15.4.4 New............................................................................................................................................... 79 31
15.4.5 Delete............................................................................................................................................ 79 32
15.4.6 The gcnew operator....................................................................................................................... 80 33
15.5 Explicit type conversion (cast notation) .............................................................................................. 80 34
15.6 Additive operators ............................................................................................................................... 81 35
15.6.1 Delegate combination ................................................................................................................... 81 36
15.6.2 Delegate removal .......................................................................................................................... 81 37
15.6.3 String concatenation...................................................................................................................... 81 38
15.7 Shift operators ..................................................................................................................................... 82 39
15.8 Relational operators............................................................................................................................. 82 40
15.8.1 Handle equality operators ............................................................................................................. 82 41
15.8.2 Delegate equality operators........................................................................................................... 83 42
15.8.3 String equality............................................................................................................................... 83 43
15.9 Logical AND operator......................................................................................................................... 83 44
15.10 Logical OR operator .......................................................................................................................... 84 45
15.11 Conditional operator.......................................................................................................................... 84 46
15.12 Assignment operators ........................................................................................................................ 84 47
15.13 Constant expressions ......................................................................................................................... 84 48
15.14 Property and event rewrite rules........................................................................................................ 85 49
16. Statements................................................................................................................................................ 88 50
16.1 Selection statements ............................................................................................................................ 88 51
16.1.1 The switch statement..................................................................................................................... 88 52
16.2 Iteration statements.............................................................................................................................. 88 53
