Beginning C - From Beginner to Pro.

Table of Contents
About the Authors
About the Technical Reviewer
Acknowledgments
Introduction
Chapter 1: Programming in C
	The C Language
	The Standard Library
	Learning C
	Creating C Programs
		Editing
		Compiling
		Linking
		Executing
	Creating Your First Program
	Editing Your First Program
	Dealing with Errors
	Dissecting a Simple Program
		Comments
		Preprocessing Directives
		Defining the main() Function
		Keywords
		The Body of a Function
		Outputting Information
		Function Arguments
		Control Characters
		Trigraph Sequences
	The Preprocessor
	Developing Programs in C
		Understanding the Problem
		Detailed Design
		Implementation
		Testing
	Functions and Modular Programming
	Common Mistakes
	Points to Remember
	Summary
Chapter 2: First Steps in Programming
	Memory in Your Computer
	What Is a Variable?
		Naming Variables
		Variables That Store Integers
		Using Variables
		Initializing Variables
	Basic Arithmetic Operations
		More on Division with Integers
		Unary Operators
		Unary Minus Operator
	Variables and Memory
		Signed Integer Types
		Unsigned Integer Types
		Specifying Integer Constants
			Hexadecimal Constants
			Octal Constants
			Default Integer Constant Types
	Working with Floating-Point Numbers
		Floating-Point Number Representation
		Floating-Point Variables
		Division Using Floating-Point Values
		Controlling the Number of Decimal Places in the Output
		Controlling the Output Field Width
	More Complicated Expressions
	Defining Named Constants
	Knowing Your Limitations
	Introducing the sizeof Operator
	Choosing the Correct Type for the Job
	Explicit Type Conversion
		Automatic Conversions
		Rules for Implicit Conversions
		Implicit Conversions in Assignment Statements
	More Numeric Data Types
		Character Type
		Character Input and Character Output
		Enumerations
		Choosing Enumerator Values
		Unnamed Enumeration Types
		Variables That Store Boolean Values
	The op= Form of Assignment
	Mathematical Functions
	Designing a Program
		The Problem
		The Analysis
		The Solution
			Step 1
			Step 2
			Step 3
	Summary
Chapter 3: Making Decisions
	The Decision-Making Process
		Arithmetic Comparisons
		The Basic if Statement
		Extending the if statement: if-else
		Using Blocks of Code in if Statements
		Nested if Statements
		Testing Characters
		Logical Operators
			The AND Operator &&
			The OR Operator ||
			The NOT Operator !
		The Conditional Operator
		Operator Precedence: Who Goes First?
	Multiple-Choice Questions
		Using else-if Statements for Multiple Choices
		The switch Statement
		The goto Statement
	Bitwise Operators
		The op= Use of Bitwise Operators
		Using Bitwise Operators
	Designing a Program
		The Problem
		The Analysis
		The Solution
			Step 1
			Step 2
			Steps 3 and 4
	Summary
Chapter 4: Loops
	How Loops Work
	Introducing the Increment and Decrement Operators
	The for Loop
	General Form of the for Loop
	More on the Increment and Decrement Operators
		The Increment Operator
		The Prefix and Postfix Forms of the Increment Operator
		The Decrement Operator
	The for Loop Revisited
		Modifying the for Loop Control Variable
		A for Loop with No Parameters
		The break Statement in a Loop
		Limiting Input Using a for Loop
		Generating Pseudo-random Integers
		More for Loop Control Options
		Floating-Point Loop Control Variables
		Chars loop Control Variables
	The while Loop
	Nested Loops
	Nested Loops and the goto Statement
	The do-while Loop
	The continue Statement
	Designing a Program
		The Problem
		The Analysis
		The Solution
			Step 1
			Step 2
			Step 3
			Step 4
			Step 5
	Summary
Chapter 5: Arrays
	An Introduction to Arrays
		Programming Without Arrays
		What Is an Array?
		Using an Array
	The Address of Operator
	Arrays and Addresses
	Initializing an Array
	Finding the Size of an Array
	Multidimensional Arrays
	Initializing Multidimensional Arrays
	Constant Arrays
	Variable-Length Arrays
	Designing a Program
		The Problem
		The Analysis
		The Solution
			Step 1
			Step 2
			Step 3
			Step 4
	Summary
