Cheatsheet

Minimal program

#include <stdio.h>

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

Compile and run

gcc main.c -o app        # compile
gcc -Wall -Wextra main.c # with warnings on
gcc -E main.c            # stop after preprocessing
gcc -g main.c            # include debug symbols
./app                    # run

Output and input

printf("%d %5.2f %s %c\n", n, f, str, ch);
scanf("%d %f", &n, &f);       /* & required except for arrays */

puts(str);                        /* prints and adds \n     */
fgets(buf, sizeof buf, stdin);   /* safe line input        */
ch = getchar();  putchar(ch);   /* one character at a time */

Format specifiers

Width, precision, and flags

"%5d"     /* width 5, right aligned  */
"%-5d"    /* width 5, left aligned   */
"%05d"    /* pad with zeros          */
"%.2f"    /* 2 decimal places        */
"%8.3f"   /* width 8, 3 decimals     */
"%+d"     /* always show the sign    */

Escape sequences

\n  newline      \t  tab          \\  backslash
\r  carriage ret \0  null char    \"  double quote
\b  backspace    \a  bell         \'  single quote

Sizes and ranges (typical 64-bit system)

* long is 4 bytes on Windows. Always confirm with sizeof.

Declaring and qualifying

int a = 10, b = 20;
const float PI = 3.14f;    /* cannot be modified      */
volatile int flag;          /* may change externally   */
unsigned long total = 0UL;

enum { MAX = 100 };          /* typed, scoped constant  */
#define SIZE 50              /* textual constant        */

Literal suffixes and type conversion

10      int        10U    unsigned    10L   long
3.14    double     3.14f  float       0x1F  hex
017     octal      0b1010 binary (ext) 'A'  char

float avg = (float)sum / count;   /* explicit cast */
/* promotion order: char → int → long → float → double */

Precedence — highest to lowest

 1. () [] . -> ++(post) --(post)      left → right
 2. ++(pre) --(pre) + - ! ~ * & sizeof (cast)   right → left
 3. * / %                             left → right
 4. + -                               left → right
 5. << >>                             left → right
 6. < <= > >=                         left → right
 7. == !=                             left → right
 8. &      9. ^      10. |             left → right
11. &&    12. ||                       left → right
13. ?:                                right → left
14. = += -= ...                       right → left
15. ,                                 left → right

Bit tricks

x & 1               /* odd if 1                  */
x << n              /* multiply by 2^n           */
x >> n              /* divide by 2^n             */
x | (1 << n)        /* set bit n                 */
x & ~(1 << n)       /* clear bit n               */
x ^ (1 << n)        /* toggle bit n              */
(x >> n) & 1        /* read bit n                */

int a[5];                        /* uninitialised          */
int b[5] = {1, 2, 3, 4, 5};
int c[5] = {1, 2};             /* rest are 0             */
int d[5] = {0};                /* all zeros              */
int e[]  = {1, 2, 3};          /* size inferred = 3      */

int n = sizeof(b) / sizeof(b[0]);   /* element count */

2D arrays

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

for (i = 0; i < 2; i++)
    for (j = 0; j < 3; j++)
        printf("%d ", m[i][j]);

/* Row-major: address of m[i][j] = base + (i*cols + j)*sizeof(int) */
/* As a parameter, all dimensions but the first are required:      */
void show(int m[][3], int rows);

Arrays decay to pointers when passed, so sizeof inside the function gives the pointer size. Always pass the element count separately. C does no bounds checking.

char s1[] = "hello";      /* modifiable, 6 bytes    */
char s2[20] = "hello";    /* room to grow           */
const char *s3 = "hello";  /* literal, do not modify */

Common patterns

fgets(buf, sizeof buf, stdin);
buf[strcspn(buf, "\n")] = '\0';   /* strip newline    */

if (strcmp(a, b) == 0) ...           /* equal — never == */

scanf("%49s", name);                /* bound the width  */
scanf("%[^\n]", line);               /* read with spaces */

/* char classification — <ctype.h> */
isalpha isdigit isalnum isspace isupper islower toupper tolower

Never use gets() — removed in C11. Use fgets.

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

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

int s = add(3, 4);              /* call       */

void f(int x) {
    x = 99;   /* copy only */
}
f(a);        /* a unchanged */

void g(int *x) {
    *x = 99;  /* the original */
}
g(&a);       /* a becomes 99 */

Recursion and function pointers

