Node:Concept index, Next:Bits and pieces, Previous:Code index, Up:Top

---

Concept index

• ./ (dot-slash) prefix in shell: Basic ideas
• \ (backslash), for makefile continuation lines: A simple makefile
• Actual parameters: Actual parameters and formal parameters
• Actual parameters, passing as pointers: Passing pointers correctly
• Addition operator: Expressions and operators
• Addresses, memory: Pointers
• Advantages of the C language: Advantages of C
• Allocation of memory: Memory allocation
• AND assignment: Bitwise operators
• AND, bitwise, truth table: Bitwise AND
• Annotating programs: Comments
• ANSI Standard C: Functions, Example comment, A word about style
• argc, example of: argc and argv
• argp, example of: argp description
• Argument count variable: argc and argv
• Argument vector: argc and argv
• argv, example of: argc and argv
• Arithmetic operators: More Special Assignments, Expressions and values
• Array bounds: Array bounds
• Array out of bounds errors: Array out of bounds
• Arrays: Arrays
• Arrays and for loops: Arrays and for loops
• Arrays and hidden operators: Arrays and hidden operators
• Arrays and nested loops: Arrays and nested loops
• Arrays and pointers, equivalence of: Arrays as Parameters
• Arrays as parameters: Arrays as Parameters
• Arrays of strings: String arrays
• Arrays of structures: Arrays of structures
• Arrays, bounds of: Array bounds
• Arrays, defining: Arrays
• Arrays, initializing: Initializing arrays, Arrays and nested loops, Arrays and for loops
• Arrays, multidimensional: Multidimensional arrays, Arrays, Nested loops
• Arrays, multidimensional, initializing: Arrays and nested loops
• Arrays, one-based: Arrays
• Arrays, out of bounds: Array out of bounds
• Arrays, reading from streams: Block input and output
• Arrays, writing to streams: Block input and output
• Arrays, zero-based nature of: Arrays
• Assignment: Errors
• Assignment operator: The assignment operator
• Assignment operator, confused with equality operator: Comparisons and logic, Important note about assignment
• Assignment, example of: Errors
• Assignments, hidden: Hidden assignments
• Automobile as metaphor for computer: Introduction
• backslash (\), for makefile continuation lines: A simple makefile
• Binary digits: Machine-level operators
• Binary trees: Binary trees
• Bit masks: Masks, Truth tables and bit masks
• Bit strings: Machine-level operators
• Bit-shift left assignment: Bitwise operators
• Bit-shift left operator: Bitwise operators
• Bit-shift right assignment: Bitwise operators
• Bit-shift right operator: Bitwise operators
• Bits: Machine-level operators
• Bitwise AND: Bitwise operators
• Bitwise AND, truth table: Bitwise AND
• Bitwise exclusive OR: Bitwise operators
• Bitwise exclusive OR, truth table: Bitwise exclusive OR (XOR/EOR)
• Bitwise inclusive OR: Bitwise operators
• Bitwise inclusive OR, truth table: Bitwise inclusive OR
• Bitwise NOT: Bitwise operators
• Bitwise NOT, truth table: Bitwise NOT
• Bitwise operators: Bitwise operators
• Black boxes: Introduction
• Black boxes, disadvantages of: Advantages of C
• Block input: Block input and output
• Block output: Block input and output
• Blocks, code: Local variables
• Bookmark, file position compared to: File position
• Boolean values: Comparisons and logic, Expressions and operators
• Bounds of arrays: Array bounds
• Boxes, black: Introduction
• break, terminating loops with: Terminating loops with break
• Breaking out of switch statement: Example 15, The switch statement
• Buffering, full: Stream buffering
• Buffering, line: Stream buffering
• Buffering, no: Stream buffering
• Buffering, stream: Stream buffering
• Buffers: Stream buffering
• Buffers, flushing: Uncoordinated output
• Bugs: Errors
• Bugs, compile-time: Errors
• Building block, function as: The form of a C program
• Building libraries: Building a library
• Buildings as metaphor for functions: Scope
• Bytes: Machine-level operators
• C language and peripherals: Advantages of C
• C language as high-level language: Introduction
• C language as standard: Preface
• C language, advantages of: Advantages of C
• C language, case-sensitivity of: Typographical errors
• C language, concealed difficulties: Advantages of C
• C language, flexibility of: Advantages of C
• C language, power of: Advantages of C, Preface
• C language, succinctness of: Advantages of C
• C language, unforgiving nature: Preface
• C language, why it is useful: Preface
• C program, simplest: The form of a C program
• C, ANSI Standard: Functions, Example comment, A word about style
• C, reserved words in: Reserved words in C
• Car as metaphor for computer: Introduction
• Case-sensitivity of C language: Typographical errors
• Cast operator: Pointer types, Expressions and operators
• Casting pointer types: Pointer types
• Casting types: The cast operator
• Casting types, example: Cast operator demo
• Character conversion table: Character conversion table
• Character functions, example of: Character handling
• Character handling: Character handling
• Characters, confused with strings: Conventions and declarations
• Characters, special: Special characters
• Chess, GNU: Multidimensional arrays
• Chessboard, represented by array: Multidimensional arrays
• Classes, storage: Other storage classes, Storage classes
• clean makefile target: A simple makefile
• cleaning up: Rules for cleaning the directory
• close, example of: Closing files at a low level
• Closing files: Closing a file
• Closing files at a low level: Closing files at a low level
• Code blocks: Local variables
• Code, object: The compiler
• Code, source: The compiler
• Combining rules by prerequisite: Combining rules by prerequisite
• Comma operator: The comma operator
• Command shell: Basic ideas, Using a compiler
• Command-line options: Processing command-line options
• Commands, deducing from implicit makefile rules: Letting make deduce commands
• Comment characters: Comments, The form of a C program
• Comments: Comments, The form of a C program
• Comments, example: Comments
• Comments, style guidelines for: Comments and style
• Common library functions: Common library functions
• Communication via parameters: Communication via parameters
• Comparison operators: Logical operators, Comparisons and logic, Expressions and operators
• Compile-time bugs: Errors
• Compile-time errors: Compile-time errors, Errors
• Compiler: The compiler, Basic ideas, Using a compiler
• Compiler passes: The compiler
• Compiling libraries: Building a library
• Compiling multiple files: Compiling multiple files
• Complex data structures: Dynamic data structures, Complex data structures
• Compound decisions: Nested if statements
• Computer crash: Errors
• Concealed difficulties of C language: Advantages of C
• Constant expressions: Constant expressions
• Constants: Constants
• Constants, string: Initializing strings
• Continuation lines in makefiles: A simple makefile
• continue, optimizing loops with: Speeding loops with continue
• continue, speeding loops with: Speeding loops with continue
• Controlled recursion with data structures: Controlled recursion with data structures
• Conventions, file name: File names
• Conversion specifiers, formatted input: Formatted input conversion specifiers, sscanf
• Conversion specifiers, formatted output: Formatted output conversion specifiers
• Conversion specifiers, formatted output, modifiers: Formatted output conversion specifiers
• Conversion specifiers, formatted output, table of: Formatted output conversion specifiers
• Conversion table, character: Character conversion table
• Crash, computer: Errors
• Creating shared libraries: Building a library
• Creating static libraries: Building a library
• Creation of files: File creation
• Curly brackets as walls: Scope
• Daemons: Stream buffering
• Data structure diagrams: Data structure diagrams
• Data structures: Data structures
• Data structures with controlled recursion: Controlled recursion with data structures
• Data structures, as distinguished from structures: Data structures
• Data structures, complex: Dynamic data structures, Complex data structures
• Data structures, dynamic: Dynamic data structures
• Data structures, initializing: Initializing your data structure
• Data structures, recursive: Controlled recursion with data structures
• Data structures, setting up: Setting up a data structure
• Data types: More data types
• Data, dynamic: Memory allocation
• Debugging: Debugging
• Decisions: Decisions
• Decisions, compound: Nested if statements
• Declaration, variable: Type errors
• Declarations, style guidelines for: Declarations and initialization
• Declarations, variable: Functions
• Declaring functions: Function prototyping
• Declaring parameters: Parameters
• Declaring structures: Structure declarations
• Declaring structures with typedef: Structure declarations using typedef
• Declaring unions: Declaration of unions
• Declaring variables: Declarations, Variables and declarations
• Deducing commands from implicit makefile rules: Letting make deduce commands
• default makefile goal: make in action
• Defining your own types: Type errors
• Deleting files at a low level: Deleting files at a low level
• Deprecated formatted string input functions: Deprecated formatted string input functions
• Deprecated formatted string output functions: Deprecated formatted string output functions
• Deprecated string input functions: Deprecated string input functions
• Descriptors, file: Input and output
• Detail, levels of: Introduction
• Devices: Input and output
• Diagrams, data structures: Data structure diagrams
• Difference between while and do: do...while
• Different type argument error: different type arg
• Directives, preprocessor: Macros, A few directives, Preprocessor directives
• Directives, preprocessor, example: Macros
• Disadvantages of black boxes: Advantages of C
• Disk input: Example programs
• Disk output: Example programs
• do and while, difference between: do...while
• Dot-slash (./) prefix in shell: Basic ideas
• Dynamic data: Memory allocation
• Dynamic data structures: Dynamic data structures
• editor: Writing a makefile
• Emacs Info reader: Preface
• End-of-file functions: End-of-file and error functions
• End-of-file indicator: End-of-file and error functions
• End-of-file indicator, resetting: End-of-file and error functions
• Environment variables: Environment variables
• EOR, truth table: Bitwise exclusive OR (XOR/EOR)
• Equality operator, confused with assignment operator: Comparisons and logic, Important note about assignment
• Equals sign (=): Errors
• Equivalence of pointers and arrays: Arrays as Parameters
• Error cascade: Errors
• Error functions: End-of-file and error functions
• Error indicator: End-of-file and error functions
• Error indicator, resetting: End-of-file and error functions
• Errors: Errors
• Errors, compile time: Compile-time errors
• Errors, compile-time: Errors
• Errors, methematical: Mathematical errors
• Errors, run-time: Errors
• Errors, syntax: Errors
• Errors, type: Type errors, Errors
• Errors, typographical: Typographical errors
• Example function: Function examples
• Example program, substantial: Example programs
• Exceptions, floating-point: Mathematical errors
• Exclusive OR assignment: Bitwise operators
• Exclusive OR, bitwise, truth table: Bitwise exclusive OR (XOR/EOR)
• Executable file: Errors, File names
• Executable file, running: Basic ideas
• Expressions: Expressions
• Expressions, constant: Constant expressions
• External variables: External variables
• False Boolean value: Comparisons and logic
• fclose command, example of: Closing a file
• FDL: Preface
• File creation: File creation
• File descriptors: Low-level file routines, Input and output
• File functions, low-level: Low-level file routines
• File name conventions: File names
• File name errors, usual: Usual file name errors
• File operations, high-level: Input and output
• File operations, low-level: Input and output
• File position: File position
• File position indicator: ungetc
• File position, compared to bookmark: File position
• File routines, high-level: High-level file routines
• File, executable: Errors, File names
• File, header: File names
• File, library: File names
• File, object: File names, The compiler
• File, object code: The compiler
• File, source code: File names
• Files, closing: Closing a file
• Files, header: Header files
• Files, high-level operations on: Input and output
• Files, low-level operations on: Input and output
• Files, opening: Opening a file, Input and output
• Files, random-access: File position
• findex, example of: fgets
• Finding file positions at a low level: Finding file positions at a low level
• Flags: Machine-level operators
• Flexibility of for command: The flexibility of for
• Floating point numbers: Floating point variables
• Floating point variables: Floating point variables
• Floating-point exceptions: Mathematical errors
• Flushing buffers: Uncoordinated output
• Flushing streams: Stream buffering
• fopen command, example of: Opening a file
• for command, flexibility of: The flexibility of for
• for loops and arrays: Arrays and for loops
• for loops, nested: Arrays and nested loops
• Formal parameters: Actual parameters and formal parameters
• Format strings, printf: printf
• Formatted input conversion specifiers: Formatted input conversion specifiers, sscanf
• Formatted output conversion specifiers: Formatted output conversion specifiers
• Formatted output conversion specifiers, modifiers: Formatted output conversion specifiers
• Formatted output conversion specifiers, table of: Formatted output conversion specifiers
• Formatted string input: Formatted string input
• Formatted string input functions, deprecated: Deprecated formatted string input functions
• Formatted string output: Formatted string output
• Formatted string output functions, deprecated: Deprecated formatted string output functions
• Formatting code, style guidelines: Formatting code
• Free Documentation License: Preface
• Free software: Preface
• Freedom of style in C language: Advantages of C
• fsync, example of: Writing files at a low level
• Full buffering: Stream buffering
• Function: Basic ideas
• Function declarations: Function prototyping
• Function names: Function names
• Function names, characters available for: Function names
• Function names, style guidelines for: Variable and function names
• Function prototypes: Function prototyping
• Function prototypes, parameters in: Parameters in function prototypes
• Function prototypes, reasons for using: Function prototyping
• Function values: Functions with values
• Function, as building block: The form of a C program
• Function, example: Function examples
• Function, main: The form of a C program
• Functions: Functions
• Functions, as buildings: Scope
• Functions, common library: Common library functions
• Functions, declaring: Function prototyping
• Functions, macro: Macro functions
• Functions, macro, caveats: Macro functions
• Functions, macro, example: Extended macro example, Macro functions
• Functions, mathematical: Mathematical functions
• Functions, names of: Function names
• Functions, prototyping: Function prototyping
• Functions, return values: Functions with values
• Functions, returning values from: Functions with values
• Functions, string library: String library functions
• Functions, variadic: Variadic functions
• Functions, with values: Functions with values
• GCC: The compiler
• GDB, introduction to: Introduction to GDB
• general-purpose programming: Advantages of C
• getline, example of: getline
• Global scope: Scope
• Global variables: Global variables
• Global variables and recursion: Global variables and recursion
• Global variables, style guidelines for: Global variables and style
• GNU C Compiler: The compiler
• GNU C Library: Input and output
• GNU Chess: Multidimensional arrays
• GNU Compiler Collection: The compiler
• GNU FDL: Preface
• GNU Free Documentation License: Preface
• GNU long options: Example programs, Processing command-line options
• GNU Project: Preface
• GNU shell: Basic ideas, Using a compiler
• GNU style guidelines: Example comment
• GNU system, stability of: Errors
• GNU/Linux: Preface
• goal: make in action
• goal, makefile, default: make in action
• Header file: File names
• Header files: Header files
• Header files, for libraries: Building a library
• Hidden assignments: Hidden assignments
• Hidden operators: Hidden operators and values
• Hidden operators and arrays: Arrays and hidden operators
• Hidden operators, style guidelines for: Hidden operators and style
• High level, the: Introduction
• High-level file operations: Input and output
• High-level file routines: High-level file routines
• High-level language, C language as: Introduction
• if statements, nested: Nested if statements
• Implicit makefile rules, introduction: Letting make deduce commands
• Inclusive OR: Inclusive OR
• Inclusive OR assignment: Bitwise operators
• Inclusive OR, bitwise, truth table: Bitwise inclusive OR
• Info reader: Preface
• Initialization and pointers: Pointers and initialization
• Initialization, style guidelines for: Declarations and initialization
• Initializing arrays: Initializing arrays, Arrays and nested loops, Arrays and for loops
• Initializing data structurse: Initializing your data structure
• Initializing multidimensional arrays: Arrays and nested loops
• Initializing strings: Initializing strings
• Initializing structures: Initializing structures
• Initializing variables: Initialization
• Input: Input and output
• Input and output: Input and output
• Input conversion specifiers, formatted: Formatted input conversion specifiers, sscanf
• Input functions, string, deprecated formatted: Deprecated formatted string input functions
• Input, block: Block input and output
• Input, disk: Example programs
• Input, single-character: Single-character input and output
• Input, string: Deprecated string input functions, String input, String output and input
• Input, string formatted: Formatted string input
• Integer variables: Integer variables
• Integer variables, sizes of: Integer variables
• International Obfuscated C Code Contest: Parameters in function prototypes
• Jargon: Preface
• Kinds of library: Kinds of library
• Levels of detail: Introduction
• Libraries: Libraries
• Libraries, compiling: Building a library
• Libraries, linking to your code: Libraries
• Libraries, shared: Kinds of library
• Libraries, shared, creating: Building a library
• Libraries, static: Kinds of library
• Libraries, static, creating: Building a library
• Library file: File names
• Library functions, common: Common library functions
• Library functions, string: String library functions
• Library header files: Building a library
• Library, kinds of: Kinds of library
• Line buffering: Stream buffering
• Linked lists: Example programs, Linked lists
• Linker: The compiler
• Linking libraries to your code: Libraries
• Links: Lists and trees, Dynamic data structures
• Lists: Lists and trees
• Lists, linked: Example programs, Linked lists
• Local scope: Scope
• Local variables: Local variables
• Local variables, scope of: Local variables
• Local variables, visibility of: Local variables
• Logical operators: Logical operators
• Long options, GNU: Example programs, Processing command-line options
• Loops: Loops
• Loops, nested: Arrays and nested loops, Nested loops
• Loops, speeding: Terminating and speeding loops
• Loops, terminating: Terminating and speeding loops
• Loops, terminating with break: Terminating loops with break
• Loops, terminating with return: Terminating loops with return
• Low level, closing files at: Closing files at a low level
• Low level, deleting files at: Deleting files at a low level
• Low level, finding file positions at: Finding file positions at a low level
• Low level, opening files at: Opening files at a low level
• Low level, reading files at: Reading files at a low level
• Low level, renaming files at: Renaming files at a low level
• Low level, the: Introduction
• Low level, writing files at: Writing files at a low level
• Low-level file functions: Low-level file routines
• Low-level file operations: Input and output
• Lvalues: The assignment operator
• Macro functions: Macro functions
• Macro functions, caveats: Macro functions
• Macro functions, example: Extended macro example, Macro functions
• Macros: Macros
• main function: The form of a C program
• makefile: Writing a makefile
• Makefile commands, introduction to: Rule Introduction
• Makefile prerequisites, introduction to: Rule Introduction
• Makefile rule parts: Rule Introduction
• Makefile rule, introduction to: Rule Introduction
• Makefile rules, implicit, introduction: Letting make deduce commands
• Makefile rules, tab characters in: Rule Introduction
• Makefile targets, introduction to: Rule Introduction
• makefile, processing: make in action
• Makefile, simple: A simple makefile
• Makefiles, writing: Writing a makefile
• Masks, bit: Masks, Truth tables and bit masks
• Math functions, example of: Mathematical functions
• Mathematical errors: Mathematical errors
• Mathematical function: Mathematical functions
• Mathematical operators: Expressions and operators
• Member operator of structures: Using structures
• Members of structures: struct
• Memory addresses: Pointers
• Memory allocation: Memory allocation
• Memory, random-access: File position
• Multidimensional arrays: Multidimensional arrays, Nested loops
• Multidimensional arrays, initializing: Arrays and nested loops
• Multiple files, compiling: Compiling multiple files
• Multiplication operator: Expressions and operators
• Nested for loops: Arrays and nested loops
• Nested if statements: Nested if statements
• Nested loops: Arrays and nested loops, Nested loops
• Nested loops and arrays: Arrays and nested loops
• Nested structures: Nested structures
• Newline character, quoting in makefile: A simple makefile
• No buffering: Stream buffering
• Node, root: Dynamic data structures
• Nodes: Lists and trees, Dynamic data structures
• Nodes, root: Initializing your data structure
• NOT, bitwise, truth table: Bitwise NOT
• Null pointers: Initializing your data structure
• Numbers, floating point: Floating point variables
• Obfuscated C Code Contest, International: Parameters in function prototypes
• Object code: The compiler
• Object code file: The compiler
• Object file: File names, The compiler
• One-based arrays: Arrays
• open, example of: Closing files at a low level
• Opening files: Opening a file, Input and output
• Opening files at a low level: Opening files at a low level
• Operating system: Using a compiler
• Operating systems, 64-bit: Integer variables
• Operations, order of: Parentheses and Priority
• Operator precedence: Parentheses and Priority
• Operator, addition: Expressions and operators
• Operator, assignment: The assignment operator
• Operator, cast: Pointer types, Expressions and operators
• Operator, comma: The comma operator
• Operator, multiplication: Expressions and operators
• Operator, subtraction: Expressions and operators
• Operators: Expressions and operators
• Operators, arithmetic: More Special Assignments, Expressions and values
• Operators, bitwise: Bitwise operators
• Operators, comparison: Logical operators, Comparisons and logic, Expressions and operators
• Operators, hidden: Hidden operators and values
• Operators, hidden, and arrays: Arrays and hidden operators
• Operators, logical: Logical operators
• Operators, mathematical: Expressions and operators
• Operators, precedence of: Precedence of operators
• Operators, shift: Shift operations
• Operators, special assignment: More Special Assignments, Special Assignment Operators ++ --
• Optimizing loops: Speeding loops with continue
• Options, command-line: Processing command-line options
• OR, bitwise exclusive, truth table: Bitwise exclusive OR (XOR/EOR)
• OR, bitwise inclusive, truth table: Bitwise inclusive OR
• OR, inclusive: Inclusive OR
• Order of operation, unary operators: Unary Operator Precedence
• Order of operations: Parentheses and Priority
• Output: Input and output
• Output conversion specifiers, formatted: Formatted output conversion specifiers
• Output conversion specifiers, formatted, modifiers: Formatted output conversion specifiers
• Output conversion specifiers, formatted, table of: Formatted output conversion specifiers
• Output, block: Block input and output
• Output, disk: Example programs
• Output, formatted string: Formatted string output
• Output, single-character: Single-character input and output
• Output, string: String output and input
• Output, uncoordinated: Uncoordinated output
• Output, unformatted string: Unformatted string output
• Parameters: Parameters, Communication via parameters, Functions
• Parameters in function prototypes: Parameters in function prototypes
• Parameters, actual: Actual parameters and formal parameters
• Parameters, arrays as: Arrays as Parameters
• Parameters, communication via: Communication via parameters
• Parameters, declaring: Parameters
• Parameters, formal: Actual parameters and formal parameters
• Parameters, passing arrays as: Arrays as Parameters
• Parameters, value: Value parameters, Parameters
• Parameters, value, example of: Parameters
• Parameters, variable: Another variable parameter example, Variable parameters, Parameters
• Parentheses: Parentheses and Priority
• Parse error: parse error at...
• Parts of makefile rules: Rule Introduction
• Passes, compiler: The compiler
• Passing actual parameters as pointers: Passing pointers correctly
• Passing arrays as parameters: Arrays as Parameters
• Passing by reference: Variable parameters
• Passing by reference, origin of term: Pointers
• Passing information to program: argc and argv
• Passing information with parameters: Parameters
• Passing parameters: Parameters
• Passing parameters by reference: Parameters
• Passing parameters by value: Value parameters, Parameters
• Peripherals: Input and output
• Peripherals and C language: Advantages of C
• Peripherals as devices: Input and output
• Pipe symbol (|): Programming with pipes
• Pipes, programming with: Programming with pipes
• Pointer expressions, pronunciation of: Pointer types
• Pointer types: Pointer types
• Pointer types, casting: Pointer types
• Pointers: Pointers
• Pointers and arrays, equivalence of: Arrays as Parameters
• Pointers and initialization: Pointers and initialization
• Pointers to structures: Pointers to structures
• Pointers, types of: Pointer types
• POSIX standard, command-line conventions: Processing command-line options
• Postfix ++ operator: Postfix and prefix ++ and --
• Postfix -- operator: Postfix and prefix ++ and --
• Postfix and prefix ++, confused: Confusing foo++ and ++foo
• Postfix operators: Postfix and prefix ++ and --
• Power of C language: Advantages of C, Preface
• Precedence of operators: Precedence of operators
• Precedence, operator: Parentheses and Priority
• Prefix ++ operator: Postfix and prefix ++ and --
• Prefix -- operator: Postfix and prefix ++ and --
• Prefix operators: Postfix and prefix ++ and --
• Preprocessor: Preprocessor directives
• Preprocessor directives: Macros, A few directives, Preprocessor directives
• Preprocessor directives, example: Macros
• Prerequisite, combining rules by: Combining rules by prerequisite
• printf format strings: printf
• printf, example of: Formatted output conversion specifiers
• processing a makefile: make in action
• programming, general-purpose: Advantages of C
• Programs, annotating: Comments
• Pronunciation of pointer expressions: Pointer types
• Prototypes, function, parameters in: Parameters in function prototypes
• Prototyping function: Function prototyping
• Pseudo-code: The compiler
• Pushback: ungetc
• Pushing back characters: ungetc
• Quoting newline character in makefile: A simple makefile
• RAM: File position
• Random-access files: File position
• Random-access memory: File position
• read, example of: Writing files at a low level
• Reading arrays from streams: Block input and output
• Reading files at a low level: Reading files at a low level
• recompilation: Writing a makefile
• Recursion: Recursion
• Recursion and global variables: Global variables and recursion
• Recursion, controlled: Controlled recursion
• Recursion, controlled, with data structures: Controlled recursion with data structures
• Recursive data structures: Controlled recursion with data structures
• Reference, passing by: Variable parameters
• Reference, passing by, origin of term: Pointers
• Reference, passing parameters by: Parameters
• relinking: make in action
• Renaming files at a low level: Renaming files at a low level
• Reserved words in C: Reserved words in C
• Return codes: The exit function
• return, terminating loops with: Terminating loops with return
• Returning values from functions: Functions with values
• Root node: Dynamic data structures
• Root nodes: Initializing your data structure
• Run-time errors: Errors
• Running an executable file: Basic ideas
• scanf, string overflows with: String overflows with scanf
• Scope of local variables: Local variables
• Scope of variables: Scope
• Scope, example of: Scope example
• Scope, global: Scope
• Scope, local: Scope
• Setting up data structures: Setting up a data structure
• Shakespeare: Inclusive OR
• Shared libraries: Kinds of library
• Shared libraries, creating: Building a library
• shell command: A simple makefile
• Shell, command: Basic ideas, Using a compiler
• Shell, GNU: Basic ideas, Using a compiler
• Shift operators: Shift operations
• Simple makefile: A simple makefile
• Simplest C program: The form of a C program
• Simplifying makefiles with variables: Variables simplify makefiles
• Single-character input: Single-character input and output
• Single-character output: Single-character input and output
• Software, free: Preface
• Source code: The compiler
• Source code file: File names
• Special assignment operators: More Special Assignments, Special Assignment Operators ++ --
• Special assignment operators, example: More Special Assignments
• Special characters: Special characters
• Speeding loops: Speeding loops with continue, Terminating and speeding loops
• sscanf example: sscanf
• sscanf, common errors with: sscanf
• Stability of GNU system: Errors
• Stack: The stack in detail, The stack
• Stack, variable: Scope example
• Standard input: Stream buffering
• Standard output: Stream buffering
• Statements: Functions
• Static libraries: Kinds of library
• Static libraries, creating: Building a library
• Static variables: Static variables
• Storage classes: Other storage classes, Storage classes
• Storage, false assumptions about: Unwarranted assumptions about storage
• Stream buffering: Stream buffering
• Streams: Input and output
• Streams, reading arrays from: Block input and output
• Streams, writing arrays to: Block input and output
• String arrays: String arrays
• String constants: Initializing strings
• String input: Deprecated string input functions, String input, String output and input
• String input functions, deprecated: Deprecated string input functions
• String input functions, deprecated formatted: Deprecated formatted string input functions
• String input, formatted: Formatted string input
• String library functions: String library functions
• String output: String output and input
• String output functions, formatted, deprecated: Deprecated formatted string output functions
• String output, formatted: Formatted string output
• String output, unformatted: Unformatted string output
• String overflows with scanf: String overflows with scanf
• String values: Strings
• Strings: Strings
• Strings, confused with characters: Conventions and declarations
• Strings, initializing: Initializing strings
• Structures: struct
• Structures, -> operator: Using structures
• Structures, . dot operator: Using structures
• Structures, arrays of: Arrays of structures
• Structures, as distinguished from data structures: Data structures
• Structures, data: Data structures
• Structures, declaring: Structure declarations
• Structures, declaring with typedef: Structure declarations using typedef
• Structures, initializing: Initializing structures
• Structures, member operator of: Using structures
• Structures, members of: struct
• Structures, nested: Nested structures
• Structures, pointers to: Pointers to structures
• Structures, using: Using structures
• Style: Style, A warning about style, Example comment, A word about style
• Style guidelines: Style
• Style guidelines for comments: Comments and style
• Style guidelines for declarations: Declarations and initialization
• Style guidelines for formatting code: Formatting code
• Style guidelines for function names: Variable and function names
• Style guidelines for global variables: Global variables and style
• Style guidelines for hidden operators: Hidden operators and style
• Style guidelines for initialization: Declarations and initialization
• Style guidelines for variable names: Variable and function names
• Style, freedom of in C language: Advantages of C
• Style, warning about: A warning about style
• Subtraction operator: Expressions and operators
• Suucinctness of C language: Advantages of C
• switch statement, breaking out of: Example 15, The switch statement
• Syntax errors: Errors
• Tab characters in makefile rules: Rule Introduction
• Tables, truth: Truth tables and bit masks
• Template string, : sscanf
• Terminating loops: Terminating and speeding loops
• Terminating loops with break: Terminating loops with break
• Terminating loops with return: Terminating loops with return
• Texinfo: Preface
• To be or not to be: Inclusive OR
• Too few parameters error: too few parameters...
• Trees: Lists and trees
• Trees, binary: Binary trees
• True Boolean value: Comparisons and logic
• Truth tables: Truth tables and bit masks
• Type errors: Type errors, Errors
• typedef, declaring structures with: Structure declarations using typedef
• Types, casting: The cast operator
• Types, casting, example: Cast operator demo
• Types, defining your own: Type errors
• Types, pointer: Pointer types
• Types, variable: Type errors
• Typographical errors: Typographical errors
• Unary operators: Unary Operator Precedence
• Unary operators, order of operation: Unary Operator Precedence
• Uncoordinated output: Uncoordinated output
• Undefined reference error: undefined reference to...
• Unforgiving nature of C language: Preface
• Unformatted string output: Unformatted string output
• Unions: union
• Unions and flag variables: Using unions
• Unions, declaring: Declaration of unions
• Unions, using: Using unions
• Unreading characters: ungetc
• Using structures: Using structures
• Using unions: Using unions
• Usual file name errors: Usual file name errors
• Value parameters: Value parameters, Parameters
• Value parameters, example of: Parameters
• Value, passing parameters by: Parameters
• Values, Boolean: Comparisons and logic, Expressions and operators
• Variable: Basic ideas
• Variable declaration: Type errors
• Variable declarations: Functions
• Variable names, characters available for: Variables and declarations
• Variable names, style guidelines for: Variable and function names
• Variable parameters: Another variable parameter example, Variable parameters, Parameters
• Variable stack: Scope example
• Variable types: Type errors
• Variables: Variables and declarations
• Variables, declaring: Declarations, Variables and declarations
• Variables, environment: Environment variables
• Variables, external: External variables
• Variables, floating point: Floating point variables
• Variables, global: Global variables
• Variables, global, and recursion: Global variables and recursion
• Variables, initializing: Initialization
• Variables, integer: Integer variables
• Variables, integer, sizes of: Integer variables
• Variables, local: Local variables
• Variables, local, scope of: Local variables
• Variables, local, visibility of: Local variables
• Variables, scope of: Scope
• Variables, simplifying makefiles with: Variables simplify makefiles
• Variables, static: Static variables
• Variables, visibility of: Scope
• Variadic functions: Variadic functions
• Visibility of local variables: Local variables
• Visibility of variables: Scope
• Walls, as metaphors for curly brackets: Scope
• while and do, difference between: do...while
• write, example of: Writing files at a low level
• Writing arrays to streams: Block input and output
• Writing files at a low level: Writing files at a low level
• Writing makefiles: Writing a makefile
• XOR, truth table: Bitwise exclusive OR (XOR/EOR)
• Zero-based arrays in C: Arrays