The Little Book of C

Version 0.3.2

Content

A 100-step journey to learn C from first principles

• Download PDF - print-ready
• Download EPUB - e-reader friendly
• View LaTex - .tex source
• Source code (Github) - Markdown source
• Read on GitHub Pages

Chapter 1. Getting Started with C

1. What Is C and Why Learn It
2. Installing a C Compiler
3. Writing Your First C Program
4. Understanding main and Return Values
5. Printing with printf
6. Comments and Code Readability
7. Variables and Basic Types
8. Declaring and Initializing Variables
9. Compiling and Running Programs
10. Common Beginner Mistakes

Chapter 2. Working with Data

11. Integers, Floats, and Characters
12. Type Conversions and Casting
13. Constants and Literals
14. Operators and Expressions
15. Arithmetic Operators
16. Comparison and Logical Operators
17. Operator Precedence
18. Reading Input with scanf
19. The sizeof Operator
20. Debugging Type Errors

Chapter 3. Control Flow

21. The if Statement
22. The else and else if Clauses
23. Nested Conditionals
24. The switch Statement
25. The while Loop
26. The for Loop
27. The do-while Loop
28. Breaking and Continuing Loops
29. Using goto Safely (and Why to Avoid It)
30. Patterns of Control Flow

Chapter 4. Functions and Scope

31. Defining and Calling Functions
32. Function Parameters and Return Values
33. Local and Global Variables
34. Scope and Lifetime
35. Header Declarations (.h files)
36. Pass by Value Explained
37. Recursion and Base Cases
38. Function Prototypes and Order
39. Inline Functions
40. Organizing Code with Functions

Chapter 5. Arrays and Strings

41. Declaring Arrays
42. Indexing and Bounds
43. Multidimensional Arrays
44. Iterating over Arrays
45. Strings as Character Arrays
46. String Literals and Null Terminators
47. Common String Functions (strlen, strcpy, strcmp)
48. Inputting Strings
49. Arrays vs. Pointers (A Gentle Intro)
50. Common Array Pitfalls

Chapter 6. Pointers and Memory

51. What Is a Pointer
52. The Address-of (&) and Dereference (*) Operators
53. Pointer Arithmetic
54. Arrays and Pointers Revisited
55. Function Parameters with Pointers
56. Dynamic Memory Allocation with malloc
57. Using free Safely
58. Pointer to Pointer
59. NULL and Dangling Pointers
60. Debugging Memory Errors

Chapter 7. Structures and Modular Design

61. Defining struct Types
62. Accessing Structure Members
63. Structures and Functions
64. Nested Structures
65. Arrays of Structures
66. Typedefs for Simpler Names
67. Enums and Symbolic Constants
68. Unions and Shared Memory
69. Organizing Code into Modules
70. Splitting Code into .c and .h Files

Chapter 8. The Power of the Preprocessor

71. What Is the Preprocessor
72. #include and Header Guards
73. Defining Macros with #define
74. Working with Paths and Filenames
75. Conditional Compilation (#if, #ifdef)
76. Function-like Macros
77. Debugging with #error and #warning
78. Built-in Macros (__FILE__, __LINE__)
79. The Compilation Pipeline (Preprocess → Compile → Link)
80. Balancing Macros and Functions

Chapter 9. Files, Tools, and Concurrency

81. File I/O Basics: fopen, fclose
82. Reading and Writing Files
83. Working with Binary Files
84. Error Handling in File Operations
85. Command-Line Arguments
86. Using make and Makefiles
87. Debugging with gdb
88. Understanding Linking and Libraries
89. Simple Threads with <threads.h>
90. Synchronization and Data Safety

Chapter 10. Putting It All Together

91. Mini Project 1: Text Analyzer
92. Mini Project 2: Guessing Game
93. Mini Project 3: Calculator
94. Mini Project 4: File Copy Utility
95. Mini Project 5: Simple Logger
96. Mini Project 6: Contact Book
97. Mini Project 7: Matrix Operations
98. Mini Project 8: JSON-like Parser
99. Mini Project 9: Mini Shell
100. Mini Project 10: Tiny HTTP Server