##### C++

# Understanding Operators in C++ with Examples

- Last updated Apr 25, 2024

Operators in C++ are special symbols or keywords used to perform operations on variables and values. They are the building blocks of C++ programs and allow you to perform tasks like addition, subtraction, comparison, and more. C++ provides a wide range of operators to manipulate data, perform calculations, and control the flow of your programs. Understanding the various operators available in C++ is essential for anyone looking to become proficient in this programming language.

This tutorial is designed to provide a comprehensive understanding of C++ operators by categorizing them into different types and exploring their practical applications. Whether you are a beginner looking to grasp the fundamentals or an experienced developer seeking a quick reference, this guide will serve as a valuable resource for gaining insight into the world of operators in C++.

##### Types of Operators in C++

Operators in C++ can be categorized into several types based on their functionality. Here are the main categories of operators in C++:

**Arithmetic Operators:****Assignment Operators:****Relational Operators:****Logical Operators:****Conditional (Ternary) Operator:****Condition:**This is a boolean expression that is evaluated. If it is true, the value of the expression before the ? is returned; otherwise, the value after the : is returned.**Expression_if_true:**This is the value or expression that is returned if the condition is true.**Expression_if_false:**This is the value or expression that is returned if the condition is false.**Bitwise Operators:**- Bitwise AND (&):
- Bitwise OR (|):
- Bitwise XOR (^):
- Bitwise NOT (~)
- Left Shift (<<):
- Right Shift (>>):
**Other Operators:**

Arithmetic operators are used to perform arithmetic or mathematical operations such as addition, subtraction, multiplication or division, and more.

There are two types of arithmetic operators: unary and binary. Unary operators are used to perform operations on a single operand (one value), while binary operators work with two operands (two values).

Here's a table with examples of both unary and binary arithmetic operators in C++:

Operator |
Type |
Example |
Description |

+ |
Unary |
+7 |
Unary plus, returns the positive value of the operand. |

- |
Unary |
-7 | Unary minus, negates the value of the operand. |

++ |
Unary |
x++ | Post-increment, returns the original value of x and then increments it. |

-- |
Unary |
x-- | Post-decrement, returns the original value of y and then decrements it. |

++ |
Unary |
++x | Pre-increment, increments x and then returns the new value. |

-- |
Unary |
--x | Pre-decrement, decrements y and then returns the new value. |

+ |
Binary |
a + b | Addition, sums the values of two operands. |

- |
Binary |
a - b | Subtraction, subtracts second operand from the first. |

* |
Binary |
a * b | Multiplication, multiplies two operands. |

/ |
Binary |
a / b | Division, divides first operand by the second operand. |

% |
Binary |
a % b | Modulus, returns the remainder after the division of the first operand by the second operand. |

Here's a C++ program that demonstrates the use of both unary and binary arithmetic operators. It calculates various operations and displays the results, showing how these operators work in practice:

```
#include <iostream>
using namespace std;
int main()
{
int x = 4;
int y = 2;
// Unary Operators
cout << "Unary Operators:" << endl;
cout << "+x is " << +x << endl; // Unary plus
cout << "-y is " << -y << endl; // Unary minus
cout << "Post-increment x++ is " << x++ << ", x becomes " << x << endl; // Post-increment
cout << "Post-decrement y-- is " << y-- << ", y becomes " << y << endl; // Post-decrement
cout << "Pre-increment ++x is " << ++x << ", x becomes " << x << endl; // Pre-increment
cout << "Pre-decrement --y is " << --y << ", y becomes " << y << endl; // Pre-decrement
// Binary Operators
int a = 10;
int b = 3;
cout << "\nBinary Operators:" << endl;
cout << "a + b is " << a + b << endl; // Addition
cout << "a - b is " << a - b << endl; // Subtraction
cout << "a * b is " << a * b << endl; // Multiplication
cout << "a / b is " << a / b << endl; // Division
cout << "a % b is " << a % b << endl; // Modulus
return 0;
}
```

The output of the above code is as follows:

Unary Operators: +x is 4 -y is -2 Post-increment x++ is 4, x becomes 5 Post-decrement y-- is 2, y becomes 1 Pre-increment ++x is 6, x becomes 6 Pre-decrement --y is 0, y becomes 0 Binary Operators: a + b is 13 a - b is 7 a * b is 30 a / b is 3 a % b is 1

In C++, the assignment operator is denoted by the = symbol, and it is used to assign a value to a variable.

The following table lists assignment operators in C++ with examples:

Operator |
Name |
Example |
Description |

= |
Assignment operator |
x = 40; |
Assigns the value on the right to the variable on the left. Assigns the value 40 to variable x |

+= |
Addition assignment operator |
x += 10; |
The value of the left variable is first added to the value of the right variable and then assigns the result to the left variable. Adds 10 to the current value of x. |

-= |
Subtraction assignment operator |
x -= 5; |
With the use of this operator, the value of the left variable is first subtracted with the value of the right variable and then assigns the result to the left variable. Subtracts 5 from the current value of x. |

