Preface

• Preface to the First Edition
• 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
• Share Your Thoughts

1. Part 1: C Fundamentals

2. Chapter 1: Running Hello, World! FREE CHAPTER

• Technical requirements
• Writing your first C program
• Understanding the program development cycle
• 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
• Learning to experiment with code
• Summary

3. Chapter 2: Understanding Program Structure

• Technical requirements
• Introducing statements and blocks
• Introducing functions
• Understanding function definitions
• Order of execution
• Understanding function declarations
• Summary
• Questions

4. Chapter 3: Working with Basic Data Types

• Technical requirements
• Understanding data types
• Bytes and chunks of data
• Representing whole numbers
• Representing numbers with fractions
• Representing single characters
• Representing Boolean true/false
• Understanding the sizes of data types
• Summary
• Questions

5. Chapter 4: Using Variables and Assignments

• Technical requirements
• Understanding data types and values
• Introducing variables
• Exploring constants
• Using types and assignments
• Summary
• Questions

6. Chapter 5: Exploring Operators and Expressions

• Technical requirements
• Understanding expressions and operations
• Introducing operations on numbers
• Exploring type conversion
• Introducing operations on characters
• Order of operations and grouping
• Summary
• Questions

7. Chapter 6: 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
• Summary
• Questions

8. Chapter 7: Exploring Loops and Iterations

• 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
• Questions

9. Chapter 8: Creating and Using Enumerations

• Technical requirements
• Introducing enumerations
• The switch()… statement revisited
• Using enumerated item values as literal integer constants
• Summary
• Questions

10. Part 2: Complex Data Types

11. Chapter 9: Creating and Using Structures

• Technical requirements
• Understanding structures
• Performing operations on structures – functions
• Structures of structures
• The stepping stone to OOP
• Summary
• Questions

12. Chapter 10: Creating Custom Data Types with typedef

• Technical requirements
• Renaming intrinsic types with typedef
• Simplifying the use of enum types with typedef
• Simplifying the use of struct types with typedef
• Exploring some more useful compiler options
• Using a header file for custom types and the typedef specifiers
• Summary
• Questions

13. Chapter 11: Working with Arrays

• Technical requirements
• Declaring and initializing arrays
• Understanding variable-length arrays
• Accessing array elements
• Operating on arrays with loops
• Using functions that operate on arrays
• Summary
• Questions

14. Chapter 12: Working with Multi-Dimensional Arrays

• Technical requirements
• Going beyond 1D arrays to multi-dimensional arrays
• Declaring and initializing multi-dimensional arrays of various dimensions
• Accessing elements of multi-dimensional arrays of various dimensions
• Manipulating multi-dimensional arrays using loops within loops
• Using multi-dimensional arrays in functions
• Summary
• Questions

15. Chapter 13: Using Pointers

• Technical requirements
• Addressing pointers – the boogeyman of C programming
• Introducing pointers
• Declaring the pointer type, naming pointers, and assigning addresses
• Operations with pointers
• Verbalizing pointer operations
• Variable function arguments
• Using pointers to structures
• Summary
• Questions

16. Chapter 14: Understanding Arrays and Pointers

• Technical requirements
• Understanding array names and pointers
• Understanding array elements and pointers
• Operations on arrays using pointers
• Introducing an array of pointers to arrays
• Summary
• Questions

17. Chapter 15: Working with Strings

• Technical requirements
• Characters – the building blocks of strings
• Exploring C strings
• Declaring and initializing a string
• Creating and using an array of strings
• Common operations on strings – the standard library
• Summary
• Questions

18. Chapter 16: Creating and Using More Complex Structures

• Technical requirements
• Introducing the need for complex structures
• Revisiting card4.h
• Understanding an array of structures
• Using a structure with other structures
• Using a structure with arrays
• Using a structure with an array of structures
• Summary
• Questions

19. Part 3: Memory Manipulation

20. Chapter 17: Understanding Memory Allocation and Lifetime

