|
1 à 4
|
Conventions d'écriture: Commentaires de spécification et de stratégie, aération du code, indentation cohérente, utilisation de constantes symboliques, choix pertinents des identificateurs, portabilité du code.
Principes de programmation: Chercher à minimiser le temps d’exécution, l’utilisation de la mémoire et la répétition de code, sans compromettre la clarté du programme.
Notions élémentaires: Types de base du langage C avec leurs opérateurs et conversions automatiques, déclaration de variables, entrées et sorties de base, instructions conditionnelles et itératives, types numériques, opérateurs binaires.
Environnement de programmation: Chaîne de compilation, d’assemblage et d’exécution, présentation de divers environnements de développement (ex. : Eclipse, Visual Studio, etc.).
Commandes au préprocesseur: #define, #include, #if et #endif.
Procédures, fonctions et tests unitaires: Déclaration des fonctions, commentaires standards pour la déclaration et l’implémentation, paramètres effectifs et formels, valeur de retour, passage par valeur, portée et durée de vie des variables, factorisation du code (découpage en sous-programmes), définition et avantages, création de tests incluant données représentatives et cas limites.
Passage par adresse: Introduction aux pointeurs : déclaration, assignation et utilisation des variables pointeurs.
Macros-fonctions: Avantages, déclaration, utilisation et tests.
Tableaux: Déclaration, initialisation, accès aux éléments, passage en paramètres, algorithmes de base (ex. : minimum, maximum, etc.), déclarations de type à l’aide de typedef.
Modules externes: Inclusion, intégration et utilisation de modules externes dans un projet.
|
|
5 à 8
|
Algorithmes de base sur tableau (suite): Tris (sélection, insertion, bulle) et recherches (linéaire et binaire).
Introduction aux enregistrements (struct): Déclaration, accès aux champs, affectation et passage en paramètre.
Implémentation de modules externes de type (#ifndef et #define): Séparation en modules de déclaration (.h) et de définition (.c), définitions de types, passage par référence (avec ou sans const), implémentation des fonctions nécessaires.
Pointeurs et adresses: Arithmétique des adresses (avec démonstration de l’utilisation de sizeof), utilisation de pointeurs génériques (void *).
Classes d’allocation: La pile (stack) et le tas (heap).
Allocation dynamique et gestion de la mémoire: Utilisation des fonctions d’allocation dynamique (malloc, calloc, realloc, free), allocation de tableaux et d’enregistrements dynamiques.
Chaînes de caractères: Chaînes littérales (const char *) et fonctions standard, distinction entre char * et char[], utilisation et tests.
Type de données abstraits : Introduction aux piles (t_pile) et aux files (t_file), première implémentation de ces modules à l’aide de tableaux, utilisation et tests.
|
|
9 à 13
|
Type de données abstraits (suite): Introduction aux listes (t_liste), implémentation à l’aide de tableaux, utilisation et tests.
Chaînage dynamique: Références chaînées (nœuds), chaînage simple et chaînage double, implémentation et tests.
Piles et files dynamiques: Implémentation à l’aide du chaînage dynamique, utilisation et tests.
Listes chaînées (simple et double): Intérêt, fonctionnement, différentes implémentations (avec, obligatoirement, et sans position courante implicite), encapsulation des données et des traitements, utilisation et tests.
Fichiers textes et binaires: Utilisation du type FILE * et des fonctions classiques (fopen, fclose, feof, etc.), manipulation et tests.
|