*= |
Multiplication assignment operator |
x *= 3; |
With the use of this operator, the value of the left variable is first multiplied with the value of the right variable and then assigns the result to the left variable. Multiplies the current value of x by 3. |

/= |
Division assignment operator |
x /= 5; |
With the use of this operator, the value of the left variable is first divided by the value of the right variable and then assigns the result to the left variable. Divides the current value of x by 5. |

%= |
Modulus assignment operator |
x %= 2; |
Calculates the remainder of x divided by 2 and assigns it to x. |

Here's a C++ program that demonstrates the use of assignment operators. It calculates various operations and displays the results, showing how these operators work in practice:

```
#include <iostream>
using namespace std;
int main()
{
// Assignment Operator
int a = 6;
int b = 4;
cout << "a is " << a << endl;
cout << "b is " << b << endl;
// Add and Assignment Operator
cout << "a += b is " << (a += b) << endl;
// Subtract and Assignment Operator
cout << "a -= b is " << (a -= b) << endl;
// Multiply and Assignment Operator
cout << "a *= b is " << (a *= b) << endl;
// Divide and Assignment Operator
cout << "a /= b is " << (a /= b) << endl;
// Modulus and Assignment Operator
cout << "a %= b is " << (a %= b) << endl;
return 0;
}
```

The output of the above code is as follows:

a is 6 b is 4 a += b is 10 a -= b is 6 a *= b is 24 a /= b is 6 a %= b is 2

In C++, relational operators are used to compare two values or expressions and determine their relationship. These operators return a Boolean value (true or false) based on whether the comparison is true or false.

Here's a table listing some of the relational operators in C++:

Operator |
Name |
Example |
Description |

== |
Equal to |
x == y |
Checks if x is equal to y. |

!= |
Not equal to |
x != y |
Checks if x is not equal to y. |

< |
Less than |
x < y |
Checks if x is less than y. |

> |
Greater than |
x > y |
Checks if x is greater than y. |

<= |
Less than or equal |
x <= y |
Checks if x is less than or equal to y. |

>= |
Greater than or equal |
x >= y |
Checks if x is greater than or equal to y. |

Here's a program that demonstrates the use of relational operators in C++:

```
#include <iostream>
int main() {
int x = 2;
int y = 5;
// Equal to (==)
bool isEqual = (x == y); // false, as x is not equal to y
// Not equal to (!=)
bool isNotEqual = (x != y); // true, as x is not equal to y
// Less than (<)
bool isLessThan = (x < y); // true, as x is less than y
// Greater than (>)
bool isGreaterThan = (x > y); // false, as x is not greater than y
// Less than or equal to (<=)
bool isLessThanOrEqual = (x <= 4); // true, as x is equal to 4
// Greater than or equal to (>=)
bool isGreaterThanOrEqual = (y >= 8); // true, as y is equal to 8
std::cout << "Is x equal to y? " << isEqual << std::endl;
std::cout << "Is x not equal to y? " << isNotEqual << std::endl;
std::cout << "Is x less than y? " << isLessThan << std::endl;
std::cout << "Is x greater than y? " << isGreaterThan << std::endl;
std::cout << "Is x less than or equal to 4? " << isLessThanOrEqual << std::endl;
std::cout << "Is y greater than or equal to 8? " << isGreaterThanOrEqual << std::endl;
return 0;
}
```

The output of the above code is as follows (1 represents true, while 0 represents false):

Is x equal to y? 0 Is x not equal to y? 1 Is x less than y? 1 Is x greater than y? 0 Is x less than or equal to 4? 1 Is y greater than or equal to 8? 0

Logical operators are used to check whether a condition is true or false. If the condition is true, it returns 1 whereas if the condition is false, it returns 0.

Here's a table with some common logical operators in C++:

Operator |
Name |
Example |
Description |

&& |
Logical AND |
true && true returns true true && false returns false false && true returns false false && false returns false |
Returns true if both operands are true. |

|| |
Logical OR |
true || true returns true true || false returns true false || true returns true false || false returns false |
Returns true if at least one operand is true. |

! |
Logical NOT |
!true returns false !false returns true |
Returns true if the operand is false, and vice versa. |

Here's a program that demonstrates the use of logical operators in C++:

```
#include <iostream>
using namespace std;
int main() {
bool a = true;
bool b = false;
// Logical AND (&&) operator
bool result_and = a && b; // false
cout << "a && b is " << result_and << endl;
// Logical OR (||) operator
bool result_or = a || b; // true
cout << "a || b is " << result_or << endl;
// Logical NOT (!) operator
bool result_not_a = !a; // false
cout << "!a is " << result_not_a << endl;
bool result_not_b = !b; // true
cout << "!b is " << result_not_b << endl;
return 0;
}
```

The output of the above code is as follows (1 represents true, while 0 represents false):

a && b is 0 a || b is 1 !a is 0 !b is 1

In C++, the conditional operator, often referred to as the ternary operator, is a concise way to write conditional expressions. It provides a shorthand method for making decisions and choosing between two values based on a given condition.

