ビット単位の処理 | Programming Place Plus　新C++編

このページの概要 🔗

このページでは、前のページで取り上げた１バイト単位で処理を行う話をさらに押し進めて、１ビット単位で処理を行う方法を取り上げます。ビット単位の処理は、必要なデータ量を極限まで小さくするために役立ちます。

このページの解説は C++14 をベースとしています。

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

• ビット単位の処理
• ｎ進数の整数リテラル
  • ２進数で出力するには
  • 整数リテラルの型
• ビット単位NOT（ビット単位論理否定）
• ビット単位OR（ビット単位論理和）
  • 任意のビットを 1 にする
• ビット単位AND（ビット単位論理積）
  • ビットが 1 になっているか調べる
  • 任意のビットを 0 にする
• ビット単位XOR（ビット単位排他的論理和）
  • 任意のビットを反転する
• シフト演算
  • 乗算や除算の代替
• まとめ
• 参考リンク
• 練習問題
• 更新履歴

ビット単位の処理 🔗

「配列とポインタ」のページでは、データを１バイト単位で取り扱うため、バイト列という考え方が登場しました。今度はさらに単位を小さくして、１ビット単位での取り扱い方を学ぶことにします。ビットは情報の最小単位なので、これ以上を分解して扱うことはできません。

ビット単位で行う処理とは、あるビットに 0 か 1 を設定する、あるビットが 0 なのか 1 なのかを調べるといったことです。そのために使用する演算（ビット演算 (bitwise operation)）に、ビット単位AND、ビット単位OR、ビット単位XOR、ビット単位NOT、シフト演算といったものがあります。このページでそれぞれ解説します。

ｎ進数の整数リテラル 🔗

ビット演算を解説する前に、整数リテラルを 10進数以外で表記する方法を紹介しておきます。1ビットは、2進数の 1桁にあたるため、2進数で表記できると分かりやすいです。

整数リテラルに以下のプリフィックスを付加することで、10進数以外を使って表記できます。

実行できるプログラムは次のようになります。

#include <iostream>

int main()
{
    int num10 {1000};
    int num2 {0b1111101000};
    int num8 {01750};
    int num16 {0x3E8};

    std::cout << num10 << "\n"
              << num2 << "\n"
              << num8 << "\n"
              << num16 << "\n"
              ;
}

実行結果：

1000
1000
1000
1000

何進数で表記するかは、表記上の問題であって、表している値には違いがないことを理解してください。このサンプルでは、1000、0b1111101000、01750、0x3E8 という４つの整数リテラルが登場していますが、これはすべて、10進数の 1000 と同じ値です。実際、出力してみるとすべて 1000 になっています。

プリフィックスがあっても、桁区切り文字（「int型の限界」のページを参照）を入れることはできます（たとえば 0b11'1110'1000 のように）。

「配列とポインタ」のページで取り上げたとおり、std::oct や std::hex というマニピュレータを使えば、8進数や 16進数で出力できます（残念なことに 2進数で出力する簡単な方法はありません）。

std::oct や std::hex を使うだけでは、整数リテラルのプリフィックス（0、0x、0X）と同じものが付加されませんが、std::showbase を併用すると付加されます。std::noshowbase を使うと、プリフィックスが付加されない状態に戻ります。

#include <iostream>

int main()
{
    int num8 {01750};
    int num16 {0x3E8};

    std::cout << std::showbase
              << std::oct << num8 << "\n"
              << std::hex << num16 << "\n"
              << std::noshowbase
              << std::oct << num8 << "\n"
              << std::hex << num16 << "\n"
              ;
}

実行結果：

01750
0x3e8
1750
3e8

#include <bitset>
#include <iostream>

int main()
{
    int num2 {0b11'1110'1000};

    std::cout << std::bitset<16>(num2) << "\n";
}

0000001111101000

ビット単位NOT（ビット単位論理否定）

ではここからビット演算の説明をしていきます。１つ目は、ビット単位NOT（ビット単位論理否定） (bitwise NOT) です。

