C ++ Huffman-Code-Header

Question

im Grunde, ich habe meine Huffman-Tabelle als

std::map<std::string, char> ciMap;

Wo String ist das Bitmuster und char ist der Wert, der durch das Muster dargestellt. Das Problem ist, wie dass ich speichere als ein Header meiner komprimierten Datei, so kann ich wieder die gleiche Karte bauen, wenn ich sie entschlüsseln will?

Der Versuch, es als binäres zu speichern:

size_t mapLen = ciMap.size();
outFile.write(reinterpret_cast<char*>(&mapLen), sizeof(size_t));
outFile.write(reinterpret_cast<char*>(&ciMap), sizeof(ciMap));

Und später den Aufbau mit:

inFile.read(reinterpret_cast<char*>(&mapLen), sizeof(size_t));
inFile.read(reinterpret_cast<char*>(&ciMap), sizeof(mapLen));

nicht funktioniert, ich String initilization Fehler bekommen ... etwas mit NULL zu tun. Irgendwelche Vorschläge? Wenn Sie die Bits und die Werte der Speicherung besseren Weg Ich würde gerne hören.

Answer 1

Sie können es selbst tun, oder Sie können es mit Boost tun: http://www.boost.org/doc/libs/1_37_0/libs/serialization/doc/index.html . Was Sie gerade versuchen, nur die Karte als normalen alten Datentyp anzuzeigen, die im Wesentlichen bedeutet, dass es ein C-Datentyp ist. Aber es ist nicht, so dass es nicht / Last zu speichern. Boost-Serialisierung macht es richtig. Schau es dir an. Wenn Sie es nicht verwenden möchten, können Sie etwas tun:

typedef std::map<std::string, char> my_map;
my_map ciMap;

// saving
std::ofstream stream("file.txt");
for(my_map::const_iterator it = ciMap.begin(); it != ciMap.end(); ++it) {
    stream << it->first << " " << it->second << std::endl;
}

// loading
char c;
std::string bits;
std::ifstream stream("file.txt");
while(stream >> bits >> c)
    ciMap.insert(std::make_pair(bits, c));

Beachten Sie, dass die oben einige Änderungen benötigt, wenn die gespeicherten Zeichen zu Leerzeichen sein könnte. Aus diesem Grunde, ist es wahrscheinlich die am besten, zuerst vor dem Schreiben aus, in einen int umwandeln und dann als int Lesen beim Laden. Eigentlich empfehle ich Boost-Serialisierung und Boost-iostreams ( http :. //www.boost.org/doc/libs/1_37_0/libs/iostreams/doc/index.html ), die einen Kompressionsstrom enthält, die Ihre Daten transparent komprimieren

Answer 2

Sie können nicht nur die binären Werte auf der Festplatte auf diese Weise serialisiert. Der in der Speicherdarstellung ist nicht einfach ein zusammenhängender Speicherblock, und auch wenn es wahrscheinlich Zeiger enthalten werden, die an die Adresse des Blockes relativ sind.

Sie müssen sich über die Landkarte iterieren und individuell jedes Element serialisiert werden. Dann sie in Ihnen, um wieder die Karte rekonstruieren, indem Sie die Elemente aus Scheibe einzeln zu lesen und sie in die Karte wieder einsetzen.

Answer 3

Gute Frage. Problem hier ist, dass die Standardcontainer nicht unterstützen Serialisierung -. Sie es schreiben selbst, es ist ein Schmerz, aber es ist möglich,

Hier ist, wie Sie eine std::map zu einem Textformat Serialisierung könnten. Sie können es anpassen, um zu schreiben, was auch immer Binärformat Sie benötigen. Ersetzen Sie einfach den << Operator mit reads und writes.

template<typename K, typename V>
std::ostream &operator << (std::ostream &out, const std::map<K,V> &map) {
    out << "map " << map.size() << "\n";
    for (typename std::map<K,V>::const_iterator i = map.begin(); i != map.end(); ++i) {
        out << (*i).first << "\n" << (*i).second << "\n";
    }
    return out;
}

template<typename K, typename V>
std::istream &operator >> (std::istream &in, std::map<K,V> &map) {
    std::string mapkeyword;
    size_t num;
    in >> mapkeyword >> num;
    for (size_t i = 0; i < num; ++i) {
        K key; V value;
        in >> key >> value;
        map[key] = value;
    }
    return in;
}