ホーム / C言語 /

C言語のビット演算を完全理解！AND/OR/シフト操作の使い方

2025年4月15日火曜日

C言語

C言語のビット演算、その操作について「なんだかよく分からない…」「難しそう…」と感じていませんか？

プログラミングをしていると、時々見かける「&」や「|」、「<<」といった不思議な記号たち。実は、これらがビット演算子と呼ばれるもので、コンピュータの気持ち（？）をより深く理解し、省エネで高速なプログラムを書くための秘密兵器なんです！

「0と1の世界を直接いじるなんて、自分にできるかな…」と思うかもしれませんが、大丈夫！ 基本さえ押さえれば、思ったよりもずっと使いこなせるようになりますよ。

当記事では、C言語におけるビット演算の基本から、代表的な演算子の使い方、実践的なテクニック、そして注意点まで、まるっと解説していきます。

当記事を読むことで、以下の点を学べます。

  • ビット演算がそもそも何なのか
  • C言語で使えるビット演算子の種類とそれぞれの役割
  • AND、OR、XOR、NOT、シフト演算の具体的な使い方
  • ビット演算を用いたデータ操作テクニックの基本
  • ビット演算を使うときに気をつけるべきこと

さあ、一緒にビット演算の世界を探求しましょう！

C言語のビット演算とは？ なぜ「操作」が必要なのか？

コンピュータの中では、全ての情報が「0」と「1」の組み合わせ、つまりビットの並びとして表現されています。例えば、数字の「5」は、8ビットで表現すると「00000101」のようになります。

ビット演算とは、普段あまり意識しない、このビットの並びに対して直接行う操作のことです。
では、なぜわざわざビット単位で操作する必要があるのでしょうか？

理由はいくつかあります。

  • メモリの節約
    限られたメモリ領域に、たくさんの情報（例えば、ON/OFFのような状態）を詰め込みたい場合に役立ちます。1ビットあれば、2つの状態を表せますからね。
  • 処理の高速化
    ビット演算は、コンピュータが得意とする基本的な計算（CPUレベルでの命令に近い）なので、通常の計算（足し算や掛け算など）よりも高速に動作することがあります。特に掛け算や割り算の代わりにシフト演算を使うテクニックは有名です。
  • ハードウェアの制御
    デバイスドライバや組み込みシステムなど、ハードウェアに近い部分をプログラムで制御する場合、特定のビットをON/OFFして機器の状態を細かく設定する必要が出てきます。

このように、ビットを直接操作する技術は、パフォーマンスが求められたり、低レベルな制御が求められたりする場面で、なくてはならない知識となるわけです。

C言語ビット演算の基本！主要な演算子の種類と書き方

C言語でよく使われるビット演算子には、以下の種類があります。まずは、どんな仲間たちがいるのか、顔ぶれを見てみましょう。

  • & (ビット単位のAND / 論理積)
    2つのビット列を用意し、同じ位置のビットが両方とも1の場合に、結果のビットが1になります。
  • | (ビット単位のOR / 論理和)
    2つのビット列を用意し、同じ位置のビットのどちらか一方、または両方が1の場合に、結果のビットが1になります。
  • ^ (ビット単位のXOR / 排他的論理和)
    2つのビット列を用意し、同じ位置のビットが異なる場合（片方が1で、もう片方が0）に、結果のビットが1になります。
  • ~ (ビット単位のNOT / ビット反転)
    1つのビット列を用意し、全てのビットを反転させます（0は1に、1は0に）。
  • << (左シフト)
    1つのビット列を用意し、全てのビットを指定した数だけ左に移動させます。右端には0が補充されます。
  • >> (右シフト)
    1つのビット列を用意し、全てのビットを指定した数だけ右に移動させます。左端の扱いは少し注意が必要です（後述します）。

これらの演算子は、整数型の変数（char, int, longなど）に対して使います。基本的な書き方は、算術演算子（+, - など）と同じような感覚です。

int a = 5;  // 2進数: 00000101
int b = 3;  // 2進数: 00000011
int result;

result = a & b; // AND演算
result = a | b; // OR演算
result = a ^ b; // XOR演算
result = ~a;    // NOT演算
result = a << 1; // 左に1ビットシフト
result = a >> 1; // 右に1ビットシフト

それでは、各演算子が具体的にどんな動きをするのか、順番に見ていきましょう。

論理積 (AND) `&` の使い方とサンプルコード