以前、「要素を探索する」のページで、論理否定という演算（演算子は !）を解説しました。論理否定は、オペランドが true なら false に、false なら true になるというものでした。ビット単位NOT はこれのビット版で、対象のビットが 1 なら 0、0 なら 1 になります。ビットの 0 と 1 が逆になることから、ビット反転 (bit flipping) と呼ぶことがあります。

【上級】正確には、オペランドの１の補数を求める演算と定義されます^[3]。

ビット単位NOT の演算子は ~ です。

~式

~ の代わりに使える表記（代替表現）として compl があります^[13]。まったく同じ意味として使えるため、単純に置き換えられます。ただし、Visual Studio ではコンパイラオプションに /permissive- （Visual Studio 2015 の場合は /Za）の指定が必要です。

「式」は、整数型か unscoped enum でなければなりません。

なお、演算を行う前に整数拡張（「整数型」のページを参照）が行われ、結果の型は整数拡張後の型です^[4]。

実際に試してみます。

#include <bitset>
#include <iostream>

int main()
{
    std::cout << std::bitset<4>(~0b0011u) << "\n"
              << std::bitset<8>(~0b11001100u) << "\n";
}

実行結果：

1100
00110011

ビットが反転されていることが分かります。

ビット単位NOT は、オペランドそのものの値を変更するわけではないので、変数の値をビット反転するときは、結果を変数に書き戻す必要があります。

auto value = 0b1100u;
~value;           // 結果を捨てている。value の値は変わらない
value = ~value;   // value がビット反転する

任意のビットだけを反転させたい場合は、ビット単位XOR を使います。

ここまでのサンプルプログラムでは、~ のオペランドに uサフィックスが付けて符号無し整数型にしています。強制されているわけではないですが、（ビット単位NOT 以外のビット演算も含めて）ビット演算は符号無し整数型に対して使うのが安全です^[5]。なぜなら、符号付き整数型には、符号ビット (sign bit)と呼ばれる特別なビットが含まれているためです。普通、最上位のビットのところが符号ビットとして使われており、これが 1 のとき負の整数であることを意味します。符号無し整数型には、符号ビットがなく、すべてのビットを数を表現するために使い尽くします（そのため、符号無し整数型のほうが、扱える上限値が大きくなる）。ビット演算は符号ビットのことを特別扱いせずに操作してしまうため、予想外の結果を生むことがあります。

ビット単位OR（ビット単位論理和） 🔗

次は、ビット単位OR（ビット単位論理和） (bitwise OR) です。

以前、「要素を探索する」のページで、論理OR という演算（演算子は ||）を解説しました。論理OR は２つの論理値のいずれか、あるいは両方が true であるときにかぎって結果が true になり、それ以外の場合は false になるという演算でした。ビット単位OR はこれのビット版で、２つのビットのいずれか、あるいは両方が 1 であるときにかぎって結果が 1 になり、それ以外の場合は 0 になるという演算です。

ビット単位OR の演算子は | です。

式 | 式

| の代わりに使える表記（代替表現）として bitor があります^[13]。まったく同じ意味として使えるため、単純に置き換えられます。ただし、Visual Studio ではコンパイラオプションに /permissive- （Visual Studio 2015 の場合は /Za）の指定が必要です。

「式」は、整数型か unscoped enum でなければなりません。ビット単位NOT のところでも触れたとおり、符号無し整数型に対して使うのが安全ではあります。

実際に試してみます。0 と 1 の組み合わせは 4通りなので、4ビットの整数同士でビット演算を行って、すべてのパターンを網羅して確認してみます。

#include <bitset>
#include <iostream>

int main()
{
    auto value1 = 0b0011u;
    auto value2 = 0b0101u;

    std::cout << std::bitset<4>(value1 | value2) << "\n";
}

実行結果：

0111

0011 と 0101 に対してビット単位OR を行っています。同じ桁にあるビットどうしが演算の対象になります。結果は 0111 です。つまり、以下の表のような結果になったわけで、２つのビットのいずれか、あるいは両方が 1 のときに、結果が 1 になることが分かります。

value = value | 0b1100u;

value |= 0b1100u;

#include <bitset>
#include <iostream>

int main()
{
    auto value = 0b0110'0011u;

    value |= 0b1010'1010u;
    std::cout << std::bitset<8>(value) << "\n";
}

