Rostoperatoren

Wie im wirklichen Leben helfen uns die Betreiber in der Programmierung, bestimmte Funktionen mit einer Programmiersprache zu definieren und auszuführen. Jede eigenständige Programmiersprache bietet eine Reihe von Operatoren, mit denen wir Vorgänge ausführen können. Zu den allgemeinen Betreibern gehören mathematische Operatoren, logische Operatoren usw.

In diesem Leitfaden wird erläutert, wie man mit verschiedenen Betreibern zusammenarbeitet, die von der Rust -Programmiersprache bereitgestellt werden.

Lassen Sie uns anfangen ..

R8ust -Operatoren

Rust liefert den folgenden Operatorensatz:

1. Rechenzeichen
2. Logische Operatoren
3. Vergleichsoperatoren
4. Bitgewise -Operatoren
5. Verbindungszuweisungsoperatoren

Rost arithmetische Operatoren

Wie der Name schon sagt, ermöglichen arithmetische Operatoren es uns, arithmetische Operationen an einer Reihe von Operanden auszuführen. Zu den gemeinsamen mathematischen Operationen gehören Addition, Subtraktion, Teilung usw.

Im Folgenden sind die beliebten arithmetischen Operatoren aufgeführt:

Bedienungssymbol	Name des Bedieners	Beschreibung
+	Arithmetische Addition	Gibt die Summe von zwei oder mehr Operanden zurück
-	Arithmetische Subtraktion	Gibt den Unterschied zwischen zwei oder mehr Operanden zurück.
*	Arithmetische Multiplikation	Gibt das Produkt von zwei oder mehr Operanden zurück
/	Arithmetische Aufteilung	Gibt den Quotienten der linken Operandendividende durch den rechten Operanden zurück
%	Arithmetischer Rest.	Gibt den Rest aus der Abteilung des linken Operanden durch den rechten Operanden zurück.

Wir können veranschaulichen, wie die arithmetischen Operatoren in Rost verwendet werden, wie unten gezeigt:

fn main ()
// Rechenzeichen
sei x = 10;
lass y = 2;
println!("Sum: ", x + y);
println!("Differnce: ", x - y);
println!("Produkt: ", x * y);
println!("Quotient: ", x / y);
println!("Modulo: ", x % y);

Der obige Code sollte zurückgeben:

Rost logische Operatoren

Die zweite Kategorie von Operatoren, die vom Rust Lang unterstützt werden, ist logische Operatoren. Diese Arten von Operatoren werden verwendet, um zwei oder mehr boolesche Bedingungen zu kombinieren. Logische Operatoren geben immer einen booleschen Wert zurück.

Sie beinhalten:

Bedienungssymbol	Name des Bedieners	Beschreibung
&&	Kurzschluss logisch und	Gibt true zurück, wenn alle angegebenen Bedingungen als wahr bewertet werden.
||	Kurzschluss logisch oder	Gibt true zurück, wenn mindestens eine der angegebenen Bedingungen wahr ist.
!	Logisch nicht	Negiert das Ergebnis eines booleschen Ausdrucks. Wenn die Bedingung wahr ist, gibt der Nichtbetreiber falsch zurück.

Die Implementierung des Beispielcodes ist wie gezeigt:

fn main ()
// Rechenzeichen
sei x = true;
lass y = falsch;
println!("Logisch und: ", (x && y));
println!("Logisch oder: ", (x || y));
println!("Logisch nicht: ", ((!X));
println!("Logisch nicht: ", ((!y));

Der obige Code sollte zurückgeben wie:

Rost -Vergleichsbetreiber

Vergleichsbetreiber vergleichen zwei Operanden und geben einen Booleschen Wert anhand der Bedingung zurück.

Diese Betreiber umfassen:

Bedienungssymbol	Name des Bedieners	Beschreibung
>	Größer als	Gibt true zurück, wenn der Operand links größer ist als der rechte Operand.
<	Weniger als	Gibt true zurück, wenn der linke Operand geringer ist als der rechte Operand.
> =	Größer als oder gleich wie	Gibt true zurück, wenn der linke Operand größer oder gleich dem rechten Operanden ist.
<=	Gleich oder kleiner als	Gibt true zurück, wenn der linke Operand kleiner oder gleich dem rechten Operanden ist.
==	Gleich	Return true, wenn der linke Operand gleicher rechter Operanden ist.
!=	Nicht gleichzusetzen mit	Gibt true zurück, wenn der linke Operand nicht gleich rechter Operanden ist.

Wir können die Verwendung der Vergleichsoperatoren veranschaulichen, wie im folgenden Code gezeigt:

fn main ()
sei x = 10;
lass y = 2;
println!("Ist x größer als y: ", (x> y));
println!("Ist x weniger als y: ", (x < y));
println!("ist x gleich y: ", (x == y));
println!("Ist x größer als oder gleich: ", (x> = y));
println!("Ist x weniger oder gleich: ", (x <= y));
println!("X ist nicht gleich y: ", (x != y));

Der obige Code sollte zurückgeben:

Rost -Bitgewise -Operatoren

Bitgewise -Operatoren sind es gewohnt, bitweise Operationen durchzuführen. Sie beinhalten:

Bedienungssymbol	Name des Bedieners	Beschreibung
&	Bitweise und	Führt boolean und auf jedem Stück durch.
|	Bitweise oder	Führen Sie Boolesche oder jedes Stück durch
^	Bitweise xor	Führt exklusive boolean oder auf jedem Bit durch.
!	Bitweise nicht	Führt Unary nicht aus.
<<	Bitvershift links	verschiebt den linken Bitoperanden nach links durch den vom rechten Operanden angegebenen Betrag.
>>	Richtige Bitschicht	Verschiebt den linken Operanden um den von dem rechten Operanden angegebenen Wert.

Ein Beispiel -Quellcode wird unten angezeigt:

fn main ()
sei x = 10;
lass y = 2;
println!("Bitwise und: ", (x & y));
println!("Bitwise oder: ", (x | y));
println!("Bitgewise exklusiv oder: ", (x ^ y));
println!("Left Bitshift ", (x << y));
println!("Right Bitshift: ", (x >> y));
println!("Bitwise Not: ", ((!X));

Der obige Code sollte die Ausgabe wie gezeigt zurückgeben:

Bitweise und: 2
Bitweise oder: 10
Bitweise exklusiv oder: 8
Bitshift links 40
RECHTE BITSCHAFT: 2
Bitweise nicht: -11

Rostverbindungszuweisungsoperatoren

Verbindungszuweisungsoperatoren werden verwendet, um den Wert rechts dem Wert links zuzuweisen. Diese beinhalten:

Bedienungssymbol	Name des Bedieners
+=	Arithmetische Addition und Zuordnung
-=	Arithmetische Subtraktion und Zuordnung
*=	Arithmetische Multiplikation und Zuordnung
/=	Arithmetische Aufteilung und Zuordnung
>> =	Rechtsverschiebung und Aufgabe
<<=	Linksverschiebung und Aufgabe
%=	Arithmetischer Rest und Zuordnung
& =	Bitweise und und Zuordnung
| =	Bitweise oder und Zuordnung
^=	Bitweise exklusive oder Zuordnung

Abschluss

In diesem Artikel wurden Rust -Operatoren besprochen und wie wir sie in unseren Programmen verwenden können. Überprüfen Sie die Rost -Dokumentation, um zu erkunden.

Vielen Dank für das Lesen!!