C PROGRAMMING FOR DUMMIES,

Title Page
Copyright Page
Table of Contents
Introduction
	Why the C Language?
	The C Programming For Dummies Approach
	How This Book Works
	Icons Used in This Book
	Parting Thoughts
Part 1 The ABs of C
	Chapter 1 A Quick Start for the Impatient
		What You Need to Program
		Command Prompt Programming
		IDE Programming
			Installing Code::Blocks
			Touring the Code::Blocks workspace
		Your First Program
			Coding at the command prompt
			Building a new Code::Blocks project
			Building and running
	Chapter 2 The Programming Thing
		The History of Programming
			Reviewing early programming history
			Introducing the C language
		The Programming Process
			Understanding programming
			Writing source code
			Compiling and linking
			Running and testing
	Chapter 3 Anatomy of C
		Parts of the C Language
			Keywords
			Functions
			Operators
			Variables and values
			Statements and structure
			Comments
		Behold the Typical C Program
			Understanding C program structure
			Setting the main() function
			Returning something to the operating system
			Adding a function
Part 2 C Programming 101
	Chapter 4 Trials and Errors
		Display Stuff on the Screen
			Displaying a humorous message
			Introducing the puts() function
			Adding more text
			Commenting out a statement
			Goofing up on purpose
		More Text Output Nonsense
			Displaying text with printf()
			Introducing the printf() function
			Understanding the newline
			Employing escape sequences
			Goofing up on purpose again
	Chapter 5 Values and Simple Math
		A Venue for Various Values
			Understanding values
			Displaying values with printf()
			Minding the extra zeros
		The Computer Does the Math
			Doing simple arithmetic
			Reviewing the float-integer thing
			Pretending integers are floats
	Chapter 6 A Place to Put Stuff
		Values That Vary
			Setting up a quick example
			Introducing data types
			Using variables
		Variable Madness!
			Using more-specific data types
			Working with several variables
			Assigning a value upon creation
			Reusing variables
		Constants Always the Same
			Using the same value over and over
			Constants in your code
			Putting constants to use
	Chapter 7 Input and Output
		Character I/O
			Understanding input and output devices
			Fetching characters with getchar()
			Using the putchar() function
			Working with character variables
		Text I/O, but Mostly I
			Storing strings
			Introducing the scanf() function
			Reading a string with scanf()
			Reading values with scanf()
			Using fgets() for text input
	Chapter 8 Decision Making
		What If?
			Making a simple comparison
			Introducing the if keyword
			Comparing values in various ways
			Knowing the difference between = and ==
			Forgetting where to put the semicolon
		Multiple Decisions
			Making more-complex decisions
			Adding a third option
		Multiple Comparisons with Logic
			Building a logical comparison
			Adding some logical operators
		The Old Switch Case Trick
			Making a multiple-choice selection
			Understanding the switch-case structure
			Taking no breaks
		The Weird ?: Decision Thing
	Chapter 9 Loops, Loops, Loops
		A Little Déjà Vu
		The Thrill of for Loops
			Doing something x number of times
			Introducing the for loop
			Counting with the for statement
			Looping letters
			Nesting for loops
		The Joy of the while Loop
			Structuring a while loop
			Using the do while loop
		Loopy Stuff
			Looping endlessly
			Looping endlessly but on purpose
			Breaking out of a loop
			Adding multiple for loop conditions
			Screwing up a loop
	Chapter 10 Fun with Functions
		Anatomy of a Function
			Constructing a function
			Prototyping (or not)
		Functions and Variables
			Using variables in functions
			Sending a value to a function
			Sending multiple values to a function
			Creating functions that return values
			Returning early
		Constants of the Global Kind
			Introducing defined constants
			Putting defined constants to use
