%%file hello.c
#include <stdio.h>

int main() {
    printf("Hello world");
    return 0;
}

Overwriting hello.c

!gcc hello.c -o hello

!./hello

Hello world

man printf
man 2 write

gcc -g hello.c -o hello
gdb hello

%%file hello2.c
#include <stdio.h>
#define GREETINGS printf("Hello world")

int main() {
    GREETINGS;
    return 0;
}

Overwriting hello2.c

!gcc hello2.c -o hello2
!./hello2

Hello world

%%file macro.c
#include <stdio.h>
#define REPEAT_TWICE(a) a "-" a

int main() {
    printf("1) " "Hello" "-" "Hello" "\n");
    printf("2) " REPEAT_TWICE("Hello") "\n");
    return 0;
}

Overwriting macro.c

!gcc macro.c -o macro
!./macro

1) Hello-Hello
2) Hello-Hello

%%file hello3.c
#include <stdio.h>
#ifdef FRENCH
#  define MESSAGE "Bonjour tout le monde"
#else
#  define MESSAGE "Hello world"
#endif

int main() { printf(MESSAGE); return 0; }

Overwriting hello3.c

!gcc hello3.c -o hello3 && ./hello3

Hello world

!gcc hello3.c -o hello3 -DFRENCH && ./hello3

Bonjour tout le monde

#ifndef MY_MODULE_H
#define MY_MODULE_H
// ...
#endif

%%file a.h
#ifndef A_H
#define A_H
void a();
#endif

Overwriting a.h

%%file a.c
#include <stdio.h>
#include "a.h"

void a() {
    printf("hello\n");
}

Overwriting a.c

%%file main.c
#include "a.h"

int main() {
    a();
    return 0;
}

Overwriting main.c

!gcc -c a.c
!gcc main.c a.o -o main
!./main

hello

%%file sizeof.c
#include <stdint.h>
#include <stdio.h>

int main() {
    int a;
    printf("sizof(a) = %zu\n", sizeof(a));
    printf("sizof(int) = %zu\n", sizeof(int));
    printf("sizof(int16) = %zu\n", sizeof(int16_t));
    printf("sizof(int32) = %zu\n", sizeof(int32_t));
    return 0;
}

Overwriting sizeof.c

!gcc sizeof.c -o sizeof
!./sizeof

sizof(a) = 4
sizof(int) = 4
sizof(int16) = 2
sizof(int32) = 4

static void detail() {
    //...
}

void f() {
    detail();
    //...
}

%%file division.c
#include <stdio.h>

int main() {
    int a = 7, b = 2;
    // Euclidean division
    printf("%d = %d * %d + %d\n", a, b, a / b, a % b);
    // Usual division
    double x = 7;
    printf("%lf = %d * %lf\n", x, b, x / b);
    return 0;
}

Overwriting division.c

!gcc division.c -o division
!./division

7 = 2 * 3 + 1
7.000000 = 2 * 3.500000

%%file lazy.c
#include <stdbool.h>
#include <stdio.h>

bool is_true() {
    printf("true");
    return true;
}

bool is_false() {
    printf("false");
    return false;
}

int main() {
    bool b = is_false() && is_true();
    return 0;
}

Overwriting lazy.c

!gcc lazy.c -o lazy
!./lazy

false

(0 <= i) && (i < 5)

(x & (1 << 7)) >> 7

#include <stdio.h>

int main() {
    printf(
        "Hello, my name is Bond.\n"
        "James Bond\n"
    );
    return 0;
}

%%file printf.c
#include <stdio.h>

int main() {
    int x = 7;
    float y = 5.67;
    double z = 5.67;
    printf("1) x = %d\n", x);
    printf("2) y = %f\n", y);
    printf("3) y = %lf\n", z);
    printf("4) x = %d  y = %0.2f  z = %0.3lf\n", x, y, z);
    return 0;
}

Overwriting printf.c

!gcc -Wall printf.c -o printf
!./printf

1) x = 7
2) y = 5.670000
3) y = 5.670000
4) x = 7  y = 5.67  z = 5.670

#include <stdio.h>

int main() {
    int x;
    printf("Integer? ");
    scanf("%d", &x);
    printf("x = %d\n");
    return 0;
}

#include <stdio.h>

int main() {
    int x = 7;
    if (x % 2 == 0) {
        printf("Even\n");
    } else {
        printf("Odd\n");
    } // Odd
    return 0;
}

