PLB CONSULTANT : 03. Programmation en C

Première approche pratique

Organisation d'un programme structuré en C

Vue générale d’un programme C basique (main)

Composants de base du langage

Types et constantes de base

Stockage et passage de paramètres

Variables globales et locales

Arguments de fonction : passage par valeur

Code de retour des fonctions 

Entrées/sorties formatées (scanf, printf)

Utilisation élémentaire de la chaîne de production (compilation, build)

Travaux pratiques (à titre indicatif)

Objectifs : Prendre en main son environnement et écrire un premier programme simple qui permet d’introduire la syntaxe de base mais aussi un premier contact avec les aspects mémoires nécessaire pour bien comprendre les pointeurs par la suite.

Description : On affiche la taille des différents types de données standards en mémoire (int, char, float, …) en utilisant les éléments fondamentaux du langage (compilation, main, printf, …) autour de problématique mémoire (sizeof, types de données).

Variables, adresses, pointeurs

Schéma générale de la mémoire (différentes zones)

Le rôle du compilateur par rapport à la mémoire

Vie de la mémoire durant l’exécution d’un programme C (pile, tas, zone d’allocation statique, appel fonction, etc.)

Opérateurs d'adressage (&)

Passage d'arguments par adresse

L’exemple de scanf … et ses pièges

Ne pas confondre pointeur, adresse et entier

Travaux pratiques (à titre indicatif)

Objectifs : Comprendre le fonctionnement de l’allocation mémoire des variables dans la pile (locales, arguments) et le mécanisme d’adressage pour introduire les pointeurs et la problématique du passage par valeur (variable non modifiée) 

Description : Écriture d’une fonction permutant deux variables

Mécanismes et syntaxe du langage

Opérateurs, expressions numériques et opérations sur les nombres

Opérateurs arithmétiques

Mécanismes d'évaluation des expressions

Post et pré-incrémentation de décrémentation

Précédence et associativité des opérateurs

Opérateurs de base et expressions logiques

Affectations

Boucles (for, while)

Mécanismes de fonctionnement des expressions logiques

Opérateurs de comparaison

Gestion du flux d'entrée/sortie standard

Prototype de filtre

Instruction if

Opérateurs logiques

Compléments sur les types de données

Maîtrise des types complexes

Implémentation des types en mémoire selon les normes 

Conversion explicite de types : casting

Les types numériques composés.

Règle de conversion dans les expressions mixtes

Initialisation des variables

Formats d'entrée/sortie associés aux types numériques

Travaux pratiques (à titre indicatif)

Objectifs : Compléter sa maîtrise de la syntaxe. Maîtriser les règles d’analyse syntaxique en C, les opérateurs et les conversions de types implicites et explicites (cast). 

Description : Écriture de fonctions de contrôles et de comparaisons de variables. 

Opérations numériques sur des variables de différents types (moyenne, somme, etc.).

Compléments sur les opérateurs

Opérateurs binaires (ET, OU, OU exclusif, complément à 1)

Décalages binaires

Opérateur ternaire d'alternative

L'instruction switch

L'instruction do while

Instructions associées aux boucles

Travaux pratiques (à titre indicatif)

Objectifs : Savoir manipuler les opérateurs bas niveau. Traduire les normes de façon concrète pour le développeur en insistant sur les différences d’implémentation entre les différents types (int, float, etc.) et les problèmes de bug ou de portabilité qui peuvent en découler

Description : Visualisation détaillée du format d’un float 32 bits en mémoire selon la norme IEEE754 en affichant sa structure binaire (010100010….) grâce aux opérateurs unaires combinés dans des fonctions. Écriture d’une fonction de test de la valeur du bit x d’une variable y. Écriture de fonctions de calcul puissantes s’appuyant sur les propriétés de décalage binaire.

Tableaux, pointeurs et chaîne de caractères

Compléments sur les pointeurs

Différences entre pointeur et adresse d’une variable

Manipulations de différents types de pointeur (int*, char*, float*, …)

A quoi correspond void* ?

Les pièges (oubli du &, écriture dans une zone non allouée, etc.)

L’allocation dynamique de mémoire (malloc)

Les pointeurs vers des structures de données 

Arithmétiques sur les pointeurs

Tableaux et chaînes de caractères

Définition et utilisation classique des tableaux

Équivalences pointeurs/tableaux

Chaînes de caractères

Bien comprendre le sens et les différences des symboles comme ‘a’, ʺaʺ’, ’\0’, 0, 1, ‘1’, 

Initialisation des tableaux

Exemples de manipulation de chaînes de caractères

Travaux pratiques (à titre indicatif)

Objectifs : Comprendre l’implémentation des tableaux en mémoire et leur interprétation par le compilateur.

Savoir manipuler les tableaux et maîtriser la gestion des chaînes de caractère (char*)

Description : (RE)écriture des fonctions standards de manipulations des chaînes de caractères (strcpy, strlen, strcmp, strncmp). Fonction permettant de rendre « propre » une chaîne de caractères en terme de contenu (liste de caractères interdits) et de longueur maximale. Fonction générant des mots de passe aléatoire à partir de notre propre dictionnaire de symboles (tableau de caractères), un niveau de complexité et une taille passée en argument.