11101011

// 8個の情報を bool型で表現すると、sizeof(bool) * 8（＝最小でも 8バイト）が必要
bool settings[8] {};
settings[2] = true;
settings[7] = true;

// 8個の情報をそれぞれ 1ビットで表現すると、8ビット（＝1バイト）に収まる
unsigned char settings {};
settings |= 0b0000'0100u;
settings |= 0b1000'0000u;
settings |= 0b1101'1101u;  // 一気に設定できる利点もある

ビット単位AND（ビット単位論理積） 🔗

次は、ビット単位AND（ビット単位論理積） (bitwise AND) です。

以前、「要素を探索する」のページで、論理AND という演算（演算子は &&）を解説しました。論理AND は２つの論理値がともに true であるときにかぎって結果が true になり、それ以外の場合は false になるという演算でした。ビット単位AND はこれのビット版で、２つのビットがともに 1 であるときにかぎって結果が 1 になり、それ以外の場合は 0 になるという演算です。

ビット単位AND の演算子は & です。

式 & 式

& の代わりに使える表記（代替表現）として bitand があります^[13]。まったく同じ意味として使えるため、単純に置き換えられます。ただし、Visual Studio ではコンパイラオプションに /permissive- （Visual Studio 2015 の場合は /Za）の指定が必要です。

「式」は、整数型か unscoped enum でなければなりません。ビット単位NOT のところでも触れたとおり、符号無し整数型に対して使うのが安全ではあります。

実際に試してみます。0 と 1 の組み合わせは 4通りなので、4ビットの整数同士でビット演算を行って、すべてのパターンを網羅して確認してみます。

#include <bitset>
#include <iostream>

int main()
{
    auto value1 = 0b0011u;
    auto value2 = 0b0101u;

    std::cout << std::bitset<4>(value1 & value2) << "\n";
}

実行結果：

0001

0011 と 0101 に対してビット単位AND を行っています。同じ桁にあるビットどうしが演算の対象になります。結果は 0001 です。つまり、以下の表のような結果になったわけで、２つのビットがともに 1 のときだけ、結果が 1 になることが分かります。

#include <iostream>

int main()
{
    auto value1 = 1234u;
    auto value2 = 1235u;

    std::cout << (value1 & 0b1) << "\n"
              << (value2 & 0b1) << "\n";
}

0
1

#include <iostream>

int main()
{
    auto value1 = 1234u;
    auto value2 = 1235u;

    std::cout << std::boolalpha
              << ((value1 & 0b1) != 0) << "\n"
              << ((value2 & 0b1) != 0) << "\n";
}

false
true

value = value & 0b1100u;
value &= 0b1100u;

#include <bitset>
#include <iostream>

int main()
{
    auto value = 0b1110'1011u;

    value &= ~0b0000'1111u;
    std::cout << std::bitset<8>(value) << "\n";
}

11100000

value &= ~0b0000'1111u;
value &= 0b1111'0000u;  // これでも同じことだが

constexpr auto lower4bits = 0b0000'1111u;  // 下位4ビットを操作するためのビット列

value |= lower4bits;   // ビットを立てる
value &= ~lower4bits;  // ビットを降ろす

ビット単位XOR（ビット単位排他的論理和）

次は、ビット単位XOR（ビット単位排他的論理和） (bitwise XOR、bitwise exclusive OR) です。

XOR は exclusive OR を省略したものです。EOR や EX-OR のように表現されることもあります。また、排他的(exclusive) でない OR（つまり通常のビット単位OR）のことを、bitwise inclusive OR と表現することがあります。

ビット単位XOR は、２つのビットが同じときに結果が 0 になり、同じでないときに 1 になるという演算です。

ビット単位XOR の演算子は ^ です。

式 ^ 式

^ の代わりに使える表記（代替表現）として xor があります^[13]。まったく同じ意味として使えるため、単純に置き換えられます。ただし、Visual Studio ではコンパイラオプションに /permissive- （Visual Studio 2015 の場合は /Za）の指定が必要です。

「式」は、整数型か unscoped enum でなければなりません。ビット単位NOT のところでも触れたとおり、符号無し整数型に対して使うのが安全ではあります。

