CKTIS / C++
Entrada/salida y serialización binaria explícita
La entrada y salida transfiere datos, mientras que la serialización define su representación. Aprende a codificar un entero en orden little-endian, decodificarlo de forma segura y complementar la validación de ida y vuelta con una comprobación de bytes conocidos.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
serialization: value -> specified bytes; deserialization: validated bytes -> value; round-trip validation: deserialize(serialize(value)) == valueLa entrada/salida (I/O) transfiere datos entre un programa y su entorno. La serialización convierte valores en una representación acordada, mientras que la deserialización los reconstruye tras comprobar la entrada. Los flujos de C++ permiten leer y escribir; transferir bytes por sí solo no define un formato de datos.
Un formato debería especificar el ancho de los campos, el orden de los bytes y las reglas de validación. El orden little-endian coloca primero el byte menos significativo: 0x1234 se codifica como 0x34, 0x12. El ejemplo codifica un entero sin signo de 16 bits en exactamente dos bytes de 8 bits. Los desplazamientos y las máscaras hacen que el formato sea independiente del orden de bytes de la máquina; requiere CHAR_BIT == 8 y que esté disponible el tipo opcional std::uint16_t.
Volcar la memoria sin procesar de un objeto no es un formato portable: su representación puede contener bits de relleno y depender de la implementación, y los punteros no almacenan los datos a los que apuntan. Que se permita copiar los bytes de tipos trivially copyable no garantiza que los archivos sean compatibles entre plataformas. El modo binario de un archivo tampoco estandariza la representación de los objetos.
La validación de ida y vuelta comprueba deserialize(serialize(value)) == value. El ejemplo también compara los bytes con un resultado conocido, porque dos algoritmos incorrectos pueden compensar sus errores. El decodificador rechaza longitudes distintas de dos antes de acceder a los datos; aquí, toda secuencia de dos bytes es un valor válido. Los formatos más grandes también necesitan comprobaciones de rangos, longitudes y versiones, además de gestionar los errores de I/O.
El código está pensado para compilarse con una opción de C++23. El código fuente mostrado se ejecutó sin cambios en un entorno aislado y su salida coincidió exactamente con el resultado indicado. Esa ejecución no verifica el funcionamiento en un entorno de producción. La fuente eel.is es un borrador de trabajo en evolución, no una publicación congelada de C++23.
Ejemplos
#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;
}
Resultado
bytes: 52 18 round-trip: true known bytes: true invalid length rejected: true
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.