 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 
 addressof operator:   Address of Data 
 aliasing (of storage):   Aliasing 
 alignment of type:   Type Alignment 
 allocating memory dynamically:   Dynamic Memory Allocation 
 allocation filescope variables:   Allocating FileScope 
 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, variablelength:   VariableLength 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):   RoundTrip 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   
 callbyvalue:   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 
 commandline parameters:   Commandline 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 floatingpoint 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, floatingpoint:   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:   OnceOnly Headers 
 conversion between pointers and integers:   PointerInteger 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:   dowhile 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 floatingpoint arithmetic:   Exact FloatingPoint 
 exact specification of floatingpoint 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 
 filescope variables:   FileScope Variables 
 filescope variables, allocating:   Allocating FileScope 
 firstclass 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 
 floatingpoint arithmetic invalid optimizations:   Invalid Optimizations 
 floatingpoint arithmetic with complex numbers:   Complex Arithmetic 
 floatingpoint arithmetic, exact:   Exact FloatingPoint 
 floatingpoint constants:   Floating Constants 
 floatingpoint constants, exact specification of:   Exact Floating Constants 
 floatingpoint error recovery:   Error Recovery 
 floatingpoint fused multiplyadd:   Fused MultiplyAdd 
 floatingpoint infinity:   Handling Infinity 
 floatingpoint machine epsilon:   Machine Epsilon 
 floatingpoint NaN:   Handling NaN 
 floatingpoint representations:   Floating Representations 
 floatingpoint roundtrip base conversion:   RoundTrip Base Conversion 
 floatingpoint rounding control:   Rounding Control 
 floatingpoint rounding issues:   Rounding Issues 
 floatingpoint scaling by powers of the base:   Scaling by the Base 
 floatingpoint signed zeros:   Signed Zeros 
 floatingpoint significance loss:   Significance Loss 
 floatingpoint types:   FloatingPoint Data Types 
 floatingpoint 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, oldstyle:   OldStyle 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 
 functionlike macros:   Functionlike Macros 
 functions:   Functions 
 functions that accept variablelength arrays:   VariableLength Array Parameters 
 functions with array parameters:   Arrays as Parameters 
 functions, nested:   Nested Functions 
 functions, static:   Static Functions 
 fused multiplyadd in floatingpoint computations:   Fused MultiplyAdd 

G   
 global variables:   FileScope Variables 
 goto statement:   goto Statement 
 goto with computed label:   Labels as Values 
 grammar, binary operator:   Binary Operator Grammar 
 greaterorequal operator:   Numeric Comparisons 
 greaterthan operator:   Numeric Comparisons 
 guard macro:   OnceOnly Headers 

H   
 handler (for signal):   Signals 
 header file:   Header Files 
 hexadecimal floatingpoint constants:   Exact Floating Constants 

I   
 identifiers:   Identifiers 
 identifiers:   Preprocessing Tokens 
 IEEE 7542008 Standard:   Floating Representations 
 if statement:   if Statement 
 if …else statement:   ifelse Statement 
 imaginary constants:   Imaginary Constants 
 including just once:   OnceOnly Headers 
 incomplete array types:   Incomplete Array Types 
 incomplete types:   Incomplete Types 
 increment operator:   Increment/Decrement 
 incrementing pointers:   Pointer Increment/Decrement 
 infinity in floatingpoint 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 :   LowLevel Pointer Arithmetic 
 invalid optimizations in floatingpoint arithmetic:   Invalid Optimizations 
 iteration:   Loop Statements 
 iterative Fibonacci function:   Iterative Fibonacci 

K   
 K&Rstyle function definitions:   OldStyle 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 
 leftassociative:   Binary Operator Grammar 
 lengthzero arrays:   Zero Length 
 lessorequal operator:   Numeric Comparisons 
 lessthan 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:   LowLevel 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:   Objectlike 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 floatingpoint arithmetic:   Handling NaN 
 NaNsalwayspropagate 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 
 notequal 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 
 objectlike macro:   Objectlike Macros 
 offset of structure fields:   Field Offset 
 oldstyle function definitions:   OldStyle 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, greaterorequal:   Numeric Comparisons 
 operator, greaterthan:   Numeric Comparisons 
 operator, increment:   Increment/Decrement 
 operator, lessorequal:   Numeric Comparisons 
 operator, lessthan:   Numeric Comparisons 
 operator, multiplication:   Basic Arithmetic 
 operator, negation:   Basic Arithmetic 
 operator, notequal:   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:   VariableLength Array Parameters 
 parameter list:   Function Parameter Variables 
 parameter variables in functions:   Function Parameter Variables 
 parameters lists, variable length:   Variable Number of Arguments 
 parameters, commandline:   Commandline 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, lowlevel:   LowLevel Pointer Arithmetic 
 pointer comparison:   Pointer Comparison 
 pointer dereferencing:   Pointer Dereference 
 pointer increment and decrement:   Pointer Increment/Decrement 
 pointer type conversion:   Aliasing 
 pointerinteger conversion:   PointerInteger 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:   OnceOnly Headers 
 reporting errors:   Diagnostics 
 reporting warnings:   Diagnostics 
 representation of floatingpoint 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 
 roundtrip base conversion:   RoundTrip 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 
 selfreference:   SelfReferential 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 floatingpoint 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 floatingpoint 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 :   dowhile Statement 
 statement, expression:   Expression Statement 
 statement, for :   for Statement 
 statement, goto :   goto Statement 
 statement, if :   if Statement 
 statement, if …else :   ifelse 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:   Objectlike Macros 
 system header files:   Header Files 

T   
 tab (ASCII character):   Character Constants 
 tab character in source:   Whitespace 
 tentative definition:   Allocating FileScope 
 thunks:   Nested Functions 
 token:   Lexical Syntax 
 token concatenation:   Concatenation 
 token pasting:   Concatenation 
 truncation:   Integer Conversion 
 truth value:   Numeric Comparisons 
 two’scomplement 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, floatingpoint:   FloatingPoint 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 :   PointerInteger 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 
 UTF8 String Constants:   UTF8 String Constants 

V   
 variable declarations:   Variable Declarations 
 variable declarations, combining:   Combining Variable Declarations 
 variable number of arguments:   Variadic Macros 
 variablelength array parameters:   VariableLength Array Parameters 
 variablelength arrays:   Arrays of Variable Length 
 variablelength parameter lists:   Variable Number of Arguments 
 variables:   Variables 
 variables, const :   const 
 variables, filescope:   FileScope Variables 
 variables, global:   FileScope 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 :   OnceOnly Headers 

Z   
 zero, division by:   Division and Remainder 
 zerolength arrays:   Zero Length 
 zeroorigin indexing:   Array Example 
