2. 程式人生 > >位域與位運算

位域與位運算

阿新 • • 發佈：2018-05-28
() key byte 內存 十進制 一次 內存對齊 常用 都沒有

有些數據在存儲時並不需要占用一個完整的字節，只需要占用一個或幾個二進制位即可。例如開關只有通電和斷電兩種狀態，用 0 和 1 表示足以，也就是用一個二進位。正是基於這種考慮，C語言又提供了一種叫做位域的數據結構。

在結構體定義時，我們可以指定某個成員變量所占用的二進制位數（Bit），這就是位域。請看下面的例子：

  1. struct bs{
  2. unsigned m;
  3. unsigned n: 4;
  4. unsigned char ch: 6;
  5. }

:後面的數字用來限定成員變量占用的位數。成員 m 沒有限制，根據數據類型即可推算出它占用 4 個字節（Byte）的內存。成員 n、ch 被:

後面的數字限制，不能再根據數據類型計算長度，它們分別占用 4、6 位（Bit）的內存。

n、ch 的取值範圍非常有限，數據稍微大些就會發生溢出，請看下面的例子：

  1. #include <stdio.h>
  3. int main(){
  4. struct bs{
  5. unsigned m;
  6. unsigned n: 4;
  7. unsigned char ch: 6;
  8. } a = { 0xad, 0xE, ‘$‘};
  9. //第一次輸出
  10. printf("%#x, %#x, %c\n", a.m, a.n, a.ch);
  11. //更改值後再次輸出
  12. a.m = 0xb8901c;
  13. a.n = 0x2d;
  14. a.ch = ‘z‘;
  15. printf("%#x, %#x, %c\n", a.m, a.n, a.ch);
  17. return 0;
  18. }

運行結果：
0xad, 0xe, $
0xb8901c, 0xd, :

對於 n 和 ch，第一次輸出的數據是完整的，第二次輸出的數據是殘缺的。

第一次輸出時，n、ch 的值分別是 0xE、0x24（‘$‘ 對應的 ASCII 碼為 0x24），換算成二進制是 1110、10 0100，都沒有超出限定的位數，能夠正常輸出。

第二次輸出時，n、ch 的值變為 0x2d、0x7a（‘z‘ 對應的 ASCII 碼為 0x7a），換算成二進制分別是 10 1101、111 1010，都超出了限定的位數。超出部分被直接截去，剩下 1101、11 1010，換算成十六進制為 0xd、0x3a（0x3a 對應的字符是 :）。

C語言標準規定，位域的寬度不能超過它所依附的數據類型的長度。通俗地講，成員變量都是有類型的，這個類型限制了成員變量的最大長度，:

後面的數字不能超過這個長度。

例如上面的 bs，n 的類型是 unsigned int，長度為 4 個字節，共計 32 位，那麽 n 後面的數字就不能超過 32；ch 的類型是 unsigned char，長度為 1 個字節，共計 8 位，那麽 ch 後面的數字就不能超過 8。

我們可以這樣認為，位域技術就是在成員變量所占用的內存中選出一部分位寬來存儲數據。

C語言標準還規定，只有有限的幾種數據類型可以用於位域。在 ANSI C 中，這幾種數據類型是 int、signed int 和 unsigned int（int 默認就是 signed int）；到了 C99，_Bool 也被支持了。

關於C語言標準以及 ANSI C 和 C99 的區別，我們已在VIP教程《C語言的兩套標準》中進行了講解。

但編譯器在具體實現時都進行了擴展，額外支持了 char、signed char、unsigned char 以及 enum 類型，所以上面的代碼雖然不符合C語言標準，但它依然能夠被編譯器支持。

位域的存儲

C語言標準並沒有規定位域的具體存儲方式，不同的編譯器有不同的實現，但它們都盡量壓縮存儲空間。

位域的具體存儲規則如下：
1) 當相鄰成員的類型相同時，如果它們的位寬之和小於類型的 sizeof 大小，那麽後面的成員緊鄰前一個成員存儲，直到不能容納為止；如果它們的位寬之和大於類型的 sizeof 大小，那麽後面的成員將從新的存儲單元開始，其偏移量為類型大小的整數倍。

以下面的位域 bs 為例：

  1. #include <stdio.h>
  3. int main(){
  4. struct bs{
  5. unsigned m: 6;
  6. unsigned n: 12;
  7. unsigned p: 4;
  8. };
  9. printf("%d\n", sizeof(struct bs));
  11. return 0;
  12. }

