C first steps: from your first program to pointers

Source, compile, run: your first program

Goal After this you can write a small C program, compile it, run it, and say what source, compile and run each mean.

A computer follows instructions. A programming language is a way to write instructions so that people can read them. C is one such language. It is old, small and fast, and many operating systems are written in it.

Getting a C program to work has three steps, and each has a name.

Source code is the text you write. You save it in a plain text file whose name ends in .c, for example hello.c. The computer cannot follow this text directly.

To compile is to translate the source code into machine code, the numbers a processor can follow. The tool that does the translating is the compiler. It reads hello.c and writes a new file, the executable, which is a file the computer can run. While compiling, the compiler also checks your text and stops if it finds a serious mistake.

To run is to ask the computer to carry out the executable. The program prints its output and then stops.

You repeat the cycle many times: edit the source, compile, run. If you change the source but forget to compile, you run the old program.

Every C program starts in a function called main. A function is a named group of instructions. The first line of the example, the one with #include, brings in the description of printf, the function that prints text. The curly brackets { } mark where main begins and ends. Each instruction inside is a statement, and a statement ends with a semicolon.

On your own computer you do this in a terminal. Four commands are enough for now. To see which folder you are in, type:
pwd
To list the files in the folder, type:
ls
To make a new folder called c-practice, type:
mkdir c-practice
To move into that folder, type:
cd c-practice

Press Return after each command. Now create the file with nano, an editor that runs inside the terminal:
nano hello.c
Type the program, press Ctrl and O together and then Return to save, and press Ctrl and X to leave. Any plain text editor works as well. Do not use a word processor, because it adds hidden formatting. Then compile and run:
cc -std=c11 -Wall -Wextra hello.c -o hello
./hello

Here cc is the compiler. hello.c is the source. The part -o hello means "name the executable hello". Take care here: the name after -o is the file the compiler creates, and it replaces any file with that name. Never write your .c file there. The options -Wall and -Wextra ask the compiler to point out suspicious code, and lesson 8 explains them. The text ./hello means "the program called hello in this folder". If the compile line prints nothing, it worked.

You can also press the Run button on the example below. It does the compile and run steps for you inside the page.

// hello.c: my first program
#include <stdio.h>

int main(void) {
    printf("Hello, Leon!\n");
    printf("This program ran.\n");
    return 0;
}

Hello, Leon!
This program ran.

printf("Hello, Leon!\n")
return 0;

printf("Hello, Leon!\n");
return 0;

hello

./hello

printf("Hello, Leon!");

printf("Hello, Leon!\n");

(edit hello.c, save it)
./hello

cc -std=c11 -Wall -Wextra hello.c -o hello && ./hello

printf and format specifiers: printing values

Goal After this you can print numbers, letters and text with printf, and pick the right specifier for each.

printf prints text. The first thing you give it is the format string, a piece of text in double quotes. Most of it is printed as written. But a percent sign followed by a letter is a placeholder, called a format specifier. printf replaces each placeholder with the next value you list after the format string, in order.

For example, this line prints Leon is 20 years old:
printf("Leon is %d years old\n", 20);
The %d is the placeholder for a whole number. The 20 is the value that fills it. The values after the format string are called arguments.

These specifiers cover most needs:
%d a whole number (type int)
%f a number with a decimal point (type double). Writing %.2f shows exactly two digits after the point.
%c one character, such as A
%s a string, which is text such as Mia
%x a whole number in hexadecimal, which is base 16 with the digits 0 to 9 and a to f. The number 255 prints as ff.
%zu a size, the kind of number that sizeof produces (lesson 3)
%% a percent sign itself

You can put a width between the % and the letter. %5d pads the number with spaces to at least 5 characters, and %-5d does the same but keeps the number at the left.

The specifier must match the value. printf cannot check the type of a value. It trusts you. If you write %d and pass a number with a decimal point, the output is nonsense, and only the compiler's warnings (lesson 8) can catch it. The number of placeholders must also equal the number of values.

Special characters inside the quotes start with a backslash. This is called an escape sequence. \n is a new line, \t is a tab, \" is a quote mark and \\ is a backslash.

Double quotes make text. Single quotes make one character: 'A' is the letter A and "A" is a piece of text. Lesson 3 and lesson 6 return to this.

#include <stdio.h>

