Preface

• Who this book is for
• What this book covers
• To get the most out of this book
• Download the example code files
• Download the color images
• Conventions used
• Get in touch
• Reviews

1. Section 1: C Fundamentals

2. Running Hello, World! FREE CHAPTER

• Technical requirements
• Writing your first C program
• Hello, world!
• Understanding the program development cycle
• Edit
• Compile
• Many C compilers for every OS
• A note about IDEs
• Installing a compiler on Linux, macOS, or Windows
• Run
• Verify
• Repeat
• A note about debugging
• Creating, typing, and saving your first C program
• Compiling your first C program
• Running your first C program
• Writing comments to clarify the program later
• Some guidelines on commenting code
• Adding comments to the Hello, world! program
• Learning to experiment with code
• Summary

3. Understanding Program Structure

• Technical requirements
• Introducing statements and blocks
• Experimenting with statements and blocks
• Understanding delimiters
• Understanding whitespace
• Introducing statements
• Introducing functions
• Understanding function definitions
• Exploring function identifiers
• Exploring the function block
• Exploring function return values
• Passing in values with function parameters
• Order of execution
• Understanding function declarations
• Summary

4. Working with Basic Data Types

• Technical requirements
• Understanding data types
• Bytes and chunks of data
• Representing whole numbers
• Representing positive and negative whole numbers
• Specifying different sizes of integers
• Representing numbers with decimals
• Representing single characters
• Representing Boolean true/false
• Understanding the sizes of data types
• The sizeof() operator
• Ranges of values
• Summary

5. Using Variables and Assignment

• Technical requirements
• Understanding types and values
• Introducing variables
• Naming variables
• Introducing explicit types of variables
• Using explicit typing with initialization
• Exploring constants
• Literal constants
• Defined values
• Explicitly typed constants
• Naming constant variables
• Using types and assignment
• Using explicit assignment, the simplest statement
• Assigning values by passing function parameters
• Assignment by the function return value
• Summary

6. Exploring Operators and Expressions

• Technical requirements
• Expressions and operations
• Introducing operations on numbers
• Considering the special issues resulting from operations on numbers
• Understanding NaN
• Understanding underflow NaN
• Understanding overflow NaN
• Considering precision
• Exploring type conversion
• Understanding implicit type conversion and values
• Using explicit type conversion – casting
• Introducing operations on characters
• Exploring logical and relational operators
• Bitwise operators
• The conditional operator
• The sequence operator
• Compound assignment operators
• Multiple assignments in a single expression
• Incremental operators
• Postfix versus prefix incrementation
• Order of operations and grouping
• Summary

7. Exploring Conditional Program Flow

• Technical requirements
• Understanding conditional expressions
• Introducing the if()… else… complex statement
• Using a switch()… complex statement
• Introducing multiple if()… statements
• Using nested if()… else… statements
• The dangling else… problem
• Summary

8. Exploring Loops and Iteration

• Technical requirements
• Understanding repetition
• Understanding brute-force repetition
• Introducing the while()… statement
• Introducing the for()… statement
• Introducing the do … while() statement
• Understanding loop equivalency
• Understanding unconditional branching – the dos and (mostly) don'ts of goto
• Further controlling loops with break and continue
• Understanding infinite loops
• Summary

9. Creating and Using Enumerations

• Technical requirements
• Introducing enumerations
• Defining enumerations
• Using enumerations
• The switch()… statement revisited
• Summary

10. Section 2: Complex Data Types

11. Creating and Using Structures

• Technical requirements
• Understanding structures
• Declaring structures
• Initializing structures and accessing structure elements
• Performing operations on structures – functions
• Structures of structures
• Initializing structures with functions
• Printing a structure of structures – reusing functions
• The stepping stone to object-oriented programming
• Summary

12. Creating Custom Data Types with typedef

• Technical requirements
• Renaming intrinsic types with typedef
• Using synonyms
• Simplifying the use of enum types with typedef
• Simplifying the use of struct types with typedef
• Other uses of typedef
• Some more useful compiler options
• Using a header file for custom types and the typedef specifiers
• Summary

13. Working with Arrays

• Technical requirements
• Declaring and initializing arrays
• Initializing arrays
• Accessing array elements
• Assigning values to array elements
• Operating on arrays with loops
• Using functions that operate on arrays
• Summary

14. Working with Multi-Dimensional Arrays