運行結果：
4

m、n、p 的類型都是 unsigned int，sizeof 的結果為 4 個字節（Byte），也即 32 個位（Bit）。m、n、p 的位寬之和為 6+12+4 = 22，小於 32，所以它們會挨著存儲，中間沒有縫隙。

sizeof(struct bs) 的大小之所以為 4，而不是 3，是因為要將內存對齊到 4 個字節，以便提高存取效率，這將在《C語言和內存》專題的《C語言內存對齊，提高尋址效率》一節中詳細講解。

如果將成員 m 的位寬改為 22，那麽輸出結果將會是 8，因為 22+12 = 34，大於 32，n 會從新的位置開始存儲，相對 m 的偏移量是 sizeof(unsigned int)，也即 4 個字節。

如果再將成員 p 的位寬也改為 22，那麽輸出結果將會是 12，三個成員都不會挨著存儲。

2) 當相鄰成員的類型不同時，不同的編譯器有不同的實現方案，GCC 會壓縮存儲，而 VC/VS 不會。

請看下面的位域 bs：

  1. #include <stdio.h>
  3. int main(){
  4. struct bs{
  5. unsigned m: 12;
  6. unsigned char ch: 4;
  7. unsigned p: 4;
  8. };
  9. printf("%d\n", sizeof(struct bs));
  11. return 0;
  12. }

在 GCC 下的運行結果為 4，三個成員挨著存儲；在 VC/VS 下的運行結果為 12，三個成員按照各自的類型存儲（與不指定位寬時的存儲方式相同）。

3) 如果成員之間穿插著非位域成員，那麽不會進行壓縮。例如對於下面的 bs：

  1. struct bs{
  2. unsigned m: 12;
  3. unsigned ch;
  4. unsigned p: 4;
  5. };

在各個編譯器下 sizeof 的結果都是 12。

通過上面的分析，我們發現位域成員往往不占用完整的字節，有時候也不處於字節的開頭位置，因此使用&獲取位域成員的地址是沒有意義的，C語言也禁止這樣做。地址是字節（Byte）的編號，而不是位（Bit）的編號。

無名位域

位域成員可以沒有名稱，只給出數據類型和位寬，如下所示：

  1. struct bs{
  2. int m: 12;
  3. int : 20; //該位域成員不能使用
  4. int n: 4;
  5. };

無名位域一般用來作填充或者調整成員位置。因為沒有名稱，無名位域不能使用。

上面的例子中，如果沒有位寬為 20 的無名成員，m、n 將會挨著存儲，sizeof(struct bs) 的結果為 4；有了這 20 位作為填充，m、n 將分開存儲，sizeof(struct bs) 的結果為 8。

所謂位運算，就是對一個比特（Bit）位進行操作比特（Bit）是一個電子元器件，8個比特構成一個字節（Byte），它已經是粒度最小的可操作單元了。

C語言提供了六種位運算符：

運算符 & | ^ ~ << >>
說明 按位與 按位或 按位異或 取反 左移 右移

按位與運算（&）

一個比特（Bit）位只有 0 和 1 兩個取值，只有參與&運算的兩個位都為 1 時，結果才為 1，否則為 0。例如1&1為 1，0&0為 0，1&0也為 0，這和邏輯運算符&&非常類似。

C語言中不能直接使用二進制，&兩邊的操作數可以是十進制、八進制、十六進制，它們在內存中最終都是以二進制形式存儲，&就是對這些內存中的二進制位進行運算。其他的位運算符也是相同的道理。

例如，9 & 5可以轉換成如下的運算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在內存中的存儲）
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在內存中的存儲）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 （1 在內存中的存儲）

也就是說，按位與運算會對參與運算的兩個數的所有二進制位進行&運算，9 & 5的結果為 1。

又如，-9 & 5可以轉換成如下的運算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在內存中的存儲）
& 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在內存中的存儲）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在內存中的存儲）

-9 & 5的結果是 5。

再強調一遍，&是根據內存中的二進制位進行運算的，而不是數據的二進制形式；其他位運算符也一樣。以-9&5為例，-9 的在內存中的存儲和 -9 的二進制形式截然不同：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在內存中的存儲）
-0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （-9 的二進制形式，前面多余的 0 可以抹掉）


