C++で2進数を扱う方法：リテラル表記から変換・出力の実装まで解説

コンピュータがデータを処理する際、その最小単位は「0」か「1」の2つの状態で表される「ビット」です。

プログラミング言語の中でもハードウェアに近い低レイヤの操作を得意とするC++において、2進数を直接扱う技術は非常に重要です。

ビットフラグによるメモリ節約、ネットワーク通信におけるパケット構造の解析、画像処理でのピクセル操作など、2進数の知識と操作スキルが求められる場面は多岐にわたります。

かつてのC++では2進数を直接記述する標準的なリテラルが存在せず、16進数や8進数で代用していましたが、近年の規格アップデートにより、直感的かつ強力な操作が可能になりました。

本記事では、C++における2進数リテラルの書き方から、主要な変換手法、最新のC++20/23での出力方法まで、実戦で役立つ知識を網羅的に解説します。

2進数リテラルの基本とC++の進化

C++において数値をコード上に直接記述する際、10進数以外にもいくつかの基数を利用できます。

特に2進数は、ビットの状態を視覚的に把握するのに最適です。

C++14から導入された2進数リテラル

以前のC++規格では、2進数を表現するために0x（16進数）や0（8進数）を利用するのが一般的でした。

しかし、C++14において待望の2進数リテラルが導入されました。

これにより、数値を0bまたは0Bで始めることで、直接2進数として記述できるようになりました。

#include <iostream>

int main() {
    // 2進数リテラルを用いた変数宣言
    int binary_val = 0b101010; // 10進数で42
    
    std::cout << "値: " << binary_val << std::endl;

    return 0;
}

値: 42

このように、0bを接頭辞として付けるだけで、コンパイラはそれを2進数として認識します。

これはマジックナンバーを減らし、ビットマスクなどを定義する際の可読性を飛躍的に向上させます。

桁区切り文字の活用

長い2進数を記述すると、桁数を数え間違えたり、一目で値を判別できなかったりすることがあります。

C++14では、リテラルの中にシングルクォート（’）を挿入できる「桁区切り文字」も導入されました。

これはコンパイラによって無視されるため、数値の意味を変えることなく視認性を高めることができます。

#include <iostream>

int main() {
    // 8ビットごとに区切って記述
    uint32_t mask = 0b1111'0000'1010'0101;
    
    std::cout << "マスク値: " << mask << std::endl;

    return 0;
}

マスク値: 61605

特にビットフィールドやレジスタの設定値を扱う場合、4ビットや8ビット単位で区切ることで、ドキュメントとの照合が非常に容易になります。

std::bitsetによる2進数の出力と操作

C++で2進数を扱う上で最も歴史があり、汎用性が高いのが<bitset>ヘッダに含まれるstd::bitsetクラスです。

これは固定長のビット列を管理するためのクラスであり、数値から2進数文字列への変換や、ビットごとの操作を直感的に行えます。

std::bitsetの基本的な使い方

std::bitsetはテンプレート引数として「ビット数」を指定します。

整数値を渡すことで、その値を指定したビット幅の2進数として保持できます。

#include <iostream>
#include <bitset>

int main() {
    uint8_t value = 210;
    
    // 8ビットのbitsetオブジェクトを作成
    std::bitset<8> b(value);
    
    // 標準出力に流すと2進数形式で表示される
    std::cout << "2進数表示: " << b << std::endl;
    
    return 0;
}

2進数表示: 11010010

std::bitsetの便利な点は、operator<<がオーバーロードされているため、そのままstd::coutで出力できる点です。

ビット情報の取得と編集

std::bitsetには、特定のビットを操作するための便利なメンバ関数が多数用意されています。

以下に具体的な操作例を示します。

#include <iostream>
#include <bitset>

