ビット演算


○バイトとビット

　これまで，何回か主記憶（メモリー）の構造を図をつかって説明してきました．
主記憶は，１バイトのメモリーが１列に連続的に並んだもので，１バイト単位にアドレスがついていると説明してきました．また，int型の整数やfloat型の実数は４バイト，double型の変数は８バイトで表現されると説明してきました．（整数は４バイトでない場合もありますが）．
ＣＰＵがデータを読み書きするときは，バイトを単位に読み書きします．しかし，この１バイトのメモリには，更に微細な構造があります．すなわち，１バイトのメモリーはより細かく見ると８個のセルで構成されています．図で表現すると次のようになります．
 
　
　　 　　 　　 　　 　　 　　 　　 　　
ビット 　 ７　 　　６　　　 ５　　　４　　　 ３　　　２　　　 １　　　 ０

この１個のセルのことをビットとよびます．ビットは記憶の最小単位で，１または０（つまり２進数）を記憶します．これら，８個のビットは切り離すことはできないと考えて下さい．ＣＰＵはメモリーのデータを８ビットまるごと（言い換えれば，１バイトを単位として）読み書きします．また，主記憶のアドレスというのは，この８ビットで構成される１バイトづつに割り当てられた番号ということになります．

　ついでに，左端のビットのことを最上位ビット，右端のビットを最下位ビットとよぶことも覚えておいて下さい．また，最下位ビットを第０ビット，最上位ビットを第７ビットと番号をつけて呼ぶこともあります．（最上位ビットを８，最下位ビットを１と番号付けする人もいます）


○ビットパターン

　１ビットは，０または１を記憶するとのべましたが，いま，８ビットすなわち１バイトで数値を表現することを考えてみましょう．
次に示すように数値を正の整数に限れば０〜２５５までの２５６通り（２の８乗とおり）の数値が表現できます．データを下の図のように１と０で表現したものを「ビットパターン」と呼ぶことも覚えておいて下さい，
 
 
 
１０進：０
０ ０ ０ ０ ０ ０ ０ ０
１０進：１
０ ０ ０ ０ ０ ０ ０ １
１０進：２
０ ０ ０ ０ ０ ０ １ ０
１０進：３
０ ０ ０ ０ ０ ０ １ １
１０進：４
０ ０ ０ ０ ０ １ ０ ０
１０進：５
０ ０ ０ ０ ０ １ ０ １
１０進：６
０ ０ ０ ０ ０ １ １ ０
・・・ 　
１０進：２５５
１ １ １ １ １ １ １ １


○ビット演算　その１　シフト演算

　次に，１０進数の１，２，４，８，・・・，１２８の場合についてビットパターンを表示してみると，次の図のように表すことができます．
 
１０進：０
０ ０ ０ ０ ０ ０ ０ ０
１０進：１
０ ０ ０ ０ ０ ０ ０ １
１０進：２
０ ０ ０ ０ ０ ０ １ ０
１０進：４
０ ０ ０ ０ ０ １ ０ ０
１０進：８
０ ０ ０ ０ １ ０ ０ ０
１０進：１６
０ ０ ０ １ ０ ０ ０ ０
１０進：３２
０ ０ １ ０ ０ ０ ０ ０
１０進：６４
０ １ ０ ０ ０ ０ ０ ０
１０進：１２８
１ ０ ０ ０ ０ ０ ０ ０

　これらの数値の間には次のような関係があります．２は１の２倍，４は２の２倍，８は２の２倍，１６は８の２倍，３２は１６の２倍，６４は３２の２倍，１２８は６４の２倍となります．
　これらのビットパターンを見比べて下さい．そうです．２倍される度に１が左へ１つづつビットシフトすることが分かると思います．
　逆に，例えば，１２８から始めて，次々に右へビットをシフトさせると，１／２づつ小さくなっていることが分かると思います．
そうです．
数値を２倍するには，ビットを左へシフトし，１／２するには右へシフトさせればよいのです．この演算は，ＣＰＵによりますが通常の乗算（＊）除算（／）で計算するより，ン十倍も計算が速いのです．（だからといって，数値計算などで使うためにあるのではありません！もちろん使えるならどこで使っても構いませんが）

