Operators

Types

Arithmetic

Arithmetic operators are used to perform mathematical calculations.

int a = 10;
int b = 5;

int addition = a + b;   // Addition operator
int subtraction = a - b;   // Subtraction operator
int multiplication = a * b;   // Multiplication operator
int division = a / b;   // Division operator
int modulus = a % b;   // Modulus (remainder) operator

Logical

Logical operators are used to perform logical operations on boolean values.

bool a = true;
bool b = false;

bool logicalAnd = (a && b);   // Logical AND operator
bool logicalOr = (a || b);   // Logical OR operator
bool logicalNotA = !a;   // Logical NOT operator for a
bool logicalNotB = !b;   // Logical NOT operator for b

Bitwise

Bitwise operators are used to perform operations on individual bits of integer values.

int a = 10;
int b = 5;

int bitwiseAnd = a & b;   // Bitwise AND operator
int bitwiseOr = a | b;   // Bitwise OR operator
int bitwiseXor = a ^ b;   // Bitwise XOR (exclusive OR) operator
int bitwiseNotA = ~a;   // Bitwise NOT operator for a
int leftShift = a << 1;   // Left shift operator
int rightShift = a >> 1;   // Right shift operator

These are just a few examples of the types of operators in C++. It’s important to note that the usage and behavior of operators can vary depending on the data types they are used with.

Relational

Relational operators are used to compare values and return a boolean result (true or false).

int a = 10;
int b = 5;

bool equal = (a == b);   // Equal to operator
bool notEqual = (a != b);   // Not equal to operator
bool greaterThan = (a > b);   // Greater than operator
bool lessThan = (a < b);   // Less than operator
bool greaterThanOrEqual = (a >= b);   // Greater than or equal to operator
bool lessThanOrEqual = (a <= b);   // Less than or equal to operator

Assignment

Assignment operators are used to assign values to variables.

int a = 10;
int b = 5;

a += b;   // Equivalent to: a = a + b
a -= b;   // Equivalent to: a = a - b
a *= b;   // Equivalent to: a = a * b
a /= b;   // Equivalent to: a = a / b
a %= b;   // Equivalent to: a = a % b

Syntax

Pseudocode

input length, width
area = length * width
print area

C++

#include <iostream>
using namespace std;

int main() {
    double length, width;
    cout << "Enter length: ";
    cin >> length;
    cout << "Enter width: ";
    cin >> width;

    double area = length * width;
    cout << "Area of the rectangle: " << area << endl;

    return 0;
}

Python

length = float(input("Enter length: "))
width = float(input("Enter width: "))

area = length * width
print("Area of the rectangle:", area)

Java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        double length, width;
        System.out.print("Enter length: ");
        length = scanner.nextDouble();
        System.out.print("Enter width: ");
        width = scanner.nextDouble();

        double area = length * width;
        System.out.println("Area of the rectangle: " + area);
    }
}

Rust

use std::io;

fn main() {
    let mut input = String::new();
    println!("Enter length: ");
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let length: f64 = input.trim().parse().expect("Please enter a valid number");

    input.clear();
    println!("Enter width: ");
    io::stdin().read_line(&mut input).expect("Failed to read line");
    let width: f64 = input.trim().parse().expect("Please enter a valid number");

    let area = length * width;
    println!("Area of the rectangle: {}", area);
}

Golang

package main

import (
    "fmt"
)

func main() {
    var length, width float64

    fmt.Print("Enter length: ")
    fmt.Scan(&length)

    fmt.Print("Enter width: ")
    fmt.Scan(&width)

    area := length * width
    fmt.Println("Area of the rectangle:", area)
}

Output

The code samples above calculate the area of a rectangle given its length and width. The user enters the length and width, and the program performs the necessary calculations.

Assume the user enters length = 5 and width = 7 for all the examples.

C++ / Rust / Golang

Area of the rectangle: 35

Python / Java

Area of the rectangle: 35.0

Note: the difference in each output is due directly to the nature of integer division within each given language.