Types of Operators in Programming

Types of operators in programming are symbols or keywords that represent computations or actions performed on operands. Operands can be variables, constants, or values, and the combination of operators and operands form expressions. Operators play a crucial role in performing various tasks, such as arithmetic calculations, logical comparisons, bitwise operations, etc.

Types of Operators in Programming:

Here are some common types of operators:

• Arithmetic Operators: Perform basic arithmetic operations on numeric values.
  • Addition (+)
  • Subtraction (-)
  • Multiplication (*)
  • Division (/)
  • Modulus (%)
• Assignment Operators
  • Basic Assignment (=)
  • Add and Assign (+=)
  • Subtract and Assign (-=)
  • Multiply and Assign (*=)
  • Divide and Assign (/=)
  • Modulus and Assign (%=)
• Unary Operators
  • Increment (++)
  • Decrement (--)
  • Unary Plus (+)
  • Unary Minus (-)
  • Logical NOT (!)
• Comparison Operators
  • Equal to (==)
  • Not Equal to (!=)
  • Less Than (<)
  • Greater Than (>)
  • Less Than or Equal To (<=)
  • Greater Than or Equal To (>=)
• Logical Operators
  • Logical AND (&&)
  • Logical OR (||)
  • Logical NOT (!)
• Bitwise Operators
  • Bitwise AND (&)
  • Bitwise OR (|)
  • Bitwise XOR (^)
  • Bitwise NOT (~)
  • Left Shift (<<)
  • Right Shift (>>)
• Conditional Operator
  • Ternary Operator (?:)

These operators provide the building blocks for creating complex expressions and performing diverse operations in programming languages. Understanding their usage is crucial for writing efficient and expressive code.

Arithmetic Operators in Programming:

Arithmetic operators in programming are fundamental components of programming languages, enabling the manipulation of numeric values for various computational tasks. Here's an elaboration on the key arithmetic operators:

These operators are foundational for mathematical calculations, financial computations, and various algorithmic implementations. They are commonly used in everyday programming scenarios, providing the tools necessary for handling numerical data and solving mathematical problems within a program. Understanding how to use arithmetic operators is essential for performing precise and efficient calculations in programming.

#include <iostream>
using namespace std;

int main()
{

    int a = 10, b = 5;
    cout << a << " + " << b << " = " << a + b << endl;
    cout << a << " - " << b << " = " << a - b << endl;
    cout << a << " * " << b << " = " << a * b << endl;
    cout << a << " / " << b << " = " << a / b << endl;
    cout << a << " % " << b << " = " << a % b << endl;
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int a = 10, b = 5;
        System.out.println(a + " + " + b + " = " + (a + b));
        System.out.println(a + " - " + b + " = " + (a - b));
        System.out.println(a + " * " + b + " = " + (a * b));
        System.out.println(a + " / " + b + " = " + (a / b));
        System.out.println(a + " % " + b + " = " + (a % b));
    }
}

a = 10
b = 5

print(f"{a} + {b} = {a + b}")
print(f"{a} - {b} = {a - b}")
print(f"{a} * {b} = {a * b}")
print(f"{a} / {b} = {a / b}")
print(f"{a} % {b} = {a % b}")

// Main function
function main() {
    // Declare and initialize variables
    let a = 10, b = 5;

    // Output addition operation
    console.log(a + " + " + b + " = " + (a + b));

    // Output subtraction operation
    console.log(a + " - " + b + " = " + (a - b));

    // Output multiplication operation
    console.log(a + " * " + b + " = " + (a * b));

    // Output division operation
    console.log(a + " / " + b + " = " + (a / b));

    // Output modulus operation
    console.log(a + " % " + b + " = " + (a % b));
}

// Call the main function to execute the program
main();

10 + 5 = 15
10 - 5 = 5
10 * 5 = 50
10 / 5 = 2
10 % 5 = 0

Comparison Operators in Programming:

Comparison operators in programming are used to compare two values or expressions and return a Boolean result indicating the relationship between them. These operators play a crucial role in decision-making and conditional statements. Here are the common comparison operators:

These operators are extensively used in conditional statements, loops, and decision-making constructs to control the flow of a program based on the relationship between variables or values. Understanding comparison operators is crucial for creating logical and effective algorithms in programming.

#include <iostream>
using namespace std;

int main()
{

    int a = 5, b = 5, c = 10;
    if (a == b)
        cout << a << " is equal to " << b << endl;
    if (a != c)
        cout << a << " is not equal to " << c << endl;
    if (a < c)
        cout << a << " is less than " << c << endl;
    if (a <= b)
        cout << a << " is less than or equal to " << b << endl;
    if (c > a)
        cout << c << " is greater than " << a << endl;
    if (a >= b)
        cout << a << " is greater than or equal to " << b << endl;
    return 0;
}