　Ｃ言語では，このシフト演算を表すための，演算子が用意されています．ＣＰＵそのものにもそのような演算をする機能が備わっています．
シフト演算子は演算記号（＜＜）や（＞＞）で表現します．その使い方は直感的に分かるように＞＞が右シフト演算，＜＜が左シフト演算の記号です．

例えば，
１バイトの数値を記憶する変数ａがあったとしましょう．それには１が記憶されているとします．１はビットパターンで「０００００００１」ですね．
　　ｂ＝ａ＜＜２
と書けば，ａのビットを２回左へシフトさせることとなり，ｂには，ビットパターン「０００００１００」が代入されます．

また，ｂに１２８（「１０００００００」）を代入し
　　ｂ＝ａ＞＞４
と書けば，ａの各ビットを４回右へシフトさせることとなり，ｂにはビットパターンは「００００１０００」が代入されます．すなわち１０進数の８ですね．

上の２つの式では，ａのビットパターンそのものは，もとのままです．もし，ａのビットパターンそのものを変えたければ，複合演算子を使って，それぞれ次のように書けばよいのです．
　　ａ＜＜＝２
　　ａ＞＞＝４


○ビット演算　その２　論理積（＆）と論理和（｜）

　これは，計測器を制御したり，入出力関連のハードウェアを直接制御するプログラムを作成するときよく使われます．（このとき使用するライブラリー関数にはoutp()関数やinp()関数などがあります．参考書などで調べてみて下さい）．あっ！それから，グラフィックスのデータを処理するときなどにもよく使われます．それから，通信などでもよく使われます．初心者の人には，あまり縁がない演算かもしれません．

　まず，演算そのものをビットパターンを使って説明しましょう．


1)ビットごとの論理積【and】（演算記号　＆）

　演算のルール：　１＆１＝１，　１＆０＝０，　０＆１＝０，　０＆０＝０
　　　　　　　　（＆演算子の作用は，代数演算の積と似ていますね）
　値の代入された変数ａとｂとのビットごとの論理積を求めるには，このルールを，変数ａと変数ｂの対応するビットどうしに適用すればよいのです．

　ｃ＝ａ＆ｂ
 
変数　ａ
０ ０ ０ ０ １ １ １ １
変数　ｂ
０ １ ０ １ ０ １ １ ０
変数　ｃ=ａ＆ｂ
０ ０ ０ ０ ０ １ １ ０


２)ビットごとの論理和【or】（演算記号　｜）

　演算のルール：　１｜１＝１，　１｜０＝１，　０｜１＝１，　０｜０＝０
　　　　　　　（｜演算子の作用は，代数演算の和とにてますね．ただし，１｜１が１となるところだけが異なります．）

値の代入された変数ａとｂとのビットごとの論理和をもとめるには，このルールを変数ａと変数ｂの対応するビットどうしに適用すればよいのです．

　ｃ＝ａ｜ｂ
 
変数　ａ
０ ０ ０ ０ １ １ １ １
変数　ｂ
０ １ ０ １ ０ １ １ ０
変数　ｃ=ａ｜ｂ
０ １ ０ １ １ １ １ １


○ビット演算　その３　どのように使われるのか

　通常のデータでは，１つの文字や数値を表すのに１，２，４，８，・・・バイトを単位に１つのデータを表現します．
ところが，ハードウェアを直接操作するプログラムでは，ビット単位で情報を表現することがあります．

