EPS_GL2019-Corrigé

REPUBLIQUE DU CAMEROUN

REPUBLIC OF CAMEROON

Paix-Travail-Patrie --- Peace-Work-Fatherland

MINISTÈRE DE L’ENSEIGNEMENT SUPÉRIEUR

MINISTRY OF HIGHER EDUCATION

COMMISSION NATIONALE D’ORGANISATION DE L’EXAMEN NATIONAL DU BREVET DE TECHNICIEN SUPERIEUR (BTS)

NATIONAL COMMISSION FOR THE ORGANIZATION OF BTS EXAM

Examen National du Brevet de Technicien Supérieur - Session 2019

Spécialisation : Génie Logiciel (GL)

Épreuve écrite : EPS

Crédit : 14

Durée : 6 heures

CORRECTION DÉTAILLÉE

PARTIE 1 : Modélisation structurelle et MERISE (25 points)

Thème : Informatisation de la gestion d’une boulangerie

1. Définitions (1 point)

Flux : Représentation du mouvement d’informations, de données ou de matières entre différents éléments d’un système (acteurs, processus, stocks). Les flux peuvent être entrants ou sortants.

MERISE : Méthode d’analyse et de conception de systèmes d’information développée en France, basée sur une approche systémique et structurée. MERISE utilise plusieurs cycles.

2. Les trois cycles ou dimensions de MERISE (1 point)

1. Cycle d’abstraction : Distingue trois niveaux de modélisation : conceptuel (quoi?), organisationnel (qui, où, quand?), opérationnel (comment?).

2. Cycle de vie : Études préalable, détaillée, conception, réalisation, mise en œuvre, maintenance.

3. Cycle de décision : Structure les prises de décision avec validation à chaque étape.

3. Graphique de flux de données (4 points)

Description des flux :

Flux 1 : Demande d’approvisionnement (Responsable → P1)

Flux 2 : Commande (P1 → Fournisseur)

Flux 3 : Livraison (Fournisseur → P2)

Flux 4 : Mise en stock (P2 → Stock MP)

Flux 5 : Composants (Stock MP → P3)

Flux 6 : Ordre de production (Responsable → P3)

Flux 7 : Produits finis (P3 → Stock PF)

Flux 8 : Distribution (Stock PF → P4)

Flux 9 : Ventes (P4 → Magasin)

4. Modèle Conceptuel des Traitements (MCT) (6 points)

Processus “Approvisionnement” (2,5 points) :

Nom : Commander des matières premières

Numéro : P1

Acteur : Responsable approvisionnement

Déclencheur : Niveau de stock inférieur au seuil minimum

Préconditions : Stocks consultés, plan de production disponible

Description : Après consultation des stocks et du plan de production, le responsable établit une commande auprès d’un fournisseur.

Entrées : État des stocks, plan de production

Sorties : Bon de commande, commande transmise au fournisseur

Postconditions : Commande enregistrée, fournisseur informé.

Processus “Production” (3,5 points) :

Nom : Produire des articles

Numéro : P3

Acteur : Responsable production

Déclencheur : Demande de production (plan ou commande client)

Préconditions : Matières premières disponibles, procédé de production défini, capacité de production libre

Description : Transformation des matières premières en produits finis et dérivés selon un procédé défini.

Entrées : Matières premières, fiche de procédé, ordre de production

Sorties : Produits finis, produits dérivés, déchets (éventuellement)

Postconditions : Stocks matières premières diminués, stocks produits finis augmentés, production enregistrée.

5. Dictionnaire des Données Élémentaires (3 points)

(Le corrigé ne fournit pas de tableau détaillé, mais décrit les entités plus loin.)

6. Modèle Conceptuel des Données (MCD) (6 points)

Description des entités :

• CATÉGORIE : code, libellé, description


• SOUS-CATÉGORIE : code, libellé, description, code_catégorie


• PRODUIT : code, libellé, description, code_sous_catégorie, type (MP/PF/Dérivé)


• FOURNISSEUR : code, raison_sociale, adresse, téléphone


• COMMANDE : numéro, date, code_fournisseur


• LIGNE_COMMANDE : num_commande, code_produit, quantité, prix_achat


• FACTURE : numéro, date, code_fournisseur


• LIGNE_FACTURE : num_facture, code_produit, quantité, prix_unitaire, code_magasin


• MAGASIN : code, libellé, adresse


