XQA
Back to C++
2026-02-105 min read

Other Operators (C++)

Learn Other Operators (C++) step by step with clear examples and exercises.

Why This Matters

Learn to master C++ other operators with this detailed guide, designed to help you understand and apply these concepts effectively in exams, interviews, and real-world coding challenges. This lesson goes beyond the basics, providing practical examples, common mistakes, and interview-ready one-liners.

Why This Matters

Understanding C++ other operators is crucial for writing efficient, readable, and maintainable code. These operators help you perform various tasks like incrementing/decrementing variables, comparing values, bitwise operations, and more. Mastery of these operators will make your code more expressive and reduce the need for unnecessary functions.

Prerequisites

Before diving into C++ other operators, it is essential to have a solid understanding of:

  • Basic C++ syntax, including variables, constants, and data types
  • Control structures like if, else, and loops (for, while)
  • Functions and function overloading

Core Concept

C++ other operators can be categorized into the following groups:

  1. Arithmetic Operators
  • Addition (+)
  • Subtraction (-)
  • Multiplication (*)
  • Division (/)
  • Modulus (%)
  • Increment (++) and Decrement (--) operators
  1. Relational Operators
  • Equal to (==)
  • Not equal to (!=)
  • Greater than (>)
  • Less than (<)
  • Greater than or equal to (>=)
  • Less than or equal to (<=)
  1. Logical Operators
  • Logical AND (&&)
  • Logical OR (||)
  • Logical NOT (!)
  1. Bitwise Operators
  • Bitwise AND (&)
  • Bitwise OR (|)
  • Bitwise XOR (^)
  • Bitwise NOT (~)
  • Left shift (<<) and Right shift (>>) operators
  1. Assignment Operators
  • Simple assignment (=)
  • Compound assignment operators (e.g., +=, -=, *=, /=, %=, etc.)

Arithmetic Operators

Arithmetic operators perform mathematical operations on operands. Let's take a look at an example:

#include <iostream>
using namespace std;

int main() {
int a = 5, b = 3;
cout << "a + b: " << a + b << endl; // Output: 8
cout << "a - b: " << a - b << endl; // Output: 2
cout << "a * b: " << a * b << endl; // Output: 15
cout << "a / b: " << a / b << endl; // Output: 1 (integer division)
cout << "a % b: " << a % b << endl; // Output: 3 (remainder of integer division)
}

Increment and Decrement Operators

The increment (++) and decrement (--) operators are used to modify the value of variables. There are two types of these operators: prefix and postfix.

  • Prefix increment/decrement (++a, --a) increments or decrements the variable before using it in an expression.
  • Postfix increment/decrement (a++, a--) increments or decrements the variable after using it in an expression.

Here's an example demonstrating the difference between prefix and postfix increment operators:

#include <iostream>
using namespace std;

int main() {
int a = 5;
cout << "Prefix ++a: " << ++a << endl; // Output: 6 (increment before using)
cout << "Postfix a++: " << a++ << endl; // Output: 6 (use current value, then increment)
cout << "a: " << a << endl; // Output: 7 (value after postfix increment)
}

Relational Operators

Relational operators are used to compare operands. Here's an example demonstrating their usage:

#include <iostream>
using namespace std;

int main() {
int a = 5, b = 3;
cout << "a == b: " << (a == b) << endl; // Output: 0 (false)
cout << "a != b: " << (a != b) << endl; // Output: 1 (true)
cout << "a > b: " << (a > b) << endl; // Output: 1 (true)
cout << "a < b: " << (a < b) << endl; // Output: 0 (false)
cout << "a >= b: " << (a >= b) << endl; // Output: 1 (true)
cout << "a <= b: " << (a <= b) << endl; // Output: 0 (false)
}

Logical Operators

Logical operators are used to combine conditional expressions. Here's an example demonstrating their usage:

#include <iostream>
using namespace std;

int main() {
int a = 5, b = 3;
cout << "a > 2 && b < 4: " << (a > 2 && b < 4) << endl; // Output: 1 (true)
cout << "a > 6 || b < 0: " << (a > 6 || b < 0) << endl; // Output: 1 (true)
}

Bitwise Operators

Bitwise operators manipulate the binary representation of integers. Here's an example demonstrating their usage:

#include <iostream>
using namespace std;

int main() {
int a = 60, b = 13; // In binary: 00111100 and 00001101
cout << "a & b: " << (a & b) << endl; // Output: 8 (00001000 in binary)
cout << "a | b: " << (a | b) << endl; // Output: 61 (00111101 in binary)
cout << "a ^ b: " << (a ^ b) << endl; // Output: 49 (00110001 in binary)
}

Assignment Operators

Assignment operators are used to assign values to variables. Compound assignment operators combine an assignment operation with another arithmetic operation. Here's an example demonstrating their usage:

#include <iostream>
using namespace std;

int main() {
int a = 5;
cout << "a += 3: ";
a += 3;
cout << a << endl; // Output: 8 (a now equals 8)
}

Worked Example

Let's write a program that checks if a number is even or odd using bitwise operators.

#include <iostream>
using namespace std;

int main() {
int num;
cout << "Enter an integer: ";
cin >> num;
if (num & 1) // If the least significant bit is set, the number is odd
cout << num << " is odd.";
else
cout << num << " is even.";
return 0;
}

Common Mistakes

  1. Forgetting to include necessary headers (e.g., ``)
  2. Using operators incorrectly (e.g., using = instead of ==)
  3. Mixing up prefix and postfix increment/decrement operators
  4. Not understanding the differences between relational, logical, and bitwise operators
  5. Overlooking the importance of parentheses for operator precedence

Practice Questions

  1. Write a program that calculates the sum of two numbers using both addition (+) and bitwise OR (|) operators.
  2. Given two integers a and b, write a program that swaps their values without using a temporary variable.
  3. Write a program that checks if a given number is prime using only relational operators.
  4. Write a program that finds the maximum of three numbers using bitwise AND (&) and XOR (^) operators.
  5. Write a program that calculates the factorial of a number using recursion and compound assignment operators.

FAQ

What is the difference between prefix and postfix increment/decrement operators?

  • Prefix increments or decrements the variable before using it in an expression, while postfix increments or decrements the variable after using it in an expression.

Can I use bitwise operators for arithmetic operations?

  • No, bitwise operators are used to manipulate the binary representation of integers and should not be used for standard arithmetic operations like addition, subtraction, multiplication, etc.

Why is it important to understand the order of operator precedence when using multiple operators in an expression?

  • Understanding operator precedence helps you write expressions that are easier to read, debug, and maintain. It ensures that your code behaves as intended by correctly grouping operations according to their precedence.

How can I check if a number is even or odd without using bitwise operators?

  • You can use the modulus operator (%) to determine if a number is even or odd: if num % 2 == 0, then the number is even; otherwise, it's odd.

What are some common pitfalls when working with logical operators in C++?

  • Some common pitfalls include forgetting to account for edge cases (e.g., both conditions being false), mixing up logical and relational operators, and not using parentheses to clarify the intended order of operations.
Other Operators (C++) | C++ | XQA Learn