Part 3 Build Upon What You Know
	Chapter 11 The Unavoidable Math Chapter
		Math Operators from Beyond Infinity
			Incrementing and decrementing
			Prefixing the ++ and -- operators
			Discovering the remainder (modulus)
			Saving time with assignment operators
		Math Function Mania
			Exploring some common math functions
			Suffering through trigonometry
		It’s Totally Random
			Spewing random numbers
			Making the numbers more random
		The Holy Order of Precedence
			Getting the order correct
			Forcing order with parentheses
	Chapter 12 Give Me Arrays
		Behold the Array
			Avoiding arrays
			Understanding arrays
			Initializing an array
			Playing with character arrays (strings)
			Working with empty char arrays
			Sorting arrays
		Multidimensional Arrays
			Making a two-dimensional array
			Going crazy with three-dimensional arrays
			Declaring an initialized multidimensional array
		Arrays and Functions
			Passing an array to a function
			Returning an array from a function
	Chapter 13 Fun with Text
		Character Manipulation Functions
			Introducing the CTYPEs
			Testing characters
			Changing characters
		String Functions Galore
			Reviewing string functions
			Comparing text
			Building strings
		Fun with printf() Formatting
			Formatting floating point
			Setting the output width
			Aligning output
		Gently Down the Stream
			Demonstrating stream input
			Dealing with stream input
	Chapter 14 Structures, the Multivariable
		Hello, Structure
			Introducing the multivariable
			Understanding struct
			Filling a structure
			Making an array of structures
		Weird Structure Concepts
			Putting structures within structures
			Passing a structure to a function
	Chapter 15 Life at the Command Prompt
		Conjure a Terminal Window
			Starting a terminal window
			Running code in text mode
		Arguments for the main() Function
			Reading the command line
			Understanding main()’s arguments
		Time to Bail
			Quitting the program
			Running another program
	Chapter 16 Variable Nonsense
		Variable Control
			Typecasting into disbelief
			Creating new things with typedef
			Making static variables
		Variables, Variables Everywhere
			Using external variables
			Creating an external structure variable
			Enumerating
	Chapter 17 Binary Mania
		Binary Basics
			Understanding binary
			Outputting binary values
		Bit Manipulation
			Using the bitwise | operator
			Using bitwise &
			Operating exclusively with XOR
			Understanding the ~ and ! operators
			Shifting binary values
			Explaining the binbin() function
		The Joy of Hex
Part 4 The Advanced Part
	Chapter 18 Introduction to Pointers
		The Biggest Problem with Pointers
		Sizing Up Variable Storage
			Understanding variable storage
			Reading a variable’s size
			Checking a variable’s location
			Reviewing variable storage info
		The Hideously Complex Topic of Pointers
			Introducing the pointer
			Working with pointers
	Chapter 19 Deep into Pointer Land
		Pointers and Arrays
			Getting the address of an array
			Working pointer math in an array
			Substituting pointers for array notation
		Strings Are Pointer-Things
			Using pointers to display a string
			Using a pointer to declare a string
			Building an array of pointers
			Sorting strings
		Pointers in Functions
			Passing a pointer to a function
			Returning a pointer from a function
	Chapter 20 Memory Chunks and Linked Lists
		Give Me Memory!
			Introducing the malloc() function
			Creating string storage
			Using the calloc() function
			Getting more memory
			Freeing memory
		Lists That Link
			Allocating space for a structure
			Creating a linked list
			Editing a linked list
			Saving a linked list
	Chapter 21 It’s About Time
		What Time Is It?
			Understanding the calendar
			Working with time in C
		Time to Program
			Checking the clock
			Viewing a timestamp
			Slicing through the time string
			Snoozing
Part 5 And the Rest of It
	Chapter 22 Permanent Storage Functions
		Sequential File Access
			Understanding C file access
			Writing text to a file
			Reading text from a file
			Appending text to a file
			Writing binary data
			Reading binary data
		Random File Access
			Writing a structure to a file
			Reading and rewinding
			Finding a specific record
			Saving a linked list to a file
	Chapter 23 File Management
		Directory Madness
			Calling up a directory
			Gathering more file info
			Separating files from directories
			Exploring the directory tree
		Fun with Files
			Renaming a file
			Copying a file
			Deleting a file
	Chapter 24 Beyond Mere Mortal Projects
		The Multi-Module Monster
			Linking two source code files
			Sharing variables between modules
			Creating a custom header file
		Other Libraries to Link
	Chapter 25 Out, Bugs!
		Simple Tricks to Resolve Problems
			Documenting the flow
			Talking through your code
			Writing comments for future-you
		The Debugger
			Debugging setup
			Working the debugger
			Setting a breakpoint
			Watching variables
		Improved Error Messages
Part 6 The Part of Tens
	Chapter 26 Ten Common Boo-Boos
		Conditional Foul-Ups
		== v. =
		Dangerous Loop Semicolons
		Commas in for Loops
		Missing break in a switch Structure
		Missing Parentheses and Curly Brackets
		Don’t Ignore a Warning
		Endless Loops
		scanf() Blunders
		Streaming Input Restrictions
	Chapter 27 Ten Reminders and Suggestions
		Maintain Good Posture
		Use Creative Names
		Write a Function
		Work on Your Code a Little Bit at a Time
		Break Apart Larger Projects into Several Modules
		Know What a Pointer Is
		Add Whitespace before Condensing
		Know When if-else Becomes switch-case
		Remember Assignment Operators
		When You Get Stuck, Read Your Code Out Loud
Part 7 Appendices
	Appendix A ASCII Codes
	Appendix B Keywords
	Appendix C Operators
	Appendix D Data Types
	Appendix E Escape Sequences
	Appendix F Conversion Characters
	Appendix G Order of Precedence
Index
EULA