int main(void) {
    int apples = 3;
    double price = 2.5;
    char grade = 'A';

    printf("Leon bought %d apples.\n", apples);
    printf("Each costs %.2f, so the total is %.2f.\n", price, apples * price);
    printf("Grade: %c\n", grade);
    printf("Name: %s\n", "Mia");
    printf("Hex: %x, character code: %d\n", 255, grade);
    printf("Padded: [%5d] [%-5d]\n", 42, 42);
    printf("Ratio: 50%%\n");
    printf("A quote \" and a backslash \\\n");
    return 0;
}

Leon bought 3 apples.
Each costs 2.50, so the total is 7.50.
Grade: A
Name: Mia
Hex: ff, character code: 65
Padded: [   42] [42   ]
Ratio: 50%
A quote " and a backslash \

printf("%d\n", 2.5);

printf("%f\n", 2.5);

printf("%d and %d\n", 7);

printf("%d and %d\n", 7, 8);

printf('Hello\n');

printf("Hello\n");

printf("Sale: 50% off\n");

printf("Sale: 50%% off\n");

Variables, types and sizes

Goal After this you can declare variables, choose between int, double and char, read a simple arithmetic expression, and find how many bytes a type takes.

A variable is a named box in the computer's memory that holds one value. You make one by declaring it: write the type, then the name, then usually a starting value.
int count = 7;

The type says what kind of value fits in the box and how big the box is. You need three types for now. An int is a whole number such as -3, 0 or 42. A double is a number with a decimal point, such as 3.14. A char is one character, such as 'A', written in single quotes.

The sign = means assign. It works out the right side and stores the result in the box on the left. It is not the equals of mathematics. The statement count = count + 1 means "take the value in count, add one, and store it back". The statement count += 2 is a short way to write count = count + 2.

Always give a variable a starting value. A box that you never filled holds leftover bits, and reading it gives unpredictable results.

An expression is a piece of code that works out to a value, such as 2 + 3 * 4. To read one, find which part is worked out first. Brackets come first. Then come *, / and % (multiply, divide, remainder), and then + and -. Operators of the same level go from left to right. So 2 + 3 * 4 is 14, and (2 + 3) * 4 is 20. When you are unsure, add brackets.

There are two traps. First, dividing an int by an int gives an int, and the fraction is thrown away. So 7 / 2 is 3. The % operator gives the remainder, so 7 % 2 is 1. If you want 3.5, make one side a double, as in 7 / 2.0. Second, an int has a limited range, roughly minus 2 billion to plus 2 billion. The header limits.h provides INT_MAX, the largest int. Going past it is undefined behaviour, which means the language makes no promise at all about what happens.

Memory is counted in bytes. A bit is a single 0 or 1, and a byte is a group of bits, 8 on ordinary computers. The operator sizeof gives the number of bytes that a type or variable takes. On ordinary computers a char takes 1, an int takes 4 and a double takes 8. The constant CHAR_BIT, from limits.h, is the number of bits in a byte.

A char is stored as a small number: 'A' is 65. That is why 'A' + 1 is 66, the code of 'B'.

#include <stdio.h>
#include <limits.h>

int main(void) {
    int count = 7;
    double ratio = 7.0 / 2;
    char letter = 'A';

    printf("count = %d, ratio = %.1f\n", count, ratio);
    printf("7 / 2 = %d, 7 %% 2 = %d, 7 / 2.0 = %.1f\n", 7 / 2, 7 % 2, 7 / 2.0);
    printf("2 + 3 * 4 = %d, (2 + 3) * 4 = %d\n", 2 + 3 * 4, (2 + 3) * 4);

    count = count + 1;
    count += 2;
    printf("count is now %d\n", count);

    printf("letter %c has code %d, and letter + 1 is %c\n", letter, letter, letter + 1);
    printf("sizes: char %zu, int %zu, double %zu\n", sizeof(char), sizeof(int), sizeof(double));
    printf("bits in a byte: %d, largest int: %d\n", CHAR_BIT, INT_MAX);
    return 0;
}

count = 7, ratio = 3.5
7 / 2 = 3, 7 % 2 = 1, 7 / 2.0 = 3.5
2 + 3 * 4 = 14, (2 + 3) * 4 = 20
count is now 10
letter A has code 65, and letter + 1 is B
sizes: char 1, int 4, double 8
bits in a byte: 8, largest int: 2147483647

double half = 1 / 2;

double half = 1 / 2.0;

int total;
total = total + 5;

int total = 0;
total = total + 5;