Chapter 6: Applications with Strings and Text
	What Is a String?
	Variables That Store Strings
	Arrays of Strings
	Operations with Strings
		Checking for C11/C17 Support
		Finding the Length of a String
		Copying Strings
		Concatenating Strings
		Comparing Strings
		Searching a String
			The Idea of a Pointer
			Searching a String for a Character
			Searching a String for a Substring
		Tokenizing a String
		Reading Newline Characters into a String
	Analyzing and Transforming Strings
		Converting Character Case
		Converting Strings to Numerical Values
	Designing a Program
		The Problem
		The Analysis
		The Solution
			Step 1
			Step 2
			Step 3
	Summary
Chapter 7: Pointers
	A First Look at Pointers
		Declaring Pointers
		Accessing a Value Through a Pointer
		Using Pointers
		Testing for a NULL Pointer
		Pointers to Constants
		Constant Pointers
		Naming Pointers
	Arrays and Pointers
	Multidimensional Arrays
		Multidimensional Arrays and Pointers
		Accessing Array Elements
	Using Memory As You Go
		Dynamic Memory Allocation: The malloc() Function
		Releasing Dynamically Allocated Memory
		Memory Allocation with the calloc() Function
		Extending Dynamically Allocated Memory
	Handling Strings Using Pointers
		Using Arrays of Pointers
		Pointers and Array Notation
	Designing a Program
		The Problem
		The Analysis
		The Solution
			Step 1
			Step 2
			Step 3
			Step 4
			Step 5
			Step 6
			Step 7
			Step 8
		The Complete Program
	Summary
Chapter 8: Structuring Your Programs
	Program Structure
		Variable Scope and Lifetime
		Variable Scope and Functions
	Functions
		Defining a Function
			Naming a Function
			Function Parameters
			Specifying the Return Value Type
		The return Statement
	The Pass-by-Value Mechanism
	Function Prototypes
	Pointers As Parameters and Return Types
		const Parameters
		Perils of Returning Pointers
	Summary
Chapter 9: More on Functions
	Pointers to Functions
		Declaring a Pointer to a Function
		Calling a Function Through a Function Pointer
		Arrays of Pointers to Functions
		Pointers to Functions As Arguments
	Variables in Functions
		Static Variables: Keeping Track Within a Function
		Sharing Variables Between Functions
	Functions That Call Themselves: Recursion
	Functions with a Variable Number of Arguments
		Copying a va_list
		Basic Rules for Variable-Length Argument Lists
	The main() Function
	Terminating a Program
		The abort() Function
		The exit() and atexit() Functions
		The _Exit() Function
		The quick_exit() and at_quick_exit() Functions
	Enhancing Performance
		Declaring Functions Inline
		Using the restrict Keyword
		The _Noreturn Function Specifier
	Designing a Program
		The Problem
		The Analysis
		The Solution
			Step 1
			Step 2
			Step 3
			Step 4
	Summary
Chapter 10: Essential Input and Output
	Input and Output Streams
	Standard Streams
	Input from the Keyboard
		Formatted Keyboard Input
		Input Format Control Strings
		Characters in the Input Format String
		Variations on Floating-Point Input
		Reading Hexadecimal and Octal Values
		Reading Characters Using scanf_s()
		String Input from the Keyboard
		Single-Character Keyboard Input
	Output to the Screen
		Formatted Output Using printf_s()
		Escape Sequences
		Integer Output
		Outputting Floating-Point Values
		Character Output
	Other Output Functions
		Unformatted Output to the Screen
		Formatted Output to an Array
		Formatted Input from an Array
	Summary
