| Index Entry | | Section |
|---|
|
| # | | |
|---|
| # operator: | | Stringification |
| ## operator: | | Concatenation |
|
| ? | | |
|---|
| ?: side effect: | | Conditional Branches |
|
| \ | | |
|---|
| ‘\a’: | | Character Constants |
| ‘\b’: | | Character Constants |
| ‘\e’: | | Character Constants |
| ‘\f’: | | Character Constants |
| ‘\n’: | | Character Constants |
| ‘\r’: | | Character Constants |
| ‘\t’: | | Character Constants |
| ‘\v’: | | Character Constants |
|
| _ | | |
|---|
| ‘_’ in variables in macros: | | Macros and Auto Type |
| _Complex keyword: | | Complex Data Types |
| _Complex_I: | | Imaginary Constants |
| __attribute__((packed)): | | Packed Structures |
| __complex__ keyword: | | Complex Data Types |
|
| A | | |
|---|
| accessing array elements: | | Accessing Array Elements |
| addition operator: | | Basic Arithmetic |
| address of a label: | | Labels as Values |
| address-of operator: | | Address of Data |
| aliasing (of storage): | | Aliasing |
| alignment of type: | | Type Alignment |
| allocating memory dynamically: | | Dynamic Memory Allocation |
| allocation file-scope variables: | | Allocating File-Scope |
| argument promotions: | | Argument Promotions |
| arguments: | | Macro Arguments |
| arguments in macro definitions: | | Macro Arguments |
| arithmetic operators: | | Arithmetic |
| arithmetic, pointer: | | Pointer Arithmetic |
| array: | | Arrays |
| array as parameters: | | Arrays as Parameters |
| array elements, accessing: | | Accessing Array Elements |
| array example: | | Array Example |
| array fields, flexible: | | Flexible Array Fields |
| array of length zero: | | Zero Length |
| array of variable length: | | Arrays of Variable Length |
| array parameters, variable-length: | | Variable-Length Array Parameters |
| array types, incomplete: | | Incomplete Array Types |
| array values, constructing: | | Constructing Array Values |
| array, declaring: | | Declaring an Array |
| array, declaring: | | Declaring Arrays and Pointers |
| array, layout in memory: | | Multidimensional Arrays |
| array, multidimensional: | | Multidimensional Arrays |
| arrays and pointers: | | Pointers and Arrays |
| assigning function pointers: | | Assigning Function Pointers |
| assigning structures: | | Structure Assignment |
| assignment expressions: | | Assignment Expressions |
| assignment in subexpressions: | | Assignment in Subexpressions |
| assignment type conversions: | | Assignment Type Conversions |
| assignment, modifying: | | Modifying Assignment |
| assignment, simple: | | Simple Assignment |
| associativity and ordering: | | Associativity and Ordering |
| attributes: | | Attributes |
| auto declarations: | | auto and register |
|
| B | | |
|---|
| backspace: | | Character Constants |
| base conversion (floating point): | | Round-Trip Base Conversion |
| bell character: | | Character Constants |
| binary integer constants: | | Integer Constants |
| binary operator grammar: | | Binary Operator Grammar |
| bit fields: | | Bit Fields |
| bitwise operators: | | Bitwise Operations |
| block: | | Blocks |
| block scope: | | Scope |
| boolean type: | | Boolean Type |
| branch cuts: | | Complex Arithmetic |
| branches of conditional expression: | | Conditional Branches |
| break statement: | | break Statement |
| bytes: | | Storage |
|
| C | | |
|---|
| call-by-value: | | Function Call Semantics |
| calling function pointers: | | Calling Function Pointers |
| calling functions: | | Function Calls |
| carriage return in source: | | Whitespace |
| case labels in initializers: | | Designated Inits |
| case of letters in identifiers: | | Identifiers |
| case ranges: | | Case Ranges |
| cast: | | Explicit Type Conversion |
| cast to a union: | | Cast to Union |
| character constants: | | Character Constants |
| character set: | | Characters |
| CHAR_BIT: | | Integer Representations |
| cloning: | | Label Value Caveats |
| combining variable declarations: | | Combining Variable Declarations |
| comma operator: | | Comma Operator |
| command-line parameters: | | Command-line Parameters |
| commenting out code: | | Deleted Code |
| comments: | | Comments |
| common type: | | Common Type |
| comparison, pointer: | | Pointer Comparison |
| comparisons: | | Numeric Comparisons |
| compatible types: | | Compatible Types |
| compilation module: | | Compilation |
| compiler options for integer overflow: | | Signed Overflow |
| compiling: | | Compile Example |
| complete example program: | | Complete Program |
| complex arithmetic in floating-point calculations: | | Complex Arithmetic |
| complex conjugation: | | Complex Data Types |
| complex constants: | | Imaginary Constants |
| complex numbers: | | Complex Data Types |
| compound statement: | | Blocks |
| computed gotos: | | Labels as Values |
| computed includes: | | Computed Includes |
| concatenation: | | Concatenation |
| conditional expression: | | Conditional Expression |
| conditional group: | | ifdef |
| conditionals: | | Conditionals |
| conjunction operator: | | Logical Operators |
| conjunction, bitwise: | | Bitwise Operations |
| const fields: | | const Fields |
| const variables and fields: | | const |
| constant data types, integer: | | Integer Const Type |
| constants: | | Constants |
| constants, character: | | Character Constants |
| constants, floating-point: | | Floating Constants |
| constants, imaginary: | | Imaginary Constants |
| constants, integer: | | Integer Constants |
| constants, string: | | String Constants |
| constants, wide character: | | Wide Character Constants |
| constants, wide string: | | Wide String Constants |
| constructing array values: | | Constructing Array Values |
| constructors, structure: | | Structure Constructors |
| continuation of lines: | | Line Continuation |
| continue statement: | | continue Statement |
| controlling macro: | | Once-Only Headers |
| conversion between pointers and integers: | | Pointer-Integer Conversion |
| conversions, type: | | Type Conversions |
| counting vowels and punctuation: | | switch Example |
| crash: | | Stack |
|
| D | | |
|---|
| declararing functions: | | Function Declarations |
| declaration of variables: | | Variable Declarations |
| declarations inside expressions: | | Statement Exprs |
| declarations, combining: | | Combining Variable Declarations |
| declarations, extern: | | Extern Declarations |
| declaring an array: | | Declaring an Array |
| declaring arrays and pointers: | | Declaring Arrays and Pointers |
| declaring function pointers: | | Declaring Function Pointers |
| decrement operator: | | Increment/Decrement |
| decrementing pointers: | | Pointer Increment/Decrement |
| defined: | | defined |
| defining functions: | | Function Definitions |
| dereferencing pointers: | | Pointer Dereference |
| designated initializers: | | Designated Inits |
| diagnostic: | | Diagnostics |
| digraphs: | | Digraphs |
| directive line: | | Directives |
| directive name: | | Directives |
| directives: | | Directives |
| disjunction operator: | | Logical Operators |
| disjunction, bitwise: | | Bitwise Operations |
| division by zero: | | Division and Remainder |
| division operator: | | Basic Arithmetic |
| do–while statement: | | do-while Statement |
| downward funargs: | | Nested Functions |
| drawbacks of pointer arithmetic: | | Pointer Arithmetic Drawbacks |
| Duff’s device: | | Duffs Device |
| dynamic memory allocation: | | Dynamic Memory Allocation |
|
| E | | |
|---|
| elements of arrays: | | Arrays |
| empty macro arguments: | | Macro Arguments |
| enumeration types: | | Enumeration Types |
| enumerator: | | Enumeration Types |
| environment variables: | | Environment Variables |
| equal operator: | | Numeric Comparisons |
| error recovery (floating point): | | Error Recovery |
| escape (ASCII character): | | Character Constants |
| escape sequence: | | Character Constants |
| exact floating-point arithmetic: | | Exact Floating-Point |
| exact specification of floating-point constants: | | Exact Floating Constants |
| example program, complete: | | Complete Program |
| exception flags (floating point): | | Exception Flags |
| executable file: | | Compile Example |
| execution control expressions: | | Execution Control Expressions |
| exit status: | | Values from main |
| EXIT_FAILURE: | | Values from main |
| EXIT_SUCCESS: | | Values from main |
| expansion of arguments: | | Argument Prescan |
| explicit type conversion: | | Explicit Type Conversion |
| expression statement: | | Expression Statement |
| expression, conditional: | | Conditional Expression |
| expressions containing statements: | | Statement Exprs |
| expressions, execution control: | | Execution Control Expressions |
| extern declarations: | | Extern Declarations |
| extern inline function: | | Inline Function Definitions |
|
| F | | |
|---|
| failure: | | Values from main |
| Fibonacci function, iterative: | | Iterative Fibonacci |
| Fibonacci function, recursive: | | Recursive Fibonacci |
| field offset: | | Field Offset |
| fields in structures: | | Structures |
| file-scope variables: | | File-Scope Variables |
| file-scope variables, allocating: | | Allocating File-Scope |
| first-class object: | | Limitations of C Arrays |
| flexible array fields: | | Flexible Array Fields |
| floating arithmetic exception flags: | | Exception Flags |
| floating overflow: | | Exception Flags |
| floating point example: | | Float Example |
| floating underflow: | | Special Float Values |
| floating underflow: | | Exception Flags |
| floating-point arithmetic invalid optimizations: | | Invalid Optimizations |
| floating-point arithmetic with complex numbers: | | Complex Arithmetic |
| floating-point arithmetic, exact: | | Exact Floating-Point |
| floating-point constants: | | Floating Constants |
| floating-point constants, exact specification of: | | Exact Floating Constants |
| floating-point error recovery: | | Error Recovery |
| floating-point fused multiply-add: | | Fused Multiply-Add |
| floating-point infinity: | | Handling Infinity |
| floating-point machine epsilon: | | Machine Epsilon |
| floating-point NaN: | | Handling NaN |
| floating-point representations: | | Floating Representations |
| floating-point round-trip base conversion: | | Round-Trip Base Conversion |
| floating-point rounding control: | | Rounding Control |
| floating-point rounding issues: | | Rounding Issues |
| floating-point scaling by powers of the base: | | Scaling by the Base |
| floating-point signed zeros: | | Signed Zeros |
| floating-point significance loss: | | Significance Loss |
| floating-point types: | | Floating-Point Data Types |
| floating-point values, special: | | Special Float Values |
| for statement: | | for Statement |
| formfeed: | | Character Constants |
| formfeed in source: | | Whitespace |
| forward declaration: | | Static Functions |
| forward function declarations: | | Forward Function Declarations |
| full expression: | | Sequence Points |
| function body: | | Function Body |
| function call semantics: | | Function Call Semantics |
| function calls: | | Function Calls |
| function declarations: | | Function Declarations |
| function declarations, forward: | | Forward Function Declarations |
| function definitions: | | Function Definitions |
| function definitions, inline: | | Inline Function Definitions |
| function definitions, old-style: | | Old-Style Function Definitions |
| function header: | | Function Header |
| function parameter lists, variable length: | | Variable Number of Arguments |
| function parameter variables: | | Function Parameter Variables |
| function pointers: | | Function Pointers |
| function pointers, assigning: | | Assigning Function Pointers |
| function pointers, calling: | | Calling Function Pointers |
| function pointers, declaring: | | Declaring Function Pointers |
| function prototype: | | Function Declarations |
| function prototype scope: | | Scope |
| function scope: | | Scope |
| function-like macros: | | Function-like Macros |
| functions: | | Functions |
| functions that accept variable-length arrays: | | Variable-Length Array Parameters |
| functions with array parameters: | | Arrays as Parameters |
| functions, nested: | | Nested Functions |
| functions, static: | | Static Functions |
| fused multiply-add in floating-point computations: | | Fused Multiply-Add |
|
| G | | |
|---|
| global variables: | | File-Scope Variables |
| goto statement: | | goto Statement |
| goto with computed label: | | Labels as Values |
| grammar, binary operator: | | Binary Operator Grammar |
| greater-or-equal operator: | | Numeric Comparisons |
| greater-than operator: | | Numeric Comparisons |
| guard macro: | | Once-Only Headers |
|
| H | | |
|---|
| handler (for signal): | | Signals |
| header file: | | Header Files |
| hexademical floating-point constants: | | Exact Floating Constants |
|
| I | | |
|---|
| identifiers: | | Identifiers |
| identifiers: | | Preprocessing Tokens |
| IEEE 754-2008 Standard: | | Floating Representations |
| if statement: | | if Statement |
| if…else statement: | | if-else Statement |
| imaginary constants: | | Imaginary Constants |
| including just once: | | Once-Only Headers |
| incomplete array types: | | Incomplete Array Types |
| incomplete types: | | Incomplete Types |
| increment operator: | | Increment/Decrement |
| incrementing pointers: | | Pointer Increment/Decrement |
| infinity in floating-point arithmetic: | | Handling Infinity |
| initializers: | | Initializers |
| initializers with labeled elements: | | Designated Inits |
| inline function definitions: | | Inline Function Definitions |
| inline functions, omission of: | | Inline Function Definitions |
| integer arithmetic: | | Integer Arithmetic |
| integer constant data types: | | Integer Const Type |
| integer constants: | | Integer Constants |
| integer overflow: | | Integer Overflow |
| integer overflow, compiler options: | | Signed Overflow |
| integer ranges: | | Maximum and Minimum Values |
| integer representations: | | Integer Representations |
| integer types: | | Integer Types |
| internal block: | | Blocks |
| intptr_t: | | Pointer Arithmetic Low Level |
| invalid optimizations in floating-point arithmetic: | | Invalid Optimizations |
| iteration: | | Loop Statements |
| iterative Fibonacci function: | | Iterative Fibonacci |
|
| K | | |
|---|
| K&R-style function definitions: | | Old-Style Function Definitions |
| keyword: | | Identifiers |
|
| L | | |
|---|
| label: | | goto Statement |
| labeled elements in initializers: | | Designated Inits |
| labels as values: | | Labels as Values |
| layout of structures: | | Structure Layout |
| left-associative: | | Binary Operator Grammar |
| length-zero arrays: | | Zero Length |
| less-or-equal operator: | | Numeric Comparisons |
| less-than operator: | | Numeric Comparisons |
| lexical syntax: | | Lexical Syntax |
| limitations of C arrays: | | Limitations of C Arrays |
| line continuation: | | Line Continuation |
| line control: | | Line Control |
| linefeed in source: | | Whitespace |
| linking object files: | | Compilation |
| local labels: | | Local Labels |
| local variables: | | Local Variables |
| local variables in macros: | | Macros and Auto Type |
| logical operators: | | Logical Operators |
| loop statements: | | Loop Statements |
| low level pointer arithmetic: | | Pointer Arithmetic Low Level |
| lvalues: | | Lvalues |
|
| M | | |
|---|
| machine epsilon (floating point): | | Machine Epsilon |
| macro argument expansion: | | Argument Prescan |
| macro arguments and directives: | | Directives Within Macro Arguments |
| macros: | | Macros |
| macros in include: | | Computed Includes |
| macros with arguments: | | Macro Arguments |
| macros with variable arguments: | | Variadic Macros |
| macros, local labels: | | Local Labels |
| macros, local variables in: | | Macros and Auto Type |
| macros, types of arguments: | | Auto Type |
| main function: | | The main Function |
| make rules: | | Compilation |
| manifest constants: | | Object-like Macros |
| maximum integer values: | | Maximum and Minimum Values |
| memory allocation, dynamic: | | Dynamic Memory Allocation |
| memory organization: | | Storage |
| minimum integer values: | | Maximum and Minimum Values |
| modifying assignment: | | Modifying Assignment |
| modulus: | | Division and Remainder |
| multidimensional arrays: | | Multidimensional Arrays |
| multiplication operator: | | Basic Arithmetic |
|
| N | | |
|---|
| NaN in floating-point arithmetic: | | Handling NaN |
| NaNs-always-propagate rule: | | Handling NaN |
| negation operator: | | Basic Arithmetic |
| negation operator, logical: | | Logical Operators |
| negation, bitwise: | | Bitwise Operations |
| nested block: | | Blocks |
| nested functions: | | Nested Functions |
| newline: | | Character Constants |
| newline in source: | | Whitespace |
| not a number: | | Handling NaN |
| not-equal operator: | | Numeric Comparisons |
| null directive: | | Null Directive |
| null pointers: | | Null Pointers |
| null statement: | | Null Statement |
| numbers, preprocessing: | | Preprocessing Tokens |
| numeric comparisons: | | Numeric Comparisons |
|
| O | | |
|---|
| object file: | | Compilation |
| object-like macro: | | Object-like Macros |
| offset of structure fields: | | Field Offset |
| old-style function definitions: | | Old-Style Function Definitions |
| omitting types in declarations: | | Omitting Types |
| operand execution ordering: | | Reordering of Operands |
| operand ordering: | | Ordering of Operands |
| operand promotions: | | Operand Promotions |
| operator precedence: | | Binary Operator Grammar |
| operator, addition: | | Basic Arithmetic |
| operator, comma: | | Comma Operator |
| operator, decrement: | | Increment/Decrement |
| operator, division: | | Basic Arithmetic |
| operator, equal: | | Numeric Comparisons |
| operator, greater-or-equal: | | Numeric Comparisons |
| operator, greater-than: | | Numeric Comparisons |
| operator, increment: | | Increment/Decrement |
| operator, less-or-equal: | | Numeric Comparisons |
| operator, less-than: | | Numeric Comparisons |
| operator, multiplication: | | Basic Arithmetic |
| operator, negation: | | Basic Arithmetic |
| operator, not-equal: | | Numeric Comparisons |
| operator, postdecrement: | | Postincrement/Postdecrement |
| operator, postincrement: | | Postincrement/Postdecrement |
| operator, remainder: | | Division and Remainder |
| operator, subtraction: | | Basic Arithmetic |
| operators: | | Operators/Punctuation |
| operators, arithmetic: | | Arithmetic |
| operators, assignment: | | Assignment Expressions |
| operators, bitwise: | | Bitwise Operations |
| operators, comparison: | | Numeric Comparisons |
| operators, logical: | | Logical Operators |
| operators, shift: | | Shift Operations |
| operators, shift: | | Shift Operations |
| optimization and ordering: | | Optimization and Ordering |
| order of execution: | | Order of Execution |
| ordering and optimization: | | Optimization and Ordering |
| ordering and postincrement: | | Postincrement and Ordering |
| ordering of operands: | | Reordering of Operands |
| ordering of operands: | | Ordering of Operands |
| overflow, compiler options: | | Signed Overflow |
| overflow, floating: | | Exception Flags |
| overflow, integer: | | Integer Overflow |
| overlaying structures: | | Overlaying Structures |
|
| P | | |
|---|
| packed structures: | | Packed Structures |
| parameter forward declaration: | | Variable-Length Array Parameters |
| parameter list: | | Function Parameter Variables |
| parameter variables in functions: | | Function Parameter Variables |
| parameters lists, variable length: | | Variable Number of Arguments |
| parameters, command-line: | | Command-line Parameters |
| parentheses in macro bodies: | | Operator Precedence Problems |
| pitfalls of macros: | | Macro Pitfalls |
| pointer arithmetic: | | Pointer Arithmetic |
| pointer arithmetic, drawbacks: | | Pointer Arithmetic Drawbacks |
| pointer arithmetic, low level: | | Pointer Arithmetic Low Level |
| pointer comparison: | | Pointer Comparison |
| pointer dereferencing: | | Pointer Dereference |
| pointer increment and decrement: | | Pointer Increment/Decrement |
| pointer type conversion: | | Aliasing |
| pointer-integer conversion: | | Pointer-Integer Conversion |
| pointers: | | Pointers |
| pointers and arrays: | | Pointers and Arrays |
| pointers to functions: | | Function Pointers |
| pointers, declaring: | | Declaring Arrays and Pointers |
| pointers, null: | | Null Pointers |
| pointers, restrict-qualified: | | restrict Pointers |
| pointers, void: | | Void Pointers |
| postdecrement expression: | | Postincrement/Postdecrement |
| postincrement and ordering: | | Postincrement and Ordering |
| postincrement expression: | | Postincrement/Postdecrement |
| precedence, operator: | | Binary Operator Grammar |
| predecrement expression: | | Increment/Decrement |
| predefined macros: | | Predefined Macros |
| preincrement expression: | | Increment/Decrement |
| preprocessing: | | Preprocessing |
| preprocessing directives: | | Directives |
| preprocessing numbers: | | Preprocessing Tokens |
| preprocessing tokens: | | Preprocessing Tokens |
| prescan of macro arguments: | | Argument Prescan |
| primitive types: | | Primitive Types |
| printf: | | Complete Explanation |
| problems with macros: | | Macro Pitfalls |
| promotion of arguments: | | Argument Promotions |
| prototype of a function: | | Function Declarations |
| punctuation: | | Operators/Punctuation |
|
| Q | | |
|---|
| QNaN: | | Special Float Values |
| quote directories: | | Search Path |
|
| R | | |
|---|
| ranges in case statements: | | Case Ranges |
| ranges of integer types: | | Maximum and Minimum Values |
| recursion: | | Function Body |
| recursion, drawbacks of: | | Stack |
| recursive Fibonacci function: | | Recursive Fibonacci |
| redefining macros: | | Undefining and Redefining Macros |
| referencing structure fields: | | Referencing Fields |
| register declarations: | | auto and register |
| remainder operator: | | Division and Remainder |
| reordering of operands: | | Reordering of Operands |
| repeated inclusion: | | Once-Only Headers |
| reporting errors: | | Diagnostics |
| reporting warnings: | | Diagnostics |
| representation of floating-point numbers: | | Floating Representations |
| representation of integers: | | Integer Representations |
| reserved words: | | Identifiers |
| restrict pointers: | | restrict Pointers |
| return (ASCII character): | | Character Constants |
| return statement: | | return Statement |
| returning values from main: | | Values from main |
| round-trip base conversion: | | Round-Trip Base Conversion |
| rounding: | | Rounding |
| rounding control (floating point): | | Rounding Control |
| rounding issues (floating point): | | Rounding Issues |
|
| S | | |
|---|
| scaling floating point by powers of the base: | | Scaling by the Base |
| scope: | | Scope |
| segmentation fault: | | Stack |
| self-reference: | | Self-Referential Macros |
| semantics of function calls: | | Function Call Semantics |
| semicolons (after macro calls): | | Swallowing the Semicolon |
| sequence points: | | Sequence Points |
| shift count: | | Shift Operations |
| shift operators: | | Shift Operations |
| side effect in ?:: | | Conditional Branches |
| side effects (in macro arguments): | | Duplication of Side Effects |
| SIGBUS: | | Signals |
| SIGFPE: | | Signals |
| signal: | | Signals |
| signed types: | | Signed and Unsigned Types |
| signed zeros in floating-point arithmetic: | | Signed Zeros |
| significance loss (floating point): | | Significance Loss |
| SIGSEGV: | | Signals |
| simple assignment: | | Simple Assignment |
| size of type: | | Type Size |
| SNaN: | | Special Float Values |
| space character in source: | | Whitespace |
| special floating-point values: | | Special Float Values |
| stack: | | Stack |
| stack frame: | | Stack |
| stack frame: | | Stack |
| stack overflow: | | Stack |
| standard output: | | Complete Explanation |
| statement, break: | | break Statement |
| statement, continue: | | continue Statement |
| statement, do–while: | | do-while Statement |
| statement, expression: | | Expression Statement |
| statement, for: | | for Statement |
| statement, goto: | | goto Statement |
| statement, if: | | if Statement |
| statement, if…else: | | if-else Statement |
| statement, null: | | Null Statement |
| statement, return: | | return Statement |
| statement, switch: | | switch Statement |
| statement, while: | | while Statement |
| statements: | | Statements |
| statements inside expressions: | | Statement Exprs |
| statements, loop: | | Loop Statements |
| static assertions: | | Static Assertions |
| static function, declaration: | | Static Functions |
| static functions: | | Static Functions |
| static local variables: | | Static Local Variables |
| sticky exception flags (floating point): | | Exception Flags |
| storage organization: | | Storage |
| string: | | Strings |
| string constants: | | String Constants |
| stringification: | | Stringification |
| structure assignment: | | Structure Assignment |
| structure constructors: | | Structure Constructors |
| structure field offset: | | Field Offset |
| structure fields, constant: | | const Fields |
| structure fields, referencing: | | Referencing Fields |
| structure layout: | | Structure Layout |
| structures: | | Structures |
| structures, overlaying: | | Overlaying Structures |
| structures, unnamed: | | Unnamed Types as Fields |
| subexpressions, assignment in: | | Assignment in Subexpressions |
| subnormal numbers: | | Special Float Values |
| subtraction operator: | | Basic Arithmetic |
| success: | | Values from main |
| switch statement: | | switch Statement |
| symbolic constants: | | Object-like Macros |
| system header files: | | Header Files |
|
| T | | |
|---|
| tab (ASCII character): | | Character Constants |
| tab character in source: | | Whitespace |
| tentative definition: | | Allocating File-Scope |
| thunks: | | Nested Functions |
| token: | | Lexical Syntax |
| token concatenation: | | Concatenation |
| token pasting: | | Concatenation |
| truncation: | | Integer Conversion |
| truth value: | | Numeric Comparisons |
| two’s-complement representation: | | Integer Representations |
| twosum: | | Error Recovery |
| type alignment: | | Type Alignment |
| type conversion, pointer: | | Aliasing |
| type conversions: | | Type Conversions |
| type designator: | | Type Designators |
| type size: | | Type Size |
| type tags: | | Type Tags |
| type, boolean: | | Boolean Type |
| type, void: | | The Void Type |
| typedef names: | | Defining Typedef Names |
| types of integer constants: | | Integer Const Type |
| types, compatible: | | Compatible Types |
| types, complex: | | Complex Data Types |
| types, enumeration: | | Enumeration Types |
| types, floating-point: | | Floating-Point Data Types |
| types, incomplete: | | Incomplete Types |
| types, integer: | | Integer Types |
| types, primitive: | | Primitive Types |
| types, signed: | | Signed and Unsigned Types |
| types, unsigned: | | Signed and Unsigned Types |
|
| U | | |
|---|
| uintptr_t: | | Pointer-Integer Conversion |
| undefining macros: | | Undefining and Redefining Macros |
| underflow, floating: | | Special Float Values |
| underflow, floating: | | Exception Flags |
| underscores in variables in macros: | | Macros and Auto Type |
| Unicode: | | Characters |
| Unicode character codes: | | Unicode Character Codes |
| union, casting to a: | | Cast to Union |
| unions: | | Unions |
| unions, unnamed: | | Unnamed Types as Fields |
| universal character names: | | Unicode Character Codes |
| unnamed structures: | | Unnamed Types as Fields |
| unnamed unions: | | Unnamed Types as Fields |
| unsafe macros: | | Duplication of Side Effects |
| unsigned types: | | Signed and Unsigned Types |
| UTF-8 String Constants: | | UTF-8 String Constants |
|
| V | | |
|---|
| variable declarations: | | Variable Declarations |
| variable declarations, combining: | | Combining Variable Declarations |
| variable number of arguments: | | Variadic Macros |
| variable-length array parameters: | | Variable-Length Array Parameters |
| variable-length arrays: | | Arrays of Variable Length |
| variable-length parameter lists: | | Variable Number of Arguments |
| variables: | | Variables |
| variables, const: | | const |
| variables, file-scope: | | File-Scope Variables |
| variables, global: | | File-Scope Variables |
| variables, local: | | Local Variables |
| variables, local, in macros: | | Macros and Auto Type |
| variables, static local: | | Static Local Variables |
| variables, volatile: | | volatile |
| variadic function: | | Variable Number of Arguments |
| variadic macros: | | Variadic Macros |
| va_copy: | | Variable Number of Arguments |
| va_end: | | Variable Number of Arguments |
| va_list: | | Variable Number of Arguments |
| va_start: | | Variable Number of Arguments |
| vertical tab: | | Character Constants |
| vertical tab in source: | | Whitespace |
| void pointers: | | Void Pointers |
| void type: | | The Void Type |
| volatile variables and fields: | | volatile |
|
| W | | |
|---|
| while statement: | | while Statement |
| whitespace characters in source files: | | Whitespace |
| wide character constants: | | Wide Character Constants |
| wide string constants: | | Wide String Constants |
| wrapper #ifndef: | | Once-Only Headers |
|
| Z | | |
|---|
| zero, division by: | | Division and Remainder |
| zero-length arrays: | | Zero Length |
| zero-origin indexing: | | Array Example |
|