#include <stdio.h>
#define BLUE 1
#define RED 2

int main() {
    int choice = 1;
    switch(choice) {
        case BLUE:
            printf("Blue!");
            break;
        case RED:
            printf("Red!");
            break;
        default:
            printf("Invalid number!");
            break;
    } // "Blue!"
    return 0;
}

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

int i, ret;
do {
    printf("Enter an integer: ");
    ret = scanf("%d", &i);
} while (ret == 1);

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

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

int main() {
    int i = 7;
    int *pi = &i;
    printf("1) i = %d *pi = %d\n", i, *pi); // 1) i = 7 *pi = 7
    *pi = 8;
    printf("2) i = %d *pi = %d\n", i, *pi); // 2) i = 8 *pi = 8
    return 0;
}

#include <stdio.h>

int main() {
    int i = 7;
    int *pi = &i;
    printf("1) i = %d *pi = %d\n", i, *pi);
    *pi = 8;
    printf("2) i = %d *pi = %d\n", i, *pi);
    int **ppi = &pi;
    **ppi = 9;
    printf(
        "3) i = %d pi = %p *pi = %d *ppi = %p **ppi = %d\n",
        i, pi, *pi, *ppi, **ppi
    );
    return 0;
}

#include <stdio.h>   // printf
#include <string.h>  // strlen

int main() {
    char * s = "hello";
    printf("%s\n", s);
    for (size_t i = 0; i < strlen(s); i++) {
        printf("%d: %c %c     %p + (%d * %d) = %p\n",
            i, s[i], *(s + i),
            s, sizeof(char), i, s + i
        );
    }
    return 0;
}

#include <stdio.h>

int increment(int i) {
    printf("2) increment: %d\n", i);
    i++;
    printf("3) increment: %d\n", i);
}

int main() {
    int i = 7;
    printf("1) main: %d\n", i);
    increment(i);
    printf("4) main: %d\n", i);
    return 0;
}

#include <stdio.h>

void increment(int i) {
    i++;
    printf("2) increment: %d %x\n", i, &i);
}

int main() {
    int i = 7;
    printf("1) main: %d %x\n", i, &i);
    increment(i);
    printf("3) main: %d %x\n", i, &i);
    return 0;
}

#include <stdio.h>

void increment(int * i) {
    (*i)++; // Or in short, *i++
}

int main() {
    int i = 7;
    printf("1) main: %d\n", i);
    increment(&i);
    printf("2) main: %d\n", i);
    return 0;
}

#include <stdio.h>

int main() {
    int array[3] = {10, 11, 12};
    printf("array size: %zu %zu\n", sizeof(array), sizeof(int) * 3);
    for (size_t i = 0; i < 3; i++) {
        printf("%d: %d, %d\n", i, array[i], *(array + i));
    }
    return 0;
}

#include <stdlib.h>

int * array = (int *) malloc(sizeof(int) * n);
if (array) {
    // ...
    free(array)
}

#include <stdio.h>

struct pair_t {
    int a;
    double b;
}; // <-- do not forget ';' here

int main() {
    struct pair_t p = {3, 4.5};
    printf("p = (a = %d, b = %lf)\n", p.a, p.b);
    p.a = -2;
    p.b = -7.8;
    printf("p = (a = %d, b = %lf)\n", p.a, p.b);
    return 0;
}

#include <stdio.h>

enum shape_t {
    SQUARE,
    CIRCLE,
    TRIANGLE,
};

int main() {
    enum shape_t shape1 = SQUARE;
    enum shape_t shape2 = TRIANGLE,
                 shape3 = CIRCLE;
    printf("shape1 = %d\n", shape1);
    printf("shape2 = %d\n", shape2);
    printf("shape3 = %d\n", shape3);
    return 0;
}

#include <stdio.h>

union my_union_t {
    int i;
    double d;
};

int main() {
    union my_union_t u;
    u.i = 7;
    printf(
        "sizeof(u.i) = %zu\n" // sizeof(u.i) = 4
        "sizeof(u.d) = %zu\n" // sizeof(u.d) = 8
        "sizeof(u) = %zu\n",  // sizeof(u) = 8
        sizeof(u.i), sizeof(u.d), sizeof(u)
    );
    printf("1) u.i = %d\n", u.i); // 7
    printf("1) u.d = %lf\n", u.d); // 0.00000
    u.d = 1.234;
    printf("2) u.i = %d\n", u.i); // -927712936
    printf("2) u.d = %lf\n", u.d); // 1.234000
    return 0;
}

