Writing C

The implementation pages build up from the compilation pipeline to a working guessing game, one concept at a time: types and values, control flow, functions, the standard library. The final page brings everything together and points you at the Doom source code — the same C you just learned to write, at a different scale. Start at Setup.

Every Program Starts Here

The first C program I wrote compiled on the third try. The first two attempts produced error messages I did not understand — something about an implicit declaration, something about a missing semicolon the compiler said was on a line that looked fine to me. I stared at it for ten minutes before noticing the missing semicolon was on the line above the one the compiler pointed at. That is a lesson you learn once and never forget: the compiler tells you where it gave up, not always where the mistake is.

When it finally ran and printed Hello, world. I felt approximately nothing, which surprised me. It was twenty lines and one function call. But looking back, that moment contained everything: a source file, a preprocessor pulling in a header, a compiler turning text into object code, a linker producing an executable, the operating system loading it. The pipeline from .c to running program is the same pipeline that built Crash Bandicoot, just at a different scale. The concepts do not change when the programs get larger.

C has five things you need before you can write anything useful: types and variables to hold values, arithmetic to transform them, control flow to make decisions and repeat, functions to organise the work, and the standard library to talk to the outside world. This chapter covers all five through four programs: hello world, a calculator, a word counter, and a guessing game. Each one introduces the next concept. By the guessing game, you have used everything.

The programs are small. The calculator is not a production calculator. The word counter counts words in a single line. The guessing game has no graphics. None of that matters yet. What matters is understanding the pipeline, reading compiler errors without panic, and seeing how the pieces connect. The scale comes later.

The Project

• Write hello.c: a program that prints a greeting and exits cleanly.
• Write calculator.c: reads two numbers and an operator from standard input, performs the operation, and prints the result. Supports +, -, *, /. Handles division by zero.
• Write words.c: reads one line from standard input and prints the number of words and the number of characters it contains.
• Write guess.c: picks a random number between 1 and 100, reads guesses from the user, and responds with "Too high.", "Too low.", or the number of attempts it took to guess correctly.

All four programs must compile cleanly with gcc -Wall -Wextra.

The Tester

The tester lives in thecodingidiot-com/f04-writing-c. Copy test.sh into your working directory and run it from there:

cp test.sh ~/f04-practice/
cd ~/f04-practice
bash test.sh

It verifies:

• hello.c compiles and its output contains a greeting.
• calculator.c compiles and produces correct results for a set of test inputs.
• words.c compiles and counts words correctly for a set of test inputs.
• guess.c compiles cleanly. The game is interactive — the tester cannot play it. That check is self-certified.

The Companion Repo

f04-writing-c