Your First C Program

The Classic "Hello, World!"

Every programming journey begins with a simple program that displays text on the screen. In C, this tradition goes back to the original "The C Programming Language" book by Kernighan and Ritchie, published in 1978. Their "hello, world" example became the de facto standard for introducing any programming language. Let's write this program and understand every component.

#include <stdio.h>

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

This five-line program contains fundamental concepts you'll use in every C program you write. Each line serves a specific purpose, and understanding them thoroughly will make learning C much easier. Let's break down what each part does and why it's written this way.

Line-by-Line Explanation

Line 1: #include <stdio.h>

This preprocessor directive tells the compiler to include the contents of the stdio.h (standard input/output) header file before compiling your program. Header files contain declarations of functions and definitions of constants that your program needs. The stdio.h header specifically provides functions for input and output operations like printf(), scanf(), and file operations.

The # symbol indicates this is a preprocessor directive - instructions processed before actual compilation. The compiler literally copies the contents of stdio.h into your source file at this location. The angle brackets <> tell the preprocessor to look for stdio.h in the standard system directories where C libraries are installed.

Without this line, the compiler wouldn't know what printf() is. You'd get an error: "implicit declaration of function 'printf'". The header file tells the compiler that printf() exists, what parameters it expects, and what it returns. This allows the compiler to verify you're using the function correctly.

Line 2: Empty Line

This blank line isn't required but improves readability. C ignores whitespace (spaces, tabs, newlines) outside of strings, so you can format code for human readability. Empty lines separate logical sections, making code easier to understand. This particular empty line separates the preprocessor directives from your program's code.

Line 3: int main(void)

Every C program must have exactly one main() function - it's where program execution begins. When you run your program, the operating system calls main() to start your code. Think of main() as the entry point, the doorway into your program.

The int before main indicates this function returns an integer value to the operating system. By convention, returning 0 means the program succeeded, and non-zero values indicate various types of errors. The operating system can check this return value to determine if your program completed successfully.

The (void) in parentheses means this function takes no parameters. In modern C (C99 and later), you should explicitly write void rather than leaving the parentheses empty. Empty parentheses in old C meant "unspecified parameters," which could lead to confusion and bugs.

Line 4: Opening Brace {

The opening curly brace marks the beginning of the function body - the actual code that executes when the function runs. Everything between this brace and the matching closing brace is part of the main() function. In C, braces create blocks of code that group statements together.

Brace placement style varies among programmers. Some put the opening brace on the same line as the function declaration (K&R style), others on its own line (Allman style). Both are fine - consistency matters more than which style you choose.

Line 5: printf("Hello, World!\\n");

This line does the actual work - it prints text to the screen. printf() is a function provided by the C standard library for formatted printing. The text inside quotes is a string literal, and \\n is an escape sequence representing a newline character (moves cursor to next line).

The semicolon at the end terminates the statement. In C, almost every statement must end with a semicolon. Forgetting semicolons is one of the most common beginner mistakes. The compiler will complain with errors that might seem cryptic at first, but you'll quickly learn to look for missing semicolons.

The name printf stands for "print formatted" - it can print not just plain text but also variables, numbers, and other data in various formats. We'll explore its formatting capabilities in later lessons. For now, understand that printf() sends output to "standard output," which is typically your terminal or console window.

Line 6: return 0;

This statement ends the main() function and returns the value 0 to the operating system. Remember that main() is declared as int, meaning it must return an integer. Returning 0 is the standard way to indicate successful program completion. If your program encounters an error, you might return 1 or another non-zero value to indicate what went wrong.

Technically, in the main() function only, you can omit the return statement, and the compiler will automatically return 0. However, explicitly writing return 0 is better practice - it makes your intention clear and works consistently across all functions, not just main().

Line 7: Closing Brace }

The closing curly brace marks the end of the main() function. It matches the opening brace on line 4. When program execution reaches this brace, the function ends. In the case of main(), this means the entire program terminates, and control returns to the operating system.

