The GNU C Programming Tutorial

The GNU C Programming Tutorial - Concept index

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