char letter = "A";

char letter = 'A';

int big = 2147483647;
big = big + 1;

int big = 2147483647;
if (big < INT_MAX) {
    big = big + 1;
}

Decisions and repetition: if and loops

Goal After this you can make a program choose with if, repeat work with for and while, and read the conditions that control them.

A program normally runs its statements from top to bottom. The statements if and the loops change that order.

A condition is an expression that is either true or false. C has no separate true and false for conditions: the number 0 means false, and any other number means true. The comparison operators work out to 1 for true and 0 for false. They are < (less than), <= (less than or equal), > (greater than), >= (greater than or equal), == (equal to) and != (not equal to). Take care: == compares two values, while a single = stores a value.

You combine conditions with && (and: both must be true), || (or: at least one must be true) and ! (not). Both && and || stop early. If the left side already decides the answer, the right side is not looked at. This is called short-circuit evaluation.

The statement if runs a block only when its condition is true. A block is a group of statements inside curly brackets. You can add else for the other case, and else if for more cases.

A loop repeats a block. A while loop checks its condition first and repeats as long as it is true. A for loop puts three parts in its brackets: a setup, a condition and a step.
for (int i = 0; i < 3; i++)
This means: start i at 0, keep going while i is less than 3, and after each pass add 1 to i. The expression i++ means i = i + 1. So the block runs with i equal to 0, 1 and 2, which is three times. Counting from 0 is normal in C. Each run through the block is an iteration.

A loop needs something that eventually makes its condition false. If nothing does, it never ends. Press Ctrl and C together in the terminal to stop it. The statement break leaves a loop at once. The statement continue skips to the next iteration.

Use curly brackets around every block, even when it holds one statement. It prevents a whole class of mistakes.

#include <stdio.h>

int main(void) {
    int total = 0;
    for (int i = 1; i <= 6; i++) {
        if (i % 2 == 0) {
            total += i;
            printf("%d is even, total is %d\n", i, total);
        } else {
            printf("%d is odd, skipped\n", i);
        }
    }

    int coins = 1;
    int days = 0;
    while (coins < 100) {
        coins = coins * 2;
        days++;
    }
    printf("coins reach %d after %d days\n", coins, days);

    int age = 17;
    if (age >= 13 && age < 20) {
        printf("age %d is a teenager\n", age);
    }
    return 0;
}

1 is odd, skipped
2 is even, total is 2
3 is odd, skipped
4 is even, total is 6
5 is odd, skipped
6 is even, total is 12
coins reach 128 after 7 days
age 17 is a teenager

int x = 3;
if (x = 5) {
    printf("five\n");
}

if (x == 5) {
    printf("five\n");
}

for (int i = 0; i < 3; i++);
{
    printf("hi\n");
}

for (int i = 0; i < 3; i++) {
    printf("hi\n");
}

if (1 < x < 5) {
    printf("between\n");
}

if (1 < x && x < 5) {
    printf("between\n");
}

int i = 0;
while (i < 3) {
    printf("%d\n", i);
}

int i = 0;
while (i < 3) {
    printf("%d\n", i);
    i++;
}

Functions and pass by value

Goal After this you can write your own function, call it, and explain why a function cannot change the variable you passed in.

A function is a named group of instructions that you can use again and again. You have already used two: main and printf. Now you write your own.

Here is a definition:
int square(int n) { return n * n; }
It has four parts. The return type, int, is the type of the value the function hands back. The word void means it hands back nothing. The name is square. The parameters, in brackets, are the names the function uses for the values it receives, and each has a type. The body, in curly brackets, holds the instructions. The statement return sends a value back and ends the function at once.

To call a function, write its name and put values in brackets: square(5). The values you give are the arguments. The call is an expression: its value is what the function returns. So square(5) is 25, and you can print it or store it in a variable.

The compiler reads the file from top to bottom. It must learn about a function before you call it. The usual way is a prototype: the first line of the function, followed by a semicolon, placed near the top of the file. It says "this function exists, with these types, and its body comes later".

Now the key rule. When you call a function, C copies each argument into the matching parameter. This is called pass by value. The function works on its own copy. Think of giving someone a photocopy of a form. They can scribble on it, and your original stays the same. So if a function sets its parameter to 0, the variable in the caller still holds the old value. To get a new value out, return it and assign it: side = add_one(side).

