バイナリ形式での読み書き | Programming Place Plus　新C++編

このページの概要

このページでは、ファイルの内容をバイナリ形式で読み書きする方法を取り上げます。これまでのページでも、ファイルを読み書きする処理は登場していますが、これまでの方法はテキスト形式で読み書きするものでした。テキスト形式は、データがテキスト（文字）だけで構成されていることを想定したものであり、どんな種類のファイルでも取り扱えなければならないバイナリエディタの実装には不向きです。

以下は目次です。要点だけをさっと確認したい方は、「まとめ」をご覧ください。

• テキスト形式とバイナリ形式
• オープンモード
• バイナリ形式での読み書き
  • 大きさを指定して書く (writeメンバ関数)
  • 大きさを指定して読む (readメンバ関数)
• パディング
• エンディアン
• すべて読む (std::istreambuf_iterator)
• まとめて書く (std::ostreambuf_iterator)
• まとめ
• 参考リンク
• 練習問題
• 更新履歴

テキスト形式とバイナリ形式

一般的にバイナリエディタは、ファイルを１つ選んで読み込み、その中身をバイト単位で表示するという作りになっています。ファイルの内容を読み込むプログラムはこれまでにも登場しているので（「ファイル処理」のページを参照）、同じ方法で実現できそうに思えます。

std::ifstream ifs("test.txt");
std::string s {};
ifs >> s;

しかしこの方法は、バイナリエディタの実装に使うには問題があります。

データの形式には、テキスト形式 (text format) とバイナリ形式 (binary format) の２つがあります。

テキスト形式では、データを構成しているバイトはどれも文字を表現しています。画像や音声のように、文字ではないデータを含んでいる場合はバイナリ形式です。

テキスト形式で画像や音声などを表現するファイルフォーマットも存在しますが、ここでは無視しています。

たとえば「12345」を文字列として記録しているならテキスト形式ですが、数値として記録しているならバイナリ形式です。前者なら、半角の数字を 1バイトで表現するエンコーディング形式（「マルチバイト文字」のページを参照）であれば、全部で 5バイトです。後者の場合、12345 という整数を表現するために最低限必要なバイト数は 2バイトです。

文字でないデータを含んでいるときに、テキスト形式のつもりで取り扱うとどんな問題が起こり得るでしょうか。

１つに、改行文字の問題があります。テキスト形式では、改行を特別な文字として表現します。改行文字の具体的な表現は環境（OS）によって異なり、Windows では「0x0D 0x0A」という 2バイトで、macOS や Linux では「0x0A」という 1バイトです。これまでに登場したプログラムがそうであったように、C++ のソースコード上では、'\n' と書くことによって、環境ごとの違いが吸収されています。テキスト形式としてファイルを読み込むとき、Windows では「0x0D 0x0A」が出現したら、１つの改行であると判断します。反対に、テキスト形式としてファイルに書き出すときには、'\n' を「0x0D 0x0A」に変換して書き込みます。バイナリ形式として取り扱うと、こうした変換が行われません。

もう１つには、ファイルの終端の問題があります。ファイルの終端には、EOF (End Of File) と呼ばれる１バイトのマーク（「0x1A」で表現）が置かれていることがあり、テキスト形式での読み込みではこれより後ろにあるデータを読み込みません。

画像や音声などのデータには、こうした特別な意味をもつ文字と同じバイトが偶然含まれている可能性があります。そういうファイルをテキスト形式として取り扱うと、改行やファイル終端であると誤認識して、おかしな結果を生んでしまいます。こうした問題を回避するため、文字データのみが書かれたファイルではない場合、バイナリ形式として取り扱わなければなりません。

バイナリエディタは、ファイルを構成するバイト列をありのまま確認することが目的のツールなので、余計な変換が行われてはいけません。そのため、バイナリ形式で読み込む必要があります。

オープンモード

ファイルをテキスト形式で扱うのか、バイナリ形式で扱うのかは、std::ofstream や std::ifstream に渡すオープンモードによって指定します。

std::ofstream ofs(パス, オープンモード);
std::ifstream ifs(パス, オープンモード);

