Topic outline

• 

  General

  Programmation orientée système

  Horaires et matériel :

  • Cours : Lundis 8¹⁵-9⁰⁰ : vidéos pré-enregistrées (à regarder avant), puis séances complémentaires en présentiel en amphi CE 6 de réponses aux questions/approfondissement (retransmises via Zoom 832-6919-1314) .
  • Exercices : Lundis 9¹⁵-11⁰⁰ en CO-020 à 023 et CO-120 (support Zoom si nécessaire: 683 6056 5248).
  • Calendrier détaillé et supports (cours, exercices) : https://progos.epfl.ch/
    

  
  

  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.

  • Calendrier / Supports de cours :

  • Accès au calendrier, supports de cours et exercices URL
  • Fora :

  • Informations générales Forum
  • Forum de discussion External tool

    si jamais, le lien direct est : https://piazza.com/class/kzmvpxwzfs13kb
    

  • Liens :

  • Séries d'exercices et corrigés URL
  • Références URL
  • Compléments du cours URL
  • Toutes les fiches résumé (PDF) URL
• 

  Exercices notés à rendre :

  L'exercice a rendre est disponible depuis le lundi 14 mars 12:00 et sera à rendre au plus tard le dimanche 27mars à 23:59. Aucun délai supplémentaire ne sera accordé.

  • Exercice à rendre Assignment

    Restricted Available until 28 March 2022, 1:15 AM
• 

  Vidéos + slides des cours

  • Timecodes des vidéos File
  • introduction 1/2 : description du cours [6:56] URL
  • introduction 2e partie : 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

  • slides (introduction : cours ; variables & opérateurs) URL

    
    
  • 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

  • slides (structures de contrôle ; fonctions) URL

    
    
  • 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

  • slides (tableaux ; enum ; struct) URL

    
    
  • 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

  • slides (entrées/sorties) URL

    
    
  • 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

  • slides (pointeurs 1/5) URL

    
    
  • 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

  • slides (pointeurs 2/5) URL

    
    
  • 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

  • slides (pointeurs 3/5) URL

    
    
  • 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

  • slides complets (cours pointeurs 4/5) File

    
    
  • 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

  • slides (pointeurs 5/5) URL

    
    
  • 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

  • slides (argv + précompilateur) URL

    
    
  • 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

  • slides (compilation séparée + Makefiles) URL

    
    
  • 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

  • slides (debugging+profiling) URL

    
    
  • 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

  • slides (bibliothèques) URL
• This topic
  

  Série Notée

  • Série notée en classe Assignment