Topic outline

  • General

    Programmation orientée système

    Horaires et matériel :


    Contenu du cours :

    • Initiation à la programmation en C : variables, expressions, structures de contrôle, fonctions, entrées-sorties, ...
    • Approfondissement des spécificités de la programmation système rudimentaire : gestion de la mémoire (pointeurs), des fichiers et autres entrées/sorties.

    Les concepts théoriques introduits lors des cours magistraux seront mis en pratique dans le cadre d'exercices sur machine.

  • Exercices notés à rendre :

    Le premier exercice noté est disponible depuis le lundi 15 mars à midi et sera à rendre au plus tard mardi 30 mars à 23:59. Aucun délai supplémentaire ne sera accordé.

    • Exercice noté No 1 Assignment
      Restricted Available until 31 March 2021, 2:05 AM

      Vous pouvez télécharger ici le sujet de cet exercice, à rendre pour mardi 30 mars 23:59 au plus tard (aucun délai supplémentaire ne sera accordé) : http://progos.epfl.ch/admin/hw2021-bcffcef.zip.

      C'est un fichier zip qui contient :

      • la donnée dans deux formats (PDF, et Markdown) ;
      • le code source de départ, à compléter ;
      • quatre fichiers correspondant aux deux exemple de la donnée.

      Vous pouvez également consulter la donnée en ligne : http://progos.epfl.ch/hw2021-bcffcef/consigne.html.

      Remarque important à propos de la tricherie :

      L'échange de code relatif à ces exercices notés est strictement interdit ! Cela inclut la diffusion de code sur le forum ou dans des dépôts publics. Le plagiat de code, de quelque façon que de soit et quelle qu'en soit la source sera considéré comme de la tricherie (c'est, en plus, illégal et passible de poursuites pénales).

      En cas de tricherie, vous recevrez la note «NA» pour toute la branche et serez de plus dénoncés et punis suivant l'ordonnance sur la discipline.


  • Vidéos + slides des cours

    • introduction 1/3 : variable et opérateurs [33:57] URL
      [important] Avertissement (pédagogie)  00:00 - 03:30
      Le langage C  03:30 - 05:52
      Compilation  05:52 - 07:50
      C vs. Java  07:50 - 09:59
      Structure général d'un programme  09:59 - 12:34
      Normes C89, C99 (et C11)  12:34 - 14:54
      Pas de POO en C  14:54 - 16:00
      Variables  16:00 - 18:43
      const  18:43 - 20:14
      [important] Affectation (sémantique de =)  20:14 - 23:40
      Opérateurs et expressions  23:40 - 24:22
      ++x vs. x++  24:22 - 27:26
      Opérateurs et expressions, suite (dont = vs. ==)  27:26 - 29:25
      Opérateur , (virgule)  29:25 - 32:04
      Fin + conclusion  32:04 - 33:57
    • structures de contrôle ; fonctions [36:36] URL
      Structures de contrôle -- introduction  00:00 - 01:46
      Blocs et portée  01:46 - 08:36
      if & switch  08:36 - 12:00
      while & for
      		  12:00 - 15:04
      break & continue
      		  15:04 - 21:55
      Copier-coller  21:55 - 24:02
      Fonctions : généralités
      		  24:02 - 24:40
      Protypage des fonctions  24:40 - 28:04
      void  28:04 - 29:44
      Appel de fonction
      		  29:44 - 30:12
      Passages d'arguments : par valeur/par référence  30:12 - 31:49
      [important] Passage par « référence »
      		  31:49 - 33:51
      Surcharge des fonctions  33:51 - 36:10
      Conclusion  36:10 - 36:35
    • tableaux ; enum ; struct [48:47] URL
      Introduction
      		  00:00 - 00:25
      Modificateurs des types élémentaires
      		  00:25 - 04:39
      Entiers égaux à leur opposé
      		  04:39 - 07:27
      enum  07:27 - 09:54
      Tableaux  09:54 - 14:25
      Variable Length Array
      		  14:25 - 15:39
      Initialisation des tableaux
      		  15:39 - 18:59
      Accès aux éléments (tableaux)
      		  18:59 - 20:11
      Passage d'un tableau à une fonction
      		  20:11 - 24:41
      Tableaux à plusieurs dimensions
      		  24:41 - 26:10
      [important] Résumé des tableaux en C
      		  26:10 - 26:56
      typedef  26:56 - 30:14
      struct  30:14 - 39:52
      [OPT] Flexible array member
      		  39:52 - 41:39
      [OPT] Autres modificateurs
      		  41:39 - 44:23
      [OPT] union
      		  44:23 - 47:20
      [OPT] Bit fields  47:20 - 47:53
      Conclusion  47:53 - 48:47
    • entrées/sorties [43:24] URL
      Introduction  00:00 - 00:47
      printf()  00:47 - 09:18
      scanf()  09:18 - 21:48
      stderr  21:48 - 22:55
      Fichiers : fopen()
      		  22:55 - 25:59
      Fichiers : utilisation
      		  25:59 - 28:17
      Fichiers : 2 exemples
      		  28:17 - 33:22
      Fichiers et flots standard
      		  33:22 - 34:36
      Fichiers binaires
      		  34:36 - 35:29
      fwrite()  35:29 - 37:41
      fread()  37:41 - 38:50
      [OPT] Déplacement tête lecture
      		  38:50 - 40:21
      [OPT] Flots dans des chaînes
      		  40:21 - 41:59
      Conclusion  41:59 - 43:24
    • pointeurs (1/5) [45:54] URL
      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] URL
      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] URL
      plan   00:00 - 00:21
      chaînes de caractères   00:21 - 07:15
      affectation de char*   07:15 - 16:19
      bibliothèque   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] URL
      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] URL
      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] URL
      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] URL
      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] URL
      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] URL
      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