[C#] Was bedeuten zwei linke Klammern "<<" in C #?


Answers

Wenn du schreibst

1 << n

Sie verschieben die Bitkombination 000000001 um n mal links und setzen damit n in den Exponenten von 2:

2^n

Damit

1 << 10

Wirklich ist

1024

Für eine Liste von sagen wir 5 Artikel wird Ihr for 32 mal zyklisch.

Question

Grundsätzlich die Fragen im Titel. Ich schaue mir den Quellcode von MVC 2 an:

[Flags]
public enum HttpVerbs {
    Get = 1 << 0,
    Post = 1 << 1,
    Put = 1 << 2,
    Delete = 1 << 3,
    Head = 1 << 4
}

und ich bin nur neugierig, was der doppelte linke Winkel Brackers << tut.




Ich weiß, dass diese Antwort so ziemlich gelöst ist, aber ich dachte, die Visualisierung könnte jemandem helfen.

[Fact] public void Bit_shift_left()
{
    Assert.Equal(Convert.ToInt32("0001", 2), 1 << 0); // 1
    Assert.Equal(Convert.ToInt32("0010", 2), 1 << 1); // 2
    Assert.Equal(Convert.ToInt32("0100", 2), 1 << 2); // 4
    Assert.Equal(Convert.ToInt32("1000", 2), 1 << 3); // 8
}



Neben der Antwort von Selman22 einige Beispiele:

Ich liste einige Werte für list.Count und was die Schleife wäre:

list.Count == 0: for (int i = 0; i < 1; i++)
list.Count == 1: for (int i = 0; i < 2; i++)
list.Count == 2: for (int i = 0; i < 4; i++)
list.Count == 3: for (int i = 0; i < 8; i++)

Und so weiter.




Es ist Bitwise Verschiebung links, es funktioniert durch Verschieben von Ziffern von binären Äquivalent der Zahl durch die angegebene (rechte Seite) Zahlen.

damit:

temp = 14 << 2

Das 00001110 von 14 ist 00001110 Verschieben bedeutet, Null von der rechten Seite zu schieben und jede Ziffer auf die linke Seite zu verschieben, wodurch 00111000 gleich 56 wird.

In deinem Beispiel:

i < (1 << list.Count)
  • 0000000001 = 1 wenn list.Count = 0 Ergebnis ist 0000000001 = 1
  • 0000000001 = 1 wenn list.Count = 1 Ergebnis ist 0000000010 = 2
  • 0000000001 = 1 wenn list.Count = 2 Ergebnis ist 0000000100 = 4
  • 0000000001 = 1 wenn list.Count = 3 Ergebnis ist 0000001000 = 8

und so weiter. Im Allgemeinen ist es gleich 2 ^ list.Count (2 erhöht um die Potenz von list.Count)




Sein (<<) ein bitweiser Linkshift-Operator, der die Bitwerte eines binären Objekts verschiebt. Der linke Operand gibt den zu verschiebenden Wert an und der rechte Operand gibt die Anzahl der Positionen an, an denen die Bits im Wert verschoben werden sollen.

In Ihrem Fall, wenn der Wert von list.count 4 ist, dann läuft die Schleife bis i <(1 << 4), was 16 (00010000) ist

00000001 << 4 = 00010000 (16)




Der Zweck der Schleife ist es höchstwahrscheinlich, alle Teilmengen des Satzes von Elementen in der Liste zu erzeugen oder zu bearbeiten. Und der Schleifenkörper hat höchstwahrscheinlich auch ein gutes Bit (har har) von bitweisen Operationen, nämlich sowohl einen weiteren Links-Shift als auch einen bitweisen-und. (Es umzuschreiben, um Pow zu verwenden, wäre mächtig dumm, ich kann kaum glauben, dass es so viele Leute gab, die das tatsächlich vorgeschlagen haben.)




Der Ausdruck (1 << N) verwendet eine Bitverschiebung in c #.

In diesem Fall wird es verwendet, um eine schnelle Ganzzahlbewertung von 2 ^ N durchzuführen, wobei n 0 bis 30 ist.

Ein gutes Werkzeug für Junge Peitschenschnäpper Entwickler, die nicht verstehen, wie Bitwechsel funktionieren, ist Windows Calc im Programmiermodus, der die Auswirkungen von Verschiebungen auf signierte Zahlen unterschiedlicher Größe visualisiert. Die Lsh und Rsh Funktionen entsprechen << bzw. >> .

Das Auswerten mit Math.Pow innerhalb der Schleifenbedingung ist (auf meinem System) etwa 7 mal langsamer als der Fragencode für N = 10, ob dies vom Kontext abhängt.

Das Zwischenspeichern der "Schleifenzahl" in einer separaten Variablen würde sie etwas beschleunigen, da der Ausdruck, der die Listenlänge betrifft, bei jeder Iteration nicht erneut ausgewertet werden muss.