Try C in Y minutes

Ah, C. Still the language of modern high-performance computing.

C is the lowest-level language most programmers will ever use, but it more than makes up for it with raw speed. Just be aware of its manual memory management and C will take you as far as you need to go.

Introduction · Types · Operators · Control Structures · Typecasting · Pointers · Functions · User-defined types and structs · Function pointers · Printing characters with printf() · Order of Evaluation · Header files · Further Reading

✨ This is an open source guide. Feel free to improve it!

About compiler flags
By default, gcc and clang are pretty quiet about compilation warnings and errors, which can be very useful information. Explicitly using stricter compiler flags is recommended. Here are some recommended defaults:
-Wall -Wextra -Werror -O2 -std=c99 -pedantic
For information on what these flags do as well as other flags, consult the man page for your C compiler (e.g. man 1 gcc) or just search online.

Introduction

Single-line and multi-line comments:

// Single-line comments start with // - only available in C99 and later.

/*
Multi-line comments look like this. They work in C89 as well.
*/

Multi-line comments don't nest:

/*
Multi-line comments don't nest /* Be careful */  // comment ends on this line...
*/ // ...not this one!

Constants are defined using #define. They are written in all-caps as a convention, not a requirement:

#define DAYS_IN_YEAR 365

Enumeration constants are another way to declare constants:

enum days {SUN, MON, TUE, WED, THU, FRI, SAT};
// SUN gets 0, MON gets 1, TUE gets 2, etc.

All statements must end with a semicolon.

Enumeration values can also be specified:

enum days {SUN = 1, MON, TUE, WED = 99, THU, FRI, SAT};
// MON gets 2 automatically, TUE gets 3, etc.
// WED get 99, THU gets 100, FRI gets 101, etc.

Import headers with #include:

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

File names between <angle brackets> tell the compiler to look in your system libraries for the headers. For your own headers, use double quotes instead of angle brackets, and provide the path:

#include "my_header.h" // local file
#include "../my_lib/my_lib_header.h" // relative path

Declare function signatures in advance in a .h file, or at the top of your .c file.

void function_1();
int function_2(void);

At a minimum, you must declare a 'function prototype' before its use in any function. Normally, prototypes are placed at the top of a file before any function definition.

// function prototype
int add_two_ints(int x1, int x2);

Although int add_two_ints(int, int); is also valid (no need to name the args), it is recommended to name arguments in the prototype as well for easier inspection.

Function prototypes are not necessary if the function definition comes before any other function that calls that function. However, it's standard practice to always add the function prototype to a header file (*.h) and then #include that file at the top. This prevents any issues where a function might be called before the compiler knows of its existence, while also giving the developer a clean header file to share with the rest of the project.

Your program's entry point is a function called main. The return type can be anything, however most operating systems expect a return type of int for error code processing.

int main(void) {
  // your program
}

The command line arguments used to run your program are also passed to main:

argc being the number of arguments - your program's name counts as 1.
argv is an array of character arrays - containing the arguments themselves. argv[0] = name of your program, argv[1] = first argument, etc.

int main (int argc, char** argv) {
  // print output using printf, for "print formatted"
  // %d is an integer, \n is a newline
  printf("%d\n", 42);
}

Take input using scanf:

// '&' is used to define the location
// where we want to store the input value
int input;
scanf("%d", &input);

Types

Compilers that are not C99-compliant require that variables must be declared at the top of the current block scope. Compilers that are C99-compliant allow declarations near the point where the value is used. For the sake of the tutorial, variables are declared dynamically under C99-compliant standards.

// ints are usually 4 bytes (use the `sizeof` operator to check)
// `%zu` stands for `size_t` type, which is returned by `sizeof`
int x_int = 1024;
printf("x_int = %d, size = %zu bytes\n", x_int, sizeof(x_int));

// shorts are usually 2 bytes
// `%hi` stands for short integers
short x_short = 42;
printf("x_short = %hi, size = %zu bytes\n", x_short, sizeof(x_short));

x_int = 1024, size = 4 bytes
x_short = 42, size = 2 bytes

