Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Entrées/sorties et sérialisation binaire explicite

Les entrées/sorties transfèrent des données, tandis que la sérialisation en définit la représentation. Apprenez à encoder un entier en ordre little-endian, à le décoder sans risque et à compléter la validation aller-retour par une comparaison avec des octets connus.

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

Syntaxe

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

Les entrées/sorties (I/O) transfèrent des données entre un programme et son environnement. La sérialisation convertit des valeurs en une représentation convenue, tandis que la désérialisation les reconstruit après avoir vérifié l’entrée. Les flux C++ permettent la lecture et l’écriture ; le transfert d’octets à lui seul ne définit pas de format de données.

Un format devrait préciser la largeur des champs, l’ordre des octets et les règles de validation. L’ordre little-endian place l’octet de poids faible en premier : 0x1234 est encodé sous la forme 0x34, 0x12. L’exemple encode un entier non signé de 16 bits dans exactement deux octets de 8 bits. Les décalages et le masquage rendent le format indépendant de l’ordre des octets de la machine ; il nécessite CHAR_BIT == 8 et la disponibilité du type facultatif std::uint16_t.

Écrire la mémoire brute d’un objet n’est pas un format portable : sa représentation peut contenir des bits de remplissage et dépendre de l’implémentation, et les pointeurs ne stockent pas les données vers lesquelles ils pointent. La possibilité de copier les octets de types trivially copyable ne garantit pas la compatibilité des fichiers entre plateformes. Le mode binaire d’un fichier ne normalise pas non plus la représentation des objets.

La validation aller-retour vérifie deserialize(serialize(value)) == value. L’exemple compare aussi les octets à un résultat connu, car deux algorithmes incorrects peuvent compenser leurs erreurs respectives. Le décodeur rejette les longueurs autres que deux avant d’accéder aux données ; ici, toute séquence de deux octets est une valeur valide. Les formats plus vastes nécessitent également des vérifications de plage, de longueur et de version, ainsi que la gestion des erreurs d’I/O.

Le code est destiné à être compilé avec une option C++23. Le code source affiché a été exécuté sans modification dans un environnement isolé, et sa sortie correspondait exactement au résultat indiqué. Cette exécution ne vérifie pas le fonctionnement en production. La source eel.is est un brouillon de travail en évolution, et non une publication C++23 figée.

Exemples

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

Résultat

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

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources