struct A1 {
 B1 b;
}

struct A2 {
 B2 b;
}

M>struct A1 {
M> B1 b;
M>}

M>struct A2 {
M> B2 b;
M>}

M>

struct Inner_v1
{
//...
};

struct A_v1
{
//...
int         i1;
Inner_v1    inner;
//...
};

struct B_v1
{
//...
Inner_v1    inner;
//...
};

struct A_v2
{
//...
char        ch1;
Inner_v1    inner; // Тут не надо повышать версию вложенной структуры
//...
};

struct ACTUAL_FILE_HEADER;

struct FILE_HEADER_2025_04_04;
struct FILE_HEADER_2024_02_11;
struct FILE_HEADER_1999_09_08;

struct ACTUAL_BITMAP_HEADER;

struct BITMAP_HEADER_V1;
struct BITMAP_HEADER_V2;

int read_file(r *reader)
{
    ACTUAL_FILE_HEADER fh;

    FILE_HEADER_2025_04_04 *fh_2025_04_04 = 0;
    FILE_HEADER_2024_02_11 *fh_2024_02_11 = 0;
    FILE_HEADER_1999_09_08 *fh_1999_09_08 = 0;

    ACTUAL_BITMAP_HEADER bmp_hdr;

    BITMAP_HEADER_V1 *bmp_hdr_v1 = 0;
    BITMAP_HEADER_V2 *bmp_hdr_v2 = 0;

    fh_2025_04_04 = read_file_header_since_2025_04_04(r);
    if (fh_2025_04_04) {
        fh = map_from_2025_04_04(fh_2025_04_04);
    } else {
        fh_2024_02_11 = read_file_header_since_2024_02_11(r);
        if (fh_2024_02_11) {
            fh = map_from_2024_02_11(fh_2024_02_11);
        } else {
            fh = read_file_header_since_1999_09_08(r);
            if (fh) {
                fh = map_from_1999_09_08(r);
            } else {
                // error
            }
        }
    }

    if (fh.version == 1) {
        bmp_hdr_v1 = read_bitmap_header_v1(r);
        bmp_hdr = map_from_bitmap_header_v1(r);
    } else if (fh.version == 2) {
        bmp_hdr_v2 = read_bitmap_header_v2(r);
        bmp_hdr = map_from_bitmap_header_v2(r);
    }

    // ...
}

FILE_HEADER_2025_04_04 read_file_header_since_2025_04_04(r *reader)
{
    FILE_HEADER_2025_04_04 fh;

    fh.field1 = r.read_bytes(2);
    if (!fh.field1) {
        // error
        return 0;
    }

    fh.field2 = r.read_bits(2);
    if (fh.field2 != 0 || fh.field2 != 1) {
        // error
        return 0;    
    }

    fh.field3 = r.read_bits(1);
    if (!fh.field3) {
        // error
        return 0;
    }
}

    fh_2025_04_04 = read_file_header_since_2025_04_04(r);
    if (fh_2025_04_04) {
        fh = map_from_2025_04_04(fh_2025_04_04);
    } else {

    fh_2025_04_04 = map_file_header_since_2025_04_04(r);
    if (!fh_2025_04_04) {
        fh = map_from_2025_04_04(fh_2025_04_04);

M>Как вам такое?

enum class Type {
    b8,   // bool
    i8,   // int8_t
    u8,   // uint8_t
    u32,  // uint32_t
    f32   // float
};

struct Entry {
    std::string_view name;
    Type type;
};

constexpr size_t NumFields = 3;
constexpr size_t NumVersions = 2;

constexpr std::array<Entry, NumFields> fields = {
    Entry{"id", Type::u8},
    Entry{"timestamp", Type::u32},
    Entry{"value", Type::f32}
};

constexpr std::array<std::array<std::optional<size_t>, NumVersions>, NumFields> offsets = {{
    {0, 0},             // id
    {std::nullopt, 4},  // timestamp (в старой версии поля не было, теперь появилось)
    {4, 8}              // value
}};

// 🔹 Получение размера типа
constexpr size_t typeSize(Type t) {
    switch (t) {
        case Type::b8:  return 1;
        case Type::i8:  return 1;
        case Type::u8:  return 1;
        case Type::u32: return 4;
        case Type::f32: return 4;
    }
    return 0;
}

// 🔹 Получение дефолтного значения
void writeDefault(std::ostream& out, Type t) {
    switch (t) {
        case Type::b8:  { bool v = false; out.write(reinterpret_cast<char*>(&v), sizeof(v)); break; }
        case Type::i8:  { int8_t v = 0; out.write(reinterpret_cast<char*>(&v), sizeof(v)); break; }
        case Type::u8:  { uint8_t v = 0; out.write(reinterpret_cast<char*>(&v), sizeof(v)); break; }
        case Type::u32: { uint32_t v = 0; out.write(reinterpret_cast<char*>(&v), sizeof(v)); break; }
        case Type::f32: { float v = 0.0f; out.write(reinterpret_cast<char*>(&v), sizeof(v)); break; }
    }
}

// 🔹 Основная функция трансформации
void transformRecord(size_t sourceVersion, std::istream& in, size_t targetVersion, std::ostream& out) {
    for (size_t i = 0; i < NumFields; ++i) {
        const auto& entry = fields[i];
        const auto& sourceOffset = offsets[i][sourceVersion];
        const auto& targetOffset = offsets[i][targetVersion];

        if (!targetOffset.has_value()) continue; // поле не входит в целевую версию

        // Перемещаемся в целевой поток на нужное место
        out.seekp(targetOffset.value(), std::ios::beg);

        if (sourceOffset.has_value()) {
            // Читаем из исходного потока
            in.seekg(sourceOffset.value(), std::ios::beg);
            size_t size = typeSize(entry.type);
            char buffer[8] = {}; // максимум 8 байт
            in.read(buffer, size);
            if (!in) throw std::runtime_error("Failed to read field: " + std::string(entry.name));
            out.write(buffer, size);
        } else {
            // Пишем дефолтное значение
            writeDefault(out, entry.type);
        }
    }
}