Variables made inside a function, including its parameters, are local. They exist only while the function runs, and other functions cannot see them. The part of the program where a name can be used is its scope. Two functions can each have a variable called n. They are separate boxes.

Lesson 7 shows how a function can change the caller's variable on purpose.

#include <stdio.h>

int square(int n);
void try_to_reset(int n);
int add_one(int n);

int main(void) {
    int side = 5;
    printf("square(%d) = %d\n", side, square(side));

    try_to_reset(side);
    printf("back in main, side is still %d\n", side);

    side = add_one(side);
    printf("after side = add_one(side), side is %d\n", side);
    return 0;
}

int square(int n) {
    return n * n;
}

void try_to_reset(int n) {
    n = 0;
    printf("inside try_to_reset, n is %d\n", n);
}

int add_one(int n) {
    return n + 1;
}

square(5) = 25
inside try_to_reset, n is 0
back in main, side is still 5
after side = add_one(side), side is 6

int main(void) {
    int n = square(3);
    printf("%d\n", n);
    return 0;
}

int square(int v) { return v * v; }

int square(int v);

int main(void) {
    int n = square(3);
    printf("%d\n", n);
    return 0;
}

int square(int v) { return v * v; }

void double_it(int n) { n = n * 2; }
/* in main: */
double_it(x);

int double_it(int n) { return n * 2; }
/* in main: */
x = double_it(x);

int twice(int n) {
    n * 2;
}

int twice(int n) {
    return n * 2;
}

int helper(void) {
    int inner = 5;
    return 1;
}

int main(void) {
    helper();
    printf("%d\n", inner);
    return 0;
}

int helper(void) {
    int inner = 5;
    return inner;
}

int main(void) {
    int got = helper();
    printf("%d\n", got);
    return 0;
}

Arrays and C strings with the terminating zero

Goal After this you can keep a row of values in an array, loop over it safely, and explain why a C string needs one extra box for the terminating zero.

An array is a row of boxes of the same type, side by side in memory. The line int scores[4]; makes four int boxes. The number in the square brackets is the length.

You reach one box by its index, which is its position number. Counting starts at 0. The boxes of scores are scores[0], scores[1], scores[2] and scores[3]. The last valid index is the length minus 1. There is no scores[4]. But C does not stop you from writing it. The program reads or writes whatever memory lies there. That is undefined behaviour (lesson 3), and it causes many bugs and security holes. The compiler and the browser page will usually not warn you. Lesson 8 shows a tool that does.

You can set starting values with curly brackets: int scores[4] = {70, 85, 90, 65};

An array does not remember its own length. The expression sizeof scores gives the total bytes, which is 16 for four ints. Dividing by sizeof scores[0], which is 4, gives the length. Use that, or a named number, so the length is written in one place only.

Text is stored as an array of char. A C string is a char array in which the text is followed by a byte with the value 0, written '\0'. It is called the terminating zero, or the null character. The zero marks the end of the text. Functions like printf and strlen read characters until they meet it.

char word[] = "Leon";
The compiler makes the array five boxes long: L, e, o, n and the terminating zero. So sizeof word is 5. The function strlen, from string.h, counts the characters before the zero, so strlen(word) is 4. A string always needs one box more than its visible length. If the zero is missing, functions keep reading past the end of the array.

You can change one character: word[0] = 'N'. But you cannot copy or compare whole arrays with = or ==. To compare strings use strcmp, from string.h. It returns 0 when the two strings are equal.

Remember the difference between 'A' and "A". 'A' is one char. "A" is a string of two boxes: the letter A and the terminating zero.

#include <stdio.h>
#include <string.h>

int main(void) {
    int scores[4] = {70, 85, 90, 65};
    int length = (int)(sizeof scores / sizeof scores[0]);
    int sum = 0;
    for (int i = 0; i < length; i++) {
        sum += scores[i];
    }
    printf("length = %d, first = %d, last = %d, sum = %d\n", length, scores[0], scores[length - 1], sum);

    char word[] = "Leon";
    printf("sizeof word = %zu, strlen word = %zu\n", sizeof word, strlen(word));
    for (int i = 0; i < 5; i++) {
        printf("word[%d] = %d\n", i, word[i]);
    }

    word[0] = 'N';
    printf("%s\n", word);
    printf("equal to Neon: %d\n", strcmp(word, "Neon") == 0);
    return 0;
}

length = 4, first = 70, last = 65, sum = 310
sizeof word = 5, strlen word = 4
word[0] = 76
word[1] = 101
word[2] = 111
word[3] = 110
word[4] = 0
Neon
equal to Neon: 1