Chars are defined as the smallest addressable unit for a processor. This is usually 1 byte, but for some systems it can be more (ex. for TMS320 from TI it's 2 bytes).

char x_char = 120;
// `%c` stands for characters
printf(
  "x_char = %c, code = %d, size = %zu bytes\n",
  x_char, x_char, sizeof(x_char)
);

char y_char = 'y'; // Char literals are quoted with ''
printf(
  "y_char = %c, code = %d, size = %zu bytes\n",
  y_char, y_char, sizeof(y_char)
);

x_char = x, code = 120, size = 1 bytes
y_char = y, code = 121, size = 1 bytes

Longs are often 4 to 8 bytes; long longs are guaranteed to be at least 8 bytes.

// `%li` stands for long integers
long x_long = 0;
printf(
  "x_long = %li, size = %zu bytes\n",
  x_long, sizeof(x_long)
);

// `%lli` stands for long long integers
long long x_long_long = 0;
printf(
  "x_long_long = %lli, size = %zu bytes\n",
  x_long_long, sizeof(x_long_long)
);

x_long = 0, size = 8 bytes
x_long_long = 0, size = 8 bytes

Floats are usually 32-bit floating point numbers. Doubles are usually 64-bit floating-point numbers.

// 'f' suffix here denotes floating point literal
float x_float = 0.0f;
// `%f` stands for floating point numbers
printf("x_float = %f, size = %zu bytes\n", x_float, sizeof(x_float));

// real numbers without any suffix are doubles
double x_double = 0.0;
printf("x_double = %f, size = %zu bytes\n", x_double, sizeof(x_double));

x_float = 0.000000, size = 4 bytes
x_double = 0.000000, size = 8 bytes

Integer types may be unsigned (greater than or equal to zero).

unsigned short ux_short;
unsigned int ux_int;
unsigned long long ux_long_long;

Chars inside single quotes are integers in machine's character set.

// 48 in the ASCII character set.
printf("'0' = %d\n", '0');

// 65 in the ASCII character set.
printf("'A' = %d\n", 'A');

'0' = 48
'A' = 65

sizeof(T) gives you the size of a variable with type T in bytes. sizeof(obj) yields the size of the expression (variable, literal, etc.).

// = 4 on most machines with 4-byte words
printf("%zu\n", sizeof(int));

If the argument of the sizeof operator is an expression, then its argument is not evaluated (except VLAs (see below)). The value it yields in this case is a compile-time constant.

int a = 1;
// size_t is an unsigned integer type of at least 2 bytes
// used to represent the size of an object.
size_t size = sizeof(a++); // a++ is not evaluated
printf("sizeof(a++) = %zu where a = %d\n", size, a);

sizeof(a++) = 4 where a = 1

Arrays must be initialized with a concrete size:

// This array occupies 1 * 20 = 20 bytes
char my_char_array[20];

// This array occupies 4 * 20 = 80 bytes
int my_int_array[20];

// (assuming 4-byte words)

You can initialize an array of twenty ints that all equal 0 thusly:

int my_array[20] = {0};

...where the {0} part is called an "array initializer".

All elements (if any) past the ones in the initializer are initialized to 0:

int my_array[5] = {1, 2};

// for loop is used to iterate over array,
// described in more detail later
for (int i = 0; i < 5; i++) {
  printf("%d ", my_array[i]);
}

1 2 0 0 0

So my_array now has five elements, all but the first two of which are 0.

You get away without explicitly declaring the size of the array IF you initialize the array on the same line:

int my_array[] = {11, 12, 13};

for (int i = 0; i < 3; i++) {
  printf("%d ", my_array[i]);
}

11 12 13

When not declaring the size, the size of the array is the number of elements in the initializer. With {11, 12, 13}, my_array is now of size 3. To evaluate the size of the array at run-time, divide its byte size by the byte size of its element type:

int my_array[] = {11, 12, 13};
size_t my_array_size = sizeof(my_array) / sizeof(my_array[0]);
printf("my_array size = %zu\n", my_array_size);

Warning. You should evaluate the size before you begin passing the array to functions (see later discussion) because arrays get "downgraded" to raw pointers when they are passed to functions (so the statement above will produce the wrong result inside the function).

Indexing an array is like other languages - or, rather, other languages are like C:

int my_array[] = {11, 12, 13};
printf("my_array[0] = %d\n", my_array[0]);

// Arrays are mutable; it's just memory!
my_array[1] = 2;
printf("my_array[1] = %d\n", my_array[1]);

my_array[0] = 11
my_array[1] = 2

In C99 (and as an optional feature in C11), variable-length arrays (VLAs) can be declared as well. The size of such an array need not be a compile time constant:

printf("Enter the array size: "); // ask the user for an array size
int array_size;
fscanf(stdin, "%d", &array_size);

int var_length_array[array_size]; // declare the VLA
printf("sizeof array = %zu\n", sizeof var_length_array);

Example:

// suppose this is coming from the user
int array_size = 10;

int var_length_array[array_size]; // declare the VLA
printf("sizeof array = %zu\n", sizeof var_length_array);

sizeof array = 40

Strings are just arrays of chars terminated by a NULL (0x00) byte, represented in strings as the special character \0. (We don't have to include the NULL byte in string literals; the compiler inserts it at the end of the array for us.)

char a_string[20] = "This is a string";
printf("%s\n", a_string); // %s formats a string

// byte #17 is 0 (as are 18, 19, and 20)
printf("a_string[16] = %d\n", a_string[16]);

This is a string
a_string[16] = 0

If we have characters between single quotes, that's a character literal. It's of type int, and not char (for historical reasons).

int cha = 'a'; // fine
char chb = 'a'; // fine too (implicit conversion from int to char)

Multi-dimensional arrays:

int multi_array[2][5] = {
  {1, 2, 3, 4, 5},
  {6, 7, 8, 9, 0}
};

// access elements:
int array_int = multi_array[0][2];
printf("multi_array[0][2] = %d\n", array_int);

multi_array[0][2] = 3

Operators

Shorthands for multiple declarations:

int i1 = 1, i2 = 2;
float f1 = 1.0, f2 = 2.0;

int b, c;
b = c = 0;

Arithmetic is straightforward:

printf("i1 + i2 = %d\n", i1 + i2);
printf("i2 - i1 = %d\n", i2 - i1);
printf("i2 * i1 = %d\n", i2 * i1);
printf("i1 / i2 = %d\n", i1 / i2); // (0.5, but truncated towards 0)

i1 + i2 = 3
i2 - i1 = 1
i2 * i1 = 2
i1 / i2 = 0

You need to cast at least one integer to float to get a floating-point result:

printf("i1 / i2 (f) = %f\n", (float)i1 / i2);
printf("i1 / i2 (d) = %f\n", i1 / (double)i2);
printf("f1 / f2     = %f\n", f1 / f2); // 0.5, plus or minus epsilon

i1 / i2 (f) = 0.500000
i1 / i2 (d) = 0.500000
f1 / f2     = 0.500000

Floating-point numbers are defined by IEEE 754, thus cannot store perfectly exact values. For instance, the following does not produce expected results because 0.1 might actually be 0.099999999999 inside the computer, and 0.3 might be stored as 0.300000000001:

(0.1 + 0.1 + 0.1) != 0.3; // => 1 (true)
// and it is NOT associative due to reasons mentioned above.
1 + (1e123 - 1e123) != (1 + 1e123) - 1e123; // => 1 (true)
// this notation is scientific notations for numbers: 1e123 = 1*10^123

It is important to note that most all systems have used IEEE 754 to represent floating points. Even Python, used for scientific computing, eventually calls C which uses IEEE 754. It is mentioned this way not to indicate that this is a poor implementation, but instead as a warning that when doing floating point comparisons, a little bit of error (epsilon) needs to be considered.

Modulo is there as well, but be careful if arguments are negative:

printf("%d\n", 11 % 3); // 2 as 11 = 2 + 3*x (x=3)
printf("%d\n", (-11) % 3); // -2, as one would expect
printf("%d\n", 11 % (-3)); // 2 and not -2, and it's quite counter intuitive

2
-2
2

Comparison operators are probably familiar, but there is no Boolean type in C. We use ints instead. 0 is false, anything else is true. (The comparison operators always yield 0 or 1.)

printf("3 == 2 -> %d\n", 3 == 2);
printf("3 != 2 -> %d\n", 3 != 2);
printf("3 > 2  -> %d\n", 3 > 2);
printf("3 < 2  -> %d\n", 3 < 2);
printf("2 <= 2 -> %d\n", 2 <= 2);
printf("2 >= 2 -> %d\n", 2 >= 2);

3 == 2 -> 0
3 != 2 -> 1
3 > 2  -> 1
3 < 2  -> 0
2 <= 2 -> 1
2 >= 2 -> 1

C99 introduced the _Bool type in stdbool.h, but its true and false values are just aliases for 1 and 0:

#include <stdbool.h>

int main() {
  bool is_true = 1;
  bool is_false = 0;
}

C is not Python - comparisons do NOT chain. Warning: The line below will compile, but it means (0 < a) < 2. This expression is always true, because (0 < a) could be either 1 or 0, and 2 is greater than 1 or 0.

int a = 42;
printf("0 < 42 < 2: %d\n", 0 < a < 2);
// instead use:
printf("0 < 42 && 42 < 2: %d\n", 0 < a && a < 2);

...

Logic works on ints:

printf("!3 -> %d\n", !3); // (Logical not)
printf("!0 -> %d\n", !0);
printf("1 && 1 -> %d\n", 1 && 1); // (Logical and)
printf("0 && 1 -> %d\n", 0 && 1);
printf("0 || 1 -> %d\n", 0 || 1); // (Logical or)
printf("0 || 0 -> %d\n", 0 || 0);

!3 -> 0
!0 -> 1
1 && 1 -> 1
0 && 1 -> 0
0 || 1 -> 1
0 || 0 -> 0

Conditional ternary expression ? ::

int e = 5;
int f = 10;
int z;
z = (e > f) ? e : f; // "if e > f return e, else return f."
printf("%d\n", z);

Increment and decrement operators:

int j = 0;

int pos = j++; // return j THEN increase j
printf("%d\n", pos);

int pre = ++j; // increase j THEN return j
printf("%d\n", pre);

// same with j-- and --j

0
2

Bitwise operators:

// bitwise negation, "1's complement", example result for 32-bit int
printf("~0x0F       -> 0x%02X\n", ~0x0F);       // bitwise NOT
printf("0x0F & 0xF0 -> 0x%02X\n", 0x0F & 0xF0); // bitwise AND
printf("0x0F | 0xF0 -> 0x%02X\n", 0x0F | 0xF0); // bitwise OR
printf("0x04 ^ 0x0F -> 0x%02X\n", 0x04 ^ 0x0F); // bitwise XOR
printf("0x01 << 1   -> 0x%02X\n", 0x01 << 1);   // bitwise left shift (by 1)
printf("0x02 >> 1   -> 0x%02X\n", 0x02 >> 1);   // bitwise right shift (by 1)

~0x0F       -> FFFFFFF0
0x0F & 0xF0 -> 0
0x0F | 0xF0 -> FF
0x04 ^ 0x0F -> B
0x01 << 1   -> 2
0x02 >> 1   -> 1

Be careful when shifting signed integers - the following are undefined:

shifting into the sign bit of a signed integer (int a = 1 << 31)
left-shifting a negative number (int a = -1 << 2)
shifting by an offset which is >= the width of the type of the LHS:
int a = 1 << 32 (UB if int is 32 bits wide)

Control Structures

If-then-else:

if (0) {
  printf("I am never run\n");
} else if (0) {
  printf("I am also never run\n");
} else {
  printf("I print\n");
}

I print

While loops with pre-conditions:

int ii = 0;
while (ii < 10) { // ANY value less than ten is true.
  printf("%d, ", ii++); // ii++ increments ii AFTER using its current value.
}

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

And post-conditions:

int kk = 0;
do {
  printf("%d, ", kk);
} while (++kk < 10); // ++kk increments kk BEFORE using its current value.

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

For loops too:

int jj;
for (jj = 0; jj < 10; jj++) {
  printf("%d, ", jj);
}

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

In C99 and newer versions, you can directly declare loop control variables in the loop's parentheses:

for (int i = 0; i < 10; i++) {
  printf("%d, ", i);
}

0, 1, 2, 3, 4, 5, 6, 7, 8, 9,

Loops and Functions MUST have a body:

int i;
for (i = 0; i <= 5; i++) {
  ; // If no body is needed, use semicolon
    // to act as the body (null statement)
}

// Or
for (i = 0; i <= 5; i++);

Branching with multiple choices:

int a = 1;
switch (a) {
case 0: // labels need to be integral *constant* expressions (such as enums)
  printf("Hey, 'a' equals 0!\n");
  break; // if you don't break, control flow falls over labels

case 1:
  printf("Huh, 'a' equals 1!\n");
  break;
  // Be careful - without a "break", execution continues until the
  // next "break" is reached.

case 3:
case 4:
  printf("Look at that.. 'a' is either 3, or 4\n");
  break;

default:
  // if `some_integral_expression` didn't match any of the labels
  fputs("Error!\n", stderr);
  exit(-1);
  break;
}

Huh, 'a' equals 1!

Using goto:

typedef enum { false, true } bool;
bool disaster = false;
int i, j;

for (i = 0; i < 100; ++i) {
  for (j = 0; j < 100; ++j) {
    if ((i + j) >= 150) {
      disaster = true;
    }
    if (disaster) {
        goto error;  // exit both for loops
    }
  }
}

error: // this is a label that you can "jump" to with "goto error;"
printf("Error occurred at i = %d & j = %d.\n", i, j);

Error occurred at i = 51 & j = 99.

It is generally considered bad practice to do so, except if you really know what you are doing. See Spaghetti code.

Typecasting

Every value in C has a type, but you can cast one value into another type if you want (with some constraints).

// You can assign vars with hex literals
// binary is not in the standard, but allowed by some
// compilers (x_bin = 0b0010010110)
int x_hex = 0x01;

Casting between types will attempt to preserve their numeric values:

printf("%d\n", x_hex);
printf("%d\n", (short) x_hex);
printf("%d\n", (char) x_hex);

1
1
1

If you assign a value greater than a types max val, it will rollover without warning:

// Max char = 255 if char is 8 bits long
printf("%d\n", (unsigned char) 257);

For determining the max value of a char, a signed char and an unsigned char, respectively, use the CHAR_MAX, SCHAR_MAX and UCHAR_MAX macros from <limits.h>.

Integral types can be cast to floating-point types, and vice-versa:

printf("%f\n", (double) 100); // %f always formats a double...
printf("%f\n", (float)  100); // ...even with a float.
printf("%d\n", (char)100.0);

100.000000
100.000000
100

Pointers

A pointer is a variable declared to store a memory address. Its declaration will also tell you the type of data it points to. You can retrieve the memory address of your variables, then mess with them.

int x = 0;
printf("%p\n", (void *)&x); // Use & to retrieve the address of a variable
// (%p formats an object pointer of type void *)
// prints some address in memory

0x7ffdb92d98d4

Pointers start with * in their declaration:

int x = 0;
int *px, not_a_pointer; // px is a pointer to an int
px = &x; // Stores the address of x in px

// Prints some address in memory
printf("%p\n", (void *)px);
// Prints "8, 4" on a typical 64-bit system
printf("%zu, %zu\n", sizeof(px), sizeof(not_a_pointer));

0x7fff4c25c0bc
8, 4

To retrieve the value at the address a pointer is pointing to, put * in front to dereference it. Note: yes, it may be confusing that * is used for both declaring a pointer and dereferencing it.

x = 42;
printf("%d\n", *px); // prints the value of x

You can also change the value the pointer is pointing to. We'll have to wrap the dereference in parenthesis because ++ has a higher precedence than *:

(*px)++; // Increment the value px is pointing to by 1
printf("%d\n", *px);
printf("%d\n", x);

1
1

Arrays are a good way to allocate a contiguous block of memory:

int x_array[20]; //declares array of size 20 (cannot change size)
for (int xx = 0; xx < 20; xx++) {
  x_array[xx] = 20 - xx;
} // Initialize x_array to 20, 19, 18,... 2, 1

// Declare a pointer of type int and initialize it to point to x_array
int* x_ptr = x_array;

x_ptr now points to the first element in the array (the integer 20). This works because arrays often decay into pointers to their first element. For example, when an array is passed to a function or is assigned to a pointer, it decays into (implicitly converted to) a pointer.

Exceptions:

// when the array is the argument of the `&` (address-of) operator:
int arr[10];
int (*ptr_to_arr)[10] = &arr; // &arr is NOT of type `int *`!
// It's of type "pointer to array" (of ten `int`s).

// or when the array is a string literal used for initializing a char array:
char otherarr[] = "foobarbazquirk";

// or when it's the argument of the `sizeof` or `alignof` operator:
int arraythethird[10];
int *ptr = arraythethird; // equivalent with int *ptr = &arr[0];
printf("%zu, %zu\n", sizeof(arraythethird), sizeof(ptr));
// probably prints "40, 4" or "40, 8"

40, 8

Pointers are incremented and decremented based on their type (this is called pointer arithmetic):

printf("%d\n", *(x_ptr + 1));
printf("%d\n", x_array[1]);

19
19

You can also dynamically allocate contiguous blocks of memory with the standard library function malloc, which takes one argument of type size_t representing the number of bytes to allocate (usually from the heap, although this may not be true on e.g. embedded systems - the C standard says nothing about it):

int *my_ptr = malloc(sizeof(*my_ptr) * 20);
for (int xx = 0; xx < 20; xx++) {
  *(my_ptr + xx) = 20 - xx; // my_ptr[xx] = 20-xx
} // Initialize memory to 20, 19, 18, 17... 2, 1 (as ints)

Be careful passing user-provided values to malloc! If you want to be safe, you can use calloc instead (which, unlike malloc, also zeros out the memory):

int *my_other_ptr = calloc(20, sizeof(int));

Note that there is no standard way to get the length of a dynamically allocated array in C. Because of this, if your arrays are going to be passed around your program a lot, you need another variable to keep track of the number of elements (size) of an array. See the functions section for more info.

size_t size = 10;
int *my_arr = calloc(size, sizeof(int));

// Add an element to the array
size++;
my_arr = realloc(my_arr, sizeof(int) * size);

if (my_arr == NULL) {
  // Remember to check for realloc failure!
  printf("realloc failed!\n");
  return 0;
}

printf("successful realloc\n");
my_arr[10] = 5;

successful realloc

Dereferencing memory that you haven't allocated gives "unpredictable results" - the program is said to invoke "undefined behavior":

printf("%d\n", *(my_ptr + 21));
// Prints who-knows-what? It may even crash.

When you're done with a malloc'd block of memory, you need to free it, or else no one else can use it until your program terminates (this is called a "memory leak"):

free(my_ptr);

Strings are arrays of char, but they are usually represented as a pointer-to-char (which is a pointer to the first element of the array). It's good practice to use const char * when referring to a string literal, since string literals shall not be modified (i.e. foo[0] = 'a' is ILLEGAL.)

const char *my_str = "This is my very own string literal";
printf("%c\n", *my_str); // first character

This is not the case if the string is an array (potentially initialized with a string literal) that resides in writable memory, as in:

char foo[] = "foo";
foo[0] = 'a'; // this is legal
printf("%s\n", foo);

aoo

Functions

Function declaration syntax:

// <return type> <function name>(<args>)
int add_two_ints(int x1, int x2) {
  return x1 + x2; // Use return to return a value
}

int main() {
  int sum = add_two_ints(40, 2);
  printf("%d\n", sum);
}

Functions are call by value. When a function is called, the arguments passed to the function are copies of the original arguments (except arrays). Anything you do to the arguments in the function do not change the value of the original argument where the function was called.

Use pointers if you need to edit the original argument values (arrays are always passed in as pointers).

Example: in-place string reversal:

// A void function returns no value
void str_reverse(char *str_in) {
  char tmp;
  size_t len = strlen(str_in); // `strlen()` is part of the c standard library
  // NOTE: string.h header file needs to be included to use strlen()
  // NOTE: length returned by `strlen` DOESN'T
  // include the terminating NULL byte ('\0')

  for (int ii = 0; ii < len / 2; ii++) {
    tmp = str_in[ii];
    str_in[ii] = str_in[len - ii - 1]; // ii-th char from end
    str_in[len - ii - 1] = tmp;
  }
}

int main() {
  char c[] = "This is a test.";
  str_reverse(c);
  printf("%s\n", c);
}

.tset a si sihT

C does not allow for returning multiple values with the return statement. If you would like to return multiple values, then the caller must pass in the variables where they would like the returned values to go. These variables must be passed in as pointers such that the function can modify them.

int return_multiple(int *array_of_3, int *ret1, int *ret2, int *ret3) {
  if (array_of_3 == NULL) {
    return 0; // return status (false)
  }

  // de-reference the pointer so we modify its value
  *ret1 = array_of_3[0];
  *ret2 = array_of_3[1];
  *ret3 = array_of_3[2];

  return 1; // return status (true)
}

int main() {
  int arr[] = {11, 22, 33};
  int a = 0;
  int b = 0;
  int c = 0;
  int ok = return_multiple(arr, &a, &b, &c);
  printf("ok=%d a=%d b=%d c=%d\n", ok, a, b, c);
}

ok=1 a=11 b=22 c=33

Another example:

void swap_numbers(int *a, int *b) {
  int temp = *a;
  *a = *b;
  *b = temp;
}

int main() {
  int first = 10;
  int second = 20;
  printf("first: %d\nsecond: %d\n", first, second);
  swap_numbers(&first, &second);
  printf("first: %d\nsecond: %d\n", first, second);
}

first: 10
second: 20
first: 20
second: 10

With regards to arrays, they will always be passed to functions as pointers. Even if you statically allocate an array like arr[10], it still gets passed as a pointer to the first element in any function calls. Again, there is no standard way to get the size of a dynamically allocated array in C.

// Size must be passed!
// Otherwise, this function has no way of knowing how big the array is.
void print_int_array(int *arr, size_t size) {
  for (int i = 0; i < size; i++) {
    printf("arr[%d] is: %d\n", i, arr[i]);
  }
}

int main() {
  int my_arr[] = { 1, 2, 3, 4, 5 };
  int size = 5;
  print_int_array(my_arr, size);
}

arr[0] is: 1
arr[1] is: 2
arr[2] is: 3
arr[3] is: 4
arr[4] is: 5

If referring to external variables outside function, you should use the extern keyword:

int i = 0;

void extern_1() {
  extern int i; // i here is now using external variable i
  i = 42;
}

int main() {
  printf("i = %d\n", i);
  extern_1();
  printf("i = %d\n", i);
}

i = 0
i = 42

Make external variables private to source file with static:

static int j = 0; // other files using extern_2() cannot access variable j

void extern_2() {
  extern int j;
}

The static keyword makes a variable inaccessible to code outside the compilation unit. (On almost all systems, a "compilation unit" is a .c file.) static can apply both to global (to the compilation unit) variables, functions, and function-local variables. When using static with function-local variables, the variable is effectively global and retains its value across function calls, but is only accessible within the function it is declared in. Additionally, static variables are initialized to 0 if not declared with some other starting value.

You can also declare functions as static to make them private. Suppose you have two functions in mylib.c:

#include <stdio.h>

// is accessible from other .c files
void public_hello() {
  printf("hello in public");
}

// is NOT accessible from other .c files
static void private_hello() {
  printf("hello in private");
}

You can call the first function from main.c:

void public_hello();

int main() {
  public_hello();
}

hello in public

But not the second one, declared as static:

void private_hello();

int main() {
  private_hello();
}

main.c:(.text+0xa): undefined reference to `private_hello'
collect2: error: ld returned 1 exit status
 (exit status 1)

User-defined types and structs

Typedefs can be used to create type aliases:

typedef int my_type;
my_type my_type_var = 0;

Structs are just collections of data, the members are allocated sequentially, in the order they are written:

struct rectangle {
  int width;
  int height;
};

It's NOT generally true that

sizeof(struct rectangle) == sizeof(int) + sizeof(int)

due to potential padding between the structure members (this is for alignment reasons).

Using structs:

int main() {
  // Fields can be initialized immediately
  struct rectangle my_rec = { 1, 2 };

  // Access struct members with .
  my_rec.width = 10;
  my_rec.height = 20;

  printf("{%d %d}\n", my_rec.width, my_rec.height);
}

{10 20}

Using pointers to structs:

int main() {
  struct rectangle my_rec = { 1, 2 };
  // You can declare pointers to structs
  struct rectangle *my_rec_ptr = &my_rec;

  // Use dereferencing to set struct pointer members...
  (*my_rec_ptr).width = 30;

  // ... or even better: prefer the -> shorthand for the sake of readability
  my_rec_ptr->height = 10; // Same as (*my_rec_ptr).height = 10;

  printf("{%d %d}\n", my_rec_ptr->width, my_rec_ptr->height);
  printf("{%d %d}\n", my_rec.width, my_rec.height);
}

{30 10}
{30 10}

You can apply a typedef to a struct for convenience:

typedef struct rectangle rect;

int area(rect r) {
  return r.width * r.height;
}

int main() {
  rect r = { 2, 4 };
  printf("area = %d\n", area(r));
}

area = 8

Typedefs can also be defined right during struct definition:

typedef struct {
  int width;
  int height;
} rect;

int main() {
  // Like before, doing this means one can type
  rect r1;

  // instead of having to type
  struct rectangle r2;
}

If you have large structs, you can pass them "by pointer" to avoid copying the whole struct:

typedef struct {
  int width;
  int height;
} rect;

int areaptr(const rect *r) {
  return r->width * r->height;
}

int main() {
  rect r = { 2, 4 };
  printf("area = %d\n", areaptr(&r));
}

area = 8

Function pointers

At run time, functions are located at known memory addresses. Function pointers are much like any other pointer (they just store a memory address), but can be used to invoke functions directly, and to pass handlers (or callback functions) around. However, definition syntax may be initially confusing.

int main() {
  char str_in[] = "Hello, World!";

  // Use str_reverse from a pointer.
  // Define a function pointer variable, named f.
  void (*f)(char *); // Signature should exactly match the target function.

  f = &str_reverse; // Assign the address for the actual function (determined at run time)
  // f = str_reverse; would work as well - functions decay into pointers, similar to arrays

  (*f)(str_in); // Just calling the function through the pointer
  // f(str_in); // That's an alternative but equally valid syntax for calling it.

  printf("%s\n", str_in);
}

!dlroW ,olleH

As long as function signatures match, you can assign any function to the same pointer. Function pointers are usually typedef'd for simplicity and readability, as follows:

typedef void (*my_fnp_type)(char *);

// Then used when declaring the actual pointer variable:
// ...
// my_fnp_type f;

Printing characters with printf()

Special characters:

'\a'; // alert (bell) character
'\n'; // newline character
'\t'; // tab character (left justifies text)
'\v'; // vertical tab
'\f'; // new page (form feed)
'\r'; // carriage return
'\b'; // backspace character
'\0'; // NULL character. Usually put at end of strings in C.
//   hello\n\0. \0 used by convention to mark end of string.
'\\'; // backslash
'\?'; // question mark
'\''; // single quote
'\"'; // double quote
'\xhh'; // hexadecimal number. Example: '\xb' = vertical tab character
'\0oo'; // octal number. Example: '\013' = vertical tab character

Print formatting:

"%d";    // integer
"%3d";   // integer with minimum of length 3 digits (right justifies text)
"%s";    // string
"%f";    // float
"%ld";   // long
"%3.2f"; // minimum 3 digits left and 2 digits right decimal float
"%7.4s"; // (can do with strings too)
"%c";    // char
"%p";    // pointer. NOTE: need to (void *)-cast the pointer, before passing
         //                it as an argument to `printf`.
"%x";    // hexadecimal
"%o";    // octal
"%%";    // prints %

Order of Evaluation

From top to bottom, top has higher precedence:

┌───────────────────────────────────┬───────────────┐
│        Operators                  │ Associativity │
├───────────────────────────────────┼───────────────┤
│ () [] -> .                        │ left to right │
│ ! ~ ++ -- + = *(type) sizeof      │ right to left │
│ * / %                             │ left to right │
│ + -                               │ left to right │
│ << >>                             │ left to right │
│ < <= > >=                         │ left to right │
│ == !=                             │ left to right │
│ &                                 │ left to right │
│ ^                                 │ left to right │
│ |                                 │ left to right │
│ &&                                │ left to right │
│ ||                                │ left to right │
│ ?:                                │ right to left │
│ = += -= *= /= %= &= ^= |= <<= >>= │ right to left │
│ ,                                 │ left to right │
└───────────────────────────────────┴───────────────┘

Header files

Header files are an important part of C as they allow for the connection of C source files and can simplify code and definitions by separating them into separate files.

Header files are syntactically similar to C source files but reside in .h files. They can be included in your C source file by using the precompiler command #include "example.h", given that example.h exists in the same directory as the C file.

Here is a sample example.h:

// A safe guard to prevent the header from being defined too many times. This
// happens in the case of circle dependency, the contents of the header is
// already defined.
#ifndef EXAMPLE_H // if EXAMPLE_H is not yet defined.
#define EXAMPLE_H // Define the macro EXAMPLE_H.

// Other headers can be included in headers and therefore transitively
// included into files that include this header.
#include <string.h>

// Like for c source files, macros can be defined in headers
// and used in files that include this header file.
#define EXAMPLE_NAME "Dennis Ritchie"

// Function macros can also be defined.
#define ADD(a, b) ((a) + (b))

// Notice the parenthesis surrounding the arguments -- this is important to
// ensure that a and b don't get expanded in an unexpected way (e.g. consider
// MUL(x, y) (x * y); MUL(1 + 2, 3) would expand to (1 + 2 * 3), yielding an
// incorrect result)

// Structs and typedefs can be used for consistency between files.
typedef struct Node {
  int val;
  struct Node *next;
} Node;

// So can enumerations.
enum traffic_light_state {GREEN, YELLOW, RED};

// Function prototypes can also be defined here for use in multiple files,
// but it is bad practice to define the function in the header. Definitions
// should instead be put in a C file.
Node create_linked_list(int *vals, int len);

// Beyond the above elements, other definitions should be left to a C source
// file. Excessive includes or definitions should also not be contained in
// a header file but instead put into separate headers or a C file.

#endif // End of the if precompiler directive.

And here is how to use it in main.c:

#include <stdio.h>
#include "example.h"

// function definition
Node create_linked_list(int *vals, int len) {
    // implementation skipped for brevity
    Node n = {42, NULL};
    return n;
}

int main() {
  printf("EXAMPLE_NAME = %s\n", EXAMPLE_NAME);
  printf("3 + 2 = %d\n", ADD(3,2));
  printf("Lights: %d -> %d -> %d\n", GREEN, YELLOW, RED);

  int vals[] = {42};
  Node list = create_linked_list(vals, 1);
  printf("{ %d }\n", list.val);
}

EXAMPLE_NAME = Dennis Ritchie
3 + 2 = 5
Lights: 0 -> 1 -> 2
{ 42 }