按位與運算通常用來對某些位清 0，或者保留某些位。例如要把 n 的高 16 位清 0 ，保留低 16 位，可以進行n & 0XFFFF運算（0XFFFF 在內存中的存儲形式為 0000 0000 -- 0000 0000 -- 1111 1111 -- 1111 1111）。

【實例】對上面的分析進行檢驗。

  1. #include <stdio.h>
  3. int main(){
  4. int n = 0X8FA6002D;
  5. printf("%d, %d, %X\n", 9 & 5, -9 & 5, n & 0XFFFF);
  6. return 0;
  7. }

運行結果：
1, 5, 2D

按位或運算（|）

參與|運算的兩個二進制位有一個為 1 時，結果就為 1，兩個都為 0 時結果才為 0。例如1|1為1，0|0為0，1|0為1，這和邏輯運算中的||非常類似。

例如，9 | 5可以轉換成如下的運算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在內存中的存儲）
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在內存中的存儲）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1101 （13 在內存中的存儲）

9 | 5的結果為 13。

又如，-9 | 5可以轉換成如下的運算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在內存中的存儲）
| 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在內存中的存儲）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在內存中的存儲）

-9 | 5的結果是 -9。

按位或運算可以用來將某些位置 1，或者保留某些位。例如要把 n 的高 16 位置 1，保留低 16 位，可以進行n | 0XFFFF0000運算（0XFFFF0000 在內存中的存儲形式為 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000）。

【實例】對上面的分析進行校驗。

  1. #include <stdio.h>
  3. int main(){
  4. int n = 0X2D;
  5. printf("%d, %d, %X\n", 9 | 5, -9 | 5, n | 0XFFFF0000);
  6. return 0;
  7. }

運行結果：
13, -9, FFFF002D

按位異或運算（^）

參與^運算兩個二進制位不同時，結果為 1，相同時結果為 0。例如0^1為1，0^0為0，1^1為0。

例如，9 ^ 5可以轉換成如下的運算：

0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在內存中的存儲）
^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在內存中的存儲）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1100 （12 在內存中的存儲）

9 ^ 5的結果為 12。

又如，-9 ^ 5可以轉換成如下的運算：

1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在內存中的存儲）
^ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0101 （5 在內存中的存儲）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0010 （-14 在內存中的存儲）

-9 ^ 5的結果是 -14。

按位異或運算可以用來將某些二進制位反轉。例如要把 n 的高 16 位反轉，保留低 16 位，可以進行n ^ 0XFFFF0000運算（0XFFFF0000 在內存中的存儲形式為 1111 1111 -- 1111 1111 -- 0000 0000 -- 0000 0000）。

【實例】對上面的分析進行校驗。

  1. #include <stdio.h>
  3. int main(){
  4. unsigned n = 0X0A07002D;
  5. printf("%d, %d, %X\n", 9 ^ 5, -9 ^ 5, n ^ 0XFFFF0000);
  6. return 0;
  7. }

運行結果：
12, -14, F5F8002D

取反運算（~）

取反運算符~為單目運算符，右結合性，作用是對參與運算的二進制位取反。例如~1為0，~0為1，這和邏輯運算中的!非常類似。。

例如，~9可以轉換為如下的運算：

~ 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在內存中的存儲）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0110 （-10 在內存中的存儲）

所以~9的結果為 -10。

例如，~-9可以轉換為如下的運算：

~ 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在內存中的存儲）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1000 （9 在內存中的存儲）

所以~-9的結果為 8。

【實例】對上面的分析進行校驗。

  1. #include <stdio.h>
  3. int main(){
  4. printf("%d, %d\n", ~9, ~-9 );
  5. return 0;
  6. }

運行結果：
-10, 8

左移運算（<<）

左移運算符<<用來把操作數的各個二進制位全部左移若幹位，高位丟棄，低位補0。

例如，9<<3可以轉換為如下的運算：

<< 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在內存中的存儲）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0100 1000 （72 在內存中的存儲）

所以9<<3的結果為 72。

又如，(-9)<<3可以轉換為如下的運算：

<< 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在內存中的存儲）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1011 1000 （-72 在內存中的存儲）

所以(-9)<<3的結果為 -72

如果數據較小，被丟棄的高位不包含 1，那麽左移 n 位相當於乘以 2 的 n 次方。