/* package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        int a = 5, b = 5, c = 10;

        if (a == b)
            System.out.println(a + " is equal to " + b);
        if (a != c)
            System.out.println(a + " is not equal to " + c);
        if (a < c)
            System.out.println(a + " is less than " + c);
        if (a <= b)
            System.out.println(a + " is less than or equal to " + b);
        if (c > a)
            System.out.println(c + " is greater than " + a);
        if (a >= b)
            System.out.println(a + " is greater than or equal to " + b);
    }
}

a = 5
b = 5
c = 10

if a == b:
    print(f"{a} is equal to {b}")
if a != c:
    print(f"{a} is not equal to {c}")
if a < c:
    print(f"{a} is less than {c}")
if a <= b:
    print(f"{a} is less than or equal to {b}")
if c > a:
    print(f"{c} is greater than {a}")
if a >= b:
    print(f"{a} is greater than or equal to {b}")

function main() {
    let a = 5, b = 5, c = 10;

    if (a === b)
        console.log(a + " is equal to " + b);
    if (a !== c)
        console.log(a + " is not equal to " + c);
    if (a < c)
        console.log(a + " is less than " + c);
    if (a <= b)
        console.log(a + " is less than or equal to " + b);
    if (c > a)
        console.log(c + " is greater than " + a);
    if (a >= b)
        console.log(a + " is greater than or equal to " + b);
}

main();

5 is equal to 5
5 is not equal to 10
5 is less than 10
5 is less than or equal to 5
10 is greater than 5
5 is greater than or equal to 5

Logical Operators in Programming:

Logical operators in programming are used to perform logical operations on Boolean values. These operators are crucial for combining or manipulating conditions and controlling the flow of a program based on logical expressions. Here are the common logical operators:

These logical operators are frequently used in conditional statements (if, else if, else), loops, and decision-making constructs to create complex conditions based on multiple Boolean expressions. Understanding how to use logical operators is essential for designing effective and readable control flow in programming.

#include <iostream>
using namespace std;

int main()
{

    // Logical AND (&&)
    int x = 5, y = 10;
    if (x > 0 && y > 0) {
        cout << "Both " << x << " and " << y
             << " are greater than 0." << endl;
    }

    // Logical OR (||)
    x = 15;
    y = -5;
    if (x > 0 || y > 0) {
        cout << "At least one of " << x << " or " << y
             << " is greater than 0." << endl;
    }

    // Logical NOT (!)
    if (!(x == y)) {
        cout << x << " is not equal to " << y << endl;
    }
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        // Logical AND (&&)
        int x = 5, y = 10;
        if (x > 0 && y > 0) {
            System.out.println("Both " + x + " and " + y
                               + " are greater than 0.");
        }

        // Logical OR (||)
        x = 15;
        y = -5;
        if (x > 0 || y > 0) {
            System.out.println("At least one of " + x
                               + " or " + y
                               + " is greater than 0.");
        }

        // Logical NOT (!)
        if (!(x == y)) {
            System.out.println(x + " is not equal to " + y);
        }
    }
}

# Logical AND (and)
x, y = 5, 10
if x > 0 and y > 0:
    print(f"Both {x} and {y} are greater than 0.")

# Logical OR (or)
x, y = 15, -5
if x > 0 or y > 0:
    print(f"At least one of {x} or {y} is greater than 0.")

# Logical NOT (not)
if not (x == y):
    print(f"{x} is not equal to {y}")

// Logical AND (&&)
let x = 5, y = 10;
if (x > 0 && y > 0) {
    console.log(`Both ${x} and ${y} are greater than 0.`);
}

// Logical OR (||)
x = 15;
y = -5;
if (x > 0 || y > 0) {
    console.log(`At least one of ${x} or ${y} is greater than 0.`);
}

// Logical NOT (!)
if (!(x === y)) {
    console.log(`${x} is not equal to ${y}`);
}

Both 5 and 10 are greater than 0.
At least one of 15 or -5 is greater than 0.
15 is not equal to -5

Assignment Operators in Programming:

Assignment operators in programming are used to assign values to variables. They are essential for storing and updating data within a program. Here are common assignment operators:

Assignment operators are fundamental for updating variable values, especially in loops and mathematical computations, contributing to the dynamic nature of programming. Understanding how to use assignment operators is essential for effective variable manipulation in a program.

#include <iostream>
using namespace std;

int main()
{

    // Assignment (=)
    int x;
    x = 10;
    cout << "x after assignment: " << x << endl;

    // Addition Assignment (+=)
    x += 3;
    cout << "x after x += 3: " << x << endl;

    // Subtraction Assignment (-=)
    x -= 2;
    cout << "x after x -= 2: " << x << endl;

    // Multiplication Assignment (*=)
    x *= 4;
    cout << "x after x *= 4: " << x << endl;

    // Division Assignment (/=)
    x /= 2;
    cout << "x after x /= 2: " << x << endl;

    // Modulo Assignment (%=)
    x %= 3;
    cout << "x after x %= 3: " << x << endl;
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        // Assignment (=)
        int x;
        x = 10;
        System.out.println("x after assignment: " + x);

        // Addition Assignment (+=)
        x += 3;
        System.out.println("x after x += 3: " + x);

        // Subtraction Assignment (-=)
        x -= 2;
        System.out.println("x after x -= 2: " + x);

        // Multiplication Assignment (*=)
        x *= 4;
        System.out.println("x after x *= 4: " + x);

        // Division Assignment (/=)
        x /= 2;
        System.out.println("x after x /= 2: " + x);

        // Modulo Assignment (%=)
        x %= 3;
        System.out.println("x after x %= 3: " + x);
    }
}

# Assignment (=)
x = 10
print("x after assignment:", x)

# Addition Assignment (+=)
x += 3
print("x after x += 3:", x)

# Subtraction Assignment (-=)
x -= 2
print("x after x -= 2:", x)

# Multiplication Assignment (*=)
x *= 4
print("x after x *= 4:", x)

# Division Assignment (/=)
x /= 2
print("x after x /= 2:", x)

# Modulo Assignment (%=)
x %= 3
print("x after x %= 3:", x)

// Assignment (=)
let x;
x = 10;
console.log("x after assignment: " + x);

// Addition Assignment (+=)
x += 3;
console.log("x after x += 3: " + x);

// Subtraction Assignment (-=)
x -= 2;
console.log("x after x -= 2: " + x);

// Multiplication Assignment (*=)
x *= 4;
console.log("x after x *= 4: " + x);

// Division Assignment (/=)
x /= 2;
console.log("x after x /= 2: " + x);

// Modulo Assignment (%=)
x %= 3;
console.log("x after x %= 3: " + x);

x after assignment: 10
x after x += 3: 13
x after x -= 2: 11
x after x *= 4: 44
x after x /= 2: 22
x after x %= 3: 1

Increment and Decrement Operators in Programming:

Increment and decrement operators in programming are used to increase or decrease the value of a variable by 1, respectively. They are shorthand notations for common operations and are particularly useful in loops. Here are the two types:

These operators are frequently employed in loops, especially for iterating through arrays or performing repetitive tasks. Their concise syntax enhances code readability and expressiveness.

#include <iostream>
using namespace std;

int main()
{
    // Increment Operator (++)
    int a = 5;
    cout << "Value of a: " << a << endl;
    a++;
    cout << "Value of a after (a++): " << a << endl;

    // Decrement Operator (--)
    int b = 8;
    cout << "Value of b: " << b << endl;
    b--;
    cout << "Value of b after (b--): " << b << endl;

    // Increment Operator in Expression
    int x = 10;
    int y = x++;
    cout << "Value of x: " << x << endl;
    cout << "Value of y (post-increment): " << y << endl;

    // Decrement Operator in Expression
    int m = 15;
    int n = --m;
    cout << "Value of m: " << m << endl;
    cout << "Value of n (pre-decrement): " << n << endl;
    return 0;
}

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public static void main(String[] args)
    {
        // Increment Operator (++)
        int a = 5;
        System.out.println("Value of a: " + a);
        a++;
        System.out.println("Value of a after (a++): " + a);

        // Decrement Operator (--)
        int b = 8;
        System.out.println("Value of b: " + b);
        b--;
        System.out.println("Value of b after (b--): " + b);

        // Increment Operator in Expression
        int x = 10;
        int y = x++;
        System.out.println("Value of x: " + x);
        System.out.println("Value of y (post-increment): " + y);

        // Decrement Operator in Expression
        int m = 15;
        int n = --m;
        System.out.println("Value of m: " + m);
        System.out.println("Value of n (pre-decrement): " + n);
    }
}

# code in python
# Increment Operator (++)
a = 5
print("Value of a:", a)
a += 1
print("Value of a after (a++):", a)

# Decrement Operator (--)
b = 8
print("Value of b:", b)
b -= 1
print("Value of b after (b--):", b)

# Increment Operator in Expression
x = 10
y = x
x += 1
print("Value of x:", x)
print("Value of y (post-increment):", y)

# Decrement Operator in Expression
m = 15
n = m
m -= 1
print("Value of m:", m)
print("Value of n (pre-decrement):", n)

#this code is contributed by Sundaram

// Increment Operator (++)
let a = 5;
console.log("Value of a: " + a);
a++;
console.log("Value of a after (a++): " + a);

// Decrement Operator (--)
let b = 8;
console.log("Value of b: " + b);
b--;
console.log("Value of b after (b--): " + b);

// Increment Operator in Expression
let x = 10;
let y = x++;
console.log("Value of x: " + x);
console.log("Value of y (post-increment): " + y);

// Decrement Operator in Expression
let m = 15;
let n = --m;
console.log("Value of m: " + m);
console.log("Value of n (pre-decrement): " + n);

Value of a: 5
Value of a after (a++): 6
Value of b: 8
Value of b after (b--): 7
Value of x: 11
Value of y (post-increment): 10
Value of m: 14
Value of n (pre-decrement): 14

Bitwise Operators in Programming:

Bitwise operators in programming perform operations at the bit level, manipulating individual bits of binary representations of numbers. These operators are often used in low-level programming, such as embedded systems and device drivers. Here are the common bitwise operators:

Bitwise operators are useful in scenarios where direct manipulation of binary representations or specific bit patterns is required, such as optimizing certain algorithms or working with hardware interfaces. Understanding bitwise operations is essential for low-level programming tasks.

#include <iostream>
using namespace std;

int main()
{
    // Bitwise AND (&)
    int A = 5, B = 3;
    cout << "(" << A << " & " << B << ") = " << (A & B) << endl;

    // Bitwise OR (|)
    cout << "(" << A << " | " << B << ") = " << (A | B) << endl;

    // Bitwise XOR (^)
    cout << "(" << A << " ^ " << B << ") = " << (A ^ B) << endl;

    // Bitwise NOT (~)
    cout << "~" << A << " = " << (~A) << endl;

    // Left Shift (<<)
    cout << "(" << A << " << 2) = " << (A << 2) << endl;

    // Right Shift (>>)
    cout << "(" << A << " >> 2) = " << (A >> 2) << endl;
    return 0;
}

class GFG {
    public static void main(String[] args)
    {
        // Bitwise AND (&)
        int A = 5, B = 3;
        System.out.println("(" + A + " & " + B
                           + ") = " + (A & B));

        // Bitwise OR (|)
        System.out.println("(" + A + " | " + B
                           + ") = " + (A | B));

        // Bitwise XOR (^)
        System.out.println("(" + A + " ^ " + B
                           + ") = " + (A ^ B));

        // Bitwise NOT (~)
        System.out.println("~" + A + " = " + (~A));

        // Left Shift (<<)
        System.out.println("(" + A
                           + " << 2) = " + (A << 2));

        // Right Shift (>>)
        System.out.println("(" + A
                           + " >> 2) = " + (A >> 2));
    }
}

# Bitwise AND (&)
A, B = 5, 3
print(f"({A} & {B}) = {A & B}")

# Bitwise OR (|)
print(f"({A} | {B}) = {A | B}")

# Bitwise XOR (^)
print(f"({A} ^ {B}) = {A ^ B}")

# Bitwise NOT (~)
print(f"~{A} = {~A}")

# Left Shift (<<)
print(f"({A} << 2) = {A << 2}")

# Right Shift (>>)
print(f"({A} >> 2) = {A >> 2}")

class GFG {
    static main() {
        // Bitwise AND (&)
        let A = 5, B = 3;
        console.log(`(${A} & ${B}) = ${A & B}`);

        // Bitwise OR (|)
        console.log(`(${A} | ${B}) = ${A | B}`);

        // Bitwise XOR (^)
        console.log(`(${A} ^ ${B}) = ${A ^ B}`);

        // Bitwise NOT (~)
        console.log(`~${A} = ${~A}`);

        // Left Shift (<<)
        console.log(`(${A} << 2) = ${A << 2}`);

        // Right Shift (>>)
        console.log(`(${A} >> 2) = ${A >> 2}`);
    }
}

// Call main function
GFG.main();

(5 & 3) = 1
(5 | 3) = 7
(5 ^ 3) = 6
~5 = -6
(5 << 2) = 20
(5 >> 2) = 1

In conclusion, operators in programming are essential for tasks like math, comparison, and logical decision-making. They handle basic operations, value comparison, and variable manipulation. Understanding these is crucial for efficient coding in different languages.