• PRODUCTION : code, date, code_produit_principal, quantité


• MOUVEMENT : code, date, type (Entrée/Sortie)


• LIGNE_MOUVEMENT : code_mouvement, code_produit, quantité, code_magasin

7. Modèle Logique de Données Relationnelles (MLDR) (4 points)

-- Table CATEGORIE

CREATE TABLE CATEGORIE (

    code_categorie VARCHAR(5) PRIMARY KEY,

    libelle VARCHAR(30) NOT NULL,

    description TEXT

);



-- Table SOUS_CATEGORIE

CREATE TABLE SOUS_CATEGORIE (

    code_sous_categorie VARCHAR(8) PRIMARY KEY,

    libelle VARCHAR(40) NOT NULL,

    description TEXT,

    code_categorie VARCHAR(5) NOT NULL,

    FOREIGN KEY (code_categorie) REFERENCES CATEGORIE(code_categorie)

);



-- Table PRODUIT

CREATE TABLE PRODUIT (

    code_produit VARCHAR(10) PRIMARY KEY,

    libelle VARCHAR(50) NOT NULL,

    description TEXT,

    code_sous_categorie VARCHAR(8) NOT NULL,

    type VARCHAR(3) CHECK (type IN ('MP', 'PF', 'DER')),

    FOREIGN KEY (code_sous_categorie) REFERENCES SOUS_CATEGORIE(code_sous_categorie)

);



-- Table FOURNISSEUR

CREATE TABLE FOURNISSEUR (

    code_fournisseur VARCHAR(10) PRIMARY KEY,

    raison_sociale VARCHAR(100) NOT NULL,

    adresse TEXT,

    telephone VARCHAR(20)

);



-- Table COMMANDE

CREATE TABLE COMMANDE (

    numero_commande VARCHAR(15) PRIMARY KEY,

    date_commande DATE NOT NULL,

    code_fournisseur VARCHAR(10) NOT NULL,

    FOREIGN KEY (code_fournisseur) REFERENCES FOURNISSEUR(code_fournisseur)

);



-- Table LIGNE_COMMANDE

CREATE TABLE LIGNE_COMMANDE (

    numero_commande VARCHAR(15),

    code_produit VARCHAR(10),

    quantite INTEGER NOT NULL,

    prix_achat DECIMAL(10,2) NOT NULL,

    PRIMARY KEY (numero_commande, code_produit),

    FOREIGN KEY (numero_commande) REFERENCES COMMANDE(numero_commande),

    FOREIGN KEY (code_produit) REFERENCES PRODUIT(code_produit)

);



-- Table MAGASIN

CREATE TABLE MAGASIN (

    code_magasin VARCHAR(10) PRIMARY KEY,

    libelle VARCHAR(50) NOT NULL,

    adresse TEXT

);



-- Table FACTURE

CREATE TABLE FACTURE (

    numero_facture VARCHAR(15) PRIMARY KEY,

    date_facture DATE NOT NULL,

    code_fournisseur VARCHAR(10) NOT NULL,

    FOREIGN KEY (code_fournisseur) REFERENCES FOURNISSEUR(code_fournisseur)

);



-- Table LIGNE_FACTURE

CREATE TABLE LIGNE_FACTURE (

    numero_facture VARCHAR(15),

    code_produit VARCHAR(10),

    quantite INTEGER NOT NULL,

    prix_unitaire DECIMAL(10,2) NOT NULL,

    code_magasin VARCHAR(10) NOT NULL,

    PRIMARY KEY (numero_facture, code_produit),

    FOREIGN KEY (numero_facture) REFERENCES FACTURE(numero_facture),

    FOREIGN KEY (code_produit) REFERENCES PRODUIT(code_produit),

    FOREIGN KEY (code_magasin) REFERENCES MAGASIN(code_magasin)

);



-- Table PRODUCTION

CREATE TABLE PRODUCTION (

    code_production VARCHAR(15) PRIMARY KEY,

    date_production DATE NOT NULL,

    code_produit_principal VARCHAR(10) NOT NULL,

    quantite_produite INTEGER NOT NULL,

    FOREIGN KEY (code_produit_principal) REFERENCES PRODUIT(code_produit)

);



-- Table COMPOSANT_PRODUCTION

