webentwicklung-frage-antwort-db.com.de

Ändern Sie ein bisschen eine ganze Zahl

Wir haben eine ganze Zahl

int x = 50;

in binär ist es

00110010

Wie kann ich das vierte Bit programmatisch ändern?

28
pedram

Sie können das vierte Bit einer Zahl setzen, indem Sie sie mit einem Wert, der außer bei dem vierten Bit überall Null ist, mit ODER verknüpfen. Dies könnte als getan werden

x |= (1u << 3);

In ähnlicher Weise können Sie das vierte Bit löschen, indem Sie es mit einem Wert, der überall eins ist, außer im vierten Bit, durch UND-Verknüpfung. Zum Beispiel:

x &= ~(1u << 3);

Schließlich können Sie das vierte Bit umschalten, indem Sie es mit XOR-Werten mit einem Wert, der überall null ist, außer im vierten Bit, umschalten:

x ^= (1u << 3);

Um zu verstehen, warum dies funktioniert, müssen wir zwei Dinge betrachten:

  1. Wie verhält sich der <<-Operator in diesem Zusammenhang?
  2. Wie verhalten sich die Operatoren AND, OR und XOR hier?

In allen drei obigen Codeausschnitten haben wir den Operator << verwendet, um einen Wert zu generieren. Der <<-Operator ist der bitweise Shift-Left-Operator, der einen Wert annimmt und dann alle Bits um einige Schritte nach links verschiebt. In Ihrem Fall habe ich verwendet

1u << 3

nehmen Sie den Wert 1 (der die binäre Darstellung 1 hat) und verschieben Sie dann alle seine Bits über drei Punkte, wobei Sie die fehlenden Werte mit 0 füllen. Dadurch wird der Binärwert 1000 erstellt, der im vierten Bit ein Bit enthält.

Nun, warum tut es

x |= (1u << 3);

das vierte Bit der Nummer setzen? Dies hat mit der Funktionsweise des Operators OR zu tun. Der |=-Operator ist wie += oder *=, außer für bitweises OR - er ist äquivalent zu

x = x | (1u << 3);

Warum setzt das ODER-Setzen von x mit dem Binärwert 1000 sein viertes Bit? Das hat mit der Art zu tun, wie OR definiert ist:

0 | 0  == 0
0 | 1  == 1
1 | 0  == 1
1 | 1  == 1

Noch wichtiger ist jedoch, dass wir dies kompakter als neu schreiben können

x | 0  == x
x | 1  == 1

Dies ist eine äußerst wichtige Tatsache, da dies bedeutet, dass das ODER-Verknüpfen eines beliebigen Bits mit Null den Wert des Bits nicht ändert, während das ODER-Verknüpfen eines Bits mit 1 dieses Bit immer auf Eins setzt. Das bedeutet, wenn wir schreiben

x |= (1u << 3);

da (1u << 3) ein Wert ist, der mit Ausnahme des vierten Bits überall Null ist, lässt das bitweise OR alle Bits von x unverändert, mit Ausnahme des vierten Bits, das dann auf Eins gesetzt wird. Allgemeiner gesagt: Durch ODER-Verknüpfung einer Zahl mit einem Wert, der aus einer Reihe von Nullen und Einsen besteht, werden alle Werte beibehalten, bei denen die Bits Null sind, und alle Werte festgelegt, bei denen die Bits Eins sind.

Nun schauen wir uns mal an

x &= ~(1u << 3);

Hierbei wird der bitweise Komplementoperator ~ verwendet, der eine Zahl übernimmt und alle seine Bits umkehrt. Wenn wir davon ausgehen, dass Ganzzahlen zwei Bytes sind (nur zur Vereinfachung), bedeutet dies, dass die tatsächliche Kodierung von (1u << 3) ist

0000000000001000

Wenn wir die Ergänzung dazu nehmen, erhalten wir die Nummer

1111111111110111

Nun wollen wir mal sehen, was passiert, wenn wir bitweise UND zwei Werte zusammensetzen. Der AND-Operator hat diese interessante Wahrheitstabelle:

0 & 0   == 0
0 & 1   == 0
1 & 0   == 0
1 & 1   == 1

Oder noch kompakter:

x & 0   == 0
x & 1   == x

Beachten Sie, dass dies bedeutet, dass, wenn wir UND zwei Zahlen zusammen ANDern, der resultierende Wert so ist, dass alle mit UND verknüpften Bits auf Null gesetzt werden, während alle anderen Bits erhalten bleiben. Das heißt, wenn wir UND mit

