16 Hello world

16.1 The first program#

By tradition, the first program greets the world.

#include <stdio.h>

int main(void)
{
    printf("Hello, world!\n");
    return 0;
}

This is a kind of work plan written in the grammar of the C language, and it is called source code. It becomes an executable file we can run only after a translator called a compiler turns it into machine code and joins it with already-made, pre-built machine code (called a library). Look at that process, and at what the first program actually produces.

But one more thing is needed before that. Where and how is the executable run once it is made? That place is the terminal.

16.2 The terminal and the shell — where a program is run#

Chapter 9 showed “a band of characters flowing one line at a time”. Today’s window onto that band is the terminal. Open it and you can type characters; something answers what you typed.

Here we need to tell two names apart: terminal and shell. They are used loosely as one, but they do different jobs.

That is, the terminal is the glass, the shell is the worker behind it. “Typing a command into the terminal” is really “typing a command to the shell through the terminal”.

16.2.1 Which terminals (windows) and which shells (workers)#

Which terminal window you use is a matter of taste; the result is the same either way. But a different worker means a different grammar — the same job is written differently, which is why, when copying a command off the internet, the first question is “whose shell is this written for?”.

How to tell which worker you are talking to also differs.

16.2.2 What a shell does — read, split, run#

Given a line, a shell always takes the same three steps.

1. Read — take the line up to the Enter.
2. Split — cut it into words at the spaces. The first word is what to do; the rest are the arguments.
3. Run — if the first word is something the shell knows itself, do it; otherwise find an executable file of that name and launch it.

The “something it knows itself” in that third step is a built-in command. It is fixed inside the shell, with no file of its own.

The names in parentheses are aliases — PowerShell attached familiar names like ls and cd to the same jobs for people arriving from Unix. Just remember that the same name is a different program.

16.2.3 Running the executable you made#

Compile the first program and one executable file appears. How it is run differs a little by platform, and this is where beginners get stuck most often.

16.2.4 Passing arguments — how a program is handed values#

The shell cuts a line into words, we said. What follows the first word is passed to the program, and those are its arguments.

gcc -Wall -o hello hello.c

Here gcc is what runs, and the four that follow are arguments. Arguments come in conventional kinds.

An argument containing a space is wrapped in quotes, because the shell splits words at spaces.

gcc -o "my program" hello.c     # when the name has a space

These are the shell’s rules, not C’s. How a C program receives those arguments — main’s argc and argv — is covered in chapter 59.

16.3 Compiling and running from the command line#

Now to turn that work plan — the source code hello.c — into an executable. There are many compilers, but their command lines fall into three patterns — GCC, Clang and MSVC. The first two share almost all their option syntax; only MSVC belongs to another lineage.

16.3.1 GCC (Linux, macOS, MinGW)#

gcc -std=c23 -Wall -Wextra -o hello hello.c
./hello

Word by word: gcc is the program to call, -std=c23 says “read this as C23”, -Wall -Wextra says “tell me everything suspicious” (chapter 18 covers why these two are always on), -o hello says “name the result hello”, and the final hello.c is the material.

Drop the -o and the result comes out named a.out — a default handed down from early Unix, short for “assembler output”.

16.3.2 Clang (the macOS default; Linux and Windows too)#

clang -std=c23 -Wall -Wextra -o hello hello.c
./hello

Clang takes the same options as GCC. It was made that way on purpose, to drop in where GCC was, so switching between the two rarely means editing a command. It is also why this book can cross-check its listings with both.

On macOS, the gcc command often runs Clang — gcc --version shows which compiler is actually running.

16.3.3 MSVC (Windows)#

MSVC differs from the start, in its option syntax. And it must be run in its own window.

cl /std:c17 /W4 hello.c
hello.exe

A window of its own is needed because MSVC relies on several environment variables (the paths to headers and libraries). The Start menu’s “x64 Native Tools Command Prompt for VS” opens a cmd with those variables set. Type cl in an ordinary cmd and you get “not recognized as an internal or external command” — not because the file is missing but because PATH was not set up, as the misconception box in “Running the executable you made” explained: a shell looks for executables only in the directories listed in PATH.

16.4 And so the first program comes out like this#

Here is the result of the two lines just typed — compile, then run.

Hello, world!

As with every result in this book, it is not decoration but what the machine really produced — every build compiles and runs the listing and puts its output here.

16.5 Reading it line by line#

Having seen it run, we now read what each of those six lines says.

#include <stdio.h> — a declaration of what we need. It means “fetch the standard input/output toolbox”, and the printf used below lives in that box. The name stdio takes the bold letters from standard input/output — under the file-name length limits of early C such compressed names became the practice, which is why most standard header names are short.

The precise identity of lines beginning with # is revealed in the next chapter (preprocessing).

int main(void) — the agreed starting point. A C program that runs on top of an operating system, as the one we are making does (a hosted implementation), starts at the function named main. To run the program is to run main. Where there is no operating system, even the name of the starting point can differ — that story is in chapter 59. The meanings of the parentheses, of int and of void are unravelled in turn in Parts IV and V.

{ and } — the fences of beginning and end. Inside the fence is the list of things main will do.

printf("Hello, world!\n"); — the substance of this program. It calls the tool named printf and lets the letters inside the quotation marks flow onto the band of standard output. \n is the very newline character we met in chapter 9 — the typewriter’s legacy is already in the first program. The semicolon at the end is the full stop of a statement.

return 0; — the parting bow. It ends main and reports 0 to the operating system, meaning “finished without trouble.”

16.6 But what happened between source and execution?#

We have just seen two objects: the source code a human reads and writes (hello.c), and the result the machine produced. But as chapter 2 taught, what a machine can execute is machine instructions only, and source code is just a text file — in the terms of chapter 8, a sequence of letters held in UTF-8. So somewhere in between there was a large event in which text became machine instructions.

The name of that event is compilation, and the next chapter tours the scene stage by stage. Seen from outside it is a single command; inside, a relay of four stages turns — in one of which our “spell” #include is broken, and in the last of which it is revealed where the substance of printf comes from.