　例えば，通信でおなじみのＲＳ−２３２Ｃインターフェースでは，文字の送受信をする場合，データとしての文字は８（または７ビット）で表し，１文字づつ送受信します．
　しかし，インターフェースそのものは，有限の時間でデータを送受信するので，ＣＰＵが自己のペースで，文字を送り続けることはできません．複数の文字を連続的に送信するには，１文字送る度にインターフェースの状態，すなわち，いま，インターフェースがＣＰＵからの文字を受け取って外部へ送信できる状態にあるかどうか確かめながら，１文字づつ送らなければなりません．これをハンドシェークとよびますが，これは，ＲＳ−２３２Ｃに限らずハードウェアレベルでデータをやりとりするときの一般的な方法なのです．
　このようなとき，インターフェース内部の状態（あるいは，インターフェースの現在の状態）を知らせるメッセージが必要となります．このメッセージはインターフェースのもつメモリー（このような場合，メモリーをレジスターと呼びます）に書き込まれます．ＣＰＵは，そのレジスターの内容をチェックし，外部への送信が可能である場合に文字をインターフェースへ渡します．
　この場合，インターフェースは，文字を「送信できる状態にある」か「送信できない状態にある」か２種類の状態を表現する必要があるわけです．２種類の状態を表現するには「１ビット」で十分です．
また，ＣＰＵがインターフェースから文字を受け取るときも，文字が受信できたかどうかレジスターをみて，文字が受信されたときデータを受け取りにいきます．この場合も文字が「受信できた」か「受信できてない」かの２通りのメッセージしか必要ないので状態は「１ビット」で表現可能です．

　このようなとき，インターフェースの内部の状態をあらわすための８ビットのレジスター（メモリ）を次のように使います．
 
レジスタ
・・ ・・ ・・ ・・ ・・ ・・ Ｒｘ Ｔｘ

ここで，Ｒｘのビット：データが受信されたとき「１」，データが受信されてないとき「０」
　　　　Ｔｘのビット：データ送信可能のとき「１」，データ送信不可のとき「０」
をあらわすとします．
　ＣＰＵは文字を受信するときは，Ｒｘのビットのみをチェックすればよいわけですが，１ビットだけ読みとることはできないので，一旦，変数ｂに１バイト全部を読み込み，２ビット目だけ１の変数ａと論理積を求めます．その結果，すなわち変数ｃの内容が０でなければ，Ｒｘのビットが１，すなわちインターフェースに文字が到着ということになり，そこへＣＰＵが文字を読みとりに行くということになるのです．このことを次の図に示します．また，もし，文字が受信できてなければＲｘのビットは０ですからｃも０ということになります．
 
変数　ａ
０ ０ ０ ０ ０ ０ １ ０
変数　ｂ
０ １ ０ １ ０ １ １ ０
変数　ｃ=ａ＆ｂ
０ ０ ０ ０ ０ ０ １ ０

　文字を送信するときは，Ｔｘのビットを同様にチェックします．ただし，この時は，当然，変数ａに「０００００００１」を代入しておかなければなりません．

　レジスターでは，２ビットまとめて３，または４種の状態を表現（あるいは，３ビットまとめて７ないし８種の状態を表現したり・・・・）する場合もあります．

□ここでは，論理演算の用途の１例のべただけですが，いろいろなプログラムを組んでいるうちに実際に遭遇することになるでしょう．
□画像処理などにもよくつかわれます．
 


○ビット演算　その４　ＸＯＲとビット反転

　ビット演算には，その他にＸＯＲ（演算記号＾）やビットを反転（~)させる演算があります．
演算のルールのみ記しておきます．


1)ビットごとのＸＯＲ（演算記号　＾）

　演算のルール：　１＾１＝０，　１＾０＝１，　０＾１＝１，　０＆０＝０
　　　　　　　　（お互いのビットが異なるとき１，お互いのビットが同じとき０）


1)ビット反転（演算記号　~）

　演算のルール：　~１＝０，　~０＝１
　　　　　　　（~ａと書けば，変数ａに記憶されたすべてのビットを反転させます）
 

○ビット演算を活用する

ビット演算は初心者にはなじみの薄いものです。しかし、一度使い方を覚えて使い出すと病み付きになるくらい便利であり効率的でもあります。

ここでは実例をまじえつつビット演算を活用する方法について説明していきたいと思います。
まず、ビット演算を利用するメリットを挙げますと・・・

