CKTIS / C++
Invoer/uitvoer en expliciete binaire serialisatie
Invoer en uitvoer verplaatsen gegevens, terwijl serialisatie de representatie ervan vastlegt. Leer hoe je een geheel getal in little-endian-volgorde codeert, veilig decodeert en de round-trip-validatie aanvult met een controle op bekende bytes.
Versie: C++23; repository compiler flag, production runtime not attested
Syntax
serialization: value -> specified bytes; deserialization: validated bytes -> value; round-trip validation: deserialize(serialize(value)) == valueInvoer/uitvoer (I/O) verplaatst gegevens tussen een programma en zijn omgeving. Serialisatie zet waarden om in een afgesproken representatie; deserialisatie reconstrueert ze nadat de invoer is gecontroleerd. C++-streams ondersteunen lezen en schrijven; alleen bytes verplaatsen definieert geen gegevensformaat.
Een formaat hoort veldbreedtes, bytevolgorde en validatieregels vast te leggen. Little-endian-volgorde plaatst de minst significante byte eerst: 0x1234 wordt gecodeerd als 0x34, 0x12. Het voorbeeld codeert één unsigned 16-bits geheel getal in precies twee 8-bits bytes. Shifts en maskering maken het formaat onafhankelijk van de bytevolgorde van de machine; vereist zijn CHAR_BIT == 8 en de beschikbaarheid van het optionele type std::uint16_t.
Het dumpen van het ruwe geheugen van een object is geen portable formaat: de representatie kan opvulbits bevatten en van de implementatie afhangen, en pointers slaan de gegevens waarnaar ze verwijzen niet op. Dat bytes van trivially copyable-typen gekopieerd mogen worden, garandeert geen compatibele bestanden op verschillende platforms. De binaire bestandsmodus standaardiseert de objectrepresentatie evenmin.
Round-trip-validatie controleert deserialize(serialize(value)) == value. Het voorbeeld vergelijkt de bytes ook met een bekende uitkomst, omdat twee onjuiste algoritmen elkaars fouten kunnen opheffen. De decoder wijst lengtes anders dan twee af voordat hij de gegevens benadert; hier is elke reeks van twee bytes een geldige waarde. Grotere formaten vereisen ook controles op bereiken, lengtes en versies, plus foutafhandeling voor I/O.
De code is bedoeld om met een C++23-optie te worden gecompileerd. De getoonde broncode is ongewijzigd uitgevoerd in een geïsoleerde omgeving en de uitvoer kwam exact overeen met het opgegeven resultaat. Daarmee is de werking in een productieomgeving niet geverifieerd. De bron eel.is is een evoluerend werkdocument, geen bevroren C++23-publicatie.
Voorbeelden
#include <array>
#include <climits>
#include <cstdint>
#include <iostream>
#include <optional>
#include <span>
static_assert(CHAR_BIT == 8);
std::array<unsigned char, 2> serialize(std::uint16_t value) {
return {static_cast<unsigned char>(value & 0xffu),
static_cast<unsigned char>(value >> 8)};
}
std::optional<std::uint16_t> deserialize(
std::span<const unsigned char> bytes) {
if (bytes.size() != 2) return std::nullopt;
return static_cast<std::uint16_t>(
static_cast<unsigned int>(bytes[0]) |
(static_cast<unsigned int>(bytes[1]) << 8));
}
int main() {
const std::uint16_t original = 0x1234;
const auto bytes = serialize(original);
const auto restored = deserialize(bytes);
const bool round_trip = restored && *restored == original;
const bool known_bytes = bytes[0] == 0x34 && bytes[1] == 0x12;
const bool rejected = !deserialize(
std::span<const unsigned char>{bytes.data(), 1});
std::cout << "bytes: " << static_cast<unsigned int>(bytes[0])
<< ' ' << static_cast<unsigned int>(bytes[1]) << '\n'
<< std::boolalpha
<< "round-trip: " << round_trip << '\n'
<< "known bytes: " << known_bytes << '\n'
<< "invalid length rejected: " << rejected << '\n';
return round_trip && known_bytes && rejected ? 0 : 1;
}
Resultaat
bytes: 52 18 round-trip: true known bytes: true invalid length rejected: true
De getoonde code en het opgegeven resultaat zijn in een geïsoleerde omgeving geverifieerd met de methode die in het verificatiebewijs voor exact deze versie is vastgelegd.