How do I serialize and deserialize contents with std::unordered_map in performance-sensitive code?

When working with performance-sensitive applications in C++, efficiently serializing and deserializing data structures like std::unordered_map is crucial. Below is an example demonstrating how to achieve this using a simple binary serialization method.

#include <unordered_map> #include <fstream> #include <sstream> #include <iostream> template <typename K, typename V> void serialize(const std::unordered_map<K, V> &map, const std::string &fileName) { std::ofstream ofs(fileName, std::ios::binary); if (!ofs) { throw std::runtime_error("Cannot open file for writing"); } size_t size = map.size(); ofs.write(reinterpret_cast(&size), sizeof(size)); for (const auto &pair : map) { size_t keySize = pair.first.size(); size_t valueSize = pair.second.size(); ofs.write(reinterpret_cast(&keySize), sizeof(keySize)); ofs.write(pair.first.data(), keySize); ofs.write(reinterpret_cast(&valueSize), sizeof(valueSize)); ofs.write(pair.second.data(), valueSize); } } template <typename K, typename V> std::unordered_map<K, V> deserialize(const std::string &fileName) { std::ifstream ifs(fileName, std::ios::binary); if (!ifs) { throw std::runtime_error("Cannot open file for reading"); } std::unordered_map<K, V> map; size_t size; ifs.read(reinterpret_cast(&size), sizeof(size)); for (size_t i = 0; i < size; ++i) { size_t keySize, valueSize; ifs.read(reinterpret_cast(&keySize), sizeof(keySize)); K key(keySize, '\0'); ifs.read(&key[0], keySize); ifs.read(reinterpret_cast(&valueSize), sizeof(valueSize)); V value(valueSize, '\0'); ifs.read(&value[0], valueSize); map.emplace(std::move(key), std::move(value)); } return map; }

C++ std::unordered_map serialization deserialization performance

Related Questions

How do I avoid rehashing overhead with std::set in multithreaded code?

How do I find elements with custom comparators with std::set for embedded targets?

How do I erase elements while iterating with std::set for embedded targets?

How do I provide stable iteration order with std::unordered_map for large datasets?

How do I reserve capacity ahead of time with std::unordered_map for large datasets?

How do I erase elements while iterating with std::unordered_map in multithreaded code?

How do I provide stable iteration order with std::map for embedded targets?

How do I provide stable iteration order with std::map in multithreaded code?

How do I avoid rehashing overhead with std::map in performance-sensitive code?

How do I merge two containers efficiently with std::map for embedded targets?