【實例】對上面的結果進行校驗。

  1. #include <stdio.h>
  3. int main(){
  4. printf("%d, %d\n", 9<<3, (-9)<<3 );
  5. return 0;
  6. }

運行結果：
72, -72

右移運算（>>）

右移運算符>>用來把操作數的各個二進制位全部右移若幹位，低位丟棄，高位補 0 或 1。如果數據的最高位是 0，那麽就補 0；如果最高位是 1，那麽就補 1。

例如，9>>3可以轉換為如下的運算：

>> 0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 1001 （9 在內存中的存儲）
-----------------------------------------------------------------------------------
0000 0000 -- 0000 0000 -- 0000 0000 -- 0000 0001 （1 在內存中的存儲）

所以9>>3的結果為 1。

又如，(-9)>>3可以轉換為如下的運算：

>> 1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 0111 （-9 在內存中的存儲）
-----------------------------------------------------------------------------------
1111 1111 -- 1111 1111 -- 1111 1111 -- 1111 1110 （-2 在內存中的存儲）

所以(-9)>>3的結果為 -2

如果被丟棄的低位不包含 1，那麽右移 n 位相當於除以 2 的 n 次方（但被移除的位中經常會包含 1）。

【實例】對上面的結果進行校驗。

  1. #include <stdio.h>
  3. int main(){
  4. printf("%d, %d\n", 9>>3, (-9)>>3 );
  5. return 0;
  6. }

運行結果：
1, -2

位域與位運算

相關推薦

位域與位運算

() key byte 內存 十進制 一次 內存對齊 常用 都沒有 有些數據在存儲時並不需要占用一個完整的字節，只需要占用一個或幾個二進制位即可。例如開關只有通電和斷電兩種狀態，用 0 和 1 表示足以，也就是用一個二進位。正是基於這種考慮，C語言又提供了一種叫做位域的數據

結構體的大小的計算與空間的優化--之位域欄位

