C++ Operators Arithmetic, Logical, Bitwise

Arithmetic And Assignment Operators

C++ operators are symbols or keywords that perform operations on values, variables, pointers, objects, and expressions. They are used for arithmetic, assignment, comparison, logical decisions, bit-level work, memory access, and compact value selection.

A good C++ learner should know the operator category, the value returned by the expression, and the order of evaluation. When an expression mixes several operator groups, parentheses and named boolean variables make the program easier to read and debug.

Operator learning should be done category by category. First identify the operands, then identify the operator, then predict the result type, and finally check whether the expression changes any variable. This habit prevents mistakes in conditions, loops, calculations, and object code.

For revision, group operators by question type. Arithmetic operators answer calculation questions. Assignment operators answer update questions. Comparison operators answer true or false questions. Logical operators answer combined decision questions. Bitwise operators answer flag and binary storage questions. The conditional operator answers short selection questions. This grouping makes exam, interview, and debugging practice easier because you can first decide the purpose of the expression before remembering the exact symbol.

When practicing C++ operators, avoid memorizing a table only. Write small programs that print results, change operand values, and compare the output with your prediction. Include negative numbers, zero, odd numbers, even numbers, and decimal values. This reveals integer division, remainder behavior, boolean output, and type conversion rules. After that, rewrite long expressions with parentheses so the intention is visible to a reader.

Arithmetic operators calculate numeric results, while assignment operators store or update values. Integer division is important because dividing two integers removes the decimal part.

Use +, -, *, /, and % for numeric operations.
Use +=, -=, *=, /=, and %= when updating the same variable.
Use double or float when decimal division is required.

Arithmetic Example

#include <iostream>
using namespace std;

int main() {
    int a = 10, b = 3;
    cout << a + b << endl;
    cout << a / b << endl;
    cout << a % b << endl;
    a += 5;
    cout << a;
    return 0;
}

Comparison And Logical Operators

Comparison operators return true or false. Logical operators combine conditions and are commonly used in if statements, loops, validation checks, and search logic.

Use == for equality and != for not equal.
Use <, <=, >, and >= for ordering comparisons.
Use && when both conditions must be true, || when one condition can be true, and ! to reverse a condition.

Eligibility Example

#include <iostream>
using namespace std;

int main() {
    int age = 21;
    bool hasId = true;
    if (age >= 18 && hasId) {
        cout << "Allowed";
    } else {
        cout << "Not allowed";
    }
    return 0;
}

Increment, Decrement, And Precedence

The increment and decrement operators change a variable by one. Prefix form changes the value before it is used, while postfix form uses the old value first and then updates it. Operator precedence decides which part of a mixed expression runs first.

Use ++count when the updated value is needed immediately.
Use count++ carefully because it returns the previous value.
Avoid expressions that modify the same variable multiple times.
Use parentheses when arithmetic, comparison, and logical operators appear together.

Bitwise And Conditional Operators

Bitwise operators work on individual bits and are useful in flags, masks, permissions, and low-level programming. The conditional operator is a compact if else expression, but it should stay readable.

Use & for bitwise AND, | for OR, ^ for XOR, ~ for NOT, and shifts for moving bits.
Use bit flags when several true or false options can be stored in one integer.
Use condition ? value1 : value2 for short value selection.

Bit Flag Example

#include <iostream>
using namespace std;

int main() {
    const int READ = 1;
    const int WRITE = 2;
    int permission = READ | WRITE;
    if (permission & READ) cout << "Read allowed" << endl;
    cout << ((permission & WRITE) ? "Write allowed" : "Write denied");
    return 0;
}

How To Read A C++ Operator Expression

Read every C++ expression from the inside out. Parentheses have priority, then unary operators, then multiplication or division, then addition or subtraction, then comparison, then logical operators, and finally assignment. You do not need to memorize every precedence row immediately, but you should recognize when an expression is becoming too dense for a beginner-friendly program.

A clean expression usually has one clear purpose. For example, calculate a value, compare two values, update a variable, or choose one of two results. When one line tries to do all of these at the same time, split it into smaller statements. This makes compiler warnings easier to understand and helps another programmer review your code.

Operators also interact with data types. The same plus operator can add numbers or work with strings in supported contexts, comparison operators produce boolean results, and bitwise operators work on integer bits. Before using an operator, confirm that the operands have the type you expect.

Identify the operands before deciding what the operator will do.
Check whether the expression only reads values or also modifies a variable.
Prefer named intermediate variables for long formulas and long conditions.
Use compiler warnings as a guide when assignment, comparison, or type conversion looks suspicious.

Operator Practice Program

#include <iostream>
using namespace std;

int main() {
    int marks = 82;
    int attendance = 76;
    bool passed = marks >= 40;
    bool eligible = passed && attendance >= 75;
    cout << "Passed: " << passed << endl;
    cout << "Eligible: " << eligible << endl;
    marks += 5;
    cout << "Grace marks result: " << marks;
    return 0;
}

Before you move on