int a[3] = {1, 2, 3};
int sum = 0;
for (int i = 0; i <= 3; i++) {
    sum += a[i];
}

for (int i = 0; i < 3; i++) {
    sum += a[i];
}

char s[4] = "Leon";

char s[5] = "Leon";
/* or let the compiler count: */
char t[] = "Leon";

if (name == "Leon") {
    printf("hello\n");
}

if (strcmp(name, "Leon") == 0) {
    printf("hello\n");
}

char name[] = "Leon";
name = "Mia";

strcpy(name, "Mia");  /* "Mia" and its zero need 4 boxes; name has 5 */

Memory as numbered boxes: address and pointer

Goal After this you can draw memory as numbered boxes, say what an address and a pointer are, and use & and * to read and change a variable through a pointer.

First in words. Picture the computer's memory as one very long street of small boxes. Each box holds one byte. Every box has a number painted on its door, counted from the start of the street. That number is the box's address.

A variable lives in one box or in several boxes in a row. An int usually needs four boxes side by side, so one int covers four addresses, and its address is the number of its first box. An array of three ints is twelve boxes in a row.

Now the new idea. An address is only a number, so it can be stored in a variable too. A variable that holds an address is a pointer. A pointer is like a card with a house number on it. The card is not the house. But from the number you can walk to the house, look inside, or change what is inside. Following the card is called dereferencing.

A small drawing, with made-up numbers. The variable age sits at address 100 and holds 20. The variable p sits at address 200 and holds the number 100. We say p points to age. The example below draws the same picture in a comment.

Now with C symbols. Two symbols do the work.
The expression &x means "the address of x".
The expression *p means "the thing that p points to".

The line int *p = &age; declares p as a pointer to an int. In a declaration, read the star as "pointer to". It also gives p the address of age. In an expression, the star means "follow the pointer". After that line, *p and age are the same box. Reading *p gives 20. Writing *p = 21 changes age.

This solves the problem from lesson 5. A function gets copies, but if the copy is an address, the function can follow it to the caller's variable. The call add_one(&age) passes the address of age. Inside, *p = *p + 1 changes the caller's age. The function scanf works this way too. In scanf("%d", &n) the & gives scanf the address of n, so scanf can store the number there.

Pointers and arrays are close relatives. The name of an array stands for the address of its first box. If q points at nums[0], then q + 1 points at nums[1]. Adding 1 to a pointer moves it forward by one whole int, which is 4 bytes, not by one byte. The expressions *(q + 1) and q[1] mean the same thing.

A pointer that points at nothing holds NULL. Never follow a NULL pointer, or a pointer that was never set. The program crashes with a segmentation fault, or it silently damages data.

If you add printf("%p\n", (void *)p); you will see a real address, such as 0x16d8a3a5c. Yours will be different, and it can change on every run.

#include <stdio.h>

/* Memory drawn as numbered boxes (the numbers are made up):

     address   contents      name
     -------   -----------   ----
       100     20            age
       200     100           p      <- p holds the address of age
*/

void add_one(int *p) {
    *p = *p + 1;
}

int main(void) {
    int age = 20;
    int *p = &age;

    printf("age = %d\n", age);
    printf("*p = %d\n", *p);
    printf("p points at age: %d\n", p == &age);

    *p = 21;
    printf("after *p = 21, age = %d\n", age);

    add_one(&age);
    printf("after add_one(&age), age = %d\n", age);

    int nums[3] = {10, 20, 30};
    int *q = nums;
    printf("*q = %d, *(q + 1) = %d, q[2] = %d\n", *q, *(q + 1), q[2]);
    printf("bytes between nums[0] and nums[1]: %d\n", (int)((char *)&nums[1] - (char *)&nums[0]));

    int *nothing = NULL;
    if (nothing == NULL) {
        printf("nothing points at no object\n");
    }
    return 0;
}

age = 20
*p = 20
p points at age: 1
after *p = 21, age = 21
after add_one(&age), age = 22
*q = 10, *(q + 1) = 20, q[2] = 30
bytes between nums[0] and nums[1]: 4
nothing points at no object

int *p;
*p = 5;

int x = 0;
int *p = &x;
*p = 5;

int x = 4;
int *p = &x;
p = 7;

*p = 7;

int *make(void) {
    int local = 5;
    return &local;
}