The ternary operator is represented by the ? : symbols and is structured as follows:

condition ? expression_if_true : expression_if_false;

Here's an explanation of each part of the above structure:

Here's a simple example that demonstrates the use of the ternary operator in C++:

```
#include <iostream>
using namespace std;
int main() {
int x = 4;
int y = 8;
int result = (x > y) ? x : y;
cout << "result is " << result << endl;
return 0;
}
```

In this example, (x > y) is the evaluated condition, checking if x is greater than y, which is false, resulting in the assignment of the value of y (which is 8) to the variable result.

The output of the above code is as follows:

result is 8

In C++, bitwise operators are used to perform operations at the binary level on integers. These operators work by manipulating the individual bits of the operands. Unlike traditional arithmetic operations such as addition, subtraction, and multiplication, which work on entire numbers, bitwise operations allow for faster processing by directly manipulating the bits.

Here's a table with examples and explanations of bitwise operators in C++:

Operator |
Name |
Example |
Description |

& |
Bitwise AND |
5 & 3 |
Compares each bit; result is 1 if both are 1. |

| |
Bitwise OR |
5 | 3 |
Compares each bit; result is 1 if at least one is 1. |

^ |
Bitwise XOR |
5 ^ 3 |
Compares each bit; result is 1 if bits are different. |

~ |
Bitwise NOT |
~5 |
Inverts all the bits; 0s become 1s and vice versa. |

<< |
Left Shift |
5 << 2 |
Shifts bits to the left, effectively multiplies by 2^2. |

>> |
Right Shift |
16 >> 2 |
Shifts bits to the right, effectively divides by 2^2. |

Here are examples of each bitwise operator in C++:

```
#include <iostream>
using namespace std;
int main() {
int a = 5; // Binary: 0101
int b = 3; // Binary: 0011
int result = a & b; // Binary: 0001 (Decimal: 1)
cout << "result is " << result << endl;
return 0;
}
```

The output of the above code is as follows:

result is 1

```
#include <iostream>
using namespace std;
int main() {
int a = 5; // Binary: 0101
int b = 3; // Binary: 0011
int result = a | b; // Binary: 0111 (Decimal: 7)
cout << "result is " << result << endl;
return 0;
}
```

The output of the above code is as follows:

result is 7

```
#include <iostream>
using namespace std;
int main() {
int a = 5; // Binary: 0101
int b = 3; // Binary: 0011
int result = a ^ b; // Binary: 0110 (Decimal: 6)
cout << "result is " << result << endl;
return 0;
}
```

The output of the above code is as follows:

result is 6

```
#include <iostream>
using namespace std;
int main() {
int a = 5; // Binary: 0101
int result = ~a; // Binary: 1010 (Decimal: -6)
cout << "result is " << result << endl;
return 0;
}
```

The output of the above code is as follows:

result is -6

```
#include <iostream>
using namespace std;
int main() {
int a = 5; // Binary: 0000 0101
int result = a << 2; // Binary: 0001 0100 (Decimal: 20)
cout << "result is " << result << endl;
return 0;
}
```

The output of the above code is as follows:

result is 20

```
#include <iostream>
using namespace std;
int main() {
int a = 16; // Binary: 0001 0000
int result = a >> 2; // Binary: 0000 0100 (Decimal: 4)
cout << "result is " << result << endl;
return 0;
}
```

The output of the above code is as follows:

result is 4

Here is a list of other common operators available in C++:

Operator |
Example |
Description |

sizeof |
sizeof(int); //4 |
Returns the size of the data type. |

& |
# //address of num |
Address-of Operator |

. |
studentObj.marks = 97; |
Member Access Operator |

-> |
ptr->marks = 97; |
It is used with pointers to access the class or variables. |

<< |
cout << 5; |
Output Stream Operator (Used for Printing) |

>> |
cin >> num; |
Input Stream Operator (Used for Getting Input) |

Here's an example that demonstrates the use of other common operators available in C++:

```
#include <iostream>
using namespace std;
int main() {
int num = 42;
int x = 5, y = 3;
string result;
// sizeof operator
cout << "Size of int: " << sizeof(int) << " bytes" << endl;
// Address-of Operator
cout << "Address of num: " << &num << endl;
// Member Access Operator
struct Student
{
int marks;
};
Student studentObj;
studentObj.marks = 97;
cout << "Marks: " << studentObj.marks << endl;
// Member Access through Pointer
Student *ptr = &studentObj;
ptr->marks = 98;
cout << "Updated Marks: " << studentObj.marks << endl;
// Output Stream Operator
cout << "Hello, World!" << endl;
// Input Stream Operator
int inputNum = 0; // Provide a default value
cout << "Enter a number (or press Enter to use the default): ";
cin >> inputNum;
cout << "You entered: " << inputNum << endl;
return 0;
}
```

The output of the above code is as follows:

Size of int: 4 bytes Address of num: 0x61ff00 Marks: 97 Updated Marks: 98 Hello, World! Enter a number (or press Enter to use the default): 5 You entered: 5