オープンモードには、以下の表に示す６種類があって、これらを組み合わせて指定します。

オープンモードの指定を省略した場合、デフォルトのオープンモードが指定されたことになります。std::ofstream のデフォルトのオープンモードは std::ios_base::out、std::ifstream なら std::ios_base::in です。いずれも std::ios_base::binary を含んでおらず、テキスト形式で取り扱うことになります。

このページではファイルを対象とした解説に限定しますが、std::istringstream や std::ostringstream でも（「stringstream」のページを参照）、初期化時の第２引数にオープンモードを渡せるようになっています。

なお、std::ios_base::app、std::ios_base::ate については、このページでは取り上げません。

「ランダムアクセス」のページで取り上げます。

上記６つの定義は std::ios_base::openmode型ですが、これは型の別名であり、具体的にどのような型なのかは処理系定義となっています。いずれも、 <ios> で定義されていますが、<iostream> をインクルードすると同時にインクルードされるため¹、多くの場合、特に気にせず使用できます。

【Ｃ言語プログラマー】３つ目までは、fopen関数の第２引数の各種指定（“r”、“w”、“b”）と、std::ios_base::app は “a” と一致しています。std::ios_base::trunc は “w” のときの挙動と一致します²。std::ios_base::ate は、開いた直後に fseek関数で末尾に移動することと同義です。

std::ofstream に std::ios_base::in を指定したり、std::ifstream に std::ios_base::out を指定したりしたらどうなるのだろうかと思うかもしれません。指定自体はできますが、std::ofstream には読み込みの関数がありませんし、std::ifstream には書き込みの関数がありませんから、結局、こうした反対方向の指定には意味がありません。もし入出力の両方が必要である場合には、std::fstream を使います。

std::ios_base::trunc を指定すると、ファイルに元々書き込まれていた内容が消えます。それならば、指定しなければ元の内容を残してくれそうですが、実際には std::ios_base::out を指定していると、std::ios_base::trunc を指定しなくても消されます。

【上級】元の内容を消さずに書き込みを行うには、std::ios_base::app を使うか（この場合は、末尾に書き足すことしかできない）、std::fstream を使って、読み書き両用でオープンする必要があります。

オープンモードは、ビット単位のフラグになっています。そのため、入力用に開きつつ、バイナリ形式として扱いたいと思ったら、std::ios_base::in | std::ios_base::binary のように、ビット単位OR（「ビット単位の処理」のページを参照）を使って結合します。

std::ofstream ofs(パス, std::ios_base::out | std::ios_base::binary);
std::ifstream ifs(パス, std::ios_base::in | std::ios_base::binary);

バイナリ形式での読み書き

では実際にバイナリ形式でファイルを読み書きしてみます。

これまでのページで使ってきた、<< や >>、std::getline関数を使う方法は、バイナリ形式の読み書きには不向きです。これらの方法は、データが空白文字や改行で区切られたフォーマット（書式）になっているときに使うものです。バイナリ形式の読み書きは、こうしたフォーマットで表現されていることを前提にできません（普通、区切りや改行の概念がなく、データが詰め込まれた状態になっています）。

C++ の標準ライブラリでは、書式が決まっている場合にうまく利用できる関数や演算子は、書式付き入力 (formatted input)、書式付き出力 (formatted output) と呼ばれ、書式を想定しないものは、書式なし入力 (unformatted input)、書式なし出力 (unformatted output) と呼ばれます。

#include <cstdint>
#include <cstdlib>
#include <fstream>
#include <iostream>

int main()
{
    // バイナリ形式でオープン
    constexpr auto path = "test.bin";
    std::ofstream ofs(path, std::ios_base::out | std::ios_base::binary);
    if (ofs.fail()) {
        std::cerr << "File open error: " << path << "\n";
        std::quick_exit(0);
    }

    // 適当なデータを書き込む
    std::int32_t a {0x123456};
    std::int64_t b {0xabcd0123LL};
    char c[] {"xyz"};
    ofs.write(reinterpret_cast<const char*>(&a), sizeof(a));
    ofs.write(reinterpret_cast<const char*>(&b), sizeof(b));
    ofs.write(c, sizeof(c));
    if (ofs.fail()) {
        std::cerr << "File write error: " << path << "\n";
        std::quick_exit(0);
    }

    ofs.close();
    if (ofs.fail()) {
        std::cerr << "File close error: " << path << "\n";
        std::quick_exit(0);
    }
}

