Previous: , Up: Top   [Contents][Index]

Concept Index

Jump to:   #   ?   \   _  
A   B   C   D   E   F   G   H   I   K   L   M   N   O   P   Q   R   S   T   U   V   W   Z  
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

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

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

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

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
dowhile 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

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

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

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

handler (for signal): Signals
header file: Header Files
hexademical floating-point constants: Exact Floating Constants

identifiers: Identifiers
identifiers: Preprocessing Tokens
IEEE 754-2008 Standard: Floating Representations
if statement: if Statement
ifelse 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&R-style function definitions: Old-Style Function Definitions
keyword: Identifiers

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

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

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

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

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

QNaN: Special Float Values
quote directories: Search Path

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

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, dowhile: do-while Statement
statement, expression: Expression Statement
statement, for: for Statement
statement, goto: goto Statement
statement, if: if Statement
statement, ifelse: 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

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

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

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

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

zero, division by: Division and Remainder
zero-length arrays: Zero Length
zero-origin indexing: Array Example

Jump to:   #   ?   \   _  
A   B   C   D   E   F   G   H   I   K   L   M   N   O   P   Q   R   S   T   U   V   W   Z  

Previous: , Up: Top   [Contents][Index]