Kram ► Codeschnipsel ► Daten Packen (C++)

Sie betrachten eine ältere Version der ionflux.org website! Bitte besuchen Sie die neue Version hier.

Daten Packen (C++)

Um Daten in eine Datei zu schreiben oder sie über ein Netzwerk zu übertragen kann es nötig sein, sie aus ihrer natürlichen Repräsentation im Speicher in eine Bytesequenz zu packen. Glücklicherweise ist es nicht nötig, eine Funktion für jeden Typ gesondert zu schreiben, dank C++ Templates. Die folgenden Codeschnipsel illustrieren, wie man Daten in eine Zeichenkette packen und aus einer Zeichenkette auspacken kann ohne spezielle Funktionen dafür schreiben zu müssen.

Die einzige Anforderung, damit dies funktionieren kann, ist, dass die Länge der Daten mittels des sizeof() Operators ermittelt werden kann. Aber selbst wenn dies nicht möglich ist, ist es einfach, eine spezialisierte Überladung der Funktion zu erstellen, die das Funktions-Template benutzt um die eigentliche Arbeit zu erledigen. Unten finden Sie ein Beispiel, das Standard C++ Zeichenketten packt, so dass sie später aus der Bytesequenz wiederhergestellt werden können.

Daten Packen

Das folgende Funktionstemplate packt Daten in eine Zeichenkette. Dies funktioniert für alle Datentypen, deren Größe mittels des sizeof() Operators ermittelt werden kann. Ein Parameter steht zur Verfügung, mit dem festgelegt werden kann, ob die Daten an den Zielpuffer angehängt werden sollen, oder ob sie dessen Inhalt einfach ersetzen sollen.

#include <string> template<class T> void pack(const T& source, std::string& target, bool append = true) { static const unsigned int dataSize = sizeof(T); std::string buffer; buffer.assign(dataSize, '0'); const unsigned char* rawData = reinterpret_cast<const unsigned char*>(&source); for (unsigned int i = 0; i < dataSize; i++) buffer[i] = rawData[dataSize - i - 1]; if (append) target.append(buffer); else target = buffer; }

Daten Auspacken

Der folgende Code kann verwendet werden, um Daten aus einer Zeichenkette auszupacken, die zuvor mittels pack() erstellt wurde. Ein Parameter steht zur Verfügung, mit dem ein Offset angegeben werden kann, an dem das Auspacken beginnen soll. Dies ist nützlich, wenn mehrere Datensätze

#include <string> template<class T> int unpack(const std::string& source, T& target, int offset = 0) { static const unsigned int dataSize = sizeof(T); if ((offset + dataSize) > source.size()) return -1; unsigned char* rawData = reinterpret_cast<unsigned char*>(&target); for (unsigned int i = 0; i < dataSize; i++) rawData[dataSize - i - 1] = source[i + offset]; return offset + dataSize; }

Zeichenkette Packen

Dieser Quellcode verwendet das pack() Funktionstemplate um die Länge einer Zeichenkette und die Zeichenkette selbst in einen Puffer zu packen. Diese Daten können dann verwendet werden, um die Zeichenkette ohne zusätzliche Informationen wiederherzustellen. Es ist ein Beispiel dafür, wie man das oben definierte Funktionstemplate verwenden kann, um spezialisierte Packfunktionen für beliebige Datentypen zu implementieren.

#include <string> void pack(const std::string& source, std::string& target, bool append = true) { std::string buffer; pack(static_cast<unsigned int>(source.size()), buffer, false); buffer.append(source); if (append) target.append(buffer); else target = buffer; }

Zeichenkette Auspacken

Dies ist die Funktion um Zeichenketten aus einer Bytesequenz auszupacken. Es basiert auf dem unpack() Funktionstemplate, das weiter oben definiert wurde, um die Länge der Zeichenkette zu ermitteln, bevor die eigentlichen Daten aus dem Quellpuffer ausgepackt werden.

#include <string> int unpack(const std::string& source, std::string& target, int offset = 0) { unsigned int dataSize = 0; offset = unpack(source, dataSize, offset); if ((offset == -1) || ((offset + dataSize) > source.size())) return -1; target = source.substr(offset, dataSize); offset += dataSize; return offset; }