実際に試してみます。0 と 1 の組み合わせは 4通りなので、4ビットの整数同士でビット演算を行って、すべてのパターンを網羅して確認してみます。

#include <bitset>
#include <iostream>

int main()
{
    auto value1 = 0b0011u;
    auto value2 = 0b0101u;

    std::cout << std::bitset<4>(value1 ^ value2) << "\n";
}

実行結果：

0110

0011 と 0101 に対してビットXOR を行っています。同じ桁にあるビットどうしが演算の対象になります。結果は 0110 です。つまり、以下の表のような結果になったわけで、２つのビットが同じ場合に結果が 0 になることが分かります。

複合代入演算子は ^= です。

^= の代わりに使える表記（代替表現）として xor_eq があります^[13]。まったく同じ意味として使えるため、単純に置き換えられます。ただし、Visual Studio ではコンパイラオプションに /permissive- （Visual Studio 2015 の場合は /Za）の指定が必要です。

#include <bitset>
#include <iostream>

int main()
{
    auto value = 0b1100'0011u;

    std::cout << std::bitset<8>(value ^ 0b1111'0000) << "\n"
              << std::bitset<8>(value ^ 0b1010'1010) << "\n";
}

00110011
01101001

シフト演算 🔗

最後に、シフト演算 (shift operation) を紹介します。

シフト演算は、ビット列を任意のビット数分だけずらす（シフトする）操作です。00111100 が 01111000 になるように、左側にずらすものを左シフト (left shift)、00111100 が 00011110 になるように、右側にずらすものを右シフト (right shift) と呼び分けます。ずらすビット数は指定できます。

左シフトなら上位側のビットが、右シフトなら下位側のビットが失われることになります。反対に、左シフトなら下位側に、右シフトなら上位側に空きができることになりますが、空いたところは 0 で埋められます。

【上級】C++ のシフト演算は、符号ビットの存在を無視しておこなう論理シフトです。算術シフトは用意されていません。

【C++20】消えていったビットが逆側から戻ってくる循環シフト（ビットローテーション）を行う関数が標準ライブラリに追加されています。std::rotl関数^[8]で左循環シフト、std::rotr関数で右循環シフト^[9]が行えます。いずれも、<bit> という標準ヘッダで宣言されています。

左シフトの演算子は <<、右シフトの演算子は >> です。複合代入演算子は <<= と >>= です。

式 << 式
式 >> 式

【上級】std::cout や std::cin などで使ってきた << や >> も、シフト演算の演算子ですが、動作がオーバーロード（上書き）され、まったく異なる意味が与えられています。

左オペランドのビット列を、右オペランドの値の分だけシフトします。「式」は、整数型か unscoped enum でなければなりません。ビット単位NOT のところでも触れたとおり、符号無し整数型に対して使うのが安全ではあります。

なお、演算を行う前に整数拡張（「整数型」のページを参照）が行われ、結果の型も整数拡張後の型です^[7]。

右オペランドが負数の場合や、左オペランドを整数拡張した後のビット数を超える数を指定した場合は、未定義の動作です^[10]。

unsigned char value {0b0011'1100};

// 右オペランドが負数なのは、未定義の動作
value <<= -1;

// 左オペランドが int に整数拡張される。
// int の大きさが 32ビットとすると、40ビットのシフトは未定義の動作
value <<= 40;

左オペランドが符号付き整数型で負数の場合、左シフトでは未定義の動作です^[11]。右シフトの場合は処理系定義の動作です^[12]。

signed char value {-15};

value <<= 2;  // 未定義の動作
value >>= 2;  // 処理系定義の動作

ややこしいので、符号無し整数型に対して使うようにするのが早いと思います。

#include <iostream>

int main()
{
    auto value = 200u;

    std::cout << (value << 1) << "\n"
              << (value >> 1) << "\n";
}

400
100

まとめ 🔗

• 整数リテラルに、プリフィックス 0b や 0B を付加すると 2進数、0 を付加すると 8進数、0x や 0X を付加すると 16進数で表記できる
  • 8進数と 16進数については、std::oct や std::hex を使って出力でき、std::showbase を併用することでプリフィックス付きで出力できる
  • 2進数の出力を同様の方法で実現する方法はない。代わりに std::bitset が利用できる（プリフィックスは自力で付けるしかない）
• 整数リテラルの型のルールは、プリフィックスが付くことで変化し、符号付き整数型が候補に加えられる
• ~ でビット単位NOT の演算が行える。これは、すべてのビットを反転する
• | でビット単位OR の演算が行える。これは、２つのビットを比べ、いずれかか両方が 1 のときに 1、そうでないときに 0 になる
• & でビット単位AND の演算が行える。これは、２つのビットを比べ、両方ともが 1 のときに 1、そうでないときに 0 になる
• ^ でビット単位XOR の演算が行える。これは、２つのビットを比べ、両者が同じであるときに 0、同じでないときに 1 になる
• << や >> はシフト演算が行える。前者はビット列を左方向（上位側）へずらし、後者は右方向（下位側）へずらす
• |、&、^、<<、>> のそれぞれに複合代入演算子がある（|=、&=、^=、<<=、>>=）
• 符号付き整数型の最上位ビットは符号を表現するために使われるので、ビット演算がこれを巻き込むと、予想外の結果をもたらす可能性がある。安全のため、ビット演算は符号なし整数型に対して適用するのがよい

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

参考リンク 🔗

• 1. C++ standard working draft N4140 §2.14.2 Integer literals - 2 | 14882: Contents
• 2. C++ standard working draft N4140 §2.14.2 Integer literals | 14882: Contents
• 3. C++ standard working draft N4140 §5.3.1 Unary operators - 10 | 14882: Contents
• 4. C++ standard working draft N4140 §5.3.1 Unary operators - 10 | 14882: Contents
• 5. ES.101: Use unsigned types for bit manipulation | C++ Core Guidelines
• 6. C++ standard working draft N4140 §5.17 Assignment and compound assignment operators | 14882: Contents
  • E1 op= E2 と E1 = E1 op E2 は、E1 の評価の回数以外は同じである
• 7. C++ standard working draft N4140 §5.8 Shift operators - 1 | 14882: Contents
• 8. rotl - cpprefjp C++日本語リファレンス
• 9. rotr - cpprefjp C++日本語リファレンス
• 10. C++ standard working draft N4140 §5.8 Shift operators - 1 | 14882: Contents
• 11. C++ standard working draft N4140 §5.8 Shift operators - 2 | 14882: Contents
• 12. C++ standard working draft N4140 §5.8 Shift operators - 3 | 14882: Contents
• 13. C++ standard working draft N4140 §2.6 Alternative tokens - 2 | 14882: Contents
• Programming Place Plus　新C++編　参考書籍
  • 当サイトの参考書籍一覧ページ。C++ に関する書籍を多数紹介
• Programming Place Plus　新C++編　リンク集
  • 当サイトの参考Webサイト集。C++ の全般的な学習に有益なサイトを紹介

練習問題 🔗

問題の難易度について。

• (確認★) このページの内容の理解を確認する問題
• (基本★～★★) このページの内容を使って解く問題
• (応用★★～★★★) このページまでに学んだことを活用して、現実的な問題を解決する問題
• (調査★★～★★★) 自力で情報を探したり、模索したりする問題
• (発展★★★) プログラムの改善など、より上を目指すような問題

★は、すべての方が取り組める入門レベルの問題です。
★★は、自力でプログラミングができるようなるために、入門者の方であっても取り組んでほしい問題です。
★★★は、本格的にプログラマーを目指す人のための問題です。

unsigned int value {~0u};

auto value = 1u;
value ^= 1;
value ^= 1;

result = (a | b) & ~(a & b);

更新履歴 🔗

• ’2024/11/2
  • ~、|、&、^、|=、&=、^= の代替表現である compl、bitor、bitand、xor、or_eq、and_eq、xor_eq についてのコラムを追加
• ’2022/11/21
  • C++20 でコンパイルが通らないので、文字列リテラルの u8プリフィックスを削除
• ’2022/8/12
  • 新規作成

• 次のページへ（バイナリ形式での読み書き）
• 前のページへ（配列とポインタ）
• 新C++編のトップページへ
• Programming Place Plus のトップページへ