• Technical requirements
• Defining storage classes
• Understanding automatic versus dynamic storage classes
• Understanding internal versus external storage classes
• Exploring the static storage class
• Summary
• Questions

21. Chapter 18: Using Dynamic Memory Allocation

• Technical requirements
• Introducing dynamic memory
• Allocating and releasing dynamic memory
• Special considerations for dynamic allocation
• The linked list dynamic data structure
• Pointers to functions
• Other dynamic data structures
• Summary
• Questions

22. Part 4: Input and Output

23. Chapter 19: Exploring Formatted Output

• Technical requirements
• Revisiting printf()
• Using format specifiers for unsigned integers
• Using format specifiers for signed integers
• Using format specifiers for floats and doubles
• Using format specifiers for strings and characters
• Summary
• Questions

24. Chapter 20: Getting Input from the Command Line

• Technical requirements
• Revisiting the main() function
• Using argc and argv
• Summary
• Questions

25. Chapter 21: Exploring Formatted Input

• Technical requirements
• Introducing streams
• Reading formatted input with scanf()
• Using internal data conversion
• Exploring unformatted I/O
• Summary
• Questions

26. Chapter 22: Working with Files

• Technical requirements
• Understanding basic file concepts
• Introducing the filesystem essentials
• Opening files for reading and writing
• Summary
• Questions

27. Chapter 23: Using File Input and File Output

• Technical requirements
• File processing
• Creating a file of unsorted names
• Reading unsorted names and sorting them for output
• Summary
• Questions

28. Part 5: Building Blocks for Larger Programs

29. Chapter 24: Working with Multi-File Programs

• Technical requirements
• Understanding multi-file programs
• Using header files for declarations and source files for definitions
• Revisiting the preprocessor
• Creating a multi-file program
• Building a multi-file program
• Summary
• Questions

30. Chapter 25: Understanding Scope

• Technical requirements
• Defining scope – visibility, extent, and linkage
• Exploring variable scope
• Understanding the block scope of variables
• Understanding scope for functions
• Summary
• Questions

31. Chapter 26: Building Multi-File Programs with Make

• Technical requirements
• Preparing dealer.c for make
• Introducing the make utility
• Using macros
• Creating rules – targets, dependencies, and actions
• A general makefile for simple projects
• Going further with make
• Summary
• Questions

32. Chapter 27: Creating Two Card Programs

• Technical requirements
• Game one – Blackjack
• Game two – One-Handed Solitaire
• Summary

33. Epilogue

• Taking the next steps

34. Assessments

• Chapter 2 – Understanding Program Structure
• Chapter 3 – Working with Basic Data Types
• Chapter 4 – Using Variables and Assignments
• Chapter 5 – Exploring Operators and Expressions
• Chapter 6 – Exploring Conditional Program Flow
• Chapter 7 – Exploring Loops and Iteration
• Chapter 8 – Creating and Using Enumerations
• Chapter 9 – Creating and Using Structures
• Chapter 10 – Creating Custom Data Types with typedef
• Chapter 11 – Working with Arrays
• Chapter 12 – Working with Multi-Dimensional Arrays
• Chapter 13 – Using Pointers
• Chapter 14 – Understanding Arrays and Pointers
• Chapter 15 – Working with Strings
• Chapter 16 – Creating and Using More Complex Structures
• Chapter 17 – Understanding Memory Allocation and Lifetime
• Chapter 18 – Using Dynamic Memory Allocation
• Chapter 19 – Exploring Formatted Output
• Chapter 20 – Getting Input from the Command Line
• Chapter 21 – Exploring Formatted Input
• Chapter 22 – Working with Files
• Chapter 23 – Using File Input and File Output
• Chapter 24 – Working with Multi-File Programs
• Chapter 25 – Understanding Scope

35. Index

• Why subscribe?

36. Other Books You May Enjoy

• Packt is searching for authors like you
• Share Your Thoughts

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 UTF to Unicode example
• The C standard library
• Method 1
• Method 2
• Method 3