Cette approche est vouée à l`échec et nécessite généralement une réécriture à partir de zéro.
Ainsi, pour résoudre ce scénario, nous pouvons essayer de diviser le problème en plusieurs sous-problèmes, puis essayer de le résoudre un par une.
Cela facilite non seulement notre tâche, mais nous permet également d`obtenir une Maintenant la grande question est de savoir comment "casser" non pas théoriquement, mais LOGICIEL. Nous verrons plusieurs types différents de telles unités dans des langages populaires ‚Äã‚Äãtels que C / C++, Python et Java. À des fins d`illustration, Supposons que nous avons tous les inserts de listes chaînées de base dans un seul programme. Puisqu`il existe de nombreuses méthodes (fonctions), nous ne pouvons pas encombrer le programme en écrivant toutes les définitions de méthodes au-dessus de la fonction principale requise. Mais même si nous le faisions, il pourrait y avoir un problème d`ordre des méthodes, lorsqu`une méthode devrait être avant une autre, et ainsi de suite. Donc, pour résoudre ce problème, nous pouvons déclarer tous les prototypes au début de le programme, puis la méthode principale et ci-dessous que nous pouvons les définir dans n`importe quel ordre : Programme : Passer à C / C++
< a href = # Python> Passer à Python
Passer à Java
C / C++
|
Compilation du code : nous pouvons compiler le programme ci-dessus :
gcc linkedlist.c -o linkedlist
Et ça marche !
Les principaux problèmes dans le code ci-dessus :
Nous pouvons déjà voir les principaux problèmes avec le programme, il n`est pas si facile de travailler avec le code individuellement ou en groupe.
Si quelqu`un veut travailler avec ce qui précède programme, puis quelques-uns des nombreux problèmes auxquels cette personne est confrontée :
- Il faut passer par le fichier source complet. pour améliorer ou améliorer certaines fonctionnalités.
- Ne peut pas être facilement réutilisé le programme comme base pour d`autres projets.
- Le code est très encombré et n`est pas du tout attrayant, ce qui rend très difficile la navigation dans le code.
Dans le cas d`un projet de groupe ou de grands programmes, l`approche ci-dessus est garantie d`augmenter les coûts globaux, l`énergie et les taux d`échec.
Approche correcte :
Nous voyons que ces lignes commencent dans chaque programme C/C++ qui commence par "#include".
Cela signifie inclure toutes les fonctions déclarées dans l`en-tête "library" (fichiers .h) et définies éventuellement dans les fichiers library.c / cpp .
Ces lignes sont prétraitées au moment de la compilation.
Nous pouvons manuellement essayer de créer une telle bibliothèque pour nos propres besoins.
Éléments importants à retenir :
- Les fichiers ".h" ne contiennent que des déclarations prototypes (telles que des fonctions, des structures) et des variables globales.
- Les fichiers ".c / .cpp" contiennent l`implémentation réelle (définitions de déclaration dans les fichiers d`en-tête)
- Lors de la compilation de tous les fichiers source, assurez-vous que plusieurs définitions de la même fonction, variable, etc. n`existent pas pour le même projet. (TRÈS IMPORTANT)
- Utilisez les fonctions statiques, pour vous limiter au fichier dans lequel elles sont déclarées.
- Utilisez le mot-clé extern pour utiliser des variables référencées par et des fichiers externes.
- Lorsque vous utilisez C++, soyez prudent avec les espaces de noms, utilisez toujours namespace_name :: function (), pour éviter les collisions. ol >
En divisant le programme en codes plus petits :
Après avoir examiné le programme ci-dessus, nous pouvons voir comment ce grand programme peut être divisé en petites parties appropriées et puis facilement traité.
Le programme ci-dessus a essentiellement 2 fonctions principales :
1) Créer, insérer et enregistrer des données dans les nœuds.
2) Afficher les nœuds
De cette façon, je peux diviser le programme en conséquence de sorte que :
1) Le fichier principal est > Pilote de programme, Nice Wrapper de Insertion Modules et où nous utilisons des fichiers supplémentaires.
2) Coller - > La véritable mise en œuvre se trouve ici.
Avec les points importants mentionnés, le programme est divisé en :
linkedlist.c - > Contient le programme de pilote
insert.c - > Contient du code pour l`insertionlinkedlist.h - > Contient les déclarations de nœud nécessaires
insert.h - > Contient les déclarations d`insertion de nœud nécessaires
Dans chaque fichier d`en-tête, nous commençons par :
#ifndef FILENAME_H #define FILENAME_H Declarations ... #endif
La raison pour laquelle nous écrivons nos déclarations entre #ifndef, #define et #endif, est d`empêcher les déclarations multiples d`identifiants tels que les types de données, les variables, etc., lorsqu`un seul et même fichier d`en-tête est appelé dans un nouveau fichier appartenant au même projet.
Pour cet exemple de programme :
insert.h - > Contient la déclaration du nœud d`insertion ainsi que la déclaration du nœud lui-même.
Il est très important de se rappeler que le compilateur peut voir les déclarations dans le fichier d`en-tête, mais si vous essayez d`écrire du code qui inclut la déclaration ailleurs, cela entraînera une erreur, car le compilateur compile chaque fichier .c individuellement avant de passer à l`étape de liaison. ,
connectedlist.h - > Un fichier d`aide qui contient Node et ses déclarations Display qui doivent être incluses pour les fichiers qui les utilisent.
insert.c - > Incluez une déclaration de nœud via #include "connectedlist.h", qui contient la déclaration ainsi que toutes les autres définitions de méthode déclarées dans insert.h.
connectedlist.c fort> - > Simple Wrapper, contenant une boucle infinie invitant l`utilisateur à insérer des données entières aux positions requises, et contenant également une méthode qui affiche la liste.
Et la dernière chose à garder à l`esprit est que cela n`a pas de sens les fichiers d`inclusion les uns dans les autres peuvent entraîner plusieurs remplacements (s) et entraîner une erreur.
En tenant compte de ce qui précède, vous devez soigneusement diviser en routines appropriées.
|
insert.h
|
insert.c
< ShopLatest questions Wiki |