Quels sont les avantages de la programmation multi-fichiers?
Un autre programmeur C m'a dit d'écrire de grandes applications dans plusieurs fichiers .c et .h différents, puis de les compiler ensemble. Ils disent que cela fonctionnera plus rapidement.
Une application multifichier s'exécute-t-elle plus rapidement qu'une application monofichier? Si oui, qu'est-ce qui le fait fonctionner plus rapidement? De plus, quels sont les autres avantages de la programmation multi-fichiers?
Quelle (s) plateforme (s) les programmes C multi-fichiers affectent-ils les performances?
- Une application Windows multi-fichiers s'exécutera-t-elle plus rapidement qu'une application mono-fichier?
- Une application MacOS à fichiers multiples s'exécutera-t-elle plus rapidement qu'une application à fichier unique?
- Une application Ubuntu multi-fichiers s'exécutera-t-elle plus rapidement qu'une application mono-fichier?
Il y a beaucoup de raisons techniques derrière l'utilisation de plusieurs fichiers lors de l'écriture de grands systèmes complexes. Tous n'ont aucun sens face à la meilleure raison d'utiliser plusieurs fichiers:
Lisibilité.
Lorsque j'écris du code qui réside dans un fichier, je présente ce que vous devez comprendre pour suivre le fonctionnement de cette partie du système. Tous les détails qui ne figurent pas dans ce fichier sont résumés, représentés avec un bon nom qui devrait garantir que vous pouvez toujours comprendre ce qui se passe ici sans piquer le nez dans les autres fichiers.
Si je n'ai pas réussi, j'ai écrit du code pourri et vous devriez m'appeler pour cela. Dans de tels cas, plusieurs fichiers vous font rarement du bien.
Sans cette considération, je peux écrire tout le programme dans un seul fichier. Le CPU ne s'en souciera pas. Cela rendra les humains misérables lorsqu'ils essaieront de le lire.
La raison technique traditionnelle est de séparer le code en unités déployables indépendamment qui peuvent changer sans avoir à redéployer tout le système. Il y a des cas où c'est très important, par exemple lorsque votre logiciel est gravé sur de nombreuses puces et que vous ne voulez pas jeter toutes les puces simplement parce qu'il faut changer.
Il est également vrai qu'être déployable indépendamment permet aux compilations d'aller plus vite car il suffit de recompiler ce qui a changé.
Même dans ces cas, je dirais toujours que le plus grand avantage est de créer une frontière qui limite ce que vous attendez de vos lecteurs qu'ils gardent dans leur tête à tout moment.
TL; DR Si les programmes multi-fichiers vous ennuient parce que vous devez continuer à chercher dans plusieurs fichiers pour les comprendre, vous regardez simplement du code mal abstrait avec de mauvais noms. Cela ne devrait pas être ce que l'on ressent. Chaque fichier doit raconter une histoire d'un point de vue.
La question tombe dans la même catégorie que pourquoi les bâtiments ne sont pas construits à partir d'un seul morceau de roche mais d'un tas de briques?
Réponse:
- plus facile à naviguer que de faire défiler un énorme fichier
- make recompile ne fonctionne que sur les fichiers liés au changement
- différentes parties du programme peuvent être programmées par différentes personnes
- le code de certains fichiers peut être placé dans des bibliothèques pour une réutilisation future
- au moment de la compilation, une erreur indiquera dans quel fichier se trouve le problème (plus facile à trouver)
- au moment de la compilation, le compilateur a besoin de beaucoup moins de mémoire (moins de matériel requis)
- au moment de la compilation plus facile pour le compilateur d'analyser le code (plus rapide)
C'est juste du haut de ma tête - il y a certainement plus d'avantages en magasin.
Les autres réponses sont correctes, mais ce qui manque, ce sont les limitations techniques réelles.
Par exemple, vous ne pouvez pas réellement enregistrer tout le code de mon application de jour dans un seul fichier - il est plus grand que les limitations de taille de fichier des systèmes de fichiers courants. Ce type de taille fait également des ravages avec les éditeurs, les compilateurs et les linters puisque l'arbre de syntaxe de ce code est encore plus grand! Et puis vous obtenez le contrôle de code source et différents outils en essayant de travailler sur des dizaines de morceaux de texte en une seule séance. Puisque vous travaillez en C, vous devez également vous soucier de votre taille binaire réelle. La plupart des systèmes d'exploitation ont une limite de taille exécutable distincte de la limite de taille du système de fichiers.
Il s'agit bien sûr d'une valeur aberrante. Plusieurs fichiers sont principalement destinés à faciliter la vie des programmeurs, mais j'espère que cela vous donnera une meilleure idée de ce que les "grandes applications" peuvent impliquer.
On m'a dit d'écrire de grandes applications dans plusieurs fichiers différents. Ils disent que cela fonctionnera plus rapidement. Qu'est-ce qui le rend plus rapide?
En outre, une application multifichier s'exécute réellement plus rapidement qu'une application monofichier.
En C, il n'y a aucune raison de supposer qu'une application multi-source s'exécute plus rapidement, et plusieurs raisons pour lesquelles elle pourrait être légèrement plus lente. L'utilisation de plusieurs fichiers est pour la commodité des développeurs.
Il existe même des systèmes de construction qui vous permettent d'écrire plusieurs fichiers qui sont combinés en un seul fichier énorme avant d'être transmis au compilateur. Cela peut s'appeler des constructions "d'unité" ou de "fusion".
La raison principale est inline : remplacer un appel à une fonction par une copie de la fonction. C n'inclut généralement pas les fonctions de différents fichiers source, sauf si l'éditeur de liens est configuré pour le faire. Cette fonctionnalité est appelée "optimisation du temps de liaison" dans GCC.
D'autres commentateurs ont évoqué l'idée de ne pas charger les bits inutilisés du programme. Cependant, le groupe de fonctions fourni par les fichiers source peut ne pas être conservé dans l'exécutable; sauf si vous utilisez un système "overlay" (généralement obsolète), ou si vous avez séparé certaines fonctionnalités en "plugins".
Sur Linux et d'autres systèmes avec mémoire virtuelle, le système d'exploitation peut décharger seul les parties inutilisées du programme.
Il y a aussi quelques avantages mineurs possibles de choses comme la déduplication constante des chaînes - encore une fois, vous pouvez laisser l'éditeur de liens gérer cela, mais il peut ne pas être activé par défaut.
Les problèmes de vitesse de construction méritent d'être examinés. Si vous divisez un programme en N fichiers, N pouvant être compris entre 100 et 10 000, la compilation d'un fichier est généralement beaucoup plus rapide que la compilation de tous les N fichiers. Cependant, dans certains cas, la collecte de tous les N fichiers en un seul fichier énorme est plus rapide que la compilation de tous séparément - à condition qu'elle ne plante pas le compilateur. Cela a tendance à être plus important en C++ où les temps de compilation peuvent être beaucoup plus longs.
En pratique, les développeurs divisent les fichiers source car cela les rend plus faciles à utiliser. Les opinions varient, mais 1 000 lignes constituent un bon nombre de lignes directrices pour commencer à envisager de fractionner un fichier.
Les avantages d'utiliser plusieurs fichiers pour un programme sont nombreux. Par exemple:
- si vous écrivez du code pour une classe dans un fichier séparé, vous pouvez utiliser cette classe dans plusieurs programmes. Il augmente la réutilisabilité du code.
- De plus, si vous voulez changer quoi que ce soit dans une classe, vous n'aurez qu'à le changer dans ce fichier particulier et le changement sera automatiquement reflété dans tous les projets faisant référence à ce fichier.
- De plus, il est conseillé d'écrire de gros programmes complexes dans plusieurs fichiers plus petits.
- Et enfin et surtout, dans les grandes organisations, plusieurs programmeurs travaillent sur un projet. Dans de tels scénarios, chaque programmeur est responsable de la conception des modules désignés; par conséquent, des fichiers séparés pour chaque programmeur sont faciles à coder puis à intégrer par la suite.
Vous pouvez trouver plus d'arguments dans cet article .
Une autre raison importante d'utiliser plusieurs fichiers que personne n'a mentionné:
Lorsque vous travaillez sur un projet de développement logiciel avec une équipe, il est très courant d'utiliser un système de contrôle de version tel que Git. Un obstacle majeur rencontré par n'importe quel VCS est la fusion du travail de plusieurs auteurs. Si vous et un autre développeur travaillez sur le même fichier en même temps, votre travail doit finalement être fusionné. Dans certains cas, vous pouvez à la fois modifier la même partie du même fichier, ce qui peut entraîner conflits de fusion: situations où le VCS ne peut pas déterminer automatiquement comment fusionner les modifications, et un humain doit faites-le manuellement.
Lorsque tout votre code est dans un seul fichier, il y a un risque accru de conflits de fusion. Quiconque travaille sur le code travaille sur le même fichier. Cela augmente la probabilité de modifier le même code en même temps ou de marcher les uns sur les autres. Même quelqu'un qui travaille sur une autre partie du fichier peut par inadvertance faire quelque chose qui interfère avec votre travail. Par exemple, ils mettent automatiquement en forme l'intégralité du fichier, renomment une fonction que vous modifiez, réorganisent le code et déplacent les fonctions, etc.
La division du code en systèmes logiques répartis sur plusieurs fichiers réduit le risque de conflits de fusion causés par plusieurs personnes travaillant sur le même fichier en même temps. Cela facilite également la résolution des conflits de fusion, car moins de code dans chaque fichier signifie des conflits plus petits et plus faciles à résoudre.
Voici le pire des cas que j'ai malheureusement rencontré auparavant: vous avez un fichier de 10 000 lignes sur lequel Tom et Sally travaillent. Ils passent chacun plusieurs heures à apporter des modifications approfondies à différentes parties du code. À un moment donné, Tom remarque une erreur d'indentation et appuie habituellement sur la touche de raccourci "auto-formatage", qui modifie l'indentation, les sauts de ligne, etc. pour tout le fichier. Plus tard, quand ils vont tous les deux valider leur code, un conflit de fusion se produit car le formatage automatique de Tom a changé presque toutes les lignes de code dans le fichier entier et le VCS ne peut pas comprendre comment fusionner les modifications. Tom ou Sally doivent maintenant passer heures de temps à fusionner manuellement 10 000 lignes de code. Si le code avait été divisé en plusieurs fichiers, ils n'auraient peut-être pas eu de conflit du tout, et même s'ils l'avaient fait, cela n'aurait pas affecté la base de code entière.
En général, cela dépend du contexte. En plus des autres réponses en javascript, python et d'autres langues que je ne connais probablement pas, un fichier importé n'est chargé qu'une seule fois. Disons que nous devons importer un fichier de 150000 mots, qui a besoin d'environ 1 seconde pour être chargé dans une variable (ou structure de données). Ensuite, nous voulons utiliser ce fichier pour savoir si un mot se trouve dans ces 150000 entrées. Nous devons également réexécuter ce processus 1000 fois, ce qui signifie environ 1000 Cependant, étant donné que nous importons le fichier 150000 entrées en tant que variable à partir d'un autre fichier, le processus entier de 1000 étapes dure environ 1 seconde.
Cependant, veuillez garder à l'esprit que le reste des réponses fournit un raisonnement beaucoup plus significatif à votre question.
Même lorsque nous avons des outils de navigation de code complexes comme Jump-to-Definition, organiser votre projet dans une arborescence de fichiers et de dossiers facilite l'intégration de nouveaux développeurs. Cela facilite la recherche du fichier dont vous avez besoin pour commencer à travailler sur une fonctionnalité.
Quant à la préoccupation "plus rapide", la plupart des compilateurs modernes prennent en charge le LTO, donc même si vous utilisez des unités de compilation distinctes (accélération de la compilation pendant le débogage), l'exécutable résultant s'exécutera à la même vitesse lorsque le LTO est activé.
Cela se résume en grande partie à:
- Vous souhaitez pouvoir naviguer facilement vers les différentes parties logiques de votre programme et afficher ces parties côte à côte
- il est plus facile de créer un environnement de programmation/IDE qui traite ces parties séparées comme des fichiers séparés que de créer un IDE qui conserve tout le code d'un programme dans un gros fichier, et doit montrer des parties de ce fichier côte à côte, etc.
Dans de nombreux cas, il n'y aurait absolument aucun problème à avoir tout votre code dans un seul fichier réel sur le disque si votre IDE était facilement en mesure de vous aider à naviguer dans ce fichier et à afficher différentes parties du fichier cote à cote.