바이너리 파일 입출력

텍스트 파일은 값을 글자로 바꾸어 저장하므로 사람이 읽을 수 있지만, 읽을 때마다 글자를 다시 값으로 바꿔야 합니다. 바이너리 파일은 값을 프로그램이 정한 바이트 배열로 저장합니다. 정해진 크기의 레코드를 바로 찾아 읽을 수 있고 형식을 조밀하게 만들 수 있지만, 바이너리라는 이유만으로 언제나 더 빠르거나 작은 것은 아닙니다.

중요한 차이는 사람이 읽는 글자 대신, 쓰는 쪽과 읽는 쪽이 함께 지키는 바이트 형식으로 값을 주고받는다는 점입니다. 이 글은 바이너리 모드가 하는 일, write()와 read()로 바이트를 옮기는 방법, 정수를 정해진 바이트 순서로 저장하는 방법, 고정 크기 레코드를 위치로 찾아 읽는 방법을 다룹니다. 예제는 1바이트가 8비트인 Windows x86-64의 GCC를 기준으로 합니다.

바이너리 모드가 하는 일

텍스트 모드에서는 운영체제에 따라 줄바꿈 같은 글자가 바뀌어 기록될 수 있습니다. Windows에서는 '\n'을 쓰면 파일에 \r\n의 두 바이트가 기록되고, 읽을 때 다시 '\n' 하나로 바뀝니다. std::ios::binary로 열면 이런 변환 없이 바이트를 그대로 주고받으며, Linux처럼 원래 변환이 없는 환경에서는 두 모드가 같습니다.

하지만 위 그림처럼 바이너리 모드는 통로를 정할 뿐, 값을 어떤 바이트로 바꿀지는 정하지 않습니다. 텍스트 파일 쓰기에서 본 것처럼 바이너리 모드에서도 <<는 숫자를 글자로 기록합니다. 값을 바이트로 저장하려면 write()를 쓰고, 다른 프로그램이나 나중의 버전도 읽을 수 있게 하려면 각 값의 바이트 수, 바이트 순서, 길이, 버전을 파일 형식으로 정해야 합니다.

write()와 read()

write(const char* data, std::streamsize n)은 data에서 n바이트를 그대로 출력하고, read(char* data, std::streamsize n)은 n바이트를 읽어 data에 채웁니다. 이 둘은 글자로 바꾸는 형식화를 하지 않는 비형식화 입출력(unformatted I/O)입니다.

read()는 n바이트를 다 채우기 전에 파일 끝에 닿으면 failbit와 eofbit를 설정하고, 그때까지 읽은 만큼만 채웁니다. 실제로 읽은 바이트 수는 gcount()로 알 수 있으므로, read() 뒤에는 스트림 상태와 gcount()를 함께 확인해 일부만 읽은 것을 성공으로 오해하지 않게 합니다. write()는 출력하지 못하면 badbit를 설정합니다.

정수를 정해진 바이트 순서로 저장하기

std::uint32_t처럼 여러 바이트로 이루어진 값은, 메모리에 바이트를 놓는 순서인 바이트 순서(endianness)가 CPU마다 다를 수 있습니다. 낮은 자리 바이트를 먼저 두는 방식을 리틀 엔디언(little-endian)이라고 하며, x86-64가 이 방식입니다. 리틀 엔디언과 빅 엔디언이 같은 값을 주소에 어떻게 놓는지는 비트·바이트·주소에서 표로 비교합니다. 메모리의 바이트를 그대로 쓰면 이 순서에 따라 파일 내용이 달라지므로, 파일 형식에서는 순서를 정하고 시프트로 바이트를 직접 만듭니다.

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

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()), 4);
    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()), 4);
    if (in.gcount() != 4 || !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;
}

