Was bedeutet & = in diesem Code?

Question

Ich verstehe *p++ &= 0xFF; in dem folgenden Code nicht. Warum erscheint der Operator &= hier?

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; 
    } 
} 

Answer 1

Es ist eine weitere assignment operator

x &= y

ist

x = x & y 

In diesem Fall Sie p erhöht wird mit FF Hinzufügen und Zuweisen p

Answer 2

Sie haben wahrscheinlich so etwas wie a += b //a = a + b gesehen.

Dies ist im Wesentlichen die gleiche Sache nur mit einem bitweisen Vergleichsoperator &. Insbesondere erhält der Benutzer hier den inversen Binärwert für p (I THINK, jemand korrigiert mich bitte) in Form von 2's Kompliment.

Sehen Sie hier für ein gutes Beispiel für bitweise Vergleich, erste Antwort: Understanding the behavior of a single ampersand operator (&) on integers

Answer 3

Es führt bitweise und den Betrieb zu jedem Element des Arrays.

Zum Beispiel, wenn p [i] = 256, wird es 0; Wenn p [i] = -1 ist, wird es 255; wenn p [i] = -2, wird es 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 

Answer 4

geworden Es werden alle Array-Inhalt in Reichweite sein runden [0255], indem UND bitweisen Operation.

Answer 5

// 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 
    } 
} 

Answer 6

Sie erhalten die niedrigstwertigen Bytes von jedem Element in dem Array * p ++ wird der Wert von p und die Menge P an die nächste Adresse wies der erhaltene Wert ein 32-Bit-Ganzzahl ist

lhs & = rhs entspricht lhs = lhs & rhs;

0xFFFF - 32 Bits 0xFF - 16 Bits

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

X & 0 0 so konvertieren sie die ersten 16 Bits auf Null immer nur die niedrigstwertigen Bits