Vertauschen von Variablenwerten ohne die Verwendung einer temporären Variable in C#

1. Tupelzuweisung in C# verwenden
2. Verwenden Sie den +-Operator, um die in C# verwendete temporäre Variable zu umgehen
3. Verwenden Sie eine Funktion zum Austauschen von Werten anstelle einer expliziten Implementierung, um die temporäre Verwendung von Variablen in C# zu verbergen
4. So verwenden Sie den XOR-Operator zum Austauschen in C#

Nehmen wir also an, Sie schreiben gerade einen Code und möchten Variablenwerte austauschen. Sie werden wahrscheinlich so etwas tun:

using System;

public class Program
{
  public static void Main(string[] args)
  {
      var val_one = 123;
      var val_two = 234;

      var val_swap = val_one;
      val_one = val_two;
      val_two = val_swap;

      Console.WriteLine("The value after swapping is: " + val_one + " and -> " + val_two);
  }
}

Hier erstellen Sie nun zuerst eine temporäre Variable namens val_swap, dann kopieren Sie den Wert val_one dorthin, sodass Sie nach der Änderung des Werts val_one den ursprünglichen Wert val_one problemlos zurück in val_two kopieren können. indem Sie ihm den Wert von val_swap zuweisen.

Heute werden wir uns damit befassen, die Verwendung dieser temporären Variablen zu eliminieren und einen solchen Austausch ohne andere Zuweisungen durchzuführen.

Tupelzuweisung in C# verwenden

Eine sehr einfache Methode, die Sie jetzt verwenden können, ist die Verwendung einer TUPLE-Zuweisung wie folgt.

(val_one, val_two) = (val_two, val_one);

Console.WriteLine("The value after swapping from the tuple method is: " + val_one + " and -> " +
                  val_two);

Ausgabe:

The value after swapping from the tuple method is: 234 and -> 123

Diese Methode wurde auch in Python verwendet; jedoch nicht Tupeln unterworfen.

Manchmal muss man jedoch Tricks anwenden, um das zu bekommen, was man will. Sehen wir uns unten ein Beispiel an.

Verwenden Sie den +-Operator, um die in C# verwendete temporäre Variable zu umgehen

Nehmen wir an, wir haben zwei Zahlen; 7 und 9. Die erste Variable hat den Wert 7 und die zweite Variable den Wert 9.

Wenn wir 9 zu 7 hinzufügen, erhalten wir 16. Weisen wir nun der ersten Variablen 16 zu.

Um 9 als Wert der ersten Variablen einzusetzen, müssen Sie den Wert 9 von der zweiten Variablen abziehen, was zu 15-9 = 7 werden würde; Verwenden Sie diesen Wert und subtrahieren Sie ihn von 15 in der ersten Variablen, um nun den Wert 9 zu erhalten.

val_one += val_two;
val_two = val_one - val_two;
val_one = val_one - val_two;

Console.WriteLine("The value after swapping is: " + val_one + " and -> " + val_two);

Ausgabe:

The value after swapping is: 234 and -> 123

Sie können feststellen, wie dies einfache Arithmetik verwendet, um die Verwendung temporärer Variablen beim Austauschen zu stoppen. Andererseits kann dies unwirksam werden, wenn sehr große genaue Werte vorhanden sind, und die Verwendung einer solchen Arithmetik kann zum Verlust einiger Werte führen.

Wenn Sie die Implementierung ausblenden und nicht nur die Verwendung einer temporären Variablen entfernen möchten, können Sie Folgendes verwenden.

Verwenden Sie eine Funktion zum Austauschen von Werten anstelle einer expliziten Implementierung, um die temporäre Verwendung von Variablen in C# zu verbergen

Sie können etwas wie folgt tun.

static void swap(ref int x, ref int y) {
  var temp = x;
  x = y;
  y = temp;
}

Und nennen Sie es dann unten wie folgt:

swap(ref val_one, ref val_two);
Console.WriteLine("The value after swapping is: " + val_one + " and -> " + val_two);

Ausgabe:

The value after swapping is: 234 and -> 123

So verwenden Sie den XOR-Operator zum Austauschen in C#

Schauen wir uns den folgenden Code an.

val_one ^= val_two ^= val_one ^= val_two;

Und seine Ausgabe:

The value after swapping is: 0 and -> 123

Sie werden feststellen, dass der erste Wert 0 ist, obwohl die zweite Variable jetzt den Wert der ersten Variable hat und ordnungsgemäß funktioniert.

Wie können wir das beheben? Lassen Sie uns zuerst einen Code wie folgt schreiben.

val_one ^= val_two;
val_two ^= val_one;
val_one ^= val_two;

Und jetzt ist die Ausgabe:

The value after swapping is: 234 and -> 123

So was ist los? Lassen Sie uns zunächst den in der ersten Anweisung angegebenen Code verstehen.

Das lässt sich wie folgt erweitern.

val_one = val_one ^ val_two;
val_two = val_two ^ val_one;
val_one = val_one ^ val_two;

Jetzt können Sie sagen, dass der erste Code dem später vorgestellten ähnlich ist, wie funktioniert er dann nicht, aber letzterer funktioniert gut?

Eine Änderung der Reihenfolge dieser arithmetischen Operationen kann zu unterschiedlichen Ergebnissen führen. Im vorigen Code hat val_one ein XOR mit sich selbst, also das Ergebnis 0.

Bei letzterem ist die Reihenfolge jedoch bereits definiert und die Werte werden perfekt berechnet, daher der Unterschied.

Denken Sie jedoch daran, für höhere Code-Ebenen kein XOR-Swapping zu verwenden. Es ist unsicher und sollte als Ersatz aufbewahrt werden.