Il y a (dans la plupart des cas, à l'exception du code interprété) deux étapes pour passer du code source (ce que vous écrivez) au code exécutable (ce que vous exécutez).
La première est la compilation qui transforme le code source en modules objets.
La seconde, la liaison, est ce qui combine les modules d'objets ensemble pour former un exécutable.
La distinction est faite, entre autres, pour permettre l'inclusion de bibliothèques tierces dans votre exécutable sans que vous ne voyiez leur code source (comme les bibliothèques pour l'accès aux bases de données, les communications réseau et les interfaces utilisateur graphiques), ou pour compiler du code dans différents langages (C et code assembleur par exemple) et les lier ensuite tous ensemble.
Quand vous statiquement lier un fichier à un exécutable, le contenu de ce fichier est inclus au moment de la liaison. En d'autres termes, le contenu du fichier est physiquement inséré dans l'exécutable que vous allez exécuter.
Lorsque vous reliez dynamiquement un pointeur vers le fichier à lier (le nom du fichier, par exemple) est inclus dans l'exécutable et le contenu de ce fichier n'est pas inclus au moment de la liaison. Ce n'est qu'au moment où l'on exécuter l'exécutable que ces fichiers liés dynamiquement sont achetés et ils ne sont achetés que dans la copie en mémoire de l'exécutable, pas celle sur le disque.
Il s'agit essentiellement d'une méthode de liaison différée. Il y a même plus une méthode différée (appelée liaison tardive sur certains systèmes) qui ne fait pas intervenir le fichier lié dynamiquement tant que vous n'essayez pas d'appeler une fonction dans ce fichier.
Les fichiers liés statiquement sont "verrouillés" à l'exécutable au moment de la liaison, de sorte qu'ils ne changent jamais. Un fichier lié dynamiquement référencé par un exécutable peut changer en remplaçant simplement le fichier sur le disque.
Cela permet de mettre à jour les fonctionnalités sans avoir à refaire le lien avec le code ; le chargeur refait le lien à chaque fois que vous l'exécutez.
C'est à la fois une bonne et une mauvaise chose - d'un côté, cela permet des mises à jour et des corrections de bogues plus faciles, de l'autre cela peut conduire à ce que les programmes cessent de fonctionner si les mises à jour sont incompatibles - cela est parfois responsable du redoutable "enfer des DLL" que certaines personnes mentionnent, dans la mesure où les applications peuvent être cassées si vous remplacez une bibliothèque liée dynamiquement par une autre qui n'est pas compatible (les développeurs qui font cela doivent s'attendre à être traqués et sévèrement punis, d'ailleurs).
En tant que exemple Dans ce cas, considérons le cas d'un utilisateur qui compile ses main.c pour la liaison statique et dynamique.
Phase Static Dynamic
-------- ---------------------- ------------------------
+---------+ +---------+
| main.c | | main.c |
+---------+ +---------+
Compile........|.........................|...................
+---------+ +---------+ +---------+ +--------+
| main.o | | crtlib | | main.o | | crtimp |
+---------+ +---------+ +---------+ +--------+
Link...........|..........|..............|...........|.......
| | +-----------+
| | |
+---------+ | +---------+ +--------+
| main |-----+ | main | | crtdll |
+---------+ +---------+ +--------+
Load/Run.......|.........................|..........|........
+---------+ +---------+ |
| main in | | main in |-----+
| memory | | memory |
+---------+ +---------+
Vous pouvez voir dans le cas statique que le programme principal et la bibliothèque d'exécution C sont liés ensemble au moment de la liaison (par les développeurs). Comme l'utilisateur ne peut généralement pas relier l'exécutable, il doit se contenter du comportement de la bibliothèque.
Dans le cas d'un programme dynamique, le programme principal est lié à la bibliothèque d'importation du runtime C (quelque chose qui déclare ce qui se trouve dans la bibliothèque dynamique, mais qui n'est pas réellement une bibliothèque dynamique). définir il). Cela permet à l'éditeur de liens de lier même si le code réel est manquant.
Ensuite, au moment de l'exécution, le chargeur du système d'exploitation effectue une liaison tardive du programme principal avec la DLL (bibliothèque de liaison dynamique ou bibliothèque partagée ou autre nomenclature) du runtime C.
Le propriétaire du runtime C peut introduire une nouvelle DLL à tout moment pour fournir des mises à jour ou des corrections de bogues. Comme indiqué précédemment, cela présente des avantages et des inconvénients.