write_u32_le는 비트 연산자의 시프트와 마스크로 값을 낮은 자리부터 한 바이트씩 나누어, 언제나 같은 순서로 4바이트를 씁니다. std::byte는 C++17에 들어온 바이트 전용 타입이고, reinterpret_cast<const char*>는 바이트 배열을 write()가 받는 char 포인터로 보는 변환입니다. 이 함수는 CPU의 바이트 순서와 상관없이 같은 파일을 만듭니다.

read_u32_le는 같은 규칙을 거꾸로 적용합니다. 읽은 4바이트를 std::to_integer<std::uint32_t>로 하나씩 정수로 바꾼 뒤, 둘째 바이트는 8비트, 셋째는 16비트, 넷째는 24비트만큼 왼쪽으로 밀어 |로 합칩니다. std::byte를 그대로 밀면 결과도 std::byte여서 8비트를 넘는 비트가 사라지므로, 먼저 32비트 정수로 바꾸는 것입니다. 그래서 다른 환경에서도 같은 값을 읽습니다.

C++은 1바이트가 8비트라고 보장하지 않으므로, static_assert로 이 형식의 전제를 컴파일할 때 확인합니다. 실제 파일 형식에는 보통 맨 앞에 형식을 알아보는 고정 값(magic number), 버전, 레코드 수나 길이를 두고, 읽는 쪽은 이를 먼저 검사합니다. 모르는 버전이나 범위를 벗어난 길이는 짐작해서 읽지 않고 거부합니다.

더 깊이: C++20과 C++23의 바이트 순서 도구

C++20의 <bit>에는 지금 플랫폼의 바이트 순서를 알려 주는 std::endian이 있습니다. std::endian::native가 std::endian::little과 같으면 모든 스칼라 타입이 리틀 엔디언이고, big과 같으면 빅 엔디언이며, 둘 다 아니면 두 방식이 섞인 플랫폼입니다. C++23에는 정수의 바이트 순서를 뒤집는 std::byteswap이 더해졌으므로, 리틀 엔디언으로 정한 형식을 빅 엔디언 플랫폼에서 다룰 때 if constexpr로 갈래를 나누어 뒤집을 수 있습니다. 다만 본문처럼 시프트와 마스크로 바이트를 만드는 방법은 플랫폼의 바이트 순서를 묻지 않고도 같은 결과를 내고 C++20 이전의 컴파일러에서도 쓸 수 있으므로, 이 도구들은 그 방법을 대신하기보다 필요할 때 고르는 선택지입니다.

float이나 double을 이런 형식으로 저장할 때는 C++20의 std::bit_cast로 비트를 그대로 같은 크기의 std::uint32_t나 std::uint64_t로 옮긴 뒤 같은 방법으로 씁니다. 이때 std::numeric_limits<float>::is_iec559를 static_assert로 함께 확인해 두면, 부동 소수점 형식이 IEEE 754가 아닌 플랫폼에서는 컴파일 단계에서 알 수 있습니다. 각 도구의 정의는 cppreference의 std::endian과 그 옆의 <bit> 함수 문서에 있습니다.

객체를 통째로 쓰는 방법의 한계

구조체를 통째로 write()하고 싶을 수도 있습니다. C++은 복사해도 안전한 단순한 타입, 즉 trivially copyable 타입의 객체를 바이트 배열로 복사했다가 같은 객체로 되돌리는 것을 허용합니다.

#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_snapshot(std::ostream& out, const Record& record) {
    out.write(reinterpret_cast<const char*>(&record), sizeof record);
    return static_cast<bool>(out);
}

하지만 이것은 같은 빌드의 프로그램이 잠시 저장했다가 다시 읽는 경우에만 쓸 수 있는 방법입니다. 이 Record는 id 4바이트와 value 8바이트 사이에 정렬을 맞추는 패딩(padding) 4바이트가 들어가 Windows x86-64의 GCC에서 sizeof가 16이며, 패딩의 값은 정해져 있지 않습니다. 구조체의 배치, 기본 타입의 크기, 바이트 순서는 컴파일러와 플랫폼에 따라 다를 수 있고, 멤버를 하나 추가하면 옛 파일을 다른 뜻으로 읽게 됩니다.

