Unterschied zwischen statischen und gemeinsam genutzten Bibliotheken?

Question

Was ist der Unterschied zwischen statischen und gemeinsam genutzten Bibliotheken?

Ich verwende Eclipse und es gibt mehrere Projekttypen, darunter Static Libraries und Shared Libraries? Hat die eine einen Vorteil gegenüber der anderen?

Answer 1

Der größte Vorteil von gemeinsam genutzten Bibliotheken ist, dass nur eine Kopie des Codes in den Speicher geladen wird, unabhängig davon, wie viele Prozesse die Bibliothek nutzen. Bei statischen Bibliotheken erhält jeder Prozess seine eigene Kopie des Codes. Dies kann zu einer erheblichen Speicherverschwendung führen.

Ein Vorteil statischer Bibliotheken besteht darin, dass alles in Ihrer Anwendung gebündelt ist. Sie müssen sich also keine Sorgen machen, dass der Kunde die richtige Bibliothek (und Version) auf seinem System hat.

Answer 2

Zusätzlich zu all den anderen Antworten wurde die Entkopplung noch nicht erwähnt:

Lassen Sie mich über einen realen Produktionscode sprechen, mit dem ich mich beschäftigt habe:

Eine sehr große Software, die aus mehr als 300 Projekten besteht (mit Visual Studio), die meist als statische Bibliotheken erstellt werden und schließlich alle in einer einzigen großen ausführbaren Datei verknüpft werden, führt zu folgenden Problemen:

-Die Verbindungszeit ist extrem lang. Es kann sein, dass Sie mehr als 15 Minuten für die Verknüpfung benötigen, für sagen wir 10 Sekunden Kompilierungszeit. -Einige Tools sind mit einer so großen ausführbaren Datei überfordert, z. B. Tools zur Speicherprüfung, die den Code instrumentieren müssen. Sie könnten an Grenzen stoßen, die als dumm angesehen wurden.

Problematischer ist die Entkopplung Ihrer Software: In diesem realen Beispiel waren die Header-Dateien jedes Projekts von allen anderen Projekten aus erreichbar. Infolgedessen war es für einen Entwickler extrem einfach, Abhängigkeiten hinzuzufügen; es ging nur darum, den Header einzubinden, da der Link am Ende alle Symbole finden wird. Das Ergebnis sind schreckliche, zyklische Abhängigkeiten und ein komplettes Durcheinander.

Bei gemeinsam genutzten Bibliotheken ist es ein bisschen mehr Arbeit, weil der Entwickler das Projekt-Build-System bearbeiten muss, um die abhängige Bibliothek hinzuzufügen. Ich habe festgestellt, dass gemeinsam genutzter Bibliothekscode in der Regel eine sauberere Code-API bietet.

Answer 3

+---------------+---------------------------+------------------------------+
| properties    | Static library            | Shared library               |
+===============+===========================+==============================+
| Linking time  | It happens as the         | Shared libraries             |
|               | last step of the          | are added during             |
|               | compilation process.      | linking process              |
|               | After the program         | when executable              |
|               | is placed                 | file and libraries           |
|               | in the memory             | are added to the memory.     |
+---------------+---------------------------+------------------------------+
| Means         | Performed by linkers      | Performed by operating System|
+---------------+---------------------------+------------------------------+
| Size          | Static libraries are      | Dynamic libraries are        |
|               | much bigger in size,      | much smaller, because        |
|               | because external          | there is only one copy       |
|               | programs are built        | of dynamic library           |
|               | in the executable file.   | that is kept in memory.      |
+---------------+---------------------------+------------------------------+
| External file | Executable file will      | In shared libraries,         |
| changes       | have to be recompiled     | no need to recompile         |
|               | if any changes were       | the executable.              |
|               | applied to external files.|                              |
+---------------+---------------------------+------------------------------+
| Time          | Takes longer to execute   | It is faster                 |
|               | because loading into the  | because shared               |
|               | memory happens every time | library code is              |
|               | while executing.          | already in the memory.       |
+---------------+---------------------------+------------------------------+
| Compatibility | Never has a compatibility | Programs are dependent       |
|               | issue,since all code is   | on having a compatible       |
|               | in one executable module. | library.Dependent program    |
|               |                           | will not work if library     |
|               |                           | gets removed from the system |
+---------------+---------------------------+------------------------------+

Answer 4

-------------------------------------------------------------------------
|  +-  |    Shared(dynamic)       |   Static Library (Linkages)         |
-------------------------------------------------------------------------
|Pros: | less memory use          |   an executable, using own libraries|
|      |                          |     ,coming with the program,       |
|      |                          |   doesn't need to worry about its   |
|      |                          |   compilebility subject to libraries|
-------------------------------------------------------------------------
|Cons: | implementations of       |   bigger memory uses                |
|      | libraries may be altered |                                     |
|      | subject to OS  and its   |                                     |
|      | version, which may affect|                                     |
|      | the compilebility and    |                                     |
|      | runnability of the code  |                                     |
-------------------------------------------------------------------------