（１）演算速度が高速である
（２）メモリの消費量を最小限に抑えることが出来る
（３）１つの変数で複数の情報を持つ事が出来る

などがあります。（１）については既に言いましたが、コンピュータが唯一理解することが出来る「機械語」のレベルでその計算命令数の差を見てみるとその速度差は歴然です。
また（２）と（３）は同じような意味合いですが、１つの情報をバイト単位ではなくビット単位で扱うことでより多くの情報を変数に詰め込むことが出来ることから言えます。

では、例として「１バイトの変数で指示を与え「画面上の決まった位置に図形を書く」プログラムを考えてみます。

まず、描画用の関数を次のように宣言します。

int Draw_Object(unsigned char mode);

mode 変数には書く図形の情報をビット単位で詰め込むことにします。
そして、この図形には次のような８つの状態があるとします。

三角形
円
線を点線にする
線を黒色にする
線を赤色にする
黒く塗りつぶす
黄色く塗りつぶす
透明にする

それぞれに１バイト変数のうち１ビットを割り当てます。
割り当ては次のようにします。
 
第nビット ７ ６ ５ ４ ３ ２ １ ０
持たせる情報 三角形 円 線を点線にする 線を黒色にする 線を赤色にする 黒く塗りつぶす 黄色く塗りつぶす 半透明にする

次に、各状態とビット位置を簡単に関連付けるために #define 構文を使って次のように定義します。（０ｘ**とは、１６進数で**という意味です。ビットを扱う時は１０進数ではなく１６進数で考えるのが自然です。もちろん１０進数でも問題はありませんが。１６進数で考えると、各ビットは８，４，２，１という４つのキーワードの組み合わせで考えることが出来ます。）

#define SQUARE          0x80  /*２進数では【１０００００００】*/
#define CIRCLE            0x40  /*【０１００００００】*/
#define DOT_LINE         0x20  /*【００１０００００】*/
#define LINE_BLACK     0x10  /*【０００１００００】*/
#define LINE_RED         0x08  /*【００００１０００】*/
#define BG_BLACK       0x04  /*【０００００１００】*/
#define BG_YELLOW     0x02  /*【００００００１０】*/
#define BG_SKELETON  0x01  /*【０００００００１】*/

これで、文字により状態を設定する環境が整いました。
ん、これはどういうことでしょうか？例えば「円で、かつ線が点線で、かつ黒く塗りつぶす」といった場合、ビットの状態を考えると【０１１００１００】となります。これを１６進数で表すと０ｘ６４となります。この値はどうやって求めるのでしょうか？？？プログラミングの時にいちいち電卓を叩くのも気が引けます。しかし、文字の組み合わせで次のように表現できるとしたら簡単だと思いませんか？

「CIRCLEで、かつDOT_LINEで、かつBG_BLACKである」

これが、#define とビット演算を使って簡単に実現できます。
上記の３つのオプションをmode変数に指定するには次のように記述します。

mode = CIRCLE | DOT_LINE | BG_BLACK;

これだけです。｜は以前出てきた論理和の演算子（OR演算子）です。
この場合、内部では
mode = 0x40 | 0x20 | 0x04;
つまり
【０１００００００】or
【００１０００００】or
【０００００１００】 = 【０１１００１００】という演算を行うことになります。

冒頭で出てきたDraw_Object関数を実際に利用する時は例えば次のように書きます。

Draw_Object(CIRCLE | DOT_LINE | BG_BLACK);
Draw_Object(CIRCLE | DOT_LINE | LINE_BLACK | BG_YELLOW);
Draw_Object(SQUARE);
Draw_Object(CIRCLE | BG_SKELETON);
Draw_Object(0); /*何も書かない*/

このように、ビットとして扱うことで簡単に関数への複数指示を行えるようになります。
つぎに、命令を受け取った関数内部ではどのように処理したらいいのかを検証します。

Draw_Object(unsigned char mode)
{
   ・・・
   ・・・
}

