C cheatsheet.

#include <stdio.h>

int main(void)
{
    puts("Hello, world!");
    return 0;
}

main is the entry point in a hosted program. Return 0 for success.

cc -std=c17 -Wall -Wextra -Wpedantic \
   hello.c -o hello
./hello

Use GCC or Clang. These commands assume a Unix-like shell.

int count = 42;
double price = 19.95;
char initial = 'C';
const int limit = 100;

#include <stdbool.h>
bool ready = true;

Single quotes hold a character. Double quotes hold a string.

&& and || short-circuit: the right side runs only when needed.

int whole = 7 / 2;         // 3
double ratio = 7.0 / 2;   // 3.5
int remainder = 7 % 2;    // 1

int max = (a > b) ? a : b;

// Short-circuit the null check.
// p must otherwise point to a valid int.
if (p != NULL && *p > 0) {
    /* p points to a positive value */
}

Integer division truncates toward zero. Division by zero and signed integer overflow are undefined behavior.

if (score >= 80) {
    puts("Great work");
} else if (score >= 50) {
    puts("Passed");
} else {
    puts("Try again");
}

switch (choice) {
case 1:
    puts("Start");
    break;
default:
    puts("Unknown choice");
    break;
}

Zero is false; nonzero is true. Without break, a switch case falls through into the next case.

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

int n = 3;
while (n > 0) {
    --n;
}

do {
    ++n;
} while (n < 3);

A do … while loop runs at least once. Use <stdio.h> for puts and printf.

int add(int a, int b);  // prototype

int main(void)
{
    int result = add(2, 3);
    return result == 5 ? 0 : 1;
}

int add(int a, int b)
{
    return a + b;
}

Declare a function before calling it. In C17, f(void) means no parameters; a declaration f() leaves the parameter types unspecified.

void increment(int *value)
{
    ++*value;
}

int main(void)
{
    int count = 0;
    increment(&count);
    return 0;
}

Arguments are passed by value, including pointers. Pass an address to let a function change the caller’s object.

#include <stddef.h>

int values[] = {10, 20, 30};
size_t length = sizeof values
              / sizeof values[0];

for (size_t i = 0; i < length; ++i) {
    values[i] += 1;
}

int grid[2][3] = {
    {1, 2, 3}, {4, 5, 6}
};

The length formula works on an actual array. A function parameter declared as an array is adjusted to a pointer; pass its length separately.

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

char name[] = "Ada";  // 4 bytes with '\0'
const char *label = "C";

size_t length = strlen(name); // 3
int same = strcmp(name, "Ada") == 0;

char message[32];
int written = snprintf(message,
    sizeof message, "Hi, %s", name);

A C string ends with '\0'. Don’t modify a string literal. strcmp compares contents; == on pointers compares addresses.

#include <stddef.h>

int value = 42;
int *p = &value;  // address of value
int copy = *p;    // read through p
*p = 7;          // changes value

int *empty = NULL;

int items[] = {10, 20, 30};
int second = *(items + 1); // items[1]

&x gets an address; *p accesses the pointed-to object. Never dereference a null, dangling, or uninitialized pointer.

int a = 1;
int b = 2;

const int *read_only = &a;
read_only = &b;  // pointer can change
// *read_only = 3;  // not allowed

int *const fixed = &a;
*fixed = 3;       // object can change
// fixed = &b;     // not allowed

const int *const both = &a;

Pointer arithmetic stays within one array, or one past its end. A one-past pointer is valid to form, but not to dereference.

#include <stdlib.h>

int main(void)
{
    size_t count = 4;
    int *values = malloc(count * sizeof *values);
    if (values == NULL) {
        return EXIT_FAILURE;
    }

    values[0] = 42;
    free(values);
    values = NULL;
    return EXIT_SUCCESS;
}

malloc leaves contents uninitialized. calloc(count, size) initializes all bits to zero. Use <stdlib.h>; no allocation cast is needed in C.

// values owns an existing allocation.
// new_count is positive; size does not overflow.
int *temporary = realloc(values,
    new_count * sizeof *values);

if (temporary != NULL) {
    values = temporary;
} else {
    // values is still valid; handle failure.
}

After a successful realloc, old pointers into the allocation are invalid. Avoid zero-size requests. Free each allocation exactly once.

typedef struct {
    int x;
    int y;
} Point;

Point origin = {.x = 0, .y = 0};
Point *p = &origin;

origin.x = 10; // access an object
p->y = 20;    // access through a pointer

p->y is shorthand for (*p).y. Struct assignment copies member values; pointer members still point to the same objects.

enum Status {
    STATUS_OK = 0,
    STATUS_ERROR = 1
};

enum Status result = STATUS_OK;

#include <stdint.h>
typedef uint_least32_t Counter;
Counter visits = 0;

typedef adds a name for an existing type. uint_least32_t is at least 32 bits; exact-width types such as uint32_t are optional.

#include <stdio.h>

char line[128];
if (fgets(line, sizeof line, stdin) != NULL) {
    printf("You entered: %s", line);
} else {
    // EOF or an input error.
}

fgets keeps the newline if it fits and adds a terminator on success. A long input line may arrive in several chunks.

#include <stdio.h>

FILE *file = fopen("notes.txt", "r");
if (file != NULL) {
    int ch;
    while ((ch = fgetc(file)) != EOF) {
        if (putchar(ch) == EOF) {
            // Handle an output error.
            break;
        }
    }
    if (ferror(file)) {
        // Handle a read error.
    }
    if (fclose(file) == EOF) {
        // Handle a close error.
    }
} else {
    perror("notes.txt");
}

Store fgetc’s result in an int to preserve EOF. Modes: r read, w create/truncate, a append; add b for binary.

#ifndef PROJECT_POINT_H
#define PROJECT_POINT_H

typedef struct {
    int x;
    int y;
} Point;

int point_distance_squared(Point p);

#endif

Use #include <stdio.h> for a standard header and #include "point.h" for a project header. Guards prevent repeated declarations.

#define BUFFER_SIZE 256

#ifdef DEBUG
    /* Debug-only code */
#endif

// Prefer a function for calculated values.
static inline int square(int x)
{
    return x * x;
}

Macros substitute tokens. A macro such as SQUARE(i++) may evaluate its argument multiple times; a function avoids that trap.

cc -std=c17 -Wall -Wextra -Wpedantic \
   -g -fsanitize=address,undefined \
   -fno-omit-frame-pointer \
   program.c -o program
./program

On supported platforms, sanitizers help find memory errors and undefined behavior while you run the program. They don’t catch every bug.