56 34 12 00 23 01 CD AB 00 00 00 00 78 79 7A 00

#include <cstdint>
#include <cstdlib>
#include <fstream>
#include <iostream>

int main()
{
    constexpr auto path = "test.bin";
    std::ifstream ifs(path, std::ios_base::in | std::ios_base::binary);
    if (ifs.fail()) {
        std::cerr << "File open error: " << path << "\n";
        std::quick_exit(0);
    }

    // データを読み込む
    std::int32_t a {};
    std::int64_t b {};
    char c[4] {};
    ifs.read(reinterpret_cast<char*>(&a), sizeof(a));
    ifs.read(reinterpret_cast<char*>(&b), sizeof(b));
    ifs.read(c, sizeof(c));
    if (ifs.fail()) {
        std::cerr << "File read error: " << path << "\n";
        std::quick_exit(0);
    }

    // 確認
    std::cout << std::hex << a << "\n"
              << std::hex << b << "\n"
              << std::dec << c << "\n";

    ifs.close();
    if (ifs.fail()) {
        std::cerr << "File close error: " << path << "\n";
        std::quick_exit(0);
    }
}

56 34 12 00 23 01 CD AB 00 00 00 00 78 79 7A 00

123456
abcd0123
xyz

std::string c(4, ' ');  // 十分なサイズが必要
ifs.read(&c[0], 4);

std::vector<char> c(4);  // 十分なサイズが必要

ifs.read(&c[0], 4);
ifs.read(c.data(), 4);  // こちらでもいい

パディング

構造体の内容を書き出す場合、構造体全体を指定すると、パディング（「メモリとオブジェクト」のページを参照）の部分まで書き出されることに注意が必要です。パディングの入り方は処理系によって異なるため、この方法で書き出したファイルが、ほかの処理系で正常に読めない可能性があります。

struct S {
    std::int64_t a;
    char b;
    std::int16_t c;
};
S s {};

ofs.write(&s, sizeof(s));  // 可能ではあるが、読み込み側もパディングを意識して正しく実装しないと、正常に読めない

面倒でも、構造体の各メンバを１つ１つ書き出す・読み込むようにコードを書き、ファイルの側にはパディングの部分が含まれないようにするのが安全です。

ofs.write(reinterpret_cast<const char*>(&s.a), sizeof(s.a));
ofs.write(reinterpret_cast<const char*>(&s.b), sizeof(s.b));
ofs.write(reinterpret_cast<const char*>(&s.c), sizeof(s.c));

ifs.read(reinterpret_cast<char*>(&s.a), sizeof(s.a));
ifs.read(reinterpret_cast<char*>(&s.b), sizeof(s.b));
ifs.read(reinterpret_cast<char*>(&s.c), sizeof(s.c));

エンディアン

もう１つ問題になるのはエンディアン（「配列とポインタ」のページを参照）です。たとえば、リトルエンディアンの処理系でバイナリ形式で書き出したファイルを、ビッグエンディアンの処理系で読み込むと、バイトの並び順が入れ替わった状態になり、正常な値を読めません。

プログラムを実行している環境のエンディアンと、ファイルのエンディアンを比べて、両者が同じなら何もする必要はありませんが、違っているのなら、読み込みのあとでバイトの順序を入れ替える処理（バイトスワッピング (byte swapping)）が必要です。

ここではリトルエンディアンとビッグエンディアンだけを想定しています。非常にレアですが、ほかにもエンディアンの種類はあるため、そうした環境では、ここで取り上げるものとは異なる実装が必要になります。