Matching braces is crucial in C. Every { must have a corresponding }. Mismatched braces cause compilation errors. Good text editors and IDEs highlight matching braces to help you keep track, and proper indentation makes it obvious which braces belong together.

Compiling and Running

Now that you understand what the program does, let's compile and run it. Create a file named hello.c (the .c extension indicates C source code) and type or paste the program. Then use your compiler to transform this human-readable source code into machine-executable binary code.

# Save the program as hello.c, then compile
gcc hello.c -o hello

# This creates an executable file named 'hello'
# The -o flag specifies the output filename
# Without -o, GCC creates 'a.out' on Unix or 'a.exe' on Windows

# Run the program
./hello        # On Linux/macOS
hello.exe      # On Windows (or just: hello)

# Output:
# Hello, World!

# Compile with warnings enabled (recommended)
gcc -Wall -Wextra hello.c -o hello

# With C standard specified
gcc -std=c11 -Wall hello.c -o hello

# Check return value (Unix/Linux/macOS)
echo $?
# Output: 0 (the value returned from main)

# Windows PowerShell
echo $LASTEXITCODE
# Output: 0

The compilation process involves several steps that GCC performs automatically: preprocessing (handling #include and other directives), compiling (translating C to assembly), assembling (converting assembly to machine code), and linking (combining your code with library functions like printf). We'll explore this process in detail in the next lesson.

Common First Program Mistakes

Even experienced programmers make typos, and beginners encounter predictable issues when writing their first C program. Understanding these common errors helps you fix them quickly when they occur.

/* Mistake 1: Missing semicolon */
printf("Hello, World!\n")   // ERROR: expected ';'

/* Mistake 2: Wrong brackets in #include */
#include (stdio.h)  // ERROR: should be <stdio.h>

/* Mistake 3: main instead of Main (case sensitive) */
int Main(void) {  // ERROR: must be lowercase 'main'
    printf("Hello\n");
    return 0;
}

/* Mistake 4: Forgetting quotes around string */
printf(Hello);  // ERROR: 'Hello' is not defined

/* Mistake 5: Wrong slash for newline */
printf("Hello\\n");  // WRONG: prints literal \n instead of newline

/* Mistake 6: Missing closing brace */
int main(void) {
    printf("Hello\n");
    return 0;
// ERROR: missing }

/* Mistake 7: Typo in function name */
print("Hello\n");  // ERROR: 'print' is undefined, should be 'printf'

/* Mistake 8: Wrong main function signature */
void main() {  // BAD: should return int
    return;    // Inconsistent with void return type
}

When you encounter compiler errors, read them carefully. Modern compilers provide helpful messages that often point directly to the problem. The error might be on the line indicated or sometimes the line before (a missing semicolon shows an error on the next line). Don't be discouraged by errors - they're normal and help you learn.

Variations and Extensions

Once you have the basic program working, try these variations to deepen your understanding. Experimentation is one of the best ways to learn programming.

#include <stdio.h>

int main(void) {
    /* Multiple print statements */
    printf("Hello, World!\n");
    printf("Welcome to C programming!\n");
    printf("Let's learn together.\n");
    
    /* Print on same line (no \n at end) */
    printf("Hello, ");
    printf("World!");
    printf("\n");  // Newline after both
    
    /* Using escape sequences */
    printf("Hello,\tWorld!\n");  // \t is tab
    printf("Hello,\nWorld!\n");  // \n is newline
    printf("Say \"Hello\"\n");   // \" is quote mark
    
    /* Returning different values */
    return 0;   // Success
    // return 1; // Could indicate an error
}

Try modifying the message, adding more printf statements, or experimenting with different return values. Each modification helps solidify your understanding of how C programs work. The more you experiment, the more comfortable you'll become with the syntax and structure.

Summary & What's Next