如何在 C 中使用 mod 2 添加來制作 XOR？

Question

我讀到 XOR 相當於 mod 2 加法。 我的假設是，這是在位級別。 意思是，5 XOR 10 不等於 (5 + 10) mod 2，因為那是不正確的 1。 因此，我編寫了以下 function：

unsigned char XOR_BIT(unsigned char A, unsigned char B)
{
    unsigned char x;
    unsigned char y;
    unsigned char c;
    unsigned char o;
    unsigned char output = 0;
    for(c = 0; c < 8; c++)
    {
        printf("=========Round %u=============\n", c);
        x = (A & (1 << c));
        printf("x: %u\n", x);
        y = (B & (1 << c));
        printf("y: %u\n", y);
        o = (x + y) % 2;
        printf("o: %u\n", o);
        output |= (o << c);
        printf("output: %u\n", output);
    }
    return output;
}

但是，這會輸出以下內容：

=========Round 0=============
x: 1
y: 0
o: 1
output: 1
=========Round 1=============
x: 0
y: 2
o: 0
output: 1
=========Round 2=============
x: 4
y: 0
o: 0
output: 1
=========Round 3=============
x: 0
y: 8
o: 0
output: 1
=========Round 4=============
x: 0
y: 0
o: 0
output: 1
=========Round 5=============
x: 0
y: 0
o: 0
output: 1
=========Round 6=============
x: 0
y: 0
o: 0
output: 1
=========Round 7=============
x: 0
y: 0
o: 0
output: 1
MyXOR: 1
Standard XOR: 15

我懷疑我要么誤解了所需的按位運算，要么我有一個代碼錯誤，但我並不完全具備該領域的必要知識來確定問題。

此 function 的預期行為是：

1. 一次抓取每個字節 1 位
2. 對每對位執行 mod 2 加法
3. 將每個結果位存儲在 output 中
4. 將 output 位作為 1 個字節返回

Answer 1

您在做模之前添加移位值（ x和y在 mod 之前應該是 0 或 1）。 你應該用

x = (A >> c) & 1;
y = (B >> c) & 1;

然后你添加它們，做模，並將位存儲到output ，就像你已經在做的那樣。

Answer 2

我讀到 XOR 相當於 mod 2 加法。 我的假設是，這是在位級別。 意思是，5 XOR 10 不等於 (5 + 10) mod 2，因為那將是 5，這是不正確的。

(5 + 10) mod 2 是 1，而不是 5，但這也與按位異或的結果不同。 您已經或多或少正確地推斷出該斷言適用於各個位，但您的代碼表明您可能沒有完全理解這一點。

按位異或完全等價於 2階循環群中的mod 2 加法，其中 mod 2 加法是普通的加法運算符。 這個群只有兩個元素，通常標記為 0 和 1。模 2 加法不會自然地定義在與其同態的群上，盡管它可以以直接的方式擴展。 巧合的是，按位與等價於對該組的元素進行乘法運算。

考慮模 2 加法的結果總是 0 或 1，這取決於加數是否分別具有相同或不同的奇偶校驗，並考慮表達式1 << c當且僅當c為零時才具有奇校驗，因此，只有當c為零時，形式A & (1 << c)的表達式才能具有奇校驗（但實際奇偶校驗也取決於A ）。 這應該向您展示為什么您的程序沒有按預期工作。

您需要將x和y設置為 0 和 1 才能執行計算。 有幾種方法可以做到這一點。 最明顯的方法是執行按位移位，例如已經描述的另一個答案。 對於您的特定目的，您還可以使用雙重邏輯否定，這在某些方面更加自然。 由於問題的對稱性，您甚至可以將其簡化為單一否定：

    x = !(A & (1 << c));
    y = !(B & (1 << c));
    o = (x + y) % 2;
    output |= (o << c);