int main() {   int len, lenBest, lenBett, len01, lenBest01;   BITAREA BitArea;   BITAREA1 BitArea1;   BITAREABETTER BitAreaBetter;   BITAREABEST BitAreaBe

C的聯合體（測試資料儲存的大小端模式） 位段（位段與位的對應關係）

/x86/Debian GNU/Linux/gcc 1 聯合體 (1)聯合體機制 聯合體的所有成員引用的是記憶體中的相同地址。訪問聯合的不同成員時，會根據此成員的型別去訪問對應的位元組，並根據此成員

C語言變數宣告加冒號的用法 稱為“位域”或“位段“

 有些資訊在儲存時，並不需要佔用一個完整的位元組， 而只需佔幾個或一個二進位制位。例如在存放一個開關量時，只有0和1 兩種狀態， 用一位二進位即可。為了節省儲存空間，並使處理簡便，C語言又提供了一種資料結構，稱為“位域”或“位段”。所謂“位域”是把一個位元組中的二進位劃

位標誌與位欄位

位標誌： 如果你正在編寫一個課程管理系統，你會以什麼樣的形式來表示你今天哪些節有課哪些節沒課呢？比如一天有12節課，如下圖所示 可能大家會問，為什麼只是記錄哪些節有課，哪些節沒課呢？這樣的資訊有什麼作用呢？當然有用，比如你要查詢某同學今天上午1、2節是否有課，又比如在排課

C語言中利用共用體、結構體、位域實現位操作

編寫過51(MCU)程式的同學都知道51架構的MCU支援位操作，這是一個很方便的特性，在讀取/修改暫存器某位的值時非常方便快捷。但其他架構的MCU大多都不支援該特性，即不支援位操作，所在在對暫存器中某一位進行操作的時候都是and/or兩個操作共同使用，在編寫程式時非常麻煩。

C語言位域和位段

有些資訊在儲存時，並不需要佔用一個完整的位元組， 而只需佔幾個或一個二進位制位。例如在存放一個開關量時，只有0和1 兩種狀態， 用一位二進位即可。為了節省儲存空間，並使處理簡便，C語言又提供了一種資料結構，稱為“位域”或“位段”。所謂“位域”是把一個位元組中的二進位劃分為幾個不同的區域， 並說明每個區域的位

位運算（&amp;、|、^）與邏輯運算（&amp;&amp;、 ||）差別

邏輯與 清空 作用 一個數 總結 與運算 位或 定位 按位與 剛無意在一篇文章中看到了位運算（&、|）和邏輯運算（&&、||）的介紹。想起了自己薄弱的基礎知識。於是百度了幾把總結了下。 首先從概念上區分下，位

Java 位運算(移位、位與、或、異或、非）與邏輯運算

高效率 邏輯與 才會 system 區別 span get 右移 邏輯 java 位運算包括：左移( << )、右移( >> ) 、無符號右移( >>> ) 、位與( & ) 、位或( | )、位非( ~ )、位異或( ^

【Java基礎】Java基本數據類型與位運算

右移 數據 bits 類型 span 網上 height 使用 常數 1.賦值運算符 賦值使用操作符“=”。它的意思是“取右邊的值（即右值），把它復制給左邊（即左值）”。右值可以是任何 常數、變量或者表達式 （只要它能 生成

Java：二進制（原碼、反碼、補碼）與位運算

無符號 位與 轉換成 轉換 不同 一個 位或 其他 log 一、二進制（原碼、反碼、補碼） 二進制的最高位是符號位（“0”代表正數，“1”代表負數）； Java中沒有無符號數； 計算機以整數的補碼進行運算； 1. 原碼：將一個整數轉換成二進制表示 以 int 類型為例

字節序，原碼和補碼與位運算

沒有 原碼 tools 大端 arr nta 內存地址 length 都是 計算機最小的數據獲取單元就是字節，一個字節byte = 8個位 bit，八個位是用二進制的形式保存的。假如11111111，如果是無符號數那麽可以保存0-255一共256（2的八次方）個數的數，

進位制轉換與位運算

1.其他進位制轉十進位制 位上的值*位數-1 相加  101=1*1 + 0*2 + 1*4   2.十進位制轉其他進位制 將該數不斷除以該進位制，直到商為0，將每步得到的餘數倒過來就是對應的進位制 356 / 2 = 0X164   3

計算機系統 二進位制原碼 補碼 反碼 詳解 JAVA 二進位制位運算（位與 位或 位取反 位異或 左移 右移）

       在計算機系統中，數值一律使用補碼來表示和儲存。在探求為何計算機要使用補碼之前， 讓我們先了解原碼， 反碼和補碼的概念。 　　對於一個數， 計算機要使用一定的編碼方式進行儲存。 原碼， 反碼， 補碼是計算機儲存一個具體數字的編碼方式。 　　一個數在計算機中的二

[LeetCode][7]Reverse Integer解析與位運算實現 -Java實現

Q： Reverse digits of an integer. Example1: x = 123, return 321Example2: x = -123, return -321 A： 以下解法和程式碼沒有借閱以往任何資料，如果有更好的解法請在評論區留言 這

位運算與乘除運算的對比實驗

Java 的JDK中存在很多位運算的使用，其目的是為了讓程式碼跑的更快一些，我們做一個實驗，看看到底可以節省多少計算時間。 以下程式碼中，分別使用了乘除運算和位運算來進行了一億次基礎操作，並列印了所消耗的時間。 /** * 比較乘除運算和位運算時間消耗上的差距 */

Java8 運算子(進位制與轉換、原碼，反碼和補碼、位運算詳解、運算子的優先順序)

進位制  binary:  1 -> 10 -> 11 -> 100  每次從後面進一位 octal:  7-> 10    八進位制是0-7之間，底數為8的計算 hexadecimal：A

位與&，位或|，位異或^運算，以及運用場景

一.按位與運算子 參加運算的兩個資料，按二進位制位進行位與運算.          例如：3&5          先將兩個資料轉化為二進位制數,然後按位進行與運算，同為1結果為1，其它情況結

記憶體對齊與位域

記憶體對齊： 在討論之前我們先看一個栗子: #include<iostream> using namespae std; int main() { struct A { int a; char b;

java中按位運算與邏輯運算的區別

問題一： JAVA中&&和&、||和|（短路與和邏輯與、短路或和邏輯或）的區別？ 首先名稱是不同的 ＆＆邏輯與　　｜｜邏輯或　　它們都是邏輯運算子 ＆　按位與　　｜　按位或　　它們都是位運算子 ｉｆ（ａ＝＝１＆＆ｂ＝＝２）　這是說既要滿足ａ＝１也要滿足