Perbedaan antara perpustakaan statis dan terbagi?

Apa perbedaan antara perpustakaan statis dan shared?

Saya menggunakan Eclipse dan ada beberapa jenis proyek termasuk Static Libraries dan Shared Libraries? Apakah yang satu memiliki keunggulan dibandingkan yang lain?

Pustaka bersama adalah file .so (atau Windows .dll, atau OS X .dylib). Semua kode yang berkaitan dengan perpustakaan ada di file ini, dan direferensikan oleh program yang menggunakannya saat run-time. Program yang menggunakan perpustakaan bersama hanya membuat referensi ke kode yang digunakan di perpustakaan bersama.

Perpustakaan statis adalah file .a (atau di Windows .lib). Semua kode yang berkaitan dengan perpustakaan ada di file ini, dan secara langsung ditautkan ke program pada waktu kompilasi. Program yang menggunakan perpustakaan statis mengambil salinan kode yang digunakannya dari perpustakaan statis dan menjadikannya bagian dari program. [Windows juga memiliki file .lib yang digunakan untuk referensi file .dll, tetapi mereka bertindak dengan cara yang sama seperti yang pertama].

Ada kelebihan dan kekurangan dalam setiap metode:

• Pustaka bersama mengurangi jumlah kode yang diduplikasi dalam setiap program yang memanfaatkan pustaka, menjaga biner tetap kecil. Ini juga memungkinkan Anda untuk mengganti objek bersama dengan yang secara fungsional setara, tetapi mungkin telah menambahkan manfaat kinerja tanpa perlu mengkompilasi ulang program yang memanfaatkannya. Akan tetapi, shared library akan memiliki biaya tambahan yang kecil untuk pelaksanaan fungsi serta biaya pemuatan run-time karena semua simbol di perpustakaan perlu dihubungkan ke hal-hal yang mereka gunakan. Selain itu, pustaka bersama dapat dimuat ke dalam aplikasi saat run-time, yang merupakan mekanisme umum untuk menerapkan sistem plug-in biner.

• Perpustakaan statis meningkatkan ukuran keseluruhan biner, tetapi itu berarti bahwa Anda tidak perlu membawa serta salinan perpustakaan yang sedang digunakan. Karena kode terhubung pada waktu kompilasi, tidak ada biaya pemuatan run-time tambahan. Kode itu ada di sana.

Secara pribadi, saya lebih suka pustaka bersama, tetapi menggunakan pustaka statis ketika perlu memastikan bahwa biner tidak memiliki banyak dependensi eksternal yang mungkin sulit dipenuhi, seperti versi spesifik dari pustaka standar C ++ atau versi spesifik dari pustaka Boost C ++.

Perpustakaan statis seperti toko buku, dan perpustakaan bersama seperti ... perpustakaan. Dengan yang pertama, Anda mendapatkan salinan buku / fungsi Anda sendiri untuk dibawa pulang; dengan yang terakhir Anda dan semua orang pergi ke perpustakaan untuk menggunakan buku / fungsi yang sama. Jadi siapa pun yang ingin menggunakan pustaka (dibagi) perlu tahu di mana itu, karena Anda harus "pergi mendapatkan" buku / fungsi. Dengan perpustakaan statis, buku / fungsi itu milik Anda, dan Anda menyimpannya di rumah / program Anda, dan begitu Anda memilikinya, Anda tidak peduli di mana atau kapan Anda mendapatkannya.

Sederhana:

• Menghubungkan statis: satu executable besar
• Tautan dinamis: eksekusi kecil ditambah satu atau lebih file perpustakaan (file .dll pada Windows, .so di Linux, atau .dib pada macOS)

Untuk pustaka statis, kode diekstraksi dari pustaka oleh linker dan digunakan untuk membangun yang dapat dieksekusi pada saat Anda mengkompilasi / membangun aplikasi Anda. Eksekusi akhir tidak memiliki dependensi pada perpustakaan pada saat run time