実行環境のエンディアンは、環境が同じであるかぎりは変化するものではないので、特定のエンディアンに決め打ちしてしまうことも１つの方法ではあります。複数の環境で使うプログラムの場合は、#if でコードを切り分けて、環境ごとにコンパイルしなおす方法があります。

もしくは、以下のようなコードで、実行時にエンディアンを判定することもできます。

【C++20】実行環境のエンディアンを std::endian::native⁸ で調べられるようになったので、ここで紹介するような技巧的な手段は不要になっています。

#include <cstdint>
#include <iostream>

int main()
{
    std::uint16_t n {1};
    if (*reinterpret_cast<unsigned char*>(&n) == 1) {
        std::cout << "Little endian.\n";
    }
    else {
        std::cout << "Big endian.\n";
    }
}

実行結果：

Little endian.

まず、2バイト以上の大きさの変数に 1 を入れておきます（1バイトの変数ではバイトの順序という考え方がないため、2バイト以上必要）。2バイトの変数n に格納した 1 は、実行環境がリトルエンディアンなら 01 00、ビッグエンディアンなら 00 01 という 2バイトの並びになります。

次に &n を unsigned char* にキャストしています。unsigned char は 1バイトなので、このキャストによって、さきほどの 2バイトの並びの上位側のバイトのメモリアドレスが得られます。そのバイトの値を * による間接参照で取り出します。この結果は、リトルエンディアンなら 01、ビッグエンディアンなら 00 になります。したがって、== 1 という比較が true になるならリトルエンディアン、false になるならビッグエンディアンであることが分かります。

読み込んだファイルのエンディアンと、実行環境のエンディアンが異なっている場合は、読み込み後にバイトスワッピングを行います。基本的にはバイトの並び順を逆転させればいいので、以下の流れがシンプルに実装できます。

1. バイト列として読み込む
2. バイトスワッピングを行う
3. 本来の型にキャストする

#include <iostream>
#include <utility>

void byte_swap16(unsigned char* bytes)
{
    std::swap(bytes[0], bytes[1]);
}

void byte_swap32(unsigned char* bytes)
{
    std::swap(bytes[0], bytes[3]);
    std::swap(bytes[1], bytes[2]);
}

void byte_swap64(unsigned char* bytes)
{
    std::swap(bytes[0], bytes[7]);
    std::swap(bytes[1], bytes[6]);
    std::swap(bytes[2], bytes[5]);
    std::swap(bytes[3], bytes[4]);
}

int main()
{
    unsigned char b1[] {0x12,0x34};  // 読み込まれたデータとする
    std::cout << std::hex << *reinterpret_cast<std::uint16_t*>(b1) << "\n";
    byte_swap16(b1);
    std::cout << std::hex << *reinterpret_cast<std::uint16_t*>(b1) << "\n";

    unsigned char b2[] {0x12,0x34,0x56,0x78};  // 読み込まれたデータとする
    std::cout << std::hex << *reinterpret_cast<std::uint32_t*>(b2) << "\n";
    byte_swap32(b2);
    std::cout << std::hex << *reinterpret_cast<std::uint32_t*>(b2) << "\n";

    unsigned char b3[] {0x12,0x34,0x56,0x78,0x90,0xab,0xcd,0xef};  // 読み込まれたデータとする
    std::cout << std::hex << *reinterpret_cast<std::uint64_t*>(b3) << "\n";
    byte_swap64(b3);
    std::cout << std::hex << *reinterpret_cast<std::uint64_t*>(b3) << "\n";
}

実行結果（リトルエンディアン環境）：

3412
1234
78563412
12345678
efcdab9078563412
1234567890abcdef

実行結果（ビッグエンディアン環境）：

1234
3412
12345678
78563412
1234567890abcdef
efcdab9078563412

もう１つのパターンとして、すでに整数型の値になっている場合は、以下のようにビット演算を駆使してバイトスワッピングを実現できます。

【C++23】std::byteswap関数⁹が追加されるので、自作する必要はなくなります。

#include <cstdint>
#include <iostream>

std::uint16_t byte_swap16(std::uint16_t value)
{
    return (value << 8)
         | (value >> 8)
         ;
}