CREATE TABLE COMPOSANT_PRODUCTION (

    code_production VARCHAR(15),

    code_produit_composant VARCHAR(10),

    quantite_utilise INTEGER NOT NULL,

    PRIMARY KEY (code_production, code_produit_composant),

    FOREIGN KEY (code_production) REFERENCES PRODUCTION(code_production),

    FOREIGN KEY (code_produit_composant) REFERENCES PRODUIT(code_produit)

);



-- Table DERIVE_PRODUCTION

CREATE TABLE DERIVE_PRODUCTION (

    code_production VARCHAR(15),

    code_produit_derive VARCHAR(10),

    quantite_obtenue INTEGER NOT NULL,

    PRIMARY KEY (code_production, code_produit_derive),

    FOREIGN KEY (code_production) REFERENCES PRODUCTION(code_production),

    FOREIGN KEY (code_produit_derive) REFERENCES PRODUIT(code_produit)

);



-- Table MOUVEMENT

CREATE TABLE MOUVEMENT (

    code_mouvement VARCHAR(15) PRIMARY KEY,

    date_mouvement DATE NOT NULL,

    type_mouvement VARCHAR(10) CHECK (type_mouvement IN ('ENTREE', 'SORTIE'))

);



-- Table LIGNE_MOUVEMENT

CREATE TABLE LIGNE_MOUVEMENT (

    code_mouvement VARCHAR(15),

    code_produit VARCHAR(10),

    quantite INTEGER NOT NULL,

    code_magasin VARCHAR(10) NOT NULL,

    PRIMARY KEY (code_mouvement, code_produit),

    FOREIGN KEY (code_mouvement) REFERENCES MOUVEMENT(code_mouvement),

    FOREIGN KEY (code_produit) REFERENCES PRODUIT(code_produit),

    FOREIGN KEY (code_magasin) REFERENCES MAGASIN(code_magasin)

);

PARTIE 2 : Modélisation orientée objet UML (20 points)

Thème : Emprunts de CD-ROM pour enfants

1. Définitions (4 points)

Encapsulation : Principe de regroupement des données (attributs) et des méthodes (opérations) qui les manipulent au sein d’une classe. L’encapsulation permet de cacher l’implémentation interne et de n’exposer que ce qui est nécessaire via une interface publique.

Polymorphisme : Capacité d’un objet à prendre plusieurs formes. En programmation orientée objet, cela permet à une méthode d’avoir des comportements différents selon le type de l’objet qui l’appelle. Exemple : redéfinition de méthode dans les classes dérivées.

Héritage : Mécanisme permettant à une classe (classe fille) de dériver d’une autre classe (classe mère), héritant ainsi de ses attributs et méthodes. L’héritage favorise la réutilisation du code et établit une relation “est-un” entre les classes.

Agrégation : Relation entre deux classes où une classe est composée d’autres classes, mais où les parties peuvent exister indépendamment du tout. C’est une relation “part-of” avec indépendance de vie.

2. Types de relations entre classes (3 points)

1. Association : Relation structurelle qui décrit un lien sémantique entre instances de classes.

2. Agrégation : Relation de type “part-of” où la partie peut exister indépendamment du tout.

3. Composition : Relation de type “part-of” plus forte où la partie ne peut exister sans le tout.

4. Généralisation/Specialisation (héritage) : Relation “est-un” entre une classe générale et une classe spécifique.

5. Dépendance : Relation d’utilisation temporaire où une classe utilise temporairement une autre classe.

3. Exigences fonctionnelles du système (4 points)

1. Gestion des adhérents : inscription, modification, suppression, consultation.

2. Gestion des CD-ROM : ajout, modification, suppression, consultation du catalogue.

3. Gestion des emprunts : enregistrement d’un emprunt, retour, consultation, gestion des retards, historique.

4. Gestion des réservations : réservation d’un CD-ROM non disponible, annulation, notification, consultation.

5. Gestion des événements : création, inscription des participants, annulation, gestion des paiements.

6. Authentification et sécurité : authentification des employés et des adhérents, gestion des rôles.

4. Diagramme de cas d’utilisation (3 points)

(Le corrigé mentionne une figure non reproduite ici. Le diagramme inclut les acteurs : Adhérent, Employé, Système de paiement externe. Cas d’utilisation : S’authentifier, Enregistrer emprunt, Réserver CD-ROM, Organiser événement, S’inscrire à événement, etc.)

5. Diagramme de séquence pour “enregistrer emprunt” (3 points)