• Technical requirements
• Going beyond one-dimensional arrays to multi-dimensional arrays
• Revisiting one-dimensional arrays
• Moving on to two-dimensional arrays
• Moving on to three-dimensional arrays
• Considering N-dimensional arrays
• Declaring and initializing multi-dimensional arrays
• Declaring arrays of two dimensions
• Initializing arrays of two dimensions
• Declaring arrays of three dimensions
• Initializing arrays of three dimensions
• Declaring and initializing arrays of N dimensions
• Accessing elements of multi-dimensional arrays
• Manipulating multi-dimensional arrays – loops within loops
• Using nested loops to traverse a two-dimensional array
• Using nested loops to traverse a three-dimensional array
• Using multi-dimensional arrays in functions
• Summary

15. Using Pointers

• Technical requirements
• Addressing pointers – the boogeyman of C programming
• Why use pointers at all?
• Introducing pointers
• Understanding direct addressing and indirect addressing
• Understanding memory and memory addressing
• Managing and accessing memory
• Exploring some analogies in the real world
• Declaring the pointer type, naming pointers, and assigning addresses
• Declaring the pointer type
• Naming pointers
• Assigning pointer values (addresses)
• Operations with pointers
• Assigning pointer values
• Differentiating between the NULL pointer and void*
• Understanding the void* type
• Accessing pointer targets
• Pointer arithmetic
• Comparing pointers
• Verbalizing pointer operations
• Variable function arguments
• Passing values by reference
• Passing addresses to functions without pointer variables
• Pointers to pointers
• Using pointers to structures
• Accessing structures and their elements via pointers
• Using pointers to structures in functions
• Summary

16. Understanding Arrays and Pointers

• Technical requirements
• Understanding array names and pointers
• Understanding array elements and pointers
• Accessing array elements via pointers
• Operations on arrays using pointers
• Using pointer arithmetic
• Using the increment operator
• Passing arrays as function pointers revisited
• Interchangeability of array names and pointers
• Introducing an array of pointers to arrays
• Summary

17. Working with Strings

• Technical requirements
• Characters – the building blocks of strings
• The char type and ASCII
• Beyond ASCII – UTF-8 and Unicode
• Operations on characters
• Getting information about characters
• Manipulating characters
• Exploring C strings
• An array with a terminator
• Strengths of C strings
• Weaknesses of C strings
• Declaring and initializing a string
• String declarations
• Initializing strings
• Passing a string to a function
• Empty strings versus null strings
• Hello, World! revisited
• Creating and using an array of strings
• Common operations on strings – the standard library
• Common functions
• Safer string operations
• Summary

18. Creating and Using More Complex Structures

• Technical requirements
• Introducing the need for complex structures
• Revisiting card4.h
• Understanding an array of structures
• Creating an array of structures
• Accessing structure elements within an array
• Manipulating an array of structures
• Using a structure with other structures
• Creating a structure consisting of other structures
• Accessing structure elements within the structure
• Manipulating a structure consisting of other structures
• Using a structure with arrays
• Understanding randomness and random number generators
• Creating a structure with an array
• Accessing array elements within a structure
• Manipulating array elements within a structure
• Revisiting the hand structure
• Revisiting hand operations
• Using a structure with an array of structures
• Creating a structure with an array of structures
• Accessing individual structure elements of the array within a structure
• Manipulating a structure with an array of structures
• Completing carddeck.c
• Revisiting the deck structure
• Revisiting deck operations
• A basic card program
• Summary

19. Section 3: Memory Manipulation

20. Understanding Memory Allocation and Lifetime

• Technical requirements
• Defining storage classes
• Understanding automatic versus dynamic storage classes
• Automatic storage
• Dynamic storage
• Understanding internal versus external storage classes
• Internal or local storage classes
• External or global storage classes
• The lifetime of automatic storage
• Exploring the static storage class
• Internal static storage
• External static storage
• The lifetime of static storage
• Summary

21. Using Dynamic Memory Allocation

• Technical requirements
• Introducing dynamic memory
• A brief tour of C's memory layout
• Allocating and releasing dynamic memory
• Allocating dynamic memory
• Releasing dynamic memory
• Accessing dynamic memory
• The lifetime of dynamic memory
• Special considerations for dynamic allocation
• Heap memory management
• Memory leaks
• The linked list dynamic data structure
• Linked list structures
• Declaring operations on a linked list
• Pointers to functions
• More complex operations on a linked list
• A program to test our linked list structure
• Other dynamic data structures
• Summary

