Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / C++

Input/output e serializzazione binaria esplicita

L’input/output trasferisce dati, mentre la serializzazione ne definisce la rappresentazione. Scopri come codificare un intero in ordine little-endian, decodificarlo in sicurezza e affiancare alla verifica di andata e ritorno un controllo con byte noti.

Versione: C++23; repository compiler flag, production runtime not attested

Sintassi

serialization: value -> specified bytes; deserialization: validated bytes -> value; round-trip validation: deserialize(serialize(value)) == value

L’input/output (I/O) trasferisce dati tra un programma e il suo ambiente. La serializzazione converte i valori in una rappresentazione concordata, mentre la deserializzazione li ricostruisce dopo aver controllato l’input. Gli stream C++ supportano lettura e scrittura; il solo trasferimento di byte non definisce un formato di dati.

Un formato dovrebbe specificare larghezza dei campi, ordine dei byte e regole di convalida. L’ordine little-endian colloca per primo il byte meno significativo: 0x1234 viene codificato come 0x34, 0x12. L’esempio codifica un intero senza segno di 16 bit in esattamente due byte da 8 bit. Shift e mascheramento rendono il formato indipendente dall’ordine dei byte della macchina; sono richiesti CHAR_BIT == 8 e la disponibilità del tipo opzionale std::uint16_t.

Scrivere la memoria grezza di un oggetto non è un formato portabile: la rappresentazione può contenere bit di riempimento e dipendere dall’implementazione, e i puntatori non memorizzano i dati a cui puntano. La possibilità di copiare i byte dei tipi trivially copyable non garantisce file compatibili tra piattaforme. Anche la modalità binaria di un file non standardizza la rappresentazione degli oggetti.

La verifica di andata e ritorno controlla deserialize(serialize(value)) == value. L’esempio confronta anche i byte con un risultato noto, perché due algoritmi errati possono compensare i rispettivi errori. Il decoder rifiuta lunghezze diverse da due prima di accedere ai dati; qui ogni sequenza di due byte è un valore valido. I formati più grandi richiedono inoltre controlli di intervalli, lunghezze e versioni, oltre alla gestione degli errori di I/O.

Il codice è pensato per essere compilato con un’opzione C++23. Il sorgente mostrato è stato eseguito senza modifiche in un ambiente isolato e l’output ha coinciso esattamente con il risultato indicato. Questa esecuzione non verifica il funzionamento in un ambiente di produzione. La fonte eel.is è una bozza di lavoro in evoluzione, non una pubblicazione C++23 congelata.

Esempi

#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;
}

Risultato

bytes: 52 18
round-trip: true
known bytes: true
invalid length rejected: true

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti