Rust Operators: A Comprehensive Guide to Efficient Code Handling

• 1. Arithmetic Operators in Rust program :
• Example 1: Addition, Subtraction and Multiplication Operators In Rust :
  • Output :
• Example 2: Division Operator In Rust :
  • Output :
  • Output :
• Example 3: Remainder Operator In Rust :
  • Output :
• 2. Compound Assignment Operators In Rust :
  • Assignment Operators :
  • Compound Assignment Operators In Rust :
• Example: Compound Assignment Operator In Rust :
  • Output :
• 3.Comparison Operators In Rust :
• Example: Comparison Operators In Rust :
  • Output :
• 4. Logical Operators In Rust :
• Example: Logical Operators In Rust :
  • Output :
    • Note :
• 5.Bitwise Operators in Rust :
• Example-Bitwise Operators in Rust:
  • Output :

In Rust Program, an operators are symbols or keywords which perform operations on variables and values. Below are some of the common types of operators in Rust Program:

1. Arithmetic Operators

2. Compound Assignment Operators

3. Logical Operators

4. Comparison Operators

5. Bitwise Operators

¶1. Arithmetic Operators in Rust program :

We can use arithmetic operators to perform addition(+), subtraction(-), multiplication(*), division(/) and Remainder(%).

Please see below a list of various arithmetic operators available in Rust Program. And we have used the variable names a and b in the example.

¶Example 1: Addition, Subtraction and Multiplication Operators In Rust :

fn main() {
    let a = 20;
    let b = 2;

    // add two variables using + operator
    let x = a + b;
    println!("{} + {} = {}", a, b, x);

    // subtract two variables using - operator
    let y = a - b;
    println!("{} - {} = {}", a, b, y);

    // multiply two variables using * operator
    let z = a * b;
    println!("{} * {} = {}", a, b, z);
}

¶Output :

20 + 2 = 22
20 - 2 = 18
20 * 2 = 40

¶Example 2: Division Operator In Rust :

fn main() {
    let dividend = 21;
    let divisor = 8;

    // arithmetic division using / operator with integers
    let division = dividend / divisor;

    println!("{} / {} = {}", dividend, divisor, division);
}

¶Output :

21 / 8 = 2

In the upon example, we used the / operator to divide two integers 21 and 8. We fond the output of the operation is 2.

In grade calculation, 21 / 8 gives 2.625. Stall, in Rust, when the use / operator is used with integer values, we found the quotient (integer) as the output.

Now If you want the correct result, you will use the / operator with floating-point values. For example-

fn main() {
    let dividend = 21.0;
    let divisor = 8.0;

    // arithmetic division using / operator with floating point values
    let division = dividend / divisor;

    println!("{} / {} = {}", dividend, divisor, division);
}

¶Output :

21 / 8 = 2.625

Above, both dividend and divisor variables are imputed floating point values. In this way, the division operation report a floating point result of 2.625.

¶Example 3: Remainder Operator In Rust :

In Rust Program, the remainder operator is represented by the % symbol. this calculates the remainder of the division of one number by other number. Please see below an example-

fn main() {
    let dividend = 21;
    let divisor = 8;

    // arithmetic remainder using % operator
    let remainder = dividend % divisor;
  
    println!("{} % {} = {}", dividend, divisor, remainder);
}

¶Output :

21 % 8 = 5

Above Example, you use the remainder operator % with two integers: 21 and 8. And The above output of the operation is 5.

Now The remainder operator %, as the name suppose, permanently returns the remainder after division.

¶2. Compound Assignment Operators In Rust :

We can use an assignment operator to assign a value for a variable. For example-

let x = 5;

Above, = is an assignment operator that assigns the value on the right 5 of the variable xon the left. The assignment operator is on of the most common operator in Rust Program.

¶Assignment Operators :

In Rust Program, assignment operators are used to assign values to variables where performing some operation on the variable’s current value. The general assignment operators in Rust are similar to which in many other programming languages. Below a list of assignment operators in Rust:

Simple Assignment (=):

its operator assigns the value on the right-hand side to the variable on the left-hand side in below

fn main() {
    let x = 10;
    println!("x: {}", x);
}

Output :

x: 10

Addition Assignment (+=):

In this operator adds the value on the right-hand side to the variable on the left-hand side

fn main() {
    let mut y = 5;
    y += 3; // equivalent to y = y + 3;
    println!("y: {}", y);
}

Output :

y: 8

Subtraction Assignment (-=):

In this operator subtracts value on the right-hand side to the variable on the left-hand side.

fn main() {
    let mut z = 8;
    z -= 2; // equivalent to z = z - 2;
    println!("z: {}", z);
}

Output :

z: 6

Multiplication Assignment (*=):

In this operator multiplies the variable on the left-hand side by the value on the right-hand side.

fn main() {
    let mut a = 4;
    a *= 3; // equivalent to a = a * 3;
    println!("a: {}", a);
}

Output :

a: 12

Division Assignment (/=):

In this operator divides the variable on the left-hand side by the value on the right-hand side.

fn main() {
    let mut b = 12;
    b /= 4; // equivalent to b = b / 4;
    println!("b: {}", b);
}

Output :

b: 3

Remainder Assignment (%=):

In this operator calculates the remainder when dividing the variable on the left-hand side by the value on the right-hand side

fn main() {
    let mut c = 13;
    c %= 5; // equivalent to c = c % 5;
    println!("c: {}", c);
}

Output :

c: 3

¶Compound Assignment Operators In Rust :

We further use an assignment operator and an arithmetic operator, below known as the a compound assignment operator. For example-

let mut x = 1;

// compound assignment operators
x += 3;

Above, += is a compound assignment operator known as an addition assignment. And this is first adds 3 to the value of x (1) and assigns to the final result (4) to x.

Please see below a list of various compound assignment operators in Rust Programming.

¶Example: Compound Assignment Operator In Rust :

fn main() {
    let mut a = 2;
  
    // arithmetic addition and assignment
    a += 3;

    println!("a = {}", a);
}

¶Output :

a = 5

¶3.Comparison Operators In Rust :

In Rust Program, comparison operators are used to comparison values and determine their relationship. this operators return a boolean value (true or false) founded on the comparison result. Below are the comparison operators in Rust:

Equality (==) and Inequality (!=):

• The equality operator (==) restraint if the values on both sides are equal.
• The inequality operator (!=) restraint if the values on both sides are not equal.

let a = 5;
let b = 7;

println!("a == b: {}", a == b);   // false
println!("a != b: {}", a != b);   // true

Ordering Operators (<, <=, >, >=):

• Less than (<) restraint if the value on the left is less than the value on the right.
• Less than or equal to (<=) restraint if the value on the left is less than or equal to the value on the right.
• Greater than (>) restraint if the value on the left is greater than the value on the right.
• Greater than or equal to (>=) restraint if the value on the left is greater than or equal to the value on the right

let x = 10;
let y = 15;

println!("x < y: {}", x < y);     // true
println!("x <= y: {}", x <= y);   // true
println!("x > y: {}", x > y);     // false
println!("x >= y: {}", x >= y);   // false

Partial Equality (PartialEq):

Rust Program also supports the PartialEq trait, which accept custom types to implement their own equality comparisons using the == and != operators.

#[derive(Debug, PartialEq)]  // Automatically implements PartialEq trait
struct Point {
    x: i32,
    y: i32,
}

let p1 = Point { x: 1, y: 2 };
let p2 = Point { x: 1, y: 2 };

println!("p1 == p2: {}", p1 == p2);   // true

We can use comparison operators to compare two values or variables. For example-

6 > 5

Above, the relational operator > (greater than) checks if 6 is greater than 5.

A relational of operator returns:

a. true in case the relation between two values is correct b. false in case the relation is incorrect

Below a list of comparison operators available in Rust Program.

¶Example: Comparison Operators In Rust :

fn main() {
    let a = 7;
    let b = 3;
    
    // use of comparison operators
    let c = a > b;
    let d = a < b;
    let e = a == b;
    
    println!("{} >= {} is {}", a, b, c);
    println!("{} <= {} is {}", a, b, d);
    println!("{} == {} is {}", a, b, e);
}

¶Output :

7 > 3 is true
7 < 3 is false
7 == 3 is false

¶4. Logical Operators In Rust :

We also can use logical operators to perform logical judgment or operations. A logical operation returns true or false trust on the conditions. For example-

(5 < 6) && (7 > 4)

In above, && is the logical AND operator which returns true if both conditions are true. In this example, all conditions are true. Below the expression is true.

Below there are mainly 3 logical operators in Rust.

¶Example: Logical Operators In Rust :

fn main() {
    let a = true;
    let b = false;
    
    // logical AND operation
    let c = a && b;

    // logical OR operation
    let d = a || b;

    // logical NOT operation
    let e = !a;
    
    println!("{} && {} = {}", a, b, c);
    println!("{} || {} = {}", a, b, d);
    println!("!{} = {}", a, e);
}

¶Output :

true && false = false
true || false = true
!true = false

¶Note :

The rational AND and OR operators are also called short-circuiting logical operators because this operators don’t evaluate the complete expression in cases they don’t need to. For example for this expression-

false || true || false

In this || operator evaluates to true because one of the compiler sees a single true expression, it scamper the evaluation and returns true directly.

¶5.Bitwise Operators in Rust :

In Rust Program, bitwise operators are used to perform operations at the sting level on integers. The bitwise operators are available in Rust Program and its similar to which in many other programming languages. Below are the common bitwise operators in Rust:

Bitwise AND (&) :

• Syntax: a & b
• Description: Practice a bitwise AND operation on every pair of corresponding bits in a and b. The result has 1 bit only where both a and b have 1 bit.

Bitwise OR (|):

• Syntax: a | b
• Description: Practice a bitwise OR operation on every pair of corresponding bits in a and b. The result has 1 bit where either a or b or both have 1 bit

Bitwise XOR (^):

• Syntax: a ^ b
• Description: Practice a bitwise exclusive OR (XOR) operation on every pair of corresponding bits in a and b. The result of a 1 bit where other a or b (but not both) have a 1 bit.

Bitwise NOT (!):

• Syntax: !a
• Description: Practice a bitwise NOT operation on every bit of a. It flips every bit, making 1s to 0s and 0s to 1s.

Bitwise Left Shift (<<):

• Syntax: a << b
• Description: Change the bits of a to the left by b positions. This is identical to multiplying a by 2^b.

Bitwise Right Shift (>>):

• Syntax: a >> b
• Description: Change the bits of a to the right by b positions. This is identical to dividing a by 2^b

¶Example-Bitwise Operators in Rust:

fn main() {
    let a: u8 = 0b1101; // Binary representation of 13
    let b: u8 = 0b1010; // Binary representation of 10

    let bitwise_and_result = a & b;
    let bitwise_or_result = a | b;
    let bitwise_xor_result = a ^ b;
    let bitwise_not_result = !a;
    let left_shift_result = a << 2;
    let right_shift_result = b >> 1;

    println!("AND: {:08b}", bitwise_and_result);
    println!("OR:  {:08b}", bitwise_or_result);
    println!("XOR: {:08b}", bitwise_xor_result);
    println!("NOT: {:08b}", bitwise_not_result);
    println!("Left Shift:  {:08b}", left_shift_result);
    println!("Right Shift: {:08b}", right_shift_result);
}

¶Output :

AND: 00000000
OR:  00001111
XOR: 00001101
NOT: 11110011
Left Shift:  11010000
Right Shift: 0101

In above example, {:08b} is used in println! macro to format the output as an 8-bit binary number