int fact(int n) {
    if (n <= 1) return 1;      /* base case      */
    return n * fact(n - 1);      /* recursive case */
}

int (*fp)(int, int) = add;    /* function pointer */
int r = fp(3, 4);

typedef int (*Op)(int, int);   /* readable alias   */

void counter(void) {
    static int n = 0;   /* survives between calls */
    n++;
}

extern int shared;      /* defined in another file */
static int privateVar;  /* invisible to other files */

int  a = 10;
int *p = &a;        /* & = address of        */
printf("%d", *p);   /* * = value at (deref)   */
*p = 20;             /* a is now 20            */

Arithmetic and array equivalence

p + 1       /* advances by sizeof(*p) bytes */
p2 - p1     /* number of elements between   */

a[i]  ==  *(a + i)  ==  *(i + a)  ==  i[a]
&a[i] ==  a + i

/* Legal: + - ++ -- comparison. Illegal: * / % on pointers */

int *p = malloc(n * sizeof(*p));   /* sizeof(*p), not sizeof(int) */
if (p == NULL) { /* handle failure */ return 1; }

int *q = realloc(p, m * sizeof(*p));
if (q != NULL) p = q;             /* never assign directly */

free(p);
p = NULL;                            /* avoid dangling        */

Dynamic 2D array — one contiguous block

int *g = malloc(rows * cols * sizeof(*g));
g[i * cols + j] = 5;                /* manual indexing */
free(g);                                /* one free        */

Rules: one free per allocation, never free twice, free inner pointers before the structure that holds them, and free(NULL) is always safe.

struct Student {
    char  name[50];
    int   roll;
    float marks;
};                                    /* semicolon! */

struct Student s1 = { "Asha", 101, 88.5 };
struct Student s2 = { .roll = 102 };   /* designated */
struct Student s3 = s1;                /* copy ok    */

s1.roll          /* variable → dot   */
p->roll          /* pointer  → arrow */

union Value { int i; float f; };

enum Day { MON, TUE, WED };        /* 0, 1, 2       */
enum St  { OK = 200, ERR = 500 };   /* explicit      */

typedef struct { int x, y; } Point;
Point pt = { 3, 5 };

struct Node { int d; struct Node *next; };  /* self-referential */

struct Flags { unsigned int on : 1; };      /* bit field        */

Structures can be assigned with = but not compared with ==. Pass large ones as const struct T *.

FILE *fp = fopen("data.txt", "r");
if (fp == NULL) { perror("data.txt"); return 1; }

while (fgets(line, sizeof line, fp) != NULL)   /* not feof! */
    fputs(line, stdout);

fclose(fp);

fwrite(&s, sizeof s, 1, fp);    /* binary record out */
fread(&t, sizeof t, 1, fp);     /* binary record in  */

fseek(fp, 0L, SEEK_END);          /* SEEK_SET/CUR/END  */
long size = ftell(fp);            /* file size         */

int main(int argc, char *argv[]) {
    /* argv[0] = program, argv[1..] = args, argv[argc] = NULL */
    if (argc < 2) return 1;
    int n = atoi(argv[1]);          /* args are strings  */
}

#include <stdio.h>        /* system paths      */
#include "my.h"           /* local first       */

#define MAX 100            /* no semicolon!     */
#define SQ(x) ((x) * (x))  /* parenthesize all  */
#undef MAX

#ifdef DEBUG  ... #endif
#ifndef MAX    ... #endif
#if V == 1    ... #elif V == 2 ... #else ... #endif

#error "stop the build"
#pragma once             /* non-standard guard */

Include guard

#ifndef MYFILE_H
#define MYFILE_H
   ... declarations ...
#endif

#x       /* "x"     stringize */
a##b     /* ab      paste     */
defined(X)  /* in #if      */
\        /* continue line */

__FILE__   __LINE__
__DATE__   __TIME__
__STDC__   __func__
_WIN32 __linux__ __APPLE__
__GNUC__   _MSC_VER

Multi-statement macro and variadic logging

#define SWAP(a, b) do { int t=(a); (a)=(b); (b)=t; } while (0)

#define LOG(fmt, ...) \
    fprintf(stderr, "[%s:%d] " fmt, __FILE__, __LINE__, __VA_ARGS__)

Frequently used snippets

srand(time(NULL));  r = rand() % 100;   /* 0..99          */
qsort(arr, n, sizeof(*arr), cmp);       /* generic sort   */
n = atoi(str);   d = atof(str);          /* string→number  */
exit(0);                                    /* end program    */