* pointeurs 1/5                    [  45:54]

  + prologue                 00:00 - 02:10
  + 3 cas d'utilisation      02:10 - 12:29
    + exemple: ptr sur fct   08:33 - 12:29
  + pointeur : définition    12:29 - 13:29
  + analogie (page carnet)   13:29 - 19:27
  + en pratique              19:27 - 25:28
  + passage par référence    25:28 - 34:00
  + const                    34:00 - 40:38
  + [OPT] références         40:38 - 45:54

--------------------------------------------
* pointeurs 2/5                    [1:05:17]

  + introduction             00:00 - 00:50
  + organisation de la mémoire
    (pile/tas ; stack/heap)  00:50 - 06:18
  + malloc()                 06:18 - 08:19
  + calloc()                 08:19 - 18:32
  + free()                   18:32 - 21:50
  + exemple                  21:50 - 29:23
  + init./Segmenation fault  29:23 - 32:23
  + règles de bon usage      32:23 - 35:10
  + exemple : tableaux dyn.  35:10 - 65:17
    + realloc()              41:16 - 44:15
    + tableaux dyn. suite    44:15 - 62:33
    + [OPT] SIZE_MAX         62:33 - 65:17

--------------------------------------------
* pointeurs 3/5                    [  53:33]

  + plan                     00:00 - 00:21
  + chaînes de caractères    00:21 - 07:15
  + affectation de char*     07:15 - 16:19
  + bibliothèque <string.h>  16:19 - 24:09
  + printf/scanf             24:09 - 25:34
  + pointeurs sur fonctions  25:34 - 29:10
  + ptr et fct génériques    29:10 - 40:07
    + exemple qsort          29:34 - 40:07
  + récapitulation de types  40:07 - 41:39
  + casting                  41:39 - 53:33

--------------------------------------------
* pointeurs 4/5                    [  38:17]

  + plan                     00:00 - 00:29
  + passages en Java         00:29 - 03:30
  + swap() en C              03:30 - 10:34
  + passages en Java (rép.)  10:34 - 14:35
  + swap() en Java           14:35 - 16:24
  + copie profonde           16:24 - 38:17

--------------------------------------------
* pointeurs 5/5                    [  58:07]

  + plan                     00:00 - 00:41
  + pointeurs et tableaux    00:41 - 19:07
  + arithmétique des ptr     19:07 - 37:58
  + sizeof()                 37:58 - 42:20
  + [OPT] flex. memb. array  42:20 - 48:55
  + [OPT] débord. tampon     49:28 - 58:07

--------------------------------------------
* argv + précompilateur            [  47:00]

  + plan                     00:00 - 00:32
  + arguments de main()      00:32 - 19:43
  + précompilation & macros  19:43 - 41:48
  + compil. conditionnelle   41:48 - 47:00

--------------------------------------------
* compilation séparée + Makefiles  [1:00:39]

  + plan                     00:00 - 00:21
  + approche modulaire       00:21 - 05:31
  + compilation séparée      05:31 - 16:34
  + édit. liens (+ chargeur) 16:34 - 26:48
  + comp. conditionnelle (2) 26:48 - 34:01
  + compléments sur les .h   34:01 - 39:13
  + [OPT] Makefiles          39:30 - 60:39

--------------------------------------------
* Debugging + Profiling            [  40:48]

  + plan                     00:00 - 00:35
  + debug -- intro           00:35 - 04:43
  + debug -- pratique gdb    04:43 - 13:22
  + optimisation             13:33 - 33:03
  + profiling                33:03 - 40:48

--------------------------------------------
* Bibliothèques standard           [  37:17]

  + plan                     00:00 - 00:17
  + bibliothèques standard   00:17 - 01:16
  + stdlib.h (dont rand())   01:16 - 07:10
  + math.h (dont codes err.) 07:10 - 19:49
  + float.h + limits.h       19:49 - 21:42
  + ctype.h + locale.h       21:42 - 26:19
  + stdarg.h (nb var. arg.)  26:19 - 35:36
  + conclusion du cours      35:36 - 37:17