~(1u << 3)

wir sind mit und

1111111111110111

In unserer obigen Tabelle bedeutet dies, dass "alle Bits mit Ausnahme des vierten Bits unverändert bleiben und dann das vierte Bit auf Null gesetzt wird."

Generell gilt: Wenn Sie einen Satz Bits löschen möchten, erstellen Sie eine Zahl, die überall dort steht, wo Sie die Bits unverändert lassen möchten, und Null, wenn Sie die Bits löschen möchten.

Zum Schluss wollen wir sehen warum

x ^= (1u << 3)

Dreht das vierte Bit der Zahl. Dies liegt daran, dass der binäre Operator XOR diese Wahrheitstabelle hat:

0 ^ 0  == 0
0 ^ 1  == 1
1 ^ 0  == 1
1 ^ 1  == 0

Beachte das

x ^ 0  == 0
x ^ 1  == ~x

Wo ~x das Gegenteil von x ist; Es ist 0 für 1 und 1 für 0. Dies bedeutet, wenn wir XOR x mit dem Wert (1u << 3) angeben, werden wir XOR-in

0000000000001000

Das heißt also "alle Bits außer dem vierten Bit beibehalten, aber das vierte Bit umdrehen". Wenn Sie eine bestimmte Anzahl von Bits umdrehen möchten, ist XOR der Wert mit einer Zahl, die den Wert Null enthält, an dem Sie die Bits intakt halten möchten, und einen Wert, an dem Sie diese Bits umkehren möchten.

Hoffe das hilft!

70
templatetypedef

Sie können immer std::bitset verwenden, wodurch das Ändern von Bits vereinfacht wird.

Oder Sie können Bit-Manipulationen verwenden (vorausgesetzt, Sie meinen, 4. Bit zählen bei eins. Ziehen Sie nicht 1 ab, wenn Sie von 0 aus zählen). Beachten Sie, dass ich 1U nur verwende, um sicherzustellen, dass die gesamte Operation für nicht signierte Nummern ausgeführt wird:

So legen Sie fest: x |= (1U << (4 - 1));

So löschen Sie: x &= ~(1U << (4 - 1));

Umschalten: x ^= (1U << (4 - 1));

13
Mark B

Um das vierte Bit zu setzen, OR mit 00001000 (binär).

Um das vierte Bit zu löschen, AND mit 11110111 (binär).

Um das vierte Bit umzuschalten, XOR mit 00001000 (binär).

Beispiele:

00110010 OR 00001000 = 00111010

00110010 UND 11110111 = 00110010

00110010 XOR 00001000 = 00111010

7
Patrick87

Einfach, da Sie oder welchen Wert Sie haben,

int x = 50;

4. Bit (von rechts) programmgesteuert setzen,

int y = x | 0x00000008;

Weil 0x vor einer Zahl vorangestellt ist, bedeutet dies, dass sie hexadezimal ist . Also 0x0 = 0000 in binär und 0x8=1000 in binärer Form .

2

Versuchen Sie eine dieser Funktionen in der Sprache C, um das n-Bit zu ändern

char bitfield;

// start at 0th position

void chang_n_bit(int n, int value)
{
    bitfield = (bitfield | (1 << n)) & (~( (1 << n) ^ (value << n) ));
}

void chang_n_bit(int n, int value)
{
    bitfield = (bitfield | (1 << n)) & ((value << n) | ((~0) ^ (1 << n)));
}

void chang_n_bit(int n, int value)
{
    if(value)
        bitfield |= 1 << n;
    else
        bitfield &= ~0 ^ (1 << n);
}

char print_n_bit(int n)
{
    return (bitfield & (1 << n)) ? 1 : 0;
}
1
Vincet

Mit dem binären AND und OR können Sie das vierte Bit umschalten.

Um das vierte Bit auf x zu setzen, würden Sie x |= 1<<3; verwenden, wobei 1<<3 eine Verschiebung von 0b0001 nach links um drei Bits ist, wodurch 0b1000 erzeugt wird.

Um das vierte Bit von x zu löschen, verwenden Sie x &= ~(1<<3);, ein binäres UND zwischen 0b00110010 (x) und (effektiv) 0b11110111, wobei jedes Bit in x, das sich nicht in Position 4 befindet, ausgeblendet wird, wodurch es gelöscht wird.

0
Dustin Howett