struct pair {
    int a;
    double b;
};
typedef struct pair pair_t;

typedef struct pair {
    int a;
    double b;
} pair_t;

#include <stdio.h>

int main() {
    FILE * fp = fopen("/etc/passwd", "r");
    if (fp) {
        // Do something
        fclose(fp);
    } else {
        // Oops
    }
    return 0;
}

int i, j, k;
FILE * fp = fopen("some_file", "w");
if (fp) {
    fprintf(fp, "%d %d %d", i, j, k);
    // ....
    fclose(fp);
}

int i, j, k;
FILE * fp = fopen("some_file", "r");
if (fp) {
    fscanf(fp, "%d %d %d", &i, &j, &k);
    // ....
    fclose(fp);
}

#include <stdio.h>

int main() {
    int i;
    printf("Hello"); // or fprintf(stdout, "Hello");
    fprintf(stderr, "Hello");
    scanf("%d", &i); // or fscanf("%d", &i);
    return 0;
}

Binary	Windows	GNU/Linux
Object	`.o`	`.o`
Runnable	`.exe`	No extension
Static library	`.lib`	`.a`
Dynamic library	`.dll`	`.so`
Kernel module	N/A	`.ko`

Shortcut	Meaning
`b main`	Breakpoint on `main` function
`b 18`	Breakpoint line 18
`no br`	Clear breakpoints
`r`	Run (until breakpoint)
`c`	Continue (until breakpoint)
`n`	Next
`s`	Step
`p x`	Print value of `x`

Operation	Operator	In place operator
Addition	`+`	`+=`
Subtraction	`-`	`-=`
Multiplication	`*`	`*=`
Division	`/`	`/=`
Module	`%`	`%=`

Operation	Operator
Not	!
And	`&&`
Or	`\|\|`
Xor	`^`

Operation	Operator
Equals	`==`
Not equals	`!=`
Lower than	`<`
Lower or equal	`<=`
Greater than	`>`
Greater or equal	`>=`

Operation	Operator	In place operator
Bitwise not	~	~=
Bitwise and	`&`	&=
Bitwise or	`\|`	\|=
Left shift	`<<`	`<<=`
Right shift	`>>`	`>>=`

Outline¶

Introduction¶

What is C?¶

Why C?¶

Hello world¶

Source file (.c)¶

Source structure¶

Compilation (gcc)¶

Under the hood¶

man¶

gdb¶

Precompiler¶

#include¶

#define (constant)¶

#define (macro)¶

#ifdef ... #else ... #endif¶

Compilation in real-life¶

Project module example¶

Base types¶

Types¶

Good practices¶

sizeof¶

Function qualifiers¶

Operators¶

Preliminaries¶

Arithmetic operators¶

Result type¶

Logical operators¶

Lazy evaluations¶

Comparison operators¶

Bitwise operators¶

Basic I/O¶

Preliminaries¶

printf¶

scanf¶

Tests¶

if ... else if ... else¶

switch... case ... break¶

Loops¶

while(...) ...¶

do ... while(...)¶

for(...; ...; ...)¶

Memory¶

Unary operators & and *¶

Pointers of pointers (... of pointers)¶

Address types and qualifiers¶

Operators¶

Strings¶

Generic address¶

Stack¶

Passage by copy¶

Passage by pointer¶

Arrays¶

Heap¶

Dynamic allocation¶

Advanced types¶

struct¶

enum¶

union¶

typedef¶

Containers¶

File descriptors¶

Preliminaries¶

fopen ... fclose¶

fprintf¶

fscanf¶

Standard streams¶

poetry and C¶

Acknowledgements¶

Source file (`.c`)¶

Compilation (`gcc`)¶

`man`¶

`gdb`¶

`#include`¶

`#define` (constant)¶

`#define` (macro)¶

`#ifdef ... #else ... #endif`¶

`sizeof`¶

`printf`¶

`scanf`¶

`if` ... `else if` ... `else`¶

`switch`... `case` ... `break`¶

`while(...) ...`¶

`do ... while(...)`¶

`for(...; ...; ...)`¶

Unary operators `&` and `*`¶

`struct`¶

`enum`¶

`union`¶

`typedef`¶

`fopen` ... `fclose`¶

`fprintf`¶

`fscanf`¶

`poetry` and C¶