포인터는 다른 실행에서는 의미가 없는 주소이며, std::string처럼 내부에 포인터와 소유 상태를 가진 객체는 바이트를 그대로 써도 글자가 저장된다는 보장이 없습니다. libstdc++처럼 짧은 문자열의 글자를 객체 안에 두는 구현에서는 글자가 함께 기록되기도 하지만, 같이 기록된 포인터는 다시 읽었을 때 의미가 없으므로 그 바이트로 객체를 되살릴 수 없습니다. 오래 보관하거나 다른 환경과 주고받을 파일은 앞의 write_u32_le처럼 필드마다 정해진 형식으로 저장하고, 레코드 크기도 sizeof(Record)가 아니라 파일 형식이 정한 상수로 둡니다.

위치를 옮겨 읽기: seekg와 tellg

레코드의 크기가 정해져 있으면, 앞의 레코드를 모두 읽지 않고 원하는 레코드의 위치로 바로 옮겨 읽을 수 있습니다. 이것을 임의 접근(random access)이라고 합니다. 읽기 위치는 seekg로 옮기고 tellg로 확인하며, 쓰기 위치는 seekp와 tellp로 다룹니다.

n번째 레코드는 파일 처음에서 n * 레코드 크기바이트 떨어진 곳에서 시작합니다. 하지만 아래 그림처럼 그 위치를 계산하기 전에 파일 크기가 레코드 크기의 배수인지, 인덱스가 레코드 수보다 작은지, 곱셈이 범위를 넘지 않는지를 먼저 확인하고, 위치를 옮긴 뒤와 읽은 뒤에도 각각 결과를 확인해야 합니다. 어느 검사에서든 실패하면 그 자리에서 거부합니다.

다음 프로그램은 ID와 점수를 4바이트씩, 레코드 하나를 8바이트로 정한 파일에서 원하는 레코드를 읽습니다.

#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 fileBytes = static_cast<std::uintmax_t>(
        static_cast<std::streamoff>(endPos));

    if (fileBytes % kRecordBytes != 0) {
        return std::nullopt; // 잘린 파일이거나 다른 형식
    }
    if (index >= fileBytes / kRecordBytes) {
        return std::nullopt; // 범위 밖의 인덱스
    }
    const auto maxOffset = static_cast<std::uintmax_t>(
        std::numeric_limits<std::streamoff>::max());
    if (index > maxOffset / kRecordBytes) {
        return std::nullopt; // 위치 계산이 범위를 넘음
    }

    const auto offset = static_cast<std::streamoff>(index * kRecordBytes);
    in.seekg(offset, std::ios::beg);
    if (!in || static_cast<std::streamoff>(in.tellg()) != 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 << "cannot read the requested record\n";
        return 1;
    }
    std::cout << "id=" << record->id << ", score=" << record->score << '\n';
}

std::optional<Record>는 C++17의 타입으로, 레코드를 읽었으면 그 값을, 읽지 못했으면 std::nullopt라는 빈 상태를 돌려줍니다. seekg(0, std::ios::end)로 끝으로 간 뒤 tellg()로 위치를 얻으면 파일 크기가 되고, tellg()가 실패하면 pos_type(-1)을 돌려줍니다. std::streamoff는 파일 안의 위치를 나타내는 부호 있는 정수 타입이어서, 곱셈 결과가 그 최댓값을 넘지 않는지도 미리 확인합니다.

레코드 파일을 만들고 읽기

읽기 프로그램을 실행하려면 같은 형식의 records.bin이 있어야 합니다. 다음 프로그램을 따로 저장해 세 레코드 (101, 80), (102, 95), (103, 70)을 기록합니다.

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

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()), 4);
    return static_cast<bool>(out);
}