AND演算子 `&` は、2つのビット列を比較し、対応するビットが両方とも1の場合だけ、結果のビットを1にします。 それ以外の場合は0になります。

例を見てみましょう。数値 5 (00000101) と 3 (00000011) でAND演算を行うと、以下のようになります。

  00000101  (5)
& 00000011  (3)
----------
  00000001  (1)

一番右のビット（1桁目）は両方1なので結果も1です。右から3番目のビット（3桁目）は上が1で下が0なので、結果は0になります。他の桁も同様に、両方1でないため0です。結果として、1 (00000001) が得られます。

AND演算は、特定のビットが立っている（1である）かを確認したり、特定の部分だけを取り出す（マスク処理）のによく使われます。

サンプルコード：特定ビットが立っているか確認

#include <stdio.h>

int main() {
    int data = 5; // 2進数: 00000101
    int mask = 4; // 2進数: 00000100 (3番目のビットだけが1)

    // data の3番目のビットが立っているか確認
    if ((data & mask) != 0) {
        printf("data の3番目のビットは立っています。\n");
    } else {
        printf("data の3番目のビットは立っていません。\n");
    }

    // data の2番目のビットが立っているか確認 (mask = 2, 00000010)
    mask = 2; // 2進数: 00000010
    if ((data & mask) != 0) {
         printf("data の2番目のビットは立っています。\n");
    } else {
         printf("data の2番目のビットは立っていません。\n");
    }

    return 0;
}

ソースコードの表示結果

data の3番目のビットは立っています。
data の2番目のビットは立っていません。

コード解説:
`data & mask` を計算すると、`mask` で1になっているビット位置だけが `data` から取り出されます。`00000101 & 00000100` の結果は `00000100` (4) となり、0ではありません。

一方、`00000101 & 00000010` の結果は `00000000` (0) となります。このようにして、特定のビットの状態を調べることができます。 `(data & mask)` のように括弧で囲むのを忘れないようにしましょう。演算子の優先順位の関係で、括弧がないと意図しない結果になることがあります。

論理和 (OR) `|` の使い方とサンプルコード

OR演算子 `|` は、2つのビット列を比較し、対応するビットのどちらか一方、または両方が1の場合に、結果のビットを1にします。 両方とも0の場合だけ、結果は0になります。

同じく数値 5 (00000101) と 3 (00000011) でOR演算を行うと、以下のようになります。

  00000101  (5)
| 00000011  (3)
----------
  00000111  (7)

一番右のビット（1桁目）は両方1なので結果は1。右から2番目のビット（2桁目）は下が1なので結果は1。右から3番目のビット（3桁目）は上が1なので結果は1です。他の桁は両方0なので0となります。結果として、7 (00000111) が得られました。

OR演算は、特定のビットを強制的に1にする（フラグを立てる）のによく使われます。

サンプルコード：特定ビットをONにする

#include <stdio.h>

int main() {
    int flags = 4; // 2進数: 00000100 (3番目のフラグのみON)
    int mask = 3;  // 2進数: 00000011 (1番目と2番目のフラグをONにするためのマスク)

    printf("元のflags: %d (2進数: 00000100)\n", flags);

    // flags の1番目と2番目のビットをONにする
    flags = flags | mask;

    printf("変更後のflags: %d (2進数: 00000111)\n", flags); // 結果は7になるはず

    return 0;
}

ソースコードの表示結果

元のflags: 4 (2進数: 00000100)
変更後のflags: 7 (2進数: 00000111)

コード解説:
`flags | mask` を計算すると、`mask` で1になっているビット位置が、`flags` の値に関わらず結果で1になります。 `00000100 | 00000011` の結果は `00000111` (7) となり、元々ONだった3番目のビットはそのまま、新たに1番目と2番目のビットがONになりました。このように、既存の状態を壊さずに特定のビットだけをONにしたい場合に便利です。

排他的論理和 (XOR) `^` の使い方とサンプルコード

XOR演算子 `^` は、2つのビット列を比較し、対応するビットが異なる場合（一方が0で他方が1）に、結果のビットを1にします。 対応するビットが同じ場合（両方0、または両方1）は、結果は0になります。

数値 5 (00000101) と 3 (00000011) でXOR演算を行うと、以下のようになります。

  00000101  (5)
^ 00000011  (3)
----------
  00000110  (6)

一番右のビット（1桁目）は両方1なので結果は0。右から2番目のビット（2桁目）は上が0で下が1なので結果は1。右から3番目のビット（3桁目）は上が1で下が0なので結果は1です。他の桁は両方0なので0となります。結果として、6 (00000110) が得られました。

