C# 什么是&；=在这个代码中是什么意思？

我不懂

*p++&=0xFF在下面的代码中。为什么操作符
&=
出现在这里

unsafe void Foo(int[,] arr)
{
    int length = arr.Length;
    fixed (int* b = arr)
    {
        int* p = b;
        for (int i = 0; i < length; i++)
         *p++ &= 0xFF;
    }
}

不安全的void Foo（int[，]arr）
{
整数长度=阵列长度；
固定（int*b=arr）
{
int*p=b；
for（int i=0；i
这是另一个

x&=y

是

在这种情况下，您将用FF增加p，并分配给p，这是另一个

x&=y

是

在本例中，您使用FF递增p，并分配给p
，因此您可能看到类似于
a+=b//a=a+b

这与按位比较运算符
&
基本相同。具体来说，这里的用户得到的是p的二进制逆值（我想，有人请纠正我），形式是2的赞美

有关按位比较的一个很好的示例，请参见此处，第一个答案：
因此您可能已经看到类似于
a+=b//a=a+b

这与按位比较运算符
&
基本相同。具体来说，这里的用户得到的是p的二进制逆值（我想，有人请纠正我），形式是2的赞美

有关按位比较的示例，请参见此处，第一个答案：
它对数组的每个元素执行按位and运算

例如，如果p[i]=256，它将变为0；如果p[i]=-1，则变为255；如果p[i]=-2，它将变为254

 256: 00000001 0000000
0xFF: 00000000 1111111
======================
   0: 00000000 0000000

  -1: 11111111 1111111
0xFF: 00000000 1111111
======================
 255: 00000000 1111111

  -2: 11111111 1111110
0xFF: 00000000 1111111
======================
 254: 00000000 1111110

它对数组的每个元素执行按位and运算

例如，如果p[i]=256，它将变为0；如果p[i]=-1，则变为255；如果p[i]=-2，它将变为254

 256: 00000001 0000000
0xFF: 00000000 1111111
======================
   0: 00000000 0000000

  -1: 11111111 1111111
0xFF: 00000000 1111111
======================
 255: 00000000 1111111

  -2: 11111111 1111110
0xFF: 00000000 1111111
======================
 254: 00000000 1111110

它将通过执行和位运算来舍入[0255]范围内的所有数组内容。
它将通过执行和位运算来舍入[0255]范围内的所有数组内容。
//例如：我们传递的数组有4个元素（arr[2,2]）
// for example: we are passing array with 4 elements (arr[2,2])

unsafe static void Foo (int[,] arr)
{
    int length = arr.Length; // length == 4

    fixed (int* b = arr) // b is a pointer to the first element of the 'arr' array (pointer is of type int)
    {
        int* p = b; // lets copy pointer to a new variable (we will change that variable in a loop)
                    // we cannot change 'b', because it is a 'fixed' variable

        for (int i = 0; i < length; i++) // iterate over all 'arr' elements (4 elements)
            *p++ &= 0xFF; // *p = *p & 255   - it means we will use only 8 low bits from 32 bit int, all 'arr' values stay between [0..255]
                          // p = p + 4 (because int is 4 bytes)
                          // now p is a pointer to the second element in the 'arr' (each element in the arr is of size 4 bytes)

        // *p =   10101101 10101101 10101101 10101101
        // & 255  00000000 00000000 00000000 11111111
        // =      00000000 00000000 00000000 10101101
    }
}

不安全静态无效Foo（int[，]arr）
{
int length=arr.length；//长度==4
已修复（int*b=arr）//b是指向“arr”数组的第一个元素的指针（指针类型为int）
{
int*p=b；//让我们将指针复制到新变量（我们将在循环中更改该变量）
//我们不能更改“b”，因为它是一个“固定”变量
for（int i=0；i
//例如：我们正在传递包含4个元素的数组（arr[2,2]）
不安全静态无效Foo（int[，]arr）
{
int length=arr.length；//长度==4
已修复（int*b=arr）//b是指向“arr”数组的第一个元素的指针（指针类型为int）
{
int*p=b；//让我们将指针复制到新变量（我们将在循环中更改该变量）
//我们不能更改“b”，因为它是一个“固定”变量
for（int i=0；i
它们从数组中的每个项中获取最低有效字节
*p++获取p指向的值，并将p设置为下一个地址
获得的值是32位整数

lhs&=rhs相当于lhs=lhs&rhs

0xFFFF-32位
0xFF-16位

0xFFFF&0xFF==0xFFFF&0x00FF

X&0为0，因此他们将前16位转换为0，只获取最低有效位
他们从数组中的每个项获取最低有效字节
*p++获取p指向的值，并将p设置为下一个地址
获得的值是32位整数

lhs&=rhs相当于lhs=lhs&rhs

0xFFFF-32位
0xFF-16位

0xFFFF&0xFF==0xFFFF&0x00FF

X&0是0，所以他们将前16位转换为0，只得到最低有效位
这只是另一个赋值运算符，如+=，但对于&。取消对p的引用，增加p，与FF（256）和，并将此结果赋回p。编译器输出应与可读形式相同，即
p[i]=p[i]&256
它是
和
变量类型是int，即四个字节。因此，代码移动了四个字节（p++），并通过将整数与0xFF求和来保留最低有效字节。这只是另一个赋值运算符，如+=，但对于&。取消对p的引用，增加p，与FF（256）和，并将此结果赋回p。编译器输出应与可读形式相同，即
p[i]=p[i]&256
它是
和
变量类型是int，即四个字节。因此，代码移动了四个字节（p++），并通过将整数与0xFF相加来仅保留最低有效字节。默认情况下它是原子的吗？分配给*p，实际上是*（原始p）@huseyintugrulbuyukisik不，它不保证是原子的。默认情况下它是原子的吗？实际上分配给*p*(