int main() {
    std::ofstream out("records.bin", std::ios::binary | std::ios::trunc);
    if (!out) {
        std::cerr << "cannot open records.bin\n";
        return 1;
    }

    const std::uint32_t records[][2]{{101, 80}, {102, 95}, {103, 70}};
    for (const auto& record : records) {
        if (!write_u32_le(out, record[0]) || !write_u32_le(out, record[1])) {
            std::cerr << "write failed\n";
            return 1;
        }
    }

    out.close();
    if (!out) {
        std::cerr << "failed to finish writing records.bin\n";
        return 1;
    }
    std::cout << "records.bin created\n";
}

두 프로그램을 같은 폴더에서 빌드하고 차례로 실행합니다. PowerShell의 (Get-Item .\records.bin).Length는 파일 크기를 바이트로 보여 줍니다.

g++ -std=c++20 -Wall -Wextra write-records.cpp -o write-records.exe
g++ -std=c++20 -Wall -Wextra read-records.cpp -o read-records.exe
.\write-records.exe
(Get-Item .\records.bin).Length
.\read-records.exe

records.bin created
24
id=103, score=70

레코드 세 개가 8바이트씩이므로 파일은 24바이트입니다. 인덱스는 0부터 세므로 2는 세 번째 레코드이고, 시작 위치는 2 × 8 = 16바이트입니다. 읽기 프로그램은 그 위치로 옮긴 것을 tellg()로 확인한 뒤 8바이트를 읽어 ID 103과 점수 70을 되돌립니다.

검사가 제대로 동작하는지도 확인합니다. 파일의 마지막 바이트를 지워 23바이트로 만들면, 8의 배수가 아니므로 파일 크기 검사에서 거부되어 cannot read the requested record를 출력하고 종료 상태 1로 끝납니다. 이 경우는 read()까지 가지 않고 거부된 것입니다. 정상 파일로 되돌린 뒤 인덱스를 3으로 바꾸면, 레코드가 세 개뿐이므로 이번에는 인덱스 검사에서 같은 메시지로 거부됩니다.

정리

• std::ios::binary는 줄바꿈 같은 텍스트 변환을 끌 뿐, 값을 바이트로 바꾸는 방식을 정하지 않으며 <<는 여전히 글자를 씁니다.
• write()와 read()는 바이트를 그대로 옮기며, read() 뒤에는 상태와 gcount()를 함께 확인합니다.
• 여러 바이트의 정수는 바이트 순서를 정하고 시프트로 바이트를 직접 만들어 저장하면, 환경과 상관없이 같은 파일이 됩니다.
• 구조체를 통째로 쓰는 것은 패딩, 배치, 바이트 순서에 묶여 같은 빌드 안의 임시 저장에만 쓸 수 있습니다.
• 임의 접근은 파일 형식이 정한 레코드 크기로 위치를 계산하고, 파일 크기, 인덱스, 곱셈 범위, 이동, 읽기를 차례로 검사합니다.

연습 문제

1. 다른 레코드 읽기

read-records.cpp에서 인덱스를 1로 바꾸면 읽기 시작 위치와 출력은 무엇인가요? 쓰기 프로그램에 (104, 60) 레코드를 추가해 파일을 다시 만들면, 파일 크기와 인덱스 3, 4의 결과는 어떻게 되나요?

2. 파일에 기록되는 바이트

write_u32_le(out, 258)은 파일에 어떤 네 바이트를 어떤 순서로 기록하나요?

3. 문자열 객체를 통째로 쓰기

std::string name = "Ada";를 out.write(reinterpret_cast<const char*>(&name), sizeof name);으로 저장하면 무엇이 잘못되나요? 어떻게 저장해야 하나요?

이것으로 8장의 파일 입출력을 마칩니다. 다음 장의 클래스와 객체의 개념에서는 데이터와 그 데이터를 다루는 함수를 하나로 묶는 클래스를 소개하고, 객체 지향 프로그래밍의 기초로 들어갑니다.