XOR演算は、特定のビットを反転させる（トグル操作）のによく使われます。同じ値で2回XOR演算を行うと、元の値に戻るという面白い性質もあります。

サンプルコード：特定ビットを反転させる

#include <stdio.h>

int main() {
    int data = 5; // 2進数: 00000101
    int mask = 3; // 2進数: 00000011 (1番目と2番目のビットを反転させるためのマスク)

    printf("元のdata: %d (2進数: 00000101)\n", data);

    // data の1番目と2番目のビットを反転させる
    data = data ^ mask;
    printf("1回目の反転後 data: %d (2進数: 00000110)\n", data); // 結果は6になるはず

    // もう一度同じマスクで反転させる
    data = data ^ mask;
    printf("2回目の反転後 data: %d (2進数: 00000101)\n", data); // 元の5に戻るはず

    return 0;
}

ソースコードの表示結果

元のdata: 5 (2進数: 00000101)
1回目の反転後 data: 6 (2進数: 00000110)
2回目の反転後 data: 5 (2進数: 00000101)

コード解説:
`data ^ mask` を計算すると、`mask` で1になっているビット位置の `data` のビットが反転します。`00000101 ^ 00000011` の結果は `00000110` (6) となり、1番目と2番目のビットが反転しました（0→1、1→0）。さらにもう一度 `00000110 ^ 00000011` を計算すると `00000101` (5) となり、元に戻ります。このように、特定のビットの状態をON/OFFで切り替えたいときにXORは便利です。

ビット反転 (NOT) `~` の使い方とサンプルコード

NOT演算子 `~` は、1つの値の全てのビットを反転させます。 0は1に、1は0になります。これまでの演算子と違い、操作対象は1つだけです（単項演算子）。

数値 5 (8ビット表現で 00000101) にNOT演算を行うと、以下のようになります。

~ 00000101  (5)
----------
  11111010  (-6) ※符号付き整数の場合

全てのビットが単純に反転します。ただし、コンピュータ内部での負の数の表現方法（通常は2の補数表現）のため、符号付き整数型（例えば `int`）で `~5` を計算すると、結果は `-6` になることが多いです。符号なし整数型（`unsigned int` など）の場合は、単純にビットが反転した大きな正の数になります。

サンプルコード：ビットを反転させる

#include <stdio.h>

int main() {
    signed char data = 5; // 8ビット符号付き整数: 00000101
    signed char result;

    result = ~data;

    // 環境によって結果の表示は異なりますが、
    // 内部的には 11111010 になっているはずです。
    // printfで10進数表示すると -6 になることが多いです。
    printf("data (5) のビット反転結果: %d\n", result);

    // 参考: 8ビットでのビットパターン表示 (簡易)
    printf("元のビット(data): ");
    for(int i = 7; i >= 0; i--) {
        printf("%d", (data >> i) & 1);
    }
    printf("\n");

    printf("反転後のビット(result): ");
     for(int i = 7; i >= 0; i--) {
        // resultをunsignedとして扱ってビット表示
        printf("%d", ((unsigned char)result >> i) & 1);
    }
    printf("\n");


    return 0;
}

ソースコードの表示結果（一例）

data (5) のビット反転結果: -6
元のビット(data): 00000101
反転後のビット(result): 11111010

コード解説:
`~data` によって、`data` の全ビットが反転します。 `00000101` は `11111010` になります。符号付き8ビット整数では、 `11111010` は 10進数で -6 を表すことが多いです。NOT演算は、全てのビットを一度に反転させたい場合に用います。 符号の扱いは少しややこしいですが、まずは「全ての0と1が入れ替わる」と覚えておきましょう。

左シフト `<<` の使い方とサンプルコード

左シフト演算子 `<<` は、指定した値のビット列全体を、指定した数だけ左に移動させます。 左に移動して空いた右側のビットには、0が補充されます。左端からはみ出したビットは消えてしまいます。

数値 5 (00000101) を 1 ビット左にシフト (`5 << 1`) すると、以下のようになります。

  00000101  (5)
<< 1
----------
  00001010  (10)

全てのビットが1つ左にずれ、一番右には0が入りました。結果は 10 (00001010) です。

左に1ビットシフトすることは、元の値を2倍することとほぼ同じ意味になります（オーバーフローしない限り）。同様に、2ビット左シフトすれば4倍、3ビット左シフトすれば8倍です。