(Le corrigé mentionne une figure. La séquence : Employé → (authentification) → Système, puis vérification disponibilité CD-ROM, création emprunt, mise à jour des réservations si nécessaire.)

6. Diagramme de classe (3 points)

(Le corrigé mentionne une figure. Classes : Employé, Adhérent, CDROM, Emprunt, Réservation, Événement, Inscription. Relations : héritage, associations, agrégations.)

PARTIE 3 : Algorithmique et Structure de Données Avancées (20 points)

Thème : Gestion des activités de réparation

III.1 Avantages et inconvénients entre Vecteurs et Listes chaînées (2 points)

Vecteurs (Tableaux) : Avantages – accès direct en O(1), occupation mémoire compacte, simplicité, cache-friendly. Inconvénients – taille fixe (redimensionnement coûteux), insertion/suppression coûteuses en O(n), gaspillage mémoire si sous‑utilisé.

Listes chaînées : Avantages – taille dynamique, insertion/suppression rapides en O(1) (si position connue), flexibilité structurelle. Inconvénients – accès séquentiel en O(n), occupation mémoire supplémentaire pour les pointeurs, complexité d’implémentation, fragmentation mémoire possible.

III.2 Déclarations des structures de données (3 points)

#include <stdio.h>

#include <stdlib.h>

#include <string.h>



typedef struct {

    int codePostal;

    char quartier[50];

    char ville[50];

} Adresse;



typedef struct {

    int code;

    char nom[50];

    char prenom[50];

    Adresse adresse;

    char telephone[20];

} Client;



typedef struct Materiel {

    int code;

    char designation[100];

    char type[50];

    char marque[50];

    char numeroSerie[50];

    int codeClient;

    struct Materiel *suivant;

} Materiel;



#define MAX_CLIENTS 50

#define TAILLE_NOM 50

#define TAILLE_DESIGNATION 100

III.3 Procédure pour créer un vecteur de N clients (3 points)

void creerVecteurClients(Client clients[], int N) {

    int i;

    printf("=== CREATION DE %d CLIENTS ===\n", N);

    for (i = 0; i < N; i++) {

        printf("\n--- Client %d ---\n", i + 1);

        printf("Code client : ");

        scanf("%d", &clients[i].code);

        getchar();

        printf("Nom : ");

        fgets(clients[i].nom, TAILLE_NOM, stdin);

        clients[i].nom[strcspn(clients[i].nom, "\n")] = '\0';

        printf("Prénom : ");

        fgets(clients[i].prenom, TAILLE_NOM, stdin);

        clients[i].prenom[strcspn(clients[i].prenom, "\n")] = '\0';

        printf("=== Adresse ===\n");

        printf("Code postal : ");

        scanf("%d", &clients[i].adresse.codePostal);

        getchar();

        printf("Quartier : ");

        fgets(clients[i].adresse.quartier, 50, stdin);

        clients[i].adresse.quartier[strcspn(clients[i].adresse.quartier, "\n")] = '\0';

        printf("Ville : ");

        fgets(clients[i].adresse.ville, 50, stdin);

        clients[i].adresse.ville[strcspn(clients[i].adresse.ville, "\n")] = '\0';

        printf("Téléphone : ");

        fgets(clients[i].telephone, 20, stdin);

        clients[i].telephone[strcspn(clients[i].telephone, "\n")] = '\0';

    }

    printf("\n%d clients créés avec succès !\n", N);

}

III.4 Procédure pour ajouter un nouveau matériel dans la liste chaînée (4 points)

void ajouterMateriel(Materiel **tete, Client clients[], int nbClients) {

    Materiel *nouveau;

    int codeClient, i, clientExiste = 0;

    printf("Code client propriétaire : ");

    scanf("%d", &codeClient);

    for (i = 0; i < nbClients; i++) {

        if (clients[i].code == codeClient) {

            clientExiste = 1;

            break;

        }

    }

    if (!clientExiste) {

        printf("Erreur : client introuvable.\n");

        return;

    }

    nouveau = (Materiel*) malloc(sizeof(Materiel));

    if (nouveau == NULL) {

        printf("Erreur d'allocation mémoire.\n");

        return;

    }

    printf("Code matériel : ");

    scanf("%d", &nouveau->code);

    getchar();

    printf("Désignation : ");

    fgets(nouveau->designation, TAILLE_DESIGNATION, stdin);

    nouveau->designation[strcspn(nouveau->designation, "\n")] = '\0';

    printf("Type : ");

    fgets(nouveau->type, 50, stdin);

    nouveau->type[strcspn(nouveau->type, "\n")] = '\0';

    printf("Marque : ");

    fgets(nouveau->marque, 50, stdin);

    nouveau->marque[strcspn(nouveau->marque, "\n")] = '\0';

    printf("Numéro de série : ");

    fgets(nouveau->numeroSerie, 50, stdin);

    nouveau->numeroSerie[strcspn(nouveau->numeroSerie, "\n")] = '\0';

    nouveau->codeClient = codeClient;

    nouveau->suivant = *tete;

    *tete = nouveau;

    printf("Matériel ajouté avec succès.\n");

}