引数modeには基本的に複数の情報が詰め込まれています。このmode変数から各ビットの情報を取り出すにはどのようにしたらいいでしょう？
難しそうですが、実際には非常に簡単です。

result = mode & 【調べたい桁】;

とすることで、result変数には０か、０以外が入ります。
例えば、

result = mode & CIRCLE;

となっていたとします。mode = CIRCLE | DOT_LINE | BG_BLACK のとき、

【０１１００１００】and
【０１００００００】 = 【０１００００００】という演算結果になり、非ゼロとなります。同様にmode = SQUARE | DOT_LINE | BG_BLACK のとき

【１０１００１００】and
【０１００００００】 = 【００００００００】という演算結果になりゼロとなります。

ゼロになるかならないかで、そのビットが０か１かを判断できます。
また、２つの状態（すなわち２ビット以上が１）が同時に起こっているかを調べたい場合はゼロ・非ゼロの判断基準ではなく、or演算子で結んだ状態と等しくなるかを調べます。
例えば、mode = CIRCLE | DOT_LINE | BG_BLACK と仮定して、

result = mode & (CIRCLE | BG_BLACK);
とすれば、CIRCLE | BG_BLACKは
【０１００００００】or
【０００００１００】 = 【０１０００１００】という演算結果になります。この結果とmodeのand演算を行うと、

【０１１００１００】and
【０１０００１００】 = 【０１０００１００】となります。この値はCIRCLE | BG_BLACKと等しくなります。プログラム中ではこの動作を
if((mode & (CIRCLE | BG_BLACK)) == (CIRCLE | BG_BLACK))
{
   ・・・
}
というような文で表現します。

上の例でmode = SQUARE | DOT_LINE | BG_BLACKのときはどうなるでしょうか？
【１０１００１００】and
【０１０００１００】 = 【０００００１００】となります。これは(CIRCLE | BG_BLACK)とは異なるため、２つのビットが同時に１になっていないと判断できます。

　まとめとして簡単なプログラムを作ってみます。
/* ビット演算サンプルプログラム その１         */
/* by Naoto Fujiwara 2000/7/1 naonao@wombat.or.jp */

#include <stdio.h>
#include <string.h>

/* (注)プログラム中に出てくるstrcat 関数は文字列バッファの最後に指定した文字を追加する関数です */
/* （例）buffer = "abcd"; strcat(buffer,"ABCD"); ->  bufferは"abcdABCD" となります*/

/* 各ビットに対応する文字表記可能なオプション指示定数を定義 */
#define PRINTF_FLOAT       0x80
#define PRINTF_INT        0x40
#define PRINTF_TAB        0x20
#define PRITNF_SPACE    0x10
#define PRINTF_COLOR_RED   0x08
#define PRINTF_COLOR_GREEN  0x04
#define PRINTF_SHOW_MYNAME 0x02

/* サンプルのデータ表示関数 */
int sample_printf(double data,int mode);

int main(void)
{
 /* 表示のテスト */
 sample_printf(3.14159,PRINTF_FLOAT);
 sample_printf(3.14159,PRINTF_INT);
 sample_printf(3.14159,PRINTF_FLOAT | PRITNF_SPACE | PRINTF_COLOR_RED);
 sample_printf(3.14159,PRINTF_FLOAT | PRINTF_COLOR_GREEN | PRINTF_SHOW_MYNAME);
 sample_printf(3.14159,PRINTF_FLOAT | PRINTF_TAB | PRITNF_SPACE | PRINTF_SHOW_MYNAME);
 sample_printf(3.14159,PRINTF_INT | PRINTF_FLOAT);
 sample_printf(3.14159,PRINTF_INT | PRINTF_TAB | PRINTF_COLOR_RED | PRINTF_SHOW_MYNAME);
 sample_printf(3.14159,PRINTF_INT | PRINTF_TAB | PRITNF_SPACE);
 return 0;
}