std::uint32_t byte_swap32(std::uint32_t value)
{
    return (value << 24)
         | (value & 0x0000'ff00) << 8
         | (value & 0x00ff'0000) >> 8
         | (value >> 24)
         ;
}

std::uint64_t byte_swap64(std::uint64_t value)
{
    return (value << 56)
         | (value & 0x0000'0000'0000'ff00) << 40
         | (value & 0x0000'0000'00ff'0000) << 24
         | (value & 0x0000'0000'ff00'0000) << 8
         | (value & 0x0000'00ff'0000'0000) >> 8
         | (value & 0x0000'ff00'0000'0000) >> 24
         | (value & 0x00ff'0000'0000'0000) >> 40
         | (value >> 56)
         ;
}

int main()
{
    std::uint16_t v16 {0x1234};
    std::cout << std::hex << v16 << "\n";
    v16 = byte_swap16(v16);
    std::cout << std::hex << v16 << "\n";

    std::uint32_t v32 {0x12345678};
    std::cout << std::hex << v32 << "\n";
    v32 = byte_swap32(v32);
    std::cout << std::hex << v32 << "\n";

    std::uint64_t v64 {0x1234567890abcdef};
    std::cout << std::hex << v64 << "\n";
    v64 = byte_swap64(v64);
    std::cout << std::hex << v64 << "\n";
}

実行結果（リトルエンディアン環境）：

1234
3412
12345678
78563412
1234567890abcdef
efcdab9078563412

実行結果（ビッグエンディアン環境）：

3412
1234
78563412
12345678
efcdab9078563412
1234567890abcdef

すべて読む (std::istreambuf_iterator)

ファイルの中身を全部一気に読み込みたいときは、std::istreambuf_iterator¹⁰ を使う方法が簡単です。

std::istreambuf_iterator は、名前のとおり、ストリームのバッファ（「ファイルとエラー」のページを参照）に対して機能するイテレータであり、std::ifstream が内部にもっているバッファを指し示しています。std::istreambuf_iterator は、<iterator> で定義されています。

以下のプログラムは、test.txt の中身全部をそのままのかたちで std::vector に読み込みます。

#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <vector>

int main()
{
    constexpr auto path = "test.txt";

    std::ifstream ifs(path, std::ios_base::in | std::ios_base::binary);
    if (ifs.fail()) {
        std::cerr << "File open error: " << path << "\n";
        std::quick_exit(0);
    }

    // ファイルの中身すべてを std::vector<char> に読み込む
    std::istreambuf_iterator<char> it_ifs_begin(ifs);
    std::istreambuf_iterator<char> it_ifs_end {};
    std::vector<char> input_data(it_ifs_begin, it_ifs_end);
    if (ifs.fail()) {
        std::cerr << "File read error: " << path << "\n";
        std::quick_exit(0);
    }

    // 読み込んだ内容をバイト列として標準出力に書き出す
    for (std::size_t i {0}; i < input_data.size(); ++i) {
        std::cout << std::setw(2) << std::setfill('0') << std::hex << std::uppercase
            << static_cast<unsigned int>(input_data[i]) << " ";
    }
    std::cout << "\n";

    ifs.close();
    if (ifs.fail()) {
        std::cerr << "File close error: " << path << "\n";
        std::quick_exit(0);
    }
}

test.txt の内容：

１行目
２行目
３行目

実行結果：

EF BC 91 E8 A1 8C E7 9B AE 0D 0A EF BC 92 E8 A1 8C E7 9B AE 0D 0A EF BC 93 E8 A1 8C E7 9B AE

std::istreambuf_iterator を使うときの型名は、取り扱うデータの大きさが char型の大きさ（つまり 1バイト単位）であることを明確にするため、std::istreambuf_iterator<char> とします。std::ifstream型の変数を渡してやることで、その std::ifstream が持っているバッファをターゲットにしたイテレータとして初期化されます。何も渡さずに定義した場合は、ファイルの終端を指すイテレータであるとみなされます。

std::vector の変数を定義するとき、２つのイテレータで範囲を渡すことで、その範囲内の要素の値による初期化が行えました（「配列」のページを参照）。そのため、std::vector<char> input_data(it_ifs_begin, it_ifs_end); というコードで、ターゲットのバッファと、ファイルの終端を指示したことになり、そのあいだにある要素、つまりファイルの中身全部による初期化が行われます。

読み込みのエラーチェックはいつも通り、std::ifstream の failメンバ関数を使うことで行います。

まとめて書く (std::ostreambuf_iterator)

さきほどの反対で、std::vector に入っているすべての値をバイナリ形式として一気に書き込みます。std::ifstream に代わって std::ofstream を使い、std::istreambuf_iterator に代わって std::ostreambuf_iterator¹¹ を使います。

#include <algorithm>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <iterator>
#include <vector>

int main()
{
    constexpr auto path = "test.bin";
    std::ofstream ofs(path, std::ios_base::out | std::ios_base::binary);
    if (ofs.fail()) {
        std::cerr << "File open error: " << path << "\n";
        std::quick_exit(0);
    }

    // 適当なデータを作る
    std::vector<unsigned char> data {};
    data.push_back(0);
    data.push_back(100);
    data.push_back(200);
    data.push_back('\n');
    data.push_back('a');
    data.push_back('b');
    data.push_back('c');

    // std::vector の中身すべてをファイルへ書き出す
    std::ostreambuf_iterator<char> it_ofs(ofs);
    std::copy(std::cbegin(data), std::cend(data), it_ofs);
    if (ofs.fail()) {
        std::cerr << "File write error: " << path << "\n";
        std::quick_exit(0);
    }

    ofs.close();
    if (ofs.fail()) {
        std::cerr << "File close error: " << path << "\n";
        std::quick_exit(0);
    }
}

実行結果（test.bin をバイナリで表示）：

00 64 C8 61 62 63

適当に作ったデータを std::ostreambuf_iterator を使って書き込みます。std::copy関数（「配列」のページを参照）を使って、std::copy(std::cbegin(data), std::cend(data), it_ofs); とすることで、data の先頭から末尾の範囲にあるものを、it_ofs が指し示すバッファ（std::ofstream が持っているバッファ）へコピーします。書き込みのためのバッファに蓄えられたデータは、バッファリングがどのような実装になっているか次第ですが、どこかのタイミングで実際にファイルへ書き込まれることになります。

書き込みのエラーチェックはいつも通り、std::ofstream の failメンバ関数を使うことで行います。ただし、バッファリングの仕組みのせいで、書き込みのコードの直後でエラーチェックを行っても意味がない可能性もあります（「ファイルとエラー」のページを参照）。

まとめ

• データを取り扱う形式として、テキスト形式とバイナリ形式がある
  • テキスト形式では、改行やファイル終端といった表現を特別に意味のあるものとみなす
  • バイナリ形式では、こうした表現を特別扱いしない
• std::ifstream、std::ofstream の初期化のとき、第２引数にオープンモードを指定できる
  • ここに std::ios_base::binary を指定すると（ほかの指定と ビット単位OR で結合する）、バイナリ形式としてオープンできる
• 指定したバイト数ずつ読み込むには、std::ifstream の readメンバ関数を使う
• 指定したバイト数ずつ書き込むには、std::ofstream の writeメンバ関数を使う
• 構造体はパディングが入り込むことがあるため、構造体全体を一度に読み書きすると、環境依存になってしまう
• 実行環境のエンディアンと、読み込むファイルのエンディアンが異なる場合、変換（バイトスワッピング）を行わないと、正常なデータを読めない
• ファイルの中身をすべて読むには、std::istreambuf_iterator を使う
• std::vector などに集めたデータを一気にファイルへ書き出すには、std::ostreambuf_iterator を使う

新C++編の【本編】の各ページには、末尾に練習問題があります。ページ内で学んだ知識を確認する簡単な問題から、これまでに学んだ知識を組み合わせなければならない問題、あるいは更なる自力での調査や模索が必要になるような高難易度な問題をいくつか掲載しています。