III.5 Sous-programme pour afficher la liste de tous les matériels d’un client (4 points)

void afficherMaterielsClient(Materiel *tete, Client clients[], int nbClients, int codeClient) {

    Materiel *courant = tete;

    int clientTrouve = 0, materielsTrouves = 0, i;

    for (i = 0; i < nbClients; i++) {

        if (clients[i].code == codeClient) {

            clientTrouve = 1;

            printf("\n=== MATERIELS DU CLIENT ===\n");

            printf("Code : %d\n", clients[i].code);

            printf("Nom : %s %s\n", clients[i].prenom, clients[i].nom);

            printf("Téléphone : %s\n", clients[i].telephone);

            printf("Adresse : %d %s, %s\n\n",

                   clients[i].adresse.codePostal,

                   clients[i].adresse.quartier,

                   clients[i].adresse.ville);

            break;

        }

    }

    if (!clientTrouve) {

        printf("ERREUR : Client introuvable (code : %d)\n", codeClient);

        return;

    }

    printf("=== LISTE DES MATERIELS ===\n");

    while (courant != NULL) {

        if (courant->codeClient == codeClient) {

            printf("\n--- Matériel %d ---\n", courant->code);

            printf("Désignation : %s\n", courant->designation);

            printf("Type : %s\n", courant->type);

            printf("Marque : %s\n", courant->marque);

            printf("Numéro de série : %s\n", courant->numeroSerie);

            materielsTrouves++;

        }

        courant = courant->suivant;

    }

    if (materielsTrouves == 0)

        printf("Aucun matériel trouvé pour ce client.\n");

    else

        printf("\nTotal : %d matériel(s) trouvé(s).\n", materielsTrouves);

}

III.6 Fonction qui retourne le nombre de matériels dans la liste chaînée (4 points)

int compterMaterielsIteratif(Materiel *tete) {

    int compte = 0;

    Materiel *courant = tete;

    while (courant != NULL) {

        compte++;

        courant = courant->suivant;

    }

    return compte;

}

PARTIE 4 : Manipulation de données (10 points)

Schéma de la base de données :

• ARTICLE (Ref, designation, PU)


• FOURNISSEURS (code_four, raison_sociale, adresse)


• COMMANDE (numero, date, fournisseur, ref, qte)

IV.1 Définition : base de données (2 points)

Base de données : Collection organisée et structurée de données, stockée électroniquement dans un système informatique. Elle permet le stockage permanent, l’accès rapide, la gestion des données, le partage, et garantit l’intégrité, la sécurité et la confidentialité.

IV.2 Définition du sigle SQL et son rôle (2 points)

SQL (Structured Query Language) : Langage de programmation standardisé pour gérer et manipuler les bases de données relationnelles. Rôle : DDL (définition des structures), DML (manipulation des données), DCL (contrôle d’accès), TCL (gestion des transactions).

IV.3 Requêtes SQL (6 points)

a) Liste des produits du fournisseur ayant le code KFOC5 :

SELECT A.Ref, A.designation, A.PU

FROM ARTICLE A

JOIN COMMANDE C ON A.Ref = C.ref

WHERE C.fournisseur = 'KFOC5'

GROUP BY A.Ref, A.designation, A.PU;

b) Liste des commandes du 10 mars 2016 :

SELECT C.numero, C.date, F.raison_sociale, A.designation, C.qte

FROM COMMANDE C

JOIN ARTICLE A ON C.ref = A.Ref

JOIN FOURNISSEURS F ON C.fournisseur = F.code_four

WHERE C.date = '2016-03-10'

ORDER BY C.numero;

c) Produit le plus cher déjà commandé :

SELECT A.Ref, A.designation, A.PU

FROM ARTICLE A