Chapter 11: Structuring Data
	Data Structures: Using struct
		Defining Structure Types and Structure Variables
		Accessing Structure Members
		Unnamed Structures
		Arrays of Structures
		Structure Members in Expressions
		Pointers to Structures
		Dynamic Memory Allocation for Structures
	More on Structure Members
		Structures As Members of a Structure
		Declaring a Structure Within a Structure
		Pointers to Structures As Structure Members
		Doubly Linked Lists
		Bit Fields in a Structure
	Structures and Functions
		Structures As Arguments to Functions
		Pointers to Structures As Function Arguments
		Structure As a Function Return Value
		Binary Trees
			Ordering Data in a Binary Tree
			Constructing a Binary Tree
			Traversing a Binary Tree
	Sharing Memory
	Designing a Program
		The Problem
		The Analysis
		The Solution
			Step 1
			Step 2
			Step 3
			Step 4
	Summary
Chapter 12: Working with Files
	The Concept of a File
		Positions in a File
		File Streams
	Accessing Files
		Opening a File
			Write Mode
			Append Mode
			Read Mode
		Buffering File Operations
		Renaming a File
		Closing a File
		Deleting a File
	Writing a Text File
	Reading a Text File
	Reading and Writing Strings to a Text File
	Formatted File Input and Output
		Formatted Output to a File
		Formatted Input from a File
	Dealing with Errors
	More Open Modes for Text Files
	The freopen_s() Function
	Binary File Input and Output
		Opening a File in Binary Mode
		Writing a Binary File
		Reading a Binary File
	Moving Around in a File
		File Positioning Operations
		Finding Out Where You Are
		Setting a Position in a File
	Using Temporary Work Files
		Creating a Temporary Work File
		Creating a Unique File Name
	Updating Binary Files
		Changing the Contents of a File
		Creating a Record from Keyboard Input
		Writing a Record to a File
		Reading a Record from a File
		Writing a File
		Listing the File Contents
		Updating the Existing File Contents
	File Open Modes Summary
	Designing a Program
		The Problem
		The Analysis
		The Solution
			Step 1
			Step 2
			Step 3
	Summary
Chapter 13: The Preprocessor and Debugging
	Preprocessing
		Including Header Files
		Defining Your Own Header Files
		Managing Multiple Source Files
		External Variables
		Static Functions
		Substitutions in Your Program Source Code
	Macros
		Macros That Look Like Functions
		Strings As Macro Arguments
		Joining Two Arguments in a Macro Expansion
	Preprocessor Directives on Multiple Lines
		Logical Preprocessor Directives
		Conditional Compilation
		Testing for Multiple Conditions
		Undefining Identifiers
		Testing for Specific Values for Identifiers
		Multiple-Choice Selections
		Standard Preprocessing Macros
		_Generic Macro
	Debugging Methods
		Integrated Debuggers
		The Preprocessor in Debugging
		Assertions
			Runtime Assertions
			Switching Off Assertions
			Compile-Time Assertions
	Date and Time Functions
		Getting Time Values
		Getting the Date
		Getting the Day for a Date
	Summary
Chapter 14: Advanced and Specialized Topics
	Working with International Character Sets
		Understanding Unicode
		Setting the Locale
		The Wide Character Type wchar_t
			Storing Wide Characters
			Operations on Wide Characters
			Working with Wide Character Strings
		Operations on Wide Character Strings
		File Stream Operations with Wide Characters
		Fixed Size Types That Store Unicode Characters
	Specialized Integer Types for Portability
		Fixed-Width Integer Types
		Minimum-Width Integer Types
		Maximum-Width Integer Types
	The Complex Number Types
		Complex Number Basics
		Complex Types and Operations
	Programming with Threads
		Creating a Thread
		Exiting a Thread
		Joining One Thread to Another
		Suspending a Thread
		Managing Thread Access to Data
			Creating a Mutex
			Acquiring a Mutex
			Releasing a Mutex
	Summary
Appendix A:
Computer Arithmetic
	Binary Numbers
	Hexadecimal Numbers
	Negative Binary Numbers
	Big-Endian and Little-Endian Systems
	Floating-Point Numbers
Appendix B:
ASCII Character Code Definitions
Appendix C:
Reserved Words in C
Appendix D:
Input and Output Format Specifications
	Output Format Specifications
	Input Format Specifications
Appendix E:
Standard Library Header Files
Index