サンプルコード：値を2倍、4倍する

#include <stdio.h>

int main() {
    int num = 5;

    printf("元の値: %d (2進数: ...00000101)\n", num);

    // 1ビット左シフト (2倍)
    int result_x2 = num << 1;
    printf("1ビット左シフト後: %d (2進数: ...00001010)\n", result_x2); // 10になるはず

    // 2ビット左シフト (4倍)
    int result_x4 = num << 2;
    printf("2ビット左シフト後: %d (2進数: ...00010100)\n", result_x4); // 20になるはず

    return 0;
}

ソースコードの表示結果

元の値: 5 (2進数: ...00000101)
1ビット左シフト後: 10 (2進数: ...00001010)
2ビット左シフト後: 20 (2進数: ...00010100)

コード解説:
`num << 1` は `num` のビット列を1つ左にずらす操作です。 `00000101` が `00001010` (10) になりました。

 `num << 2` では2つ左にずらすので `00010100` (20) となります。掛け算の代わりに左シフトを使うと、計算が速くなる場合があります。ただし、シフトしすぎて左端から重要なビットがはみ出てしまう（オーバーフロー）と、意図しない結果になるので注意が必要です。

右シフト `>>` の使い方とサンプルコード

右シフト演算子 `>>` は、指定した値のビット列全体を、指定した数だけ右に移動させます。 右端からはみ出したビットは消えてしまいます。左端に補充されるビットは、元の値の型によって挙動が異なります。

  • 符号なし整数 (unsigned int など) の場合: 左端には常に 0 が補充されます（論理シフト）。
  • 符号付き整数 (int など) の場合: 処理系によりますが、多くの場合、元の最上位ビット（符号ビット）と同じ値が補充されます（算術シフト）。つまり、元の数が正なら0、負なら1が補充されることが多いです。

数値 10 (00001010) を 1 ビット右にシフト (`10 >> 1`) すると、以下のようになります。

  00001010  (10)
>> 1
----------
  00000101  (5)  ※左端には0が補充

全てのビットが1つ右にずれ、右端の0は消えました。左端には0が補充され、結果は 5 (00000101) です。

右に1ビットシフトすることは、元の値を2で割った商（小数点以下切り捨て）を求めることとほぼ同じ意味になります。

サンプルコード：値を1/2、1/4にする

#include <stdio.h>

int main() {
    int num = 20; // 2進数: ...00010100

    printf("元の値: %d (2進数: ...00010100)\n", num);

    // 1ビット右シフト (1/2)
    int result_d2 = num >> 1;
    printf("1ビット右シフト後: %d (2進数: ...00001010)\n", result_d2); // 10になるはず

    // 2ビット右シフト (1/4)
    int result_d4 = num >> 2;
    printf("2ビット右シフト後: %d (2進数: ...00000101)\n", result_d4); // 5になるはず

    // 負の数の例 (-20 のビット表現の一例: 11101100)
    int neg_num = -20;
    int neg_result_d2 = neg_num >> 1; // 算術シフトの場合 -10 (11110110) になることが多い
    printf("元の負の値: %d\n", neg_num);
    printf("負の値を1ビット右シフト後: %d\n", neg_result_d2);


    return 0;
}

ソースコードの表示結果（一例）

元の値: 20 (2進数: ...00010100)
1ビット右シフト後: 10 (2進数: ...00001010)
2ビット右シフト後: 5 (2進数: ...00000101)
元の負の値: -20
負の値を1ビット右シフト後: -10

コード解説:
`num >> 1` は `num` のビット列を1つ右にずらす操作です。 `00010100` (20) が `00001010` (10) になりました。 `num >> 2` では2つ右にずらすので `00000101` (5) となります。

割り算の代わりに右シフトを使うと、計算が速くなる場合があります。負の数を右シフトする場合、算術シフトが行われるか論理シフトが行われるかは処理系（コンパイラなど）に依存する可能性があるため、符号なし整数（unsigned）を使う方が挙動は明確になります。

C言語ビット演算の代表的な操作テクニック

これまで見てきた演算子を組み合わせると、より実践的なビット操作が可能になります。いくつか代表的なテクニックを紹介します。

特定ビットの抽出（マスク処理）

調べたいビット位置だけが1で、他が0の「マスク」と呼ばれる値を用意し、対象の値と AND (`&`) 演算を行います。結果が0でなければ、そのビットは立っていたと判断できます。
例: `data` の下位4ビットだけを取り出す → `extracted = data & 0x0F;` (0x0F は 2進数で 00001111)