int sample_printf(double data,int mode)
{
 /* このバッファに数々の書式を入れていき、最終的にprintf関数に渡します*/
 char print_buffer[100];

 /* mode変数の値を１６進数表示 */
 printf("mode = 0x%2X : ",mode);

 /* 標準の文字をバッファに書き込む */
 strcpy(print_buffer,"表示結果−＞");

 if((mode & (PRINTF_INT | PRINTF_FLOAT)) == (PRINTF_INT | PRINTF_FLOAT))
 {
  printf("整数型と浮動小数点型を同時に指定することは出来ません\n");
  return -1;
 }

 /* ０になると、どちらのオプションも設定されていない事を意味します。 */
 /* ちなみに、下のif文は、if(!(mode & (PRINTF_INT | PRINTF_FLOAT)))  */
 /*    { ・・・　}                                         */
 /* と記述するのがベストです。                                       */
 if((mode & (PRINTF_INT | PRINTF_FLOAT)) == 0)
 {
  printf("整数型か浮動小数点型のどちらかを指定する必要があります\n");
  return -1;
 }

 /* 文字に色をつけるオプションが設定されている場合です。                          */
 /* このif文も、if(mode & PRINTF_COLOR_RED) [ ・・・ } と記述するのがベストです。 */
 if((mode & PRINTF_COLOR_RED) != 0)
 {
  strcat(print_buffer,"\x01b[31m");/* 赤色にする命令。エスケープシーケンスといいます(^_^; */
 }
 else if((mode & PRINTF_COLOR_GREEN) != 0)
 {
  strcat(print_buffer,"\x01b[32m");/* 緑色にする命令 */
 }

 /* タブを入れる */
 if((mode & PRINTF_TAB) != 0)
 {
  strcat(print_buffer,"\t");
 }

 /* スペースを入れる */
 if((mode & PRITNF_SPACE) != 0)
 {
  strcat(print_buffer,"   ");
 }

 /* 整数型表示のオプションが設定されている場合です。                                       */
 /* このif文も、if(mode & PRINTF_INT) [ ・・・ } と記述するのがベストです。                */
 /* ちなみに、引数がdouble型のため期待通りの表示は行えません(笑)あくまで実験ですので・・・ */
 if((mode & PRINTF_INT) != 0)
 {
  strcat(print_buffer,"%d");
 }
 /* 浮動小数点型のオプションが設定されている場合 */
 else
 {
  strcat(print_buffer,"%f");
 }

 /* 名前を入れる */
 if((mode & PRINTF_SHOW_MYNAME) != 0)
 {
  strcat(print_buffer,"  naonao");
 }

 /* 最後に標準で改行を入れる */
 strcat(print_buffer,"\n");

 /* 表示を行う */
 printf(print_buffer,data);
 return 0;
}
実行結果は自分の目で確かめてください(^_^)

あと、補足ですが上のプログラムで次のような操作もできます。

int mode;
mode = ~PRINTF_FLOAT;
こうすれば、PRINTF_FLOAT以外の全てのオプションを設定することになります。
つまり、
mode = PRINTF_INT | PRINTF_TAB | PRITNF_SPACE | PRINTF_COLOR_RED | PRINTF_COLOR_GREEN | PRINTF_SHOW_MYNAME;
と指定したのと同じ意味になります。

また、
mode = PRINTF_INT | PRINTF_TAB | PRITNF_SPACE;
のとき、
mode &= ~PRINTF_TAB;
とすると、PRINTF_TABを取り消したことになります。すなわち
mode = PRINTF_INT | PRITNF_SPACE;
と等しくなります。

これをビットを使って解説しますと・・・

PRINTF_INT | PRINTF_TAB | PRITNF_SPACE　は２進数では【０１１１００００】
また、　mode &= ~PRINTF_TAB 　は
mode = mode & ~PRINTF_TAB　と解釈できますので、

mode & ~PRINTF_TAB は
~【００１０００００】 -> 【１１０１１１１１】
∴【０１１１００００】 & 【１１０１１１１１】 = 【０１０１００００】
すなわち
mode = PRINTF_INT | PRITNF_SPACE;
です。

ビット演算の組み合わせであらゆる表現が出来るように頑張りましょう！！