22. Section 4: Input and Output

23. Exploring Formatted Output

• Technical requirements
• Revisiting printf()
• Understanding the general format specifier form
• Using format specifiers for unsigned integers
• Using unsigned integers in different bases
• Considering negative numbers as unsigned integers
• Exploring powers of 2 and 9 in different bases
• Printing pointer values
• Using format specifiers for signed integers
• Using the signed integer field width, precision, alignment, and zero-filling
• Formatting long-long integers
• Powers of 2 and 9 with different modifiers
• Using format specifiers for floats and doubles
• Using the floating-point field width, precision, alignment, and zero-filling
• Printing doubles in hexadecimal format
• Printing optimal field widths for doubles
• Using format specifiers for strings and characters
• Using the string field width, precision, alignment, and zero-filling
• Exploring the sub-string output
• Using single character formatting
• Summary

24. Getting Input from the Command Line

• Technical requirements
• Revisiting the main() function
• The special features of main()
• The two forms of main()
• Using argc and argv
• A simple use of argc and argv
• Command-line switches and command-line processors
• Summary

25. Exploring Formatted Input

• Technical requirements
• Introducing streams
• Understanding the standard output stream
• Understanding the standard input stream
• Revisiting the console output with printf() and fprintf()
• Exploring the console input with scanf()
• Reading formatted input with scanf()
• Reading numerical input with scanf()
• Reading string and character input with scanf()
• Using a scan set to limit possible input characters
• Controlling the scanf() input field width
• Using internal data conversion
• Using sscanf() and sprintf() to convert values into and from strings
• Converting strings into numbers with atoi() and atod()
• Exploring unformatted input and output
• Getting the string input and output to/from the console
• Using the simple input and output of strings with gets() and puts()
• Understanding why using gets() could be dangerous
• Creating a sorted list of names with fgets() and fputs()
• Summary

26. Working with Files

• Technical requirements
• Understanding basic file concepts
• Revisiting file streams
• Understanding the properties of the FILE streams
• Opening and closing a file
• Understanding file operations for each type of stream
• Introducing the filesystem essentials
• Introducing the filesystem
• Understanding a file path
• Understanding a filename
• Opening files for reading and writing
• Getting filenames from within the program
• Getting filenames from the command line
• Summary

27. Using File Input and File Output

• Technical requirements
• File processing
• Creating a template program to process filenames given on the command line
• Creating a file of unsorted names
• Trimming the input string from fgets()
• Reading names and writing names
• Reading unsorted names and sorting them for output
• Using a linked list to sort names
• Writing names in sorted order
• Summary

28. Section 5: Building Blocks for Larger Programs

29. Working with Multi-File Programs

• Technical requirements
• Understanding multi-file programs
• Using header files for declarations and source files for definitions
• Creating source files
• Creating header files
• Revisiting the preprocessor
• Understanding the limits and dangers of the preprocessor
• Knowing some dangers of the preprocessor
• Using the preprocessor effectively
• Debugging with the preprocessor
• Creating a multi-file program
• Extracting Card structures and functions
• Extracting Hand structures and functions
• Extracting Deck structures and functions
• Finishing the dealer.c program
• Building a multi-file program
• Summary

30. Understanding Scope

• Technical requirements
• Defining scope – visibility, extent, and linkage
• Exploring visibility
• Exploring extent
• Exploring linkage
• Understanding compilation units
• Putting visibility, extent, and linkage all together
• Exploring variable scope
• Understanding the block scope of variables
• Understanding function parameter scope
• Understanding file scope
• Understanding global scope
• Understanding function scope
• Understanding scope and information hiding
• Using the static specifier for functions
• Summary
• Epilog
• Taking the next steps
• More advanced C topics
• More advanced programming topics
• Picking a project for yourself
• Resources

31. Other Books You May Enjoy

• Leave a review - let other readers know what you think

Appendix

• C keywords
• Table of operators and their precedence
• Summary of useful GCC and Clang compiler options
• ASCII character set
• The Better String Library (Bstrlib)
• A quick introduction to Bstrlib
• A few simple examples
• Unicode and UTF-8
• A brief history
• Where we are today
• Moving from ASCII to UTF-8
• A UTF-to-Unicode example
• The C standard library
• Method 1
• Method 2
• Method 3