바이너리 파일 입출력

#include <fstream>
#include <iostream>

int main() {
    {
        std::ofstream out("data.bin", std::ios::binary | std::ios::trunc);
        if (!out) {
            std::cerr << "data.bin 쓰기 열기 실패\n";
            return 1;
        }

        // 이 범위에서 write() 등으로 파일 형식에 맞는 바이트를 기록합니다.

        out.close();
        if (!out) {
            std::cerr << "data.bin 쓰기 또는 닫기 실패\n";
            return 1;
        }
    }

    {
        std::ifstream in("data.bin", std::ios::binary);
        if (!in) {
            std::cerr << "data.bin 읽기 열기 실패\n";
            return 1;
        }

        // 이 범위에서 read() 뒤 상태와 읽은 바이트 수를 확인합니다.
    }
}

#include <array>
#include <climits>
#include <cstddef>
#include <cstdint>
#include <istream>
#include <ostream>

constexpr std::streamsize kU32Bytes = 4;
static_assert(CHAR_BIT == 8, "file format requires 8-bit bytes");

bool write_u32_le(std::ostream& out, std::uint32_t value) {
    const std::array<std::byte, 4> bytes{
        static_cast<std::byte>(value & 0xffu),
        static_cast<std::byte>((value >> 8) & 0xffu),
        static_cast<std::byte>((value >> 16) & 0xffu),
        static_cast<std::byte>((value >> 24) & 0xffu),
    };

    out.write(reinterpret_cast<const char*>(bytes.data()), kU32Bytes);
    return static_cast<bool>(out);
}

bool read_u32_le(std::istream& in, std::uint32_t& value) {
    std::array<std::byte, 4> bytes{};
    in.read(reinterpret_cast<char*>(bytes.data()), kU32Bytes);
    if (in.gcount() != kU32Bytes || !in) {
        return false;
    }

    value = std::to_integer<std::uint32_t>(bytes[0])
          | (std::to_integer<std::uint32_t>(bytes[1]) << 8)
          | (std::to_integer<std::uint32_t>(bytes[2]) << 16)
          | (std::to_integer<std::uint32_t>(bytes[3]) << 24);
    return true;
}

#include <cstdint>
#include <ostream>
#include <type_traits>

struct Record {
    std::uint32_t id;
    double value;
};

static_assert(std::is_trivially_copyable_v<Record>);

bool write_local_snapshot(std::ostream& out, const Record& record) {
    out.write(
        reinterpret_cast<const char*>(&record),
        static_cast<std::streamsize>(sizeof record)
    );
    return static_cast<bool>(out);
}

#include <array>
#include <climits>
#include <cstddef>
#include <cstdint>
#include <fstream>
#include <iostream>
#include <limits>
#include <optional>

struct Record {
    std::uint32_t id;
    std::uint32_t score;
};

constexpr std::uintmax_t kRecordBytes = 8;
static_assert(CHAR_BIT == 8, "file format requires 8-bit bytes");

std::uint32_t decode_u32_le(const std::byte* bytes) {
    return std::to_integer<std::uint32_t>(bytes[0])
         | (std::to_integer<std::uint32_t>(bytes[1]) << 8)
         | (std::to_integer<std::uint32_t>(bytes[2]) << 16)
         | (std::to_integer<std::uint32_t>(bytes[3]) << 24);
}

std::optional<Record> read_record(const char* path, std::uintmax_t index) {
    std::ifstream in(path, std::ios::binary);
    if (!in) {
        return std::nullopt;
    }

    in.seekg(0, std::ios::end);
    const auto endPos = in.tellg();
    if (endPos == std::ifstream::pos_type(-1)) {
        return std::nullopt;
    }

    const auto endOffset = static_cast<std::streamoff>(endPos);
    if (endOffset < 0) {
        return std::nullopt;
    }

    const auto fileBytes = static_cast<std::uintmax_t>(endOffset);
    if (fileBytes % kRecordBytes != 0) {
        return std::nullopt; // 잘린 레코드 또는 다른 형식
    }

    const auto recordCount = fileBytes / kRecordBytes;
    if (index >= recordCount) {
        return std::nullopt;
    }

    const auto maxOffset = static_cast<std::uintmax_t>(
        std::numeric_limits<std::streamoff>::max()
    );
    if (kRecordBytes > maxOffset || index > maxOffset / kRecordBytes) {
        return std::nullopt;
    }

    const auto offsetBytes = index * kRecordBytes;
    if (offsetBytes > fileBytes - kRecordBytes) {
        return std::nullopt;
    }
    const auto offset = static_cast<std::streamoff>(offsetBytes);

    in.seekg(offset, std::ios::beg);
    if (!in) {
        return std::nullopt;
    }

    const auto actualPos = in.tellg();
    if (actualPos == std::ifstream::pos_type(-1)
        || static_cast<std::streamoff>(actualPos) != offset) {
        return std::nullopt;
    }

    std::array<std::byte, kRecordBytes> bytes{};
    const auto request = static_cast<std::streamsize>(bytes.size());
    in.read(reinterpret_cast<char*>(bytes.data()), request);
    if (in.gcount() != request || !in) {
        return std::nullopt;
    }

    return Record{
        decode_u32_le(bytes.data()),
        decode_u32_le(bytes.data() + 4),
    };
}

int main() {
    const auto record = read_record("records.bin", 2);
    if (!record) {
        std::cerr << "3번째 레코드를 온전히 읽지 못했습니다.\n";
        return 1;
    }
    std::cout << "id=" << record->id << ", score=" << record->score << '\n';
}