特定ビットのセット（フラグを立てる）

セットしたいビット位置だけが1で、他が0のマスクを用意し、対象の値と OR (`|`) 演算を行います。指定したビットが強制的に1になります。
例: `flags` の3番目のビットを立てる → `flags = flags | 0x04;` (0x04 は 2進数で 00000100)

特定ビットのクリア（フラグを降ろす）

クリアしたいビット位置だけが0で、他が1のマスクを用意し、対象の値と AND (`&`) 演算を行います。指定したビットが強制的に0になります。クリアしたいビット位置だけが1のマスクを NOT (`~`) で反転させて作るのが一般的です。
例: `flags` の3番目のビットを降ろす → `flags = flags & (~0x04);` (~0x04 は 2進数で 11111011)

特定ビットの反転（トグル）

反転させたいビット位置だけが1で、他が0のマスクを用意し、対象の値と XOR (`^`) 演算を行います。指定したビットが0なら1に、1なら0に反転します。
例: `flags` の3番目のビットを反転させる → `flags = flags ^ 0x04;`

これらのテクニックは、プログラムの状態管理やデータの圧縮・展開など、様々な場面で応用されています。

C言語でビット演算を操作する際の注意点

ビット演算は強力ですが、いくつか気をつけるべき点があります。思わぬバグを生まないために、以下の点を意識しておきましょう。

演算子の優先順位

ビット演算子 (`&`, `^`, `|`) は、比較演算子 (`==`, `!=`, `<`, `>` など) よりも優先順位が低いです。例えば、`data & mask == check_value` と書くと、`mask == check_value` が先に計算されてしまい、意図通りに動作しません。必ず `(data & mask) == check_value` のように括弧 `()` を使って、演算の順序を明確にしましょう。

符号付き整数と符号無し整数の扱い

特に右シフト (`>>`) の挙動が、符号付きか符号なしかで異なる可能性があります（算術シフトか論理シフトか）。また、NOT (`~`) の結果も、符号の有無で解釈が変わります。ビット演算を行う際は、扱うデータが符号付きか無しかを意識し、可能であれば意図しない挙動を防ぐために符号なし整数型 (`unsigned char`, `unsigned int` など) を使うのが無難です。

シフト演算でのオーバーフロー

左シフト (`<<`) で、値を持つビットが左端からはみ出してしまうと、情報が失われます（オーバーフロー）。右シフト (`>>`) でも、右端からビットが失われます。シフトするビット数が、扱っている型のビット数以上にならないように注意が必要です。

処理系依存の挙動

C言語の規格では、一部のビット演算（特に負の数の右シフトなど）の挙動が厳密に定められておらず、処理系（コンパイラやCPUアーキテクチャ）に依存する場合があります。移植性の高いコードを書くためには、規格で保証された範囲での使い方を心がけるか、環境による違いを吸収するようなコードを書く必要があります。

最初は少しややこしく感じるかもしれませんが、実際にコードを書いて動かしながら、これらの点を確認していくのが理解への近道です。

【まとめ】C言語のビット演算を理解して活用しよう

当記事では、C言語におけるビット演算の基本から、AND、OR、XOR、NOT、シフトといった主要な演算子の使い方、代表的な操作テクニック、そして注意点について解説しました。

ビット演算は、コンピュータの内部動作に近いレベルでデータを扱うための技術です。
これを使いこなせるようになると、

  • メモリ効率の良いプログラム
  • 処理速度の速いプログラム
  • ハードウェアを細かく制御するプログラム

などを書く能力が向上します。

最初はとっつきにくい印象があるかもしれませんが、一度理屈が分かれば、パズルのようにビットを組み合わせて目的の操作を実現できる、面白い分野でもあります。

紹介したサンプルコードなどを参考に、ぜひご自身で色々な値を試してみて、ビット演算の動きを体感してみてください。


【関連記事】

>> C言語とは？特徴・できること・学ぶメリット

このブログを検索
  • ()

自己紹介

自分の写真
リモートワークでエンジニア兼Webディレクターとして活動しています。プログラミングやAIなど、日々の業務や学びの中で得た知識や気づきをわかりやすく発信し、これからITスキルを身につけたい人にも役立つ情報をお届けします。 note → https://note.com/yurufuri X → https://x.com/mnao111

QooQ