WHERE A.PU = (SELECT MAX(PU) FROM ARTICLE);

PARTIE 5 : Génie logiciel (20 points)

V.1 Différences entre modèle incrémental et modèle par réutilisation de composants (5 points)

Modèle incrémental	Modèle par réutilisation
Développement par versions successives, chaque version ajoutant des fonctionnalités.	Assemblage de composants logiciels existants et réutilisables.
Livraison progressive, détection précoce des erreurs, flexibilité, meilleure gestion des risques.	Réduction des coûts et délais, fiabilité accrue (composants éprouvés), standardisation.
Nécessite une bonne planification initiale, coordination complexe, tests d’intégration à chaque incrément.	Dépendance à la qualité des composants, limitations fonctionnelles, problèmes de compatibilité.
Adapté aux projets où les besoins sont bien compris mais peuvent évoluer.	Adapté aux projets avec des fonctionnalités standards et des délais courts.

V.2 Étapes du cycle de vie d’un logiciel (5 points)

1. Analyse des besoins

2. Conception (générale et détaillée)

3. Réalisation (implémentation)

4. Tests (intégration, système, validation)

5. Déploiement (installation, formation)

6. Maintenance (corrective, évolutive, adaptative, préventive).

V.3 Définitions : spécification, conception (3 points)

Spécification : Document détaillé qui décrit de manière exhaustive et non ambiguë les exigences d’un système logiciel. Sert de contrat entre client et équipe de développement. Inclut exigences fonctionnelles, non fonctionnelles, contraintes et critères d’acceptation.

Conception : Processus de transformation des spécifications en une architecture logicielle réalisable. Comprend conception générale/architecturale, conception détaillée (algorithmes, structures de données), et conception technique (choix des technologies).

V.4 Justification de la phase de spécification (2 points)

La phase de spécification est essentielle car elle :

• Établit un contrat clair entre le client et l’équipe de développement, évitant malentendus et litiges.


• Sert de référence unique pour toutes les parties prenantes.


• Permet d’estimer avec précision les coûts, délais et ressources.


• Facilite la traçabilité des exigences jusqu’à l’implémentation et aux tests.


• Identifie les risques et contraintes dès le début du projet.


• Garantit la qualité en définissant des critères d’acceptation mesurables.


• Favorise la maintenance future en documentant les choix techniques.

V.5 Définitions et justification des tests (5 points)

Tests fonctionnels : Vérifient que le logiciel répond correctement aux exigences fonctionnelles spécifiées. Approche “boîte noire”.

Tests structurels : Vérifient la qualité interne du code et son adéquation avec les spécifications techniques. Approche “boîte blanche”.

Justification : Les tests fonctionnels assurent que le logiciel répond aux besoins métier ; les tests structurels garantissent la qualité technique et la maintenabilité du code. Leur combinaison est indispensable pour obtenir un produit fiable, robuste et conforme aux attentes.

---

Résumé du document

Ce document est la correction détaillée de l’épreuve EPS du BTS Génie Logiciel session 2019 (Cameroun). Il est structuré en cinq parties.

La Partie 1 (MERISE) traite de la modélisation d’une boulangerie. On y trouve les définitions de flux et MERISE, les trois cycles de MERISE, un graphique de flux de données, les MCT pour l’approvisionnement et la production, un dictionnaire des données, le MCD (entités) et le MLDR complet en SQL.

La Partie 2 (UML) aborde la gestion des emprunts de CD-ROM pour enfants. Les concepts objet (encapsulation, polymorphisme, héritage, agrégation) sont définis, les types de relations entre classes listés, les exigences fonctionnelles détaillées, et des indications sur les diagrammes de cas d’utilisation, de séquence et de classes sont fournies.

La Partie 3 (algorithmique) propose des structures de données en C (client, matériel), des procédures pour créer un tableau de clients, ajouter un matériel dans une liste chaînée, afficher les matériels d’un client, et compter les matériels. Un tableau comparatif vecteurs/listes chaînées est donné.

La Partie 4 (manipulation de données) définit base de données et SQL, puis donne trois requêtes SQL sur un schéma ARTICLE/FOURNISSEURS/COMMANDE.

La Partie 5 (génie logiciel) compare les modèles incrémental et par réutilisation, liste les étapes du cycle de vie, définit spécification et conception, justifie la phase de spécification, et définit tests fonctionnels et structurels en justifiant leur complémentarité.