bit7z
v4.0.8
Unterstützte Funktionen • Erste Schritte • Download • Anforderungen • Erstellen und Verwenden • Spenden • Lizenz
Bit7z ist eine plattformübergreifende C ++-statische Bibliothek, mit der die Komprimierung/Extraktion von Archivdateien über eine saubere und einfache Wrapper-Schnittstelle zu den dynamischen Bibliotheken aus dem 7-Zip-Projekt über eine einfache und einfache Wrapper-Schnittstelle ermöglicht wird.
Es unterstützt die Komprimierung und Extraktion zum und vom Dateisystem oder im Speicher, das Lesen von Archivmetadaten, das Aktualisieren vorhandener Archive, die Rückruf von Betriebsfortschritten und viele andere Funktionen.
Das Vorhandensein einiger der oben genannten Merkmale hängt von der jeweiligen gemeinsamen Bibliothek zusammen, die zusammen mit Bit7z verwendet wird.
Beispielsweise sollte 7z.dll alle diese Funktionen unterstützen, 7za.dll sollte nur mit dem 7Z -Dateiformat arbeiten, und 7Zxa.dll kann nur 7Z -Dateien extrahieren. Weitere Informationen zu den 7-Zip-DLLs finden Sie auf dieser Wiki-Seite.
Am Ende werden einige andere Funktionen (z. B. die automatische Formaterkennung und die selektive Extraktion unter Verwendung regelmäßiger Ausdrücke ) standardmäßig deaktiviert, und während der Kompilierung müssen Makrodefinitionen verwendet werden, um sie zur Verfügung zu stellen (WIKI).
Im Folgenden finden Sie einige Beispiele, die zeigen, wie einige der Hauptfunktionen von Bit7Z verwendet werden.
# include < bit7z/bitfileextractor.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
Bit7zLibrary lib{ " 7za.dll " };
BitFileExtractor extractor{ lib, BitFormat::SevenZip };
// Extracting a simple archive
extractor. extract ( " path/to/archive.7z " , " out/dir/ " );
// Extracting a specific file inside an archive
extractor. extractMatching ( " path/to/archive.7z " , " file.pdf " , " out/dir/ " );
// Extracting the first file of an archive to a buffer
std::vector< byte_t > buffer;
extractor. extract ( " path/to/archive.7z " , buffer );
// Extracting an encrypted archive
extractor. setPassword ( " password " );
extractor. extract ( " path/to/another/archive.7z " , " out/dir/ " );
} catch ( const bit7z::BitException& ex ) { /* Do something with ex.what()... */ }Alternativ, wenn Sie nur an einem einzigen Archiv arbeiten müssen:
# include < bit7z/bitarchivereader.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
Bit7zLibrary lib{ " 7z.dll " };
// Opening the archive
BitArchiveReader archive{ lib, " path/to/archive.gz " , BitFormat::GZip };
// Testing the archive
archive. test ();
// Extracting the archive
archive. extractTo ( " out/dir/ " );
} catch ( const bit7z::BitException& ex ) { /* Do something with ex.what()... */ }# include < bit7z/bitfilecompressor.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
Bit7zLibrary lib{ " 7z.dll " };
BitFileCompressor compressor{ lib, BitFormat::Zip };
std::vector< std::string > files = { " path/to/file1.jpg " , " path/to/file2.pdf " };
// Creating a simple zip archive
compressor. compress ( files, " output_archive.zip " );
// Creating a zip archive with a custom directory structure
std::map< std::string, std::string > files_map = {
{ " path/to/file1.jpg " , " alias/path/file1.jpg " },
{ " path/to/file2.pdf " , " alias/path/file2.pdf " }
};
compressor. compress ( files_map, " output_archive2.zip " );
// Compressing a directory
compressor. compressDirectory ( " dir/path/ " , " dir_archive.zip " );
// Creating an encrypted zip archive of two files
compressor. setPassword ( " password " );
compressor. compressFiles ( files, " protected_archive.zip " );
// Updating an existing zip archive
compressor. setUpdateMode ( UpdateMode::Append );
compressor. compressFiles ( files, " existing_archive.zip " );
// Compressing a single file into a buffer
std::vector< bit7z:: byte_t > buffer;
BitFileCompressor compressor2{ lib, BitFormat::BZip2 };
compressor2. compressFile ( files[ 0 ], buffer );
} catch ( const bit7z::BitException& ex ) { /* Do something with ex.what()... */ }Alternativ, wenn Sie nur an einem einzigen Archiv arbeiten müssen:
# include < bit7z/bitarchivewriter.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
Bit7zLibrary lib{ " 7z.dll " };
BitArchiveWriter archive{ lib, BitFormat::SevenZip };
// Adding the items to be compressed (no compression is performed here)
archive. addFile ( " path/to/file.txt " );
archive. addDirectory ( " path/to/dir/ " );
// Compressing the added items to the output archive
archive. compressTo ( " output.7z " );
} catch ( const bit7z::BitException& ex ) { /* Do something with ex.what()... */ }# include < bit7z/bitarchivereader.hpp >
try { // bit7z classes can throw BitException objects
using namespace bit7z ;
Bit7zLibrary lib{ " 7za.dll " };
BitArchiveReader arc{ lib, " archive.7z " , BitFormat::SevenZip };
// Printing archive metadata
std::cout << " Archive properties n " ;
std::cout << " Items count: " << arc. itemsCount () << ' n ' ;
std::cout << " Folders count: " << arc. foldersCount () << ' n ' ;
std::cout << " Files count: " << arc. filesCount () << ' n ' ;
std::cout << " Size: " << arc. size () << ' n ' ;
std::cout << " Packed size: " << arc. packSize () << " nn " ;
// Printing the metadata of the archived items
std::cout << " Archived items " ;
for ( const auto & item : arc ) {
std::cout << ' n ' ;
std::cout << " Item index: " << item. index () << ' n ' ;
std::cout << " Name: " << item. name () << ' n ' ;
std::cout << " Extension: " << item. extension () << ' n ' ;
std::cout << " Path: " << item. path () << ' n ' ;
std::cout << " IsDir: " << item. isDir () << ' n ' ;
std::cout << " Size: " << item. size () << ' n ' ;
std::cout << " Packed size: " << item. packSize () << ' n ' ;
std::cout << " CRC: " << std::hex << item. crc () << std::dec << ' n ' ;
}
std::cout. flush ();
} catch ( const bit7z::BitException& ex ) { /* Do something with ex.what()... */ }Eine vollständige API -Referenz ist im Abschnitt Wiki verfügbar.
Der neueste Bit7Z V4 führte einige signifikante Veränderungen der API der Bibliothek vor.
std::string (anstelle von std::wstring ), sodass Benutzer die Bibliothek in plattformübergreifenden Projekten einfacher verwenden können (V4 führte auch die Unterstützung von Linux/MacOS).std::string S wird als UTF-8-codiert angesehen.-DBIT7Z_USE_NATIVE_STRING noch erreichen.BitExtractor -Klasse heißt jetzt BitFileExtractor .BitExtractor nur der Name einer Vorlagenklasse für alle Extraktionsklassen.BitCompressor -Klasse heißt jetzt BitFileCompressor .BitCompressor nur der Name einer Vorlagenklasse für alle Komprimierungsklassen.ProgressCallback muss nun einen bool -Wert zurückgeben, der angibt, ob der aktuelle Vorgang fortgesetzt werden kann ( true ) oder nicht ( false ).include/ in die include/bit7z/ Ordner verschoben. Daher müssen #include -Anweisungen bit7z/ auf den mitgelieferten Header -Namen vorbereiten ( #include <bit7z/bitfileextractor.hpp> .lib/<architecture>/ ; Wenn der CMake-Generator Multi-Config (z. B. Visual Studio-Generatoren) ist, ist der Standardausgangsordner lib/<architecture>/<build type>/ .BIT7Z_VS_LIBNAME_OUTDIR_STYLE -CMAKE aktivieren.Jedes veröffentlichte Paket enthält:
Pakete sind sowohl für X86- als auch für X64 -Architekturen erhältlich.
Sie können dieses Repository auch klonen/herunterladen und die Bibliothek selbst erstellen (bitte lesen Sie das Wiki).
.dll Bibliothek unter Windows, eine 7-Zip/P7zip .so Bibliothek auf Unix 3 . Zum Aufbau der Bibliothek:
cd < bit7z folder >
mkdir build && cd build
cmake ../ -DCMAKE_BUILD_TYPE=Release
cmake --build . -j --config ReleaseEine detailliertere Anleitung zum Bau dieser Bibliothek finden Sie hier.
Sie können die Bibliothek auch direkt über CMAKE in Ihr Projekt integrieren:
third_party ) oder fügen Sie es als Git-Submodul Ihres Repositorys hinzu.add_subdirectory() in Ihren CMakeLists.txt , um Bit7z zu enthalten.bit7z -Bibliothek mit dem Befehl target_link_libraries() .Zum Beispiel:
add_subdirectory ( ${CMAKE_SOURCE_DIR} /third_party/bit7z )
target_link_libraries ( ${YOUR_TARGET} PRIVATE bit7z )Die Bibliothek ist sehr anpassbar: Eine detaillierte Liste der verfügbaren Build -Optionen finden Sie im Wiki.
Während der Konfiguration von Bit7Z über CMAKE wird automatisch die neueste Version von 7-Zip heruntergeladen, die von der Bibliothek unterstützt wird.
Optional können Sie über die CMAKE -Option BIT7Z_7ZIP_VERSION eine andere Version von 7 -ZIP angeben (z. B. -DBIT7Z_7ZIP_VERSION="22.01" ).
Alternativ können Sie einen benutzerdefinierten Pfad angeben, der den 7-Zip-Quellcode über den Option BIT7Z_CUSTOM_7ZIP_PATH enthält.
Bitte beachten Sie, dass es im Allgemeinen am besten ist, dieselbe Version von 7-Zip der gemeinsam genutzten Bibliotheken zu verwenden, die Sie zur Laufzeit verwenden werden.
Standardmäßig ist Bit7Z mit dem 7z.so von 7-ZIP V23.01 und später kompatibel.
Wenn Sie vorhaben, die 7z.so von P7zip oder 7-ZIP V22.01 und früher zu verwenden, haben Sie zwei Möglichkeiten, Bit7Z kompatibel zu machen:
-DBIT7Z_USE_LEGACY_IUNKNOWN=ON ; oder-DBIT7Z_7ZIP_VERSION="22.01" ).Unter Linux und MacOS führte 7-ZIP-V23.01 Bruchänderungen an der IunkNown-Schnittstelle ein. Wenn Sie Bit7Z für eine solche Version von 7-Zip (Standard) erstellen, unterstützt dies nicht die Verwendung der gemeinsam genutzten Bibliotheken aus früheren Versionen von 7-Zip (oder von P7zip). Umgekehrt hat Bit7z für frühere Versionen von 7-Zip oder für P7zip mit den gemeinsam genutzten Bibliotheken aus 7-ZIP V23.01 und später unvereinbar.
Sie können die gemeinsam genutzten Bibliotheken von 7-ZIP V23.01 in einem rückwärtskompatiblen Modus erstellen, indem Sie das Makro Z7_USE_VIRTUAL_DESTRUCTOR_IN_IUNKNOWN definieren. Wenn dies Ihr Fall ist, müssen Sie das BIT7Z_USE_LEGACY_IUNKNOWN aktivieren, damit Bit7z funktioniert
Standardmäßig folgt Bit7z dem UTF-8 Everywhere Manifesto, um die Verwendung der Bibliothek innerhalb plattformübergreifender Projekte zu vereinfachen. Kurz gesagt, das bedeutet, dass:
std::string .std::string s werden als UTF-8-codiert angesehen. Ausgabe std::string S sind UTF-8 codiert. Bei POSIX-Systemen sind std::string s normalerweise bereits UTF-8 codiert, und es ist keine Konfiguration erforderlich.
Die Situation ist unter Windows etwas komplexer, da Windows standardmäßig std::string S als codiert mit der Systemcodeseite behandelt, die möglicherweise nicht unbedingt UTF-8 ist, wie zum Beispiel Windows-1252.
Wenn sich Ihr Programm ausschließlich mit ASCIII-Saiten befasst, sollten Sie mit den Standardeinstellungen BIT7Z in Ordnung sein (da ASCII-Zeichen auch UTF-8 sind).
Wenn Sie jedoch die folgenden Optionen haben:
Durchsetzung der UTF-8-Codeseite für Ihre gesamte Anwendung, wie von Microsoft hier erläutert:
Manuell sicherstellen, dass die Kodierung der std::string s an Bit7Z übergeben wird:
ReadConsoleW ) und konvertieren Sie sie in UTF-8 (Bit7z bietet dafür eine Dienstprogrammfunktion, bit7z::to_tstring ).SetConsoleOutputCP(CP_UTF8) aufrufen. Konfigurieren von Bit7Z für die Verwendung von UTF-16-Codierten breite Zeichenfolgen (dh std::wstring ), indem die Option BIT7Z_USE_NATIVE_STRING über CMAKE aktiviert wird.
Wenn Ihr Programm nur Windows ist oder Sie bereits breite Zeichenfolgen unter Windows verwenden, ist dies möglicherweise die beste Wahl, da es in internen String-Conversions vermieden wird (7-Zip verwendet immer breite Zeichenfolgen).
Diese Option macht die Entwicklung von plattformübergreifenden Anwendungen etwas unpraktisch, da Sie immer noch std::string auf POSIX-Systemen verwenden müssen.
Die Bibliothek bietet einen Typ alias bit7z::tstring und eine makrofunktion BIT7Z_STRING zum Definieren von Variablen und Literaturen von weiten Zeichenfolgen auf Fenstern und schmalen auf anderen Plattformen.
Sie müssen die Standardeingangs- und Ausgabe-Codierung programmgesteuert auf UTF-16 einstellen, um Unicode-Zeichen korrekt zu lesen und zu drucken:
# include < fcntl.h > // for _O_U16TEXT
# include < io.h > // for _setmode
_setmode (_fileno(stdout), _O_U16TEXT); // setting the stdout encoding to UTF16
_setmode (_fileno(stdin), _O_U16TEXT); // setting the stdin encoding to UTF16 Konfigurieren von Bit7Z So verwenden Sie die Systemcode -Seite Codierung für std::string , indem Sie die Option BIT7Z_USE_SYSTEM_CODEPAGE über CMAKE aktivieren.
Wenn Sie dieses Projekt hilfreich empfanden, sollten Sie mich mit einer kleinen Spende unterstützen, damit ich es weiter verbessern kann! Danke schön!
Dieses Projekt ist gemäß den Bestimmungen der Mozilla Public Lizenz v2.0 lizenziert.
Weitere Informationen finden Sie unter:
Ältere Versionen (v3.x und früher) von Bit7Z wurden unter der GNU General Public Lizenz V2 veröffentlicht.
Unter Windows sollten Sie Ihr Programm auch mit OleAUT32 (z. B. -lbit7z -loleaut32 ) verknüpfen.
Unter Linux und MacOS sollten Sie Ihr Programm auch mit DL (z. B. -lbit7z -ldl ) verknüpfen.
Wenn Sie die Bibliothek über CMake verwenden, werden diese Abhängigkeiten automatisch mit Ihrem Projekt verknüpft. ↩
MSVC 2010 wurde bis v2.x, MSVC 2012/2013 bis v3.x. unterstützt. ↩
Bit7z versendet nicht mit den 7-Zip-Shared-Bibliotheken. Sie können sie aus dem Quellcode erstellen, der unter 7-Zip.org verfügbar ist. ↩
