École de technologie supérieure Génie de la production automatisée
GPA665
Structures de données et algorithmes
Laboratoire 2
Chargement et analyse d’une liste de matériel (BOM)
Responsable du cours : Mohamed Cheriet, ing., Ph. D.
Rédaction du laboratoire : Yan Levasseur Révision et barème de correction : Jean-Christophe Demers Temps alloué pour ce laboratoire : 4 périodes de laboratoire
Résumé
La gestion du matériel est un facteur de rentabilité critique en entreprise. Aussi les compagnies adoptent de plus en plus des systèmes informatisés pour faire la gestion des produits en cours et en entrepôt et pour optimiser les commandes en fonction des ventes.
Ce laboratoire concerne de la gestion d’une liste de matériel mieux connue sous le nom de « Bill Of Material » (BOM).
Plus spécifiquement, vous serez appelés à réaliser le chargement d’une base de données de pièces, d’assemblages et de produits à partir d’un fichier texte. Ensuite, grâce à un moteur de liste chaînée générique, vous devrez faire le parcours des différentes listes de matériel pour en extraire des informations pertinentes à la gestion.
L’étudiant devra travailler avec des structures de données de type listes chaînées double et simple, puis à travailler intensivement avec des pointeurs, autant vers des types standard que vers des structures ou des fonctions. Finalement, toute la gestion de la mémoire sera dynamique.
Problème
Le problème de la gestion d’une liste de matériel soulève des problèmes récurrents à différents niveaux hiérarchiques. En effet, si notre BOM contient à la fois des produits, des assemblages et des pièces, nous avons trois listes à gérer. Cependant, les mécanismes qui servent à se déplacer dans la liste, à insérer et à supprimer un élément sont plus ou moins les mêmes dans les trois cas. De plus, si chaque projet possède une liste d’assemblages, et chaque assemblage une liste de pièces, le mécanisme de déplacement de bas en haut du BOM doit être robuste et adapté aux trois types de donnée à la fois.
Vous allez explorer un type de programmation générique en créant un logiciel qui sera capable de charger un BOM contenu dans un fichier texte selon une convention connue, de créer une structure de données représentant la listes des éléments de la BOM basée sur les listes chaînées, et de parcourir la structure de données créée en effectuant tests et calculs mathématiques grâce à la manipulation de pointeurs de fonctions. L’affichage du contenu du BOM, sous différents formats devra être réalisé. De plus, des statistiques sur le BOM vous seront demandées. Par contre, il n’est pas exigé de modifier, d’insérer ou de supprimer de façon interactive les éléments du BOM dans le cadre de ce projet.
Spécifications
Description du BOMLe BOM utilisé au laboratoire est une représentation simplifiée du BOM que l’on retrouve couramment en entreprise. Notre BOM comporte des éléments selon trois niveaux hiérarchiques. Les informations nécessaires concernant les éléments de notre BOM ont été choisis en considérant le type d’entreprise voulu, soit une usine qui se spécialise dans l’assemblage de produits avec stockage minimal (stratégie de production juste à temps).
Le BOM contient une liste générale des pièces, une liste générale des assemblages et une liste générale des produits. Il existe aussi des liens à partir des assemblages vers les pièces, et des liens à partir des produits vers les assemblages.
Les pièces
Premièrement, le BOM présente une liste de pièces. Celles-ci seront par exemple des organes d’assemblage (vis, écrous, joints), tôles poinçonnées, pièces usinées, arbre etc.
Les informations concernant l’identification de la pièce, son prix à l’achat (aucune pièce n’est fabriquée à l’interne) ainsi que le nombre de pièces entreposées à l’usine doivent être conservées. Les numéros d’identification de 0 à 49 999 sont réservés aux pièces.
Les assemblages
Les assemblages doivent comporter les mêmes informations que les pièces (le coût étant associé au coût de main d’œuvre & équipement pour la réalisation de l’assemblage). De plus, le temps nécessaire pour réaliser l’assemblage doit être mentionné. Finalement, une
liste est utilisée pour dénombrer les pièces qui font partie de cet assemblage. Les numéros d’identification réservés aux assemblages sont de 50 000 à 89999.
Les produits
Selon un principe similaire, les produits sont des regroupements d’assemblages (ou assemblages maîtres). Les informations contenues seront semblables au cas d’un assemblage, mais on peut omettre la quantité de produits en entrepôt (qui sera toujours nulle puisque la compagnie utilise une stratégie de gestion juste à temps). Finalement, c’est ici que l’on retrouvera le prix de vente. Une liste informera aussi sur les assemblages qui composent le produit. Finalement, les numéros d’identification réservés aux produits sont de 90 000 à 100 000.
Mandat détaillé
Dans l’optique de la mise en place d’un système informatisé de consultation et de gestion du matériel de l’usine d’assemblage, plusieurs fonctionnalités sont à implanter. Plus spécifiquement, voici les tâches à accomplir :
Vous devez charger en mémoire la structure de données complète qui représente les trois listes d’éléments du BOM et les liens qui les unissent.
Cela sera réalisé à partir d’un fichier texte qui fait office de base de données.
Les conventions pour ce fichier d’entrée seront détaillées dans une section subséquente.
Une fois le BOM chargé, on désire pouvoir afficher son contenu de plusieurs façons :
o Affichage en file de tous les éléments du BOM : les pièces, ensuite les assemblages, suivis des produits. Une ligne par élément, le tout formaté pour un affichage convivial. On doit pouvoir afficher les éléments en ordre croissant de numéro d’identification (1), ou par ordre décroissant (2) – dans ce cas-ci les produits viendront avant les assemblages et les pièces seront affichées en dernier.
o Affichage indenté de tous les produits du BOM, avec les assemblages et pièces qui les composent (3), puis affichage d’un produit spécifique, avec ses assemblages et pièces (5) (la sélection du produit voulu se fait par numéro d’identification). Voici un exemple (ici la flèche représente une tabulation) :
Nous voulons aussi faire des calculs sur les différents produits puis sur l’ensemble des pièces. Ces calculs seront réalisés par le biais de fonctions de parcours de la structure de données :
o Valeur totale des pièces et assemblages en entrepôt (4).
o Coût total d’un produit (correspond à tous les coûts encourus : y compris les coûts des assemblages et de l’achat des pièces) (6).
o Profit pour un produit (prix de vente par rapport aux coûts totaux) (7).
o Temps total pour la réalisation d’un produit spécifique en considérant que ses assemblages sont réalisés en parallèle (maximum de tous les temps d’assemblage, plus le temps associé à la finition du produit) (8).
Globalement, une interface usager simple pourra gérer la saisie du nom de fichier d’entrée et la sélection des options d’affichage et de calculs, après le chargement du BOM. Le menu pourra être géré de la façon qui vous apparaît la plus efficace. Voici un petit schéma en guise d’exemple :
Où l’astérisque indique qu’un numéro d’identification de pièce ou de produit doit être fourni avec le choix de la commande.
N.B. Par soucis de simplicité, il est conseillé de réaliser la partie affichage de ce laboratoire dans une console en mode texte
Structure de données
Une des structures de données qui vous est imposée est basée sur les listes chaînées double. Les listes de pièces, d’assemblages et de produits sont des listes chaînées doubles. Chacune de ces listes ne contient que des éléments d’un type particulier (toutes les pièces sont dans une même liste, alors que les assemblages sont dans une autres, etc.)
La complexité provient du fait qu’un assemblage contient aussi une liste de pièce et qu’un produit contient une liste d’assemblages. Chaque nœud de ces listes est composé d’un lien vers l’espace mémoire alloué pour l’élément référencé, et on y indique la quantité nécessaire.
Comme le TDA liste est utilisé à maintes reprises, il devient pertinent d’utiliser une liste généralisée, fonctionnant pour n’importe quel type d’objet. Comme les actions à effectuer sur les différentes listes sont plus ou moins les mêmes, le nombre de méthodes à réaliser pour exécuter les tâches requises sera de beaucoup réduit.
Voici la définition d’un nœud de notre liste chaînée double généralisée : typedef struct LDGNode {
void* Data; // L'élément pointé (n'importe quel type) int NumberRequired; // Le nombre d'éléments nécessaires LDGNode * Next; // Pointeur vers le noeud suivant LDGNode * Previous; // Pointeur vers le noeud précédent }LDGNode; // Noeud de Liste Double Généralisée
Le pointeur de donnée de type void nous permet de pointer vers n’importe quel type ou structure de données, par la conversion via le typecast vers le type void* (la conversion d’un type pointeur vers le type void* se fait automatiquement lorsque nécessaire). La gestion de notre liste chaînée double générique nous permet de traiter des données quelconques, mais la responsabilité du type de donnée réel contenu dans Data retombe sur le programmeur. Lorsqu’on voudra obtenir des informations spécifiques à partir de la structure dont l’adresse est conservée dans Data, il sera nécessaire d’utiliser de nouveau le typecast pour retransformer le pointeur en son type original (la conversion d’un type void* vers un autre type de pointeur ne se fait pas automatiquement : il doit être réalisé par le programmeur). On pourra ensuite accéder à ses champs de la façon habituelle.
Voici maintenant la structure qui nous permet d’accéder à la liste en tant que telle : typedef struct {
int Count; // Le nombre d'éléments dans la liste LDGNode * First; // Premier élément de la liste
LDGNode * Last; // Dernier élément de la liste }LDGList; // Liste Double Généralisée
Cette liste généralisée nous permettra de réaliser indifféremment des listes de pièces, d’assemblages ou de produits.
Voici un exemple de fonction qui permet d’allouer un élément à la fin d’une liste (une copie de cet élément – une version statique par exemple - doit exister avant l’appel de cette fonction :
int InsertLastList(LDGList *List, void *Data, int Nbr) {
LDGNode *NewNode;
if (!(NewNode = (LDGNode *) malloc(sizeof(LDGNode)))) { return 0;
} // Allocation dynamique pour un nouveau noeud NewNode->Data = Data; // Le nouveau noeud pointe NewNode->Next = NULL; // vers ce nouvel élément NewNode->NumberRequired = Nbr;
// Ajustement des pointeurs if (List->Count == 0) {
List->First = NewNode;
List->Last = NewNode;
NewNode->Previous = NULL;
} else {
List->Last->Next = NewNode;
NewNode->Previous = List->Last;
List->Last = NewNode;
}
List->Count += 1;
return 1; // Exécution réussie }
Ici, on ajoute un élément à la fin d’une liste générique. Notez que dans le cas d’une liste spécifique à l’intérieur d’un assemblage ou à l’intérieur d’un projet, il ne faut pas allouer un nouvel espace mémoire pour l’insertion d’un élément : le nœud doit pointer vers l’adresse déjà allouée à l’élément, qui se trouve dans une des listes générales. (Chaque élément ne se trouve qu’en un seul exemplaire dans toute la structure de donnée.)
Voici un exemple d’insertion dans une liste, puis d’extraction de donnée depuis la liste double généralisée. N’oubliez pas qu’il vous incombe d’avoir conscience du type de donnée qui se trouve dans votre liste (pour éviter la confusion, nous n’utiliserons dans ce laboratoire qu’un seul type de donnée par liste).
…
typedef struct {
char Title[256];
float Salary;
} Job;
LDGList JobList;
Job Job_1;
Int NumberRequired = 3;
float some_salary;
InitList(&JobList); // Fonction d’initialisation de la liste AllocJob(&Job_1, "Trainee", 10.05); // Insertion dans les
// champs de Job_1 InsertLastList (JobList, Job_1, NumberRequired);
// Insertion d’une job dans la liste, avec le nombre requis some_salary = ((Job*)JobList.First->Data)->Salary;
// Ici, JobList.First->Data retourne un pointeur de type void*
// Il est nécessaire de retrouver le type Job* avant
// d’extraire l’information du champs Salary dans la structure Job.
…
Voici la déclaration de quelques fonctions qui serviront à gérer les nœuds et les listes généralisées :
void InitList(LDGList** List);
int InsertLastList(LDGList *List, void *Data, int Nbr);
void FreeNode(LDGNode* Node);
void FreeList(LDGList* List);
Les listes chaînées définies, nous pouvons passer aux structures des éléments de notre BOM. Voici les définitions pour les pièces, assemblages et projets :
typedef struct {
char Name[BUFFER_SIZE];
int ID; // 0 à 49 999
float Cost; // Coût à l'achat
unsigned int InventoryNbr; // Nombre de pièces en inventaire } SPart;
typedef struct {
char Name[BUFFER_SIZE];
int ID; // 50 000 à 89 999
float Cost; // Coût de l'assemblage
unsigned int InventoryNbr; // Nombre d'assemblage en inventaire float WorkTime; // Temps d'assemblage
LDGList* PartList; // Liste de pièces qui composent l'assemblage } SAssembly;
typedef struct {
char Name[BUFFER_SIZE];
int ID; // 90 000 à 100 000
float Cost; // Coût de l'assemblage final / finition float WorkTime; // Temps d'assemblage final / finition float SellingPrice; // Prix de vente du produit
LDGList* AssemblyList; // Les assemblages qui composent un produit } SProduct;
typedef struct { // Le BOM contient une liste de chaque type LDGList* ProductList;
LDGList* AssemblyList;
LDGList* PartList;
} SBOM; // BOM en entier
// Le type énuméré suivant permet au fonctions de s’adapter au type // de donnée passé lors de l’appel (puisque non précisé par void*
typedef enum {TUnknown, TPart, TAssembly, TProduct} DataType;
// Ce type énuméré permet de préciser si on veut parcourir en // ordre Croissant ou Décroissant
typedef enum {Ascending, Descending} Direction;
Voici un schéma représentant une structure de donnée de type SBOM
Fonctions à réaliser
Voici un aperçu des fonctions principales à réaliser pour la gestion du BOM, dans le cadre du laboratoire. Pour ces fonctions, vous devrez respecter au possible la définition qui vous est donnée.
Fonction Description
SPart* AllocPart(char* Name, int ID, float Cost, unsigned int InventoryNbr)
Cette fonction alloue l’espace mémoire et rempli les champs d’une Pièce.
SAssembly* AllocAssembly(char* Name, int ID, float Cost, unsigned int InventoryNbr, float WorkTime)
Cette fonction alloue l’espace mémoire et rempli les champs d’un Assemblage.
SProduct* AllocProduct(char* Name, int ID, float Cost, float WorkTime, float SellingPrice)
Cette fonction alloue l’espace mémoire et rempli les champs d’un Produit.
void InitBOM(SBOM** MyBOM)
Cette fonction alloue l’espace mémoire et rempli les champs d’un BOM.
void FreeBOM(SBOM* MyBOM)
Cette fonction libère l’espace mémoire de chaque liste du BOM, puis du BOM lui-même.
int ReadInputFile(SBOM * BOM, const char *NameOfInputFile)
Cette fonction est la fonction appelée par le programme principal pour la création de la structure de donnée complète. À partir des lignes d’informations provenant du fichier texte, vous devrez utiliser des sous fonctions pour créer la liste de pièces, puis pour créer la
liste d’assemblages (en assurant la gestion de la liste de chaque assemblage vers ses pièces) et finalement la liste de produits (de même avec la liste de chaque produit vers ses assemblages).
int InsertAscendingList(LDGList *List, void* Data, DataType DT) Cette fonction est appelée pour insérer un élément selon son numéro d’identification (en ordre croissant) dans la liste List. L’appel d’une fonction de parcours avec en paramètre une fonction qui déterminera l’emplacement de l’insertion sera réalisée dans cette fonction.
DT permet de choisir la procédure en fonction du type de donnée à insérer.
void ShowBomAscending(SBOM* BOM)
Cette fonction affiche les listes générales de pièces, d’assemblages et de produits en ordre croissant de numéro d’identification. La fonction de parcours Browse doit être utilisée.
void ShowBomDescending(SBOM* BOM)
Cette fonction affiche les listes générales de pièces, d’assemblages et de produits en ordre décroissant de numéro d’identification. La fonction de parcours Browse doit être utilisée.
void ShowBomIndent(SBOM* BOM)
Cette fonction affiche tous le BOM, assemblages et pièces qui composent les produits avec indentation.
void InventoryValue(SBOM* BOM)
Cette fonction parcours les listes de pièces et d’assemblages et calcule la valeur totale de tous les éléments en inventaire (selon InventoryNbr et Cost).
void ShowIndent(SBOM* BOM, int ProductID)
Cette fonction affiche les assemblages et les pièces d’un produit, avec indentation.
void TotalCost(SBOM* BOM, int ProductID)
Selon un produit choisi, cette fonction parcours le dépliement de sa liste d’assemblages et des listes de pièces de ceux-ci afin de calculer le coût total de la réalisation d’un produit.
N’oubliez pas de multiplier le coût de chaque élément par le nombre requis.
void Profit(SBOM* BOM, int ProductID)
Cette fonction calcule le profit unitaire de la vente d’un produit. Le coût total de fabrication doit être soustrait au prix de vente du produit.
void ProductionTime(SBOM* BOM, int ProductID)
Cette fonction calcule le temps total nécessaire à l’assemblage d’un produit. Ceci correspond au maximum parmi les temps nécessaires de tous les assemblages qui le composent (assemblage en parallèle), plus le temps de finition.
void Browse(LDGList *List, Direction Dir, float *Result, int (*Func)(LDGNode*, float*, DataType DT), DataType DT)
Cette fonction parcours une liste générique et applique la fonction Func, passée en paramètre, sur le Data de chaque nœud de la liste List. Le résultat de toutes ces opérations est retourné par Result. Dir indique si le parcours se fait de façon croissante ou décroissante en fonction des numéros d’identification des éléments.
void BrowseAndStop(LDGList *List, LDGNode **Result, int WantedResult, void *ToCompare, int (*Func)(LDGNode*, float*, DataType), DataType DT)
Cette fonction parcourt une liste générique et applique la fonction Func, passée en paramètre, avec le Data de chaque nœud de la liste List. Func est une fonction de comparaison qui retourne un entier selon la comparaison avec ToCompare. L’adresse où le parcours s’est arrêté, lorsque Func a obtenu le résultat WantedResult avec sa comparaison, est retournée par Result.
void BrowseDownDisplay(LDGList *List, float *Result, int (*Func) (LDGNode*, float*, DataType DT), DataType DT)
Cette fonction parcourt vers le bas une liste et ses sous-listes afin de faire un affichage indenté.
void BrowseDownCalc(LDGList *List, float *Result, int (*Func) (LDGNode*, float*, DataType DT), DataType DT)
Cette fonction parcourt vers le bas une liste et ses sous-listes afin procéder à la fonction Func et faire des calculs qui seront retournés par Result.
int Find(LDGList *List, int ID, void** DataFound, DataType DT) Cette fonction parcourt la liste List et retourne dans DataFound l’adresse de l’élément de type DT possédant le numéro d’identification ID.
Le fichier d’entrée
Le fichier d’entrée est un fichier texte dans lequel nous retrouvons toutes les informations utiles pour définir complètement le BOM. Voici un exemple de fichier d’entrée selon le format imposé.
PIECES 20
12788 .34 144 Washer aluminium 3/4 po
43221 .22 100 Vis sis pans creux 1/8-12 UNC x 1 po 23221 .03 33 Vis micrometrique de serrage
32738 .55 900 Douille de serrage 1/2 po 7988 .29 22 Goupille fendue 3/16 dia x 1 po 19029 3.44 100 Composant electronique DH388198 36971 .64 70 Joint d'etancheite 2 po diametre
22519 .99 10 Fil de tungstene 1/16 po diametre x 6 po 41998 .50 200 Tole acier inoxydable 1/32 x 2 x 2 po 25631 2.10 54 Plaque aluminium trouee 1/4 x 1 1/2 x 3 po 43442 3.78 23 Arbre aluminium plaque 1/2 dia x 3 po 45899 4.87 11 Cle hexagonale brass 1 3/8 po longueur 344 14.76 3 Bille acier chrome 7/8 po diametre 1276 33.99 4 Tube or et aluminium 1/2 dia x 4 po
37562 3.49 7 Filtre en fibre de carbone tissee 4 x 4 po 49767 86.38 2 Arbre a cames Dragmore 32 po longueur 21289 149.32 3 Tige cannelee conique 2 1/2 x 2 po 24 .54 250 Vis allen 3/32-21 UNC x 3/4 po
796 .11 45 Vis a metal corse 1 po
10089 8.80 121 Tole acier inoxydable 1/8 x 1 x 1 1/4 po ASSEMBLAGES
5
51987 12.99 11 2 Sous-assemblage de cloison 3
41998 4 7988 3
23221 6
67198 43.35 19 1 Frame en T 2 po large 4
25631 2 43442 4 36971 4 796 7
85410 279.34 145 4 Emmetteur ondes micro 4 x 3 po 7
41998 4 41998 3 23221 2 19029 1 22519 7 1276 3 1276 18
77190 788.12 230 2 Arbre de puissance conique 10
21289 1 49767 1 37562 2 45899 1 32738 3 7988 1 12788 2 344 1 36971 1 23221 4
78761 100.17 110 2 Systeme d'entrainement 4 po 6
45899 2 25631 4 41998 2 24 12 7988 2 10089 8 PRODUITS 3
91345 126.99 40 4867.00 Convertisseur mecanique 2
67198 2 51987 3
98655 287.21 89 14019.40 Porte-Mandrin 4 po 3
77190 1 67198 2 51987 2
98659 397.10 120 6917.01 Porte outil 4 po pour fraiseuse 4
77190 1 67198 2 51987 2 78761 1
Un fichier d’entrée est disponible sur le site web.
Mots-clés
Les mots clés pour le fichier d’entrée sont PIECES, ASSEMBLAGES et PRODUITS. Le reste de l’information est obtenu selon la forme du fichier texte. Voici donc comment lire le fichier. On recherche d’abord le mot-clé PIECES. L’élément qui suit est le nombre total de pièces différentes dans le BOM. Ensuite on sait que tous éléments qui suivent seront des pièces, jusqu’à ce qu’on atteigne un autre mot-clé. On peut d’ailleurs le vérifier en observant le numéro d’identification qui doit se trouver entre 0 et 49 999 pour une pièce.
Voici comment lire les informations d’une pièce (chaque information est séparée par un espace) :
ID Coût Nombre en Inventaire Nom de la pièce
Comme le nom de l’élément sera toujours à la fin, on peut utiliser la fonction fgets pour obtenir la fin de la ligne (espaces y compris) entière. Ensuite le mot clé ASSEMBLAGES indique que les prochains éléments seront des assemblages. On retrouve aussi le nombre d’assemblages différents. Ceux-ci sont numérotés de 50 000 à 89999 et se présentent comme suit :
ID Coût Temps requis Nombre en inventaire Nom de l’assemblage
Chaque assemblage est suivi du nombre de pièces qui le compose. Tout de suite après vient la liste des pièces et leurs nombres.
Finalement le mot clé PRODUITS indique le début de l’énumération des produits. Ici aussi, on retrouvera le nombre de produits différents. Il se fait de la même façon que les assemblages et comporte les informations suivantes :
ID Coût Temps requis Prix de vente Nom de l’assemblage
Les produits sont identifiables par leur numéro d’identification qui doit se situer entre de 90 000 et 100 000. Ici encore, on dénote le nombres d’assemblages qui composent un produit, avant de les lister avec leur nombre respectif.
Utilisation de pointeurs de fonction
Il est pratique d’utiliser des pointeurs de fonctions lorsqu’on fait le parcours d’une structure de donnée. Il est possible d’appliquer une fonction sur chaque donnée, dans la même exécution de parcours, si la fonction est passée en paramètre via un pointeur de fonction.
Pour plus d’informations, un document sur l’usage des pointeurs de fonction est disponible sur le site web.
Le programme suivant montre comment exécuter une instruction sur chaque élément se trouvant dans une liste chaînée générique.
void Browse(LDGList *List, float *Result, int (*Func)(LDGNode*, float*, DataType DT), DataType DT)
{
if(Dir == Ascending){
LDGNode* current = List->First;
while(current!=NULL){
(*Func)(current, Result, DT);
current = current->Next;
} } else {
LDGNode* current = List->Last;
while(current!=NULL){
(*Func)(current, Result, DT);
current = current->Previous;
} } }
Voici les petites fonctions à réaliser, qui seront passées en paramètre (par un pointeur de fonction) dans le parcours (Les fonctions « Browse ») de liste. On y indique aussi dans quelles fonctions elles seront utiles.
Fonction Description
int AddInventoryValue(LDGNode* Node, float * Result, DataType DT) Cette fonction calcule la somme de la valeur des pièces d’un type en inventaire. On y utilise IventoryNbr et Cost. Cette valeur est rajoutée à Result. [Pour InventoryValue]
int AddCost(LDGNode* Node, float * Result, DataType DT)
Cette fonction calcule la somme de la valeur des éléments nécessaires pour produit. On y utilise RequiredNumber et Cost. Cette valeur est rajoutée à Result. . [Pour TotalCost]
int MaxTime(LDGNode* Node, float * Result, DataType DT)
Cette fonction retourne par Result le maximum entre Result et le temps requis pour la tâche d’assemblage (WorkingTime). [Pour ProductionTime]
int Display(LDGNode* Node, float * Result, DataType DT)
Cette fonction affiche les informations relatives à un élément. [Pour les fonctions « Show » sans indentation]
int DisplayIndent(LDGNode* Node, float * Result, DataType DT)
Cette fonction affiche les informations relatives à un élément. [Pour les fonctions « Show » avec indentation]
int CompareID(LDGNode* Node, float * Result, DataType DT)
Retourne -1 si le ID contenu dans Result est inférieur au ID de la pièce contenu dans Node.
Retourne 0 si le ID contenu dans Result est égal au ID de la pièce contenu dans Node.
Finalement la fonction retourne 1 si le ID contenu dans Result est supérieur au ID de la pièce contenu dans Node. [Pour l’insertion ou l’identification d’un élément dans une liste avec BrowseAndStop]
NB : Les fonctions doivent se conformer aux types : int fonction(LDGNode* Node, float * Result, DataType DT);
Note : Dans les listes générales, le nombre d’éléments requis dans la structure LDGNode
n’est jamais utilisé, puisque cette liste ne représente pas des assemblages mais des listes
complètes de tous les éléments existants (même si ceux-ci ne font pas parti d’un
assemblage).
Contraintes d’implantation
1. Vous devez utiliser le logiciel Visual C++ pour réaliser votre programme.
2. Vous devez faire une validation partielle du contenu du fichier source. Voici les éléments que vous devez considérer :
Les numéros d’identification doivent être cohérent (selon le mode en cours).
Ignorez une référence à un numéro d’identification de pièces ou d’assemblage inexistant mais mentionnez une erreur.
Les informations sur les éléments doivent être du bon type (numérique ou chaîne de caractères)
3. Dans les listes générales de pièces, d’assemblages et de produits, les éléments doivent toujours être en ordre de numéro d’identification (ordre croissant).
4. Vous ne devez utiliser aucune variable globale.
5. Votre code doit être lisible et bien documenté.
Évaluation
L’évaluation de ce laboratoire se fera par la remise d’un rapport à la période qui suit la quatrième période allouée à ce laboratoire. Le rapport doit contenir un organigramme général du déroulement de votre programme (une page). Ensuite, vous devez aussi remplir la grille d’évaluation à la dernière page de cet énoncé. Finalement, répondez aux questions suivantes, sur une à deux pages.
Pensez-vous que la structure de données imposée dans ce laboratoire est adaptée au problème de la gestion d’un BOM? Parlez des modifications que vous apporteriez à la structure de données pour l’améliorer. (15)
Prenez rapidement connaissance du TDA arbre. Pensez-vous que sa structure est mieux adaptée au problème du BOM ? Identifiez les principales difficultés dans le problème de la gestion informatisée d’un BOM. (10)
Suggérez un méthode ou une structure de donnée performante pour la recherche d’un élément. (5)
N’oubliez pas de joindre à votre rapport une disquette contenant votre programme exécutable ainsi que tous les fichiers sources (bien documentés).
Grille d’évaluation
En guise d’autoévaluation, imprimez et remplissez vous-même cette section.
Mentionnez une référence (nom de fichier et numéro de ligne) lorsque demandé pour faciliter la vérification par le correcteur.
Spécifications techniques Oui Non Référence (fichier, ligne)
5 Validation du fichier d’entrée _____________________
5 Chargement du BOM et création de la structure de données complétés 5 Affichage des listes de pièces,
assemblages et produits
_____________________
_____________________
5 Affichage des statistiques sur le BOM _____________________
Spécifications de programmation Oui Non
5 Structures de données imposées : Liste chaînée double générique
_____________________
_____________________
5 Gestion dynamique de la mémoire et
libération de l’espace alloué _____________________
5 Listes générales gérées en ordre croissant _____________________
5 Gestion efficace des pointeurs de fonction _____________________
(-10) Aucune variable globale
Qualité logicielle T.B. Bon Pauvre Référence (fichier, ligne) 5 Modularité : usage généralisé de fonctions
et regroupement logique en modules
_____________________
_____________________
5 Robustesse : Précaution pour éviter les problèmes de données erronées, etc.
_____________________
_____________________
5 Documentation : Commentaires pertinents qui accélèrent la compréhension du code
_____________________
_____________________
5 Clarté du code : Code concis et court utilisant les fonctions adaptées
_____________________
_____________________
60 TOTAL