int main() {
    std::bitset<8> bits(0b0000'1111);
    
    bits.set(7);      // 7番目（最上位）のビットを1にする
    bits.reset(0);    // 0番目（最下位）のビットを0にする
    bits.flip(4);     // 4番目のビットを反転する
    
    std::cout << "操作後: " << bits << std::endl;
    std::cout << "1の数: " << bits.count() << std::endl;
    
    if (bits.test(7)) {
        std::cout << "MSBは1です" << std::endl;
    }

    return 0;
}

操作後: 10011110
1の数: 5
MSBは1です

std::bitsetは非常に便利ですが、実行時にサイズを変更できない静的なサイズ指定が必要である点に注意してください。

最新のC++における2進数出力（std::format / std::print）

C++20以降、文字列の整形手法が劇的に進化しました。

これまで2進数を出力するにはstd::bitsetを経由するのが一般的でしたが、現在ではより直接的な方法が提供されています。

C++20：std::formatによる2進数整形

C++20で導入された<format>ライブラリを使用すると、Python風の書式指定子を用いて数値を2進数文字列に変換できます。

{:b}を用いることで、整数を直接2進数として出力可能です。

#include <iostream>
#include <format>
#include <string>

int main() {
    int num = 255;
    
    // 小文字の 'b' で2進数表示
    std::string s = std::format("Binary: {:b}", num);
    std::cout << s << std::endl;
    
    // プレフィックス(0b)付き、かつ8桁ゼロ埋め
    std::cout << std::format("Formatted: {:#010b}", num) << std::endl;

    return 0;
}

Binary: 11111111
Formatted: 0b11111111

書式指定子{:#010b}の内訳は以下の通りです。

1. #：0bプレフィックスを付与する。
2. 0：空いた桁を0で埋める。
3. 10：全体の幅を10文字にする（0bの2文字 + 8桁分）。
4. b：2進数として出力する。

C++23：std::printによる直接出力

C++23では、std::formatの結果を直接標準出力に送るstd::printが導入されました。

これにより、std::coutを使用せずに、より高速かつ簡潔に2進数を出力できるようになりました。

#include <print>

int main() {
    uint16_t val = 0b1011'0011;
    
    // C++23のstd::printを使用
    std::print("Value in binary: {:016b}\n", val);
    
    return 0;
}

Value in binary: 0000000010110011

std::printの導入により、デバッグ時などに変数のビット状態を確認する作業が大幅に簡略化されました。

文字列から2進数への逆変換

外部入力やファイルから読み込んだ「1010」といった2進数文字列を、数値型に変換する方法も重要です。

std::stoi系関数による変換

<string>ヘッダのstd::stoiやstd::stoul関数は、第3引数に基数（base）を指定できます。

ここに「2」を渡すことで、2進数文字列を数値に変換可能です。

#include <iostream>
#include <string>

int main() {
    std::string bin_str = "1101";
    
    // 基数を2に指定して変換
    int value = std::stoi(bin_str, nullptr, 2);
    
    std::cout << "数値: " << value << std::endl; // 13
    
    return 0;
}

数値: 13

変換対象の文字列に「0」や「1」以外の文字が含まれている場合、std::invalid_argument例外がスローされるため、エラーハンドリングが容易です。

bitsetのコンストラクタを利用した変換

std::bitsetは文字列を引数に取るコンストラクタを持っています。

これを利用して、文字列をビット集合として読み込み、その後to_ulong()などで数値化することも可能です。

#include <iostream>
#include <bitset>
#include <string>

int main() {
    std::string s = "101010";
    std::bitset<32> b(s);
    
    unsigned long value = b.to_ulong();
    std::cout << "値: " << value << std::endl;
    
    return 0;
}

値: 42

ただし、この方法はstd::bitsetのサイズ（この例では32）を超える文字列や、数値範囲を超える場合に注意が必要です。

ビット演算の基礎と応用

2進数を扱う最大の目的は、多くの場合ビット演算にあります。

C++にはビット単位でデータを操作するための演算子が揃っています。

主要なビット演算子

ビット演算の実践例：ビットフラグ

ビット演算の代表的な用途がビットフラグです。

1つの変数内で複数のON/OFF状態を管理できます。

#include <iostream>
#include <format>

// フラグの定義
enum Permission {
    READ    = 1 << 0, // 0b0001
    WRITE   = 1 << 1, // 0b0010
    EXECUTE = 1 << 2, // 0b0100
    DELETE  = 1 << 3  // 0b1000
};

int main() {
    uint8_t my_perm = READ | WRITE; // 0b0011
    
    // 特定のビットが立っているか確認 (AND)
    if (my_perm & READ) {
        std::cout << "読み取り権限があります" << std::endl;
    }
    
    // 権限の追加 (OR)
    my_perm |= EXECUTE; // 0b0111
    
    // 権限の削除 (AND NOT)
    my_perm &= ~WRITE; // 0b0101
    
    std::cout << std::format("現在の権限ビット: {:04b}", my_perm) << std::endl;
    
    return 0;
}

読み取り権限があります
現在の権限ビット: 0101

このように、my_perm &= ~WRITEのようなイディオムは、特定のビットのみをピンポイントで倒す（0にする）際によく使われます。

C++20の<bit>ヘッダによる高度なビット操作

C++20では、ビット操作専用の<bit>ヘッダが導入されました。

これにより、これまでコンパイラ固有の組み込み関数（Intrinsic functions）を使わなければならなかった高度なビット演算が、標準ライブラリとして提供されるようになりました。

便利なビット操作関数

<bit>ヘッダに含まれる主な関数を紹介します。

これらはテンプレート関数として提供されており、各種整数型に対して効率的に動作します。

• std::popcount: 1になっているビットの数をカウントします（Population count）。
• std::has_single_bit: 値が2のべき乗である（ビットが1つだけ立っている）かを判定します。
• std::bit_ceil / std::bit_floor: 指定した値以上の（あるいは以下の）最小（最大）の2のべき乗を求めます。
• std::rotl / std::rotr: ビットを循環シフト（ローテート）させます。

#include <iostream>
#include <bit>
#include <cstdint>

int main() {
    uint8_t n = 0b0001'0111; // 10進数で23
    
    // 1の個数を数える
    std::cout << "popcount: " << std::popcount(n) << std::endl;
    
    // 2のべき乗判定
    uint8_t power_of_two = 16;
    if (std::has_single_bit(power_of_two)) {
        std::cout << power_of_two << " は2のべき乗です" << std::endl;
    }
    
    // ローテート（左に2ビット）
    uint8_t rotated = std::rotl(n, 2);
    // 00010111 -> 01011100
    std::cout << "Rotated: " << std::bitset<8>(rotated) << std::endl;

    return 0;
}

popcount: 4
16 は2のべき乗です
Rotated: 01011100

これらの関数は、内部的にCPUの専用命令（POPCNTなど）を使用するように最適化されているため、自作のループでカウントするよりも圧倒的に高速です。

負の数の2進数表現と注意点

C++で2進数を扱う際、符号付き整数（intなど）の扱いに注意が必要です。

現代のほとんどのシステムでは、負の数は「2の補数」形式で表現されます。

2の補数とは

2の補数は、ある正の数のビットを反転させ、そこに「1」を加えることで得られます。

これにより、加算回路だけで減算を処理できるようになります。

#include <iostream>
#include <bitset>

int main() {
    int8_t positive = 5;       // 0000 0101
    int8_t negative = -5;      // 1111 1011 (2の補数)
    
    std::cout << " 5: " << std::bitset<8>(positive) << std::endl;
    std::cout << "-5: " << std::bitset<8>(static_cast<uint8_t>(negative)) << std::endl;
    
    return 0;
}

 5: 00000101
-5: 11111011

C++20からは、言語仕様として符号付き整数が2の補数表現であることを保証するようになりました。

これにより、環境依存の挙動が減り、ビット操作のポータビリティが向上しました。

右シフトの挙動（算術シフトと論理シフト）

負の数に対する右シフト（>>）は、多くの処理系で「符号ビットを維持する」算術シフトとして動作しますが、これは厳密にはC++20より前は実装依存でした。

C++20以降は、符号付き整数の右シフトが算術シフトであることが規定されました。

一方、符号なし整数（unsigned）の右シフトは常に論理シフト（空いた桁に0を詰める）となります。

ビット操作を行う場合は、予期せぬ符号拡張を防ぐために符号なし整数型（uint32_tなど）を使用するのが鉄則です。

実践的な応用：浮動小数点のビット表示

2進数操作の応用として、浮動小数点数（float）がメモリ上でどのように保持されているかを確認してみましょう。

浮動小数点はIEEE 754規格に基づき、符号部、指数部、仮数部に分かれています。

直接ビット演算を行うことはできませんが、C++20のstd::bit_castを使えば安全にビットパターンを取り出せます。

#include <iostream>
#include <bit>
#include <bitset>
#include <format>

int main() {
    float f = -0.75f;
    
    // floatのメモリ表現をuint32_tとして再解釈
    uint32_t bits = std::bit_cast<uint32_t>(f);
    
    std::cout << std::format("値: {}\n", f);
    std::cout << std::format("2進数: {:032b}\n", bits);
    
    // 各要素に分解（IEEE 754 単精度）
    uint32_t sign = (bits >> 31) & 0x1;
    uint32_t exponent = (bits >> 23) & 0xFF;
    uint32_t mantissa = bits & 0x7FFFFF;
    
    std::cout << std::format("符号: {}\n", sign);
    std::cout << std::format("指数: {:08b}\n", exponent);
    std::cout << std::format("仮数: {:023b}\n", mantissa);

    return 0;
}

値: -0.75
2進数: 10111111010000000000000000000000
符号: 1
指数: 01111110
仮数: 10000000000000000000000

std::bit_castはポインタを用いた型変換（reinterpret_cast）よりも安全で、未定義動作を回避しつつ効率的な型変換を可能にします。

数値を2進数文字列へ変換する自作関数の実装

標準ライブラリを使わず、アルゴリズムの理解のために「10進数を2進数文字列に変換する関数」を実装してみます。

#include <iostream>
#include <string>
#include <algorithm>

/**
 整数を2進数文字列に変換する
 */
std::string to_binary_string(uint32_t n) {
    if (n == 0) return "0";
    
    std::string r;
    while (n != 0) {
        // 下位1ビットを取り出して文字に変換
        r += (n % 2 == 0 ? "0" : "1");
        // 1ビット右へシフト
        n /= 2;
    }
    
    // 逆順に並んでいるので反転
    std::reverse(r.begin(), r.end());
    return r;
}

int main() {
    uint32_t test_val = 123;
    std::cout << test_val << " の2進数: " << to_binary_string(test_val) << std::endl;
    return 0;
}

123 の2進数: 1111011

この実装は、基数変換の基本である「2で割り続け、余りを記録する」というプロセスを忠実に再現したものです。

より高速な処理が必要な場合は、ビット演算（& 1 と >> 1）を用いる手法が一般的です。

2進数操作のパフォーマンスと最適化

C++において2進数（ビット）操作が好まれる最大の理由は、実行速度です。

CPUはビット演算を最小のクロックサイクルで実行できるため、計算量の多い処理をビット演算に置き換えることで劇的な高速化が期待できます。

乗算・除算の代替

2のべき乗による乗算や除算は、左シフトおよび右シフトに置き換えることができます。

int x = 10;
int mul = x << 3; // x * 8 と同等
int div = x >> 1; // x / 2 と同等

現代のコンパイラは非常に優秀なため、x * 8と記述しても自動的にシフト演算に最適化してくれます。

そのため、可読性を犠牲にしてまで手動でシフト演算を書く必要性は減っていますが、アルゴリズムレベルで「2のべき乗」を意識することは依然として重要です。

メモリの節約

例えば、8つの真偽値（bool）を保持する場合、単純な配列では1ビットずつではなく通常1バイト（8ビット）ずつメモリを消費し、計8バイト使ってしまいます。

しかし、1つのuint8_t変数の中でビットフラグとして管理すれば、消費メモリはわずか1バイトで済みます。

組み込みシステムや大規模なデータ構造を扱う場合、この差が決定的なパフォーマンスの差につながります。

まとめ

C++における2進数の扱いは、言語の進化とともに驚くほど容易かつ強力になりました。

• C++14：0bリテラルと桁区切り文字により、コード上での表現力が向上。
• C++20/23：std::formatやstd::printにより、デバッグやログ出力が簡潔に。
• bitset：豊富なメンバ関数による安全なビット管理。
• <bit>ヘッダ：popcountなどの高度なビット操作が標準化され、移植性と速度が向上。

2進数の操作をマスターすることは、C++の真の力を引き出すための第一歩です。

ビット演算を単なる数値計算の手段としてだけでなく、メモリ効率の向上やハードウェア制御の武器として使いこなせるようになれば、より高度なシステム開発が可能になるでしょう。

本記事で紹介したテクニックを、ぜひ日々のコーディングに活用してください。