Untuk pustaka bersama, kompiler / penghubung memeriksa apakah nama yang Anda tautkan ada di pustaka saat aplikasi dibuat, tetapi tidak memindahkan kode mereka ke dalam aplikasi. Pada waktu berjalan, perpustakaan bersama harus tersedia.

Bahasa pemrograman C sendiri tidak memiliki konsep perpustakaan statis atau bersama - mereka sepenuhnya merupakan fitur implementasi.

Secara pribadi, saya lebih suka menggunakan perpustakaan statis, karena membuat distribusi perangkat lunak lebih mudah. Namun, ini adalah pendapat di mana banyak darah (kiasan) telah ditumpahkan di masa lalu.

Perpustakaan statis dikompilasi sebagai bagian dari aplikasi, sedangkan perpustakaan bersama tidak. Saat Anda mendistribusikan aplikasi yang bergantung pada perpustakaan yang dibagikan, perpustakaan, mis. dll pada MS Windows perlu diinstal.

Keuntungan dari pustaka statis adalah bahwa tidak ada dependensi yang diperlukan untuk pengguna yang menjalankan aplikasi - misalnya mereka tidak perlu meng-upgrade DLL mereka apa pun. Kerugiannya adalah aplikasi Anda berukuran lebih besar karena Anda mengirimkannya dengan semua perpustakaan yang dibutuhkan.

Selain mengarah ke aplikasi yang lebih kecil, pustaka bersama menawarkan pengguna kemampuan untuk menggunakan pustaka mereka sendiri, mungkin versi yang lebih baik daripada mengandalkan salah satu yang merupakan bagian dari aplikasi

Keuntungan paling signifikan dari shared library adalah hanya ada satu salinan kode yang dimuat dalam memori, tidak peduli berapa banyak proses yang menggunakan perpustakaan. Untuk pustaka statis, setiap proses mendapatkan salinan kodenya sendiri. Ini dapat menyebabkan pemborosan memori yang signifikan.

OTOH, keuntungan dari perpustakaan statis adalah bahwa semuanya dibundel ke dalam aplikasi Anda. Jadi Anda tidak perlu khawatir bahwa klien akan memiliki perpustakaan yang tepat (dan versi) yang tersedia di sistem mereka.

Di atas semua jawaban lain, satu hal yang belum disebutkan adalah decoupling:

Biarkan saya berbicara tentang kode produksi dunia nyata, yang telah saya tangani:

Perangkat lunak yang sangat besar, terbuat dari> 300 proyek (dengan studio visual), sebagian besar dibangun sebagai lib statis dan akhirnya semua terhubung bersama dalam satu executable besar, Anda berakhir dengan masalah berikut:

Waktu -Link sangat panjang. Anda mungkin berakhir dengan lebih dari 15 menit tautan, karena katakanlah 10 detik waktu kompilasi - Beberapa alat bertekuk lutut dengan alat eksekusi yang besar, seperti alat periksa memori yang harus memasukkan kode. Anda mungkin jatuh ke dalam batas yang telah dianggap bodoh.

Yang lebih bermasalah adalah decoupling dari perangkat lunak Anda: pada contoh dunia nyata ini, file header dari setiap proyek dapat dijangkau dari proyek lain mana pun. Sebagai akibatnya, sangat mudah bagi satu pengembang untuk menambahkan dependensi; itu hanya tentang memasukkan tajuk, karena tautan pada akhirnya akan memunculkan simbol. Itu berakhir dengan ketergantungan bersepeda yang mengerikan dan kekacauan total.

Dengan shared library, ini merupakan pekerjaan ekstra karena pengembang harus mengedit sistem build proyek untuk menambahkan library dependen. Saya mengamati bahwa kode pustaka bersama cenderung menawarkan API kode yang lebih bersih.

-------------------------------------------------------------------------
|  +-  |    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  |                                     |
-------------------------------------------------------------------------