| Index Entry | Section |
|---|
|
| # |
|---|
# preprocessing operator: | Stringification |
## preprocessing 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 structures: | Structure Layout |
| 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 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 |
| arrays as parameters: | Arrays as Parameters |
| 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 |
| code point: | Unicode Character Codes |
| 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 |
| compound type: | Structures |
| 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 |
| hexadecimal floating constants: | Floating Constants |
| hexadecimal 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: | Low-Level Pointer Arithmetic |
| 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 |
| link: | Compilation |
| 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: | Low-Level Pointer Arithmetic |
| 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: | Low-Level Pointer Arithmetic |
| 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 operators: | Preproc Overview |
| 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 alignment: | Structure Layout |
| 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 |
|