Les structures

Philosophie

Accès aux éléments d’une structure

Passage d’une structure en argument de fonction

Adresse, mémoire, pointeurs et structures

Les structures emboîtées

Les structures anonymes (depuis C11)

Les champs de bits

Quand utiliser des unions ?

Liste de valeurs « fermées » et « numérisable » (enum)

La libération de la mémoire

Introduction aux structures chaînées (listes, arbres, …)

Comparaison des différentes structures de données (tableau de structures, tableau de pointeurs, liste chaînée) en terme d’occupation mémoire, de performances et de complexité

Travaux pratiques (à titre indicatif)

Objectifs : Maîtriser l’utilisation des structures de données (initialisation, accès aux éléments, passage en argument à une fonction, etc.)

Description : Création d’une structure PERSONNE, écriture de fonctions de saisie et d’affichage mono personne. Création d’un tableau de PERSONNE et écriture de nouvelles fonctions pour manipuler ce type de tableau en réutilisant les fonctions précédentes. Mise en œuvre d’une liste chaînée de PERSONNE.

Fonction de cryptage (et décryptage) utilisant des clefs stockées dans des structures

Industrialiser ses développements

Compilation séparée, classe d'allocation

Mécanisme de fonctionnement de la chaîne de production

Utilisation de bibliothèque de sources

Différents cas de figure de la compilation séparée

Notion d'objet externe

Cas des données globales et statiques

Cas des données locales

Règle de visibilité

Cas des fonctions

Compléments sur les fonctions et les initialisations

Travaux pratiques (à titre indicatif)

Objectifs : Architecturer son code en modules et comprendre le rôle des fichiers d’en tête (.h)

Description : Création d’un module regroupant les fonctions de manipulations des chaînes de caractères du TP déjà effectué (chaînes.h, chaînes.c) et compilations séparées des différents modules

Le macro processeur, la portabilité

Vue générale des directives de compilation 

Les constantes symboliques (#define)

Intérêts et limites des fonctions macros

Les inclusions de fichiers (#include)

La compilation conditionnelle (#ifdef, #ifndef, etc.)

Construction de surtypes : typedef

Travaux pratiques (à titre indicatif)

Objectifs : Utiliser les possibilités du précompilateur pour faciliter la maintenance de son code et sa portabilité

Description : Parcours commenté des en-têtes standard de la bibliothèque (stdio.h, stdlib.h, etc.). Ecriture de ses propres fichiers d’en-têtes pour se protéger de l’inclusion multiple, définir ses pseudos constantes et ses prototypes de fonctions.

Outils associés à la chaîne de production

Principes de la gestion de version avec Git

Options de compilation

Gérer les briques logicielles et les dépendances (makefile)

Construire une application avec Gradle (build)

Travaux pratiques (à titre indicatif)

Objectifs : Comprendre en détail les mécanismes de compilation, build et automatisation dans la création d’une application ou d’une bibliothèque C.

Description : Mise en œuvre de l’automatisation avec Gradle et/ou makefile en fonction de l’environnement souhaité par les participants.

Les entrées /sorties 

Principes généraux des I/O

Ouverture et fermeture d’un fichier ou d’un périphérique

Écriture et lecture formatée (exemple avec fscanf et fprintf)

Écriture et lecture d’un caractère (getc)

Écriture et lecture d’une chaîne de caractères

Écriture et lecture d’un format binaire (fread, fwrite)

Accès direct à un endroit du fichier

Conseils sur la bufferisation des I/O (performances)

Travaux pratiques (à titre indicatif)

Objectifs : Maîtriser les différents modes d’accès aux données en lecture et en écriture (caractère, paragraphe, binaire) ainsi que les possibilités de formatage (%s, %c, etc.).

Description : Chargement d’un fichier texte en mémoire, traitement, sauvegarde, rechargement (pour tester).

Chargement d’un fichier texte pour remplir un tableau de pointeurs (char*) pour disposer d’une structure souple de manipulation de texte (tableau de paragraphes). Passage d’arguments sur la ligne de commande (nom du fichier à charger). Manipulation de flux binaire sous la forme d’enregistrement d’un tableau de mesures (structures de l’un des TP précédents) dans un fichier, chargement de ce fichier dans un autre tableau, tri, puis sauvegarde pour proposer un cycle complet d’un flux : mémoire / traitement / disque. Manipulations de flux de données formatées.

Aspect avancés du langage C

Quels traitements utilisent les tableaux multidimensionnels (matrices) ?

Tableau de pointeurs et structures dérivées

Passage d’arguments en ligne de commandes (argc, argv)

Intérêt des pointeurs de fonctions

Fonctions à nombre variable d’arguments

Synthèse des différences avec le C++ (au-delà de la dimension objet)

Travaux pratiques (à titre indicatif)

Objectifs : Comprendre l’intérêt de passer une fonction en argument à une autre fonction en mettant en œuvre les pointeurs de fonction

Description : fonction de tri d’un tableau de structures de PERSONNE avec passage en argument de la fonction de tri