int make(void) {
    return 5;
}

int *p = NULL;
*p = 5;

if (p != NULL) {
    *p = 5;
}

Reading compiler messages and using -Wall

Goal After this you can read the parts of a warning or an error, fix the first error first, and turn on the compiler's checks so mistakes show up before the program runs.

The compiler talks to you in messages. They are the fastest teacher you have, if you can read them. A message looks like this:
hello.c:5:20: warning: format specifies type 'int' but the argument has type 'double' [-Wformat]

Read it from left to right. hello.c is the file. 5 is the line number. 20 is the column, the position of the character in that line. The word warning is the kind of message. The sentence says what the compiler thinks is wrong. The name in square brackets, -Wformat, is the check that fired, and you can search for it. Below the message the compiler usually shows your line, with a ^ under the spot. A line starting with note: adds detail to the message above it.

There are three kinds. An error means the compiler could not build the program, so no executable is made. A warning means the program builds but something looks wrong. Treat every warning as a bug until you know better. A note adds detail.

The messages in this guide come from clang, the compiler on a Mac. gcc, on Linux and in WSL, words them a little differently. For the example above it says: format '%d' expects argument of type 'int', but argument 2 has type 'double'. The file, line, kind, sentence and check name are all there.

By default a compiler stays quiet about many risky things. You ask for more with options, which you write after cc.
-Wall turns on the common warnings. Despite its name it does not turn on every warning.
-Wextra turns on more.
-Werror makes every warning an error, so you cannot ignore any.
-std=c11 chooses the C11 version of the language.
-g keeps line information so that tools can show your line numbers.
-fsanitize=address,undefined builds a program that checks itself while it runs. It stops at the first bad memory access or undefined operation and names the line.

A good everyday command is:
cc -std=c11 -Wall -Wextra -g -fsanitize=address,undefined main.c -o main

Some habits help. Fix the first message first: one mistake can cause a chain of later messages, so compile again after each fix. Remember that the line number is where the compiler noticed the problem, and the cause can be on the line above. Never ignore a warning you do not understand.

The sanitizer matters because the Run button on this page cannot do this job. If a program reads past the end of an array, it runs on this page and prints a normal-looking answer. Nothing checks. Built with the sanitizer, the same program stops with a report that starts with ERROR: AddressSanitizer or runtime error and names the line. That is why a real compiler is worth the ten minutes of setup.

You can now read the C in the first chapters of the course: types and sizes, conditions and loops, functions that receive copies, arrays and strings with their zero, and pointers. The course goes deeper into each of them. It also adds structures, files, allocating memory with malloc, and much more.

#include <stdio.h>

int main(void) {
    int scores[3] = {80, 90, 85};
    int sum = 0;
    for (int i = 0; i < 3; i++) {
        sum += scores[i];
    }
    double average = (double)sum / 3;
    printf("sum = %d, average = %.1f\n", sum, average);
    return 0;
}

sum = 255, average = 85.0

#include <stdio.h>
int main(void) {
    itn count = 0;
    count = count + 1;
    printf("%d\n", count);
    return 0;
}

$ cc demo.c -o demo
demo.c:3:5: error: use of undeclared identifier 'itn'
demo.c:4:5: error: use of undeclared identifier 'count'
demo.c:4:13: error: use of undeclared identifier 'count'
demo.c:5:20: error: use of undeclared identifier 'count'
4 errors generated.

int count = 0;

#include <stdio.h>
int main(void) {
    int total = 3
    printf("%d\n", total);
    return 0;
}

int total = 3;

#include <stdio.h>
int main(void) {
    int total;
    total = total + 5;
    printf("%d\n", total);
    return 0;
}

$ cc demo.c -o demo
(no output: it builds)

$ cc -std=c11 -Wall -Wextra demo.c -o demo
demo.c:4:13: warning: variable 'total' is uninitialized when used here [-Wuninitialized]

#include <stdio.h>
int main(void) {
    int a[3] = {1, 2, 3};
    int sum = 0;
    for (int i = 0; i <= 3; i++) {
        sum += a[i];
    }
    printf("%d\n", sum);
    return 0;
}

(Run button on this page, or a plain cc build: prints a normal-looking sum)

$ cc -std=c11 -Wall -Wextra -g -fsanitize=address,undefined demo.c -o demo
$ ./demo
demo.c:6:16: runtime error: index 3 out of bounds for type 'int[3]'