Operators in C++

An operator is a symbol that tells the compiler to perform specific mathematical, relational, or logical manipulations on values or variables. The data values that operators act upon are called operands.

C++ provides a rich set of built-in operators classified by their functionality and the number of operands they require (unary, binary, or ternary).

Video Explanation​

Watch

1. Arithmetic Operators​

Arithmetic operators execute standard mathematical operations. These require numerical operands.

#include <iostream>

int main() {
    int x = 10, y = 5;
    std::cout << (x + y) << "\n";  // Output: 15
    std::cout << (x / y) << "\n";  // Output: 2
    std::cout << (x % y) << "\n";  // Output: 0
    return 0;
}

2. Relational Operators​

Relational operators compare two values to determine their relationship. They always evaluate to a boolean state: true (1) or false (0).

#include <iostream>

int main() {
    int x = 10, y = 5;
    std::cout << (x > y) << "\n";   // Output: 1 (true)
    std::cout << (x == y) << "\n";  // Output: 0 (false)
    std::cout << (x <= y) << "\n";  // Output: 0 (false)
    return 0;
}

3. Logical Operators​

Logical operators are used to connect or invert expressions containing relational or boolean states.

#include <iostream>

int main() {
    int x = 10, y = 5;
    std::cout << (x > 5 && y < 10) << "\n"; // Output: 1 (true)
    std::cout << (x > 15 || y == 5) << "\n"; // Output: 1 (true)
    std::cout << !(x > 5) << "\n";            // Output: 0 (false)
    return 0;
}

4. Assignment Operators​

Assignment operators evaluate the expression on the right side and store the resulting value into the memory variable specified on the left side.

#include <iostream>

int main() {
    int x = 10;
    x += 5; // x is now 15
    x *= 2; // x is now 30
    std::cout << x << "\n"; // Output: 30
    return 0;
}

5. Increment and Decrement Operators​

These unary operators modify a single numerical variable's value by exactly 1. They come in two distinct behaviors: Prefix and Postfix.

int x = 10;
std::cout << ++x;  // Increments x to 11, prints 11
std::cout << x++;  // Prints current value (11), then increments x to 12
std::cout << x;    // Prints current value (12)

6. Bitwise Operators​

Bitwise operators manipulate the raw binary bits within integer data types directly.

#include <iostream>
// Example using 4-bit representation for simplicity:
int a = 5; // Binary: 0101
int b = 9; // Binary: 1001

std::cout << (a & b); // Binary: 0001 -> Output: 1
std::cout << (a | b); // Binary: 1101 -> Output: 13
std::cout << (a ^ b); // Binary: 1100 -> Output: 12
std::cout << (~a);    // Binary: 1010 -> Output: -6 (two's complement)
std::cout << (a << 1); // Binary: 1010 -> Output: 10
std::cout << (a >> 1); // Binary: 0010 -> Output: 2

7. Ternary Conditional Operator (?:)​

The ternary operator is the only operator in C++ that acts on three operands. It serves as a clean, inline alternative to simple if-else blocks.

Syntax​

condition ? expression_if_true : expression_if_false;

Example​

int testScore = 85;
std::string classification = (testScore >= 50) ? "Pass" : "Fail";
std::cout << classification; // Output: Pass

8. Operator Precedence and Associativity​

When evaluating a complex expression like int result = 5 + 3 * 2;, C++ relies on predefined rules to determine which operator executes first.

1. Precedence: Dictates the execution priority of different operators. For example, multiplication (*) has a higher priority rank than addition (+). Therefore, 3 * 2 is processed first.
2. Associativity: Dictates the processing direction (Left-to-Right or Right-to-Left) when two operators with the exact same precedence rank appear adjacent to each other.

Best Practice: When in doubt about operator precedence rules, wrap your planned execution segments in **parentheses ()**. Parentheses hold the absolute highest priority rank in C++ and make code significantly easier to read.

int evaluationA = 10 + 5 * 2;   // Evaluates to 20 (Multiplication occurs first)
int evaluationB = (10 + 5) * 2; // Evaluates to 30 (Parentheses override standard precedence)

Conclusion​

Mastering C++ operators is essential for writing efficient and effective code. Understanding how to use them correctly allows you to perform complex calculations, make decisions, and manipulate data with precision. Always remember to consider operator precedence and associativity to ensure your expressions evaluate as intended.