Comment utiliser C++ pour une compression et un stockage de données efficaces ?-C++-php.cn

Comment utiliser C++ pour une compression et un stockage de données efficaces ?

Comment utiliser le C++ pour une compression et un stockage de données efficaces ?

Introduction :
À mesure que la quantité de données augmente, la compression et le stockage des données deviennent de plus en plus importants. Il existe de nombreuses façons d’obtenir une compression et un stockage efficaces des données en C++. Cet article présentera certains algorithmes de compression de données et technologies de stockage de données courants en C++, et fournira des exemples de code correspondants.

1. Algorithme de compression de données

1.1 Algorithme de compression basé sur le codage de Huffman
Le codage de Huffman est un algorithme de compression de données basé sur un codage de longueur variable. Il compresse les données en attribuant des codes plus courts aux caractères (ou blocs de données) avec une fréquence plus élevée et des codes plus longs aux caractères (ou blocs de données) avec une fréquence plus faible. Voici un exemple de code pour implémenter le codage Huffman en utilisant C++ :

#include  #include  #include  #include  struct TreeNode { char data; int freq; TreeNode* left; TreeNode* right; TreeNode(char data, int freq) : data(data), freq(freq), left(nullptr), right(nullptr) {} }; struct compare { bool operator()(TreeNode* a, TreeNode* b) { return a->freq > b->freq; } }; void generateCodes(TreeNode* root, std::string code, std::unordered_map& codes) { if (root->left == nullptr && root->right == nullptr) { codes[root->data] = code; return; } generateCodes(root->left, code + "0", codes); generateCodes(root->right, code + "1", codes); } void huffmanCompression(std::string input) { std::unordered_map freqMap; for (char c : input) { freqMap[c]++; } std::priority_queue, compare> minHeap; for (auto& entry : freqMap) { minHeap.push(new TreeNode(entry.first, entry.second)); } while (minHeap.size() > 1) { TreeNode* left = minHeap.top(); minHeap.pop(); TreeNode* right = minHeap.top(); minHeap.pop(); TreeNode* parent = new TreeNode('', left->freq + right->freq); parent->left = left; parent->right = right; minHeap.push(parent); } TreeNode* root = minHeap.top(); std::unordered_map codes; generateCodes(root, "", codes); std::string compressed; for (char c : input) { compressed += codes[c]; } std::cout << "Compressed: " << compressed << std::endl; std::cout << "Uncompressed: " << input << std::endl; std::cout << "Compression ratio: " << (double)compressed.size() / input.size() << std::endl; // 清理内存 delete root; } int main() { std::string input = "abracadabra"; huffmanCompression(input); return 0; }

Copier après la connexion

1.2 Algorithme de Lempel-Ziv-Welch (LZW)
L'algorithme LZW est un algorithme de compression de données sans perte couramment utilisé dans le format d'image GIF. Il utilise un dictionnaire pour stocker les chaînes existantes et réduit la longueur de la chaîne compressée en développant continuellement le dictionnaire. Voici un exemple de code pour implémenter l'algorithme LZW en utilisant C++ :

#include  #include  #include  void lzwCompression(std::string input) { std::unordered_map dictionary; for (int i = 0; i < 256; i++) { dictionary[std::string(1, i)] = i; } std::string output; std::string current; for (char c : input) { std::string temp = current + c; if (dictionary.find(temp) != dictionary.end()) { current = temp; } else { output += std::to_string(dictionary[current]) + " "; dictionary[temp] = dictionary.size(); current = std::string(1, c); } } if (!current.empty()) { output += std::to_string(dictionary[current]) + " "; } std::cout << "Compressed: " << output << std::endl; std::cout << "Uncompressed: " << input << std::endl; std::cout << "Compression ratio: " << (double)output.size() / input.size() << std::endl; } int main() { std::string input = "abracadabra"; lzwCompression(input); return 0; }

Copier après la connexion

2. Technologie de stockage de données

2.1 Stockage de fichiers binaires
Le stockage de fichiers binaires est une méthode d'écriture de données dans un fichier sous forme binaire. Par rapport au stockage de fichiers texte, le stockage de fichiers binaires peut économiser de l'espace de stockage et lire et écrire plus rapidement. Voici un exemple de code pour le stockage de fichiers binaires en utilisant C++ :

#include  #include  struct Data { int i; double d; char c; }; void binaryFileStorage(Data data) { std::ofstream outfile("data.bin", std::ios::binary); outfile.write(reinterpret_cast(&data), sizeof(data)); outfile.close(); std::ifstream infile("data.bin", std::ios::binary); Data readData; infile.read(reinterpret_cast(&readData), sizeof(readData)); infile.close(); std::cout << "Original: " << data.i << ", " << data.d << ", " << data.c << std::endl; std::cout << "Read from file: " << readData.i << ", " << readData.d << ", " << readData.c << std::endl; } int main() { Data data {42, 3.14, 'A'}; binaryFileStorage(data); return 0; }

Copier après la connexion

2.2 Stockage de fichiers compressés
Le stockage de fichiers compressés est une méthode d'écriture de données dans un fichier dans un format compressé. Le stockage de fichiers compressés peut économiser de l'espace de stockage, mais la vitesse de lecture et d'écriture est plus lente. Voici un exemple de code pour le stockage de fichiers compressés à l'aide de C++ :

#include  #include  #include  #include  #include  void compressFileStorage(std::string input) { std::ostringstream compressedStream; z_stream defStream; defStream.zalloc = Z_NULL; defStream.zfree = Z_NULL; defStream.opaque = Z_NULL; defStream.avail_in = input.size(); defStream.next_in = (Bytef*)input.c_str(); defStream.avail_out = input.size() + (input.size() / 100) + 12; defStream.next_out = (Bytef*)compressedStream.str().c_str(); deflateInit(&defStream, Z_DEFAULT_COMPRESSION); deflate(&defStream, Z_FINISH); deflateEnd(&defStream); std::string compressed = compressedStream.str(); std::ofstream outfile("compressed.txt", std::ios::binary); outfile.write(compressed.c_str(), compressed.size()); outfile.close(); std::ifstream infile("compressed.txt", std::ios::binary); std::ostringstream decompressedStream; z_stream infStream; infStream.zalloc = Z_NULL; infStream.zfree = Z_NULL; infStream.opaque = Z_NULL; infStream.avail_in = compressed.size(); infStream.next_in = (Bytef*)compressed.c_str(); infStream.avail_out = compressed.size() * 10; infStream.next_out = (Bytef*)decompressedStream.str().c_str(); inflateInit(&infStream); inflate(&infStream, Z_NO_FLUSH); inflateEnd(&infStream); std::string decompressed = decompressedStream.str(); std::cout << "Original: " << input << std::endl; std::cout << "Compressed: " << compressed << std::endl; std::cout << "Decompressed: " << decompressed << std::endl; } int main() { std::string input = "abracadabra"; compressFileStorage(input); return 0; }

Copier après la connexion

Conclusion :
Cet article présente plusieurs algorithmes de compression de données et technologies de stockage de données courants en C++, et fournit des exemples de code correspondants. Une compression et un stockage efficaces des données peuvent être obtenus en sélectionnant des algorithmes de compression de données et des technologies de stockage appropriés. Dans les applications pratiques, la méthode la plus appropriée peut être sélectionnée en fonction des caractéristiques et des besoins des données.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!