C++ Operators

• Operator in C++ is a symbol or keyword used to perform operations on operands.
• Operands can be variables, constants, or expressions, and operators dictate how these operands are combined.

Operators in C++

• Arithmetic Operators
• Relational Operators
• Logical Operators
• Bitwise Operators
• Assignment Operators
• Unary Operators
• Ternary or Conditional Operators
• Miscellaneous Operators

Arithmetic Operators

• Addition (+): Adds two values together.
• Subtraction (-): Subtracts one value from another.
• Multiplication (*): Multiplies two values.
• Division (/): Divides one value by another.
• Modulus (%): Returns the remainder of a division operation.

1#include <iostream>
2using namespace std;
3
4int main() {
5    int num1 = 10, num2 = 5;
6
7    // Addition
8    int sum = num1 + num2;
9    cout << "Sum: " << sum << endl;
10
11    // Subtraction
12    int difference = num1 - num2;
13    cout << "Difference: " << difference << endl;
14
15    // Multiplication
16    int product = num1 * num2;
17    cout << "Product: " << product << endl;
18
19    // Division
20    int quotient = num1 / num2;
21    cout << "Quotient: " << quotient << endl;
22
23    // Modulus (remainder)
24    int remainder = num1 % num2;
25    cout << "Remainder: " << remainder << endl;
26
27    return 0;
28}
29

1Sum: 15
2Difference: 5
3Product: 50
4Quotient: 2
5Remainder: 0

Relational Operators

• Relational operators are used to comparing values and determine the relationship between them.
• These operators return either true or false. Common relational operators include:
• Equal to (==): Checks if two values are equal.
• Not equal to (!=): Checks if two values are not equal.
• Greater than (>): Checks if one value is greater than another.
• Less than (<): Check if one value is less than another.
• Greater than or equal to (>=): Checks if one value is greater than or equal to another.
• Less than or equal to (<=): Checks if one value is less than or equal to another.

1#include <iostream>
2using namespace std;
3
4int main() {
5    int num1 = 10, num2 = 5;
6
7    // Equality
8    bool isEqual = (num1 == num2);
9    cout << "Equal: " << isEqual << endl;
10
11    // Inequality
12    bool isNotEqual = (num1 != num2);
13    cout << "Not Equal: " << isNotEqual << endl;
14
15    // Greater than
16    bool isGreaterThan = (num1 > num2);
17    cout << "Greater Than: " << isGreaterThan << endl;
18
19    // Less than
20    bool isLessThan = (num1 < num2);
21    cout << "Less Than: " << isLessThan << endl;
22
23    // Greater than or equal to
24    bool isGreaterOrEqual = (num1 >= num2);
25    cout << "Greater or Equal: " << isGreaterOrEqual << endl;
26
27    // Less than or equal to
28    bool isLessOrEqual = (num1 <= num2);
29    cout << "Less or Equal: " << isLessOrEqual << endl;
30
31    return 0;
32}

1Equal: 0
2Not Equal: 1
3Greater Than: 1
4Less Than: 0
5Greater or Equal: 1
6Less or Equal: 0

Logical Operators

• Logical operators are used to perform logical operations on Boolean values.
• They are often used in conditional statements and loops. The common logical operators are:
• Logical AND (&&): Returns true if both operands are true.
• Logical OR (||): Returns true if at least one operand is true.
• Logical NOT (!): Returns the opposite of the operand's value.

1#include <iostream>
2using namespace std;
3
4int main() {
5    int a = 10, b = 0;
6
7    // Logical AND (&&)
8    int andResult = (a && b); // 0 (false)
9    cout << "AND Result: " << andResult << endl;
10
11    // Logical OR (||)
12    int orResult = (a || b); // 1 (true)
13    cout << "OR Result: " << orResult << endl;
14
15    // Logical NOT (!)
16    int notResultA = !a; // 0 (false)
17    cout << "NOT Result (a): " << notResultA << endl;
18
19    int notResultB = !b; // 1 (true)
20    cout << "NOT Result (b): " << notResultB << endl;
21
22    return 0;
23}

• Operand 1: a (with a value of 10)
• Operand 2: b (with a value of 0)
• Result: The logical AND operator (&&) evaluates to true (1) if both operands are true (non-zero). In this case, a && b evaluates to 0 (false) because b is 0, which is considered false.

• Operand 1: a (with a value of 10)
• Operand 2: b (with a value of 0)
• Result: The logical OR operator (||) evaluates to true (1) if at least one operand is true (non-zero). In this case, a || b evaluates to 1 (true) because a is 10, which is considered true.

• Operand A: a (with a value of 10)
• Operand B: b (with a value of 0)
• Result (a): The logical NOT operator (!) negates the value of the operand. In this case, !a evaluates to 0 (false) because a is initially true (non-zero), and the NOT operator flips it to false (0).
• Result (b): Similarly, !b evaluates to 1 (true) because b is initially false (0), and the NOT operator flips it to true (1).

• a && b evaluates to 0 (false) because both operands are not true.
• a || b evaluates to 1 (true) because at least one operand is true.
• !a flips the value of a from true to false.
• !b flips the value of b from false to true.

1AND Result: 0
2OR Result: 1
3NOT Result (a): 0
4NOT Result (b): 1

Bitwise Operators

• Bitwise operators work at the bit level and are used to manipulate individual bits within data.
• They are especially useful when dealing with hardware or low-level operations. Common bitwise operators include:
• Bitwise AND (&): Performs a bitwise AND operation.
• Bitwise OR (|): Performs a bitwise OR operation.
• Bitwise XOR (^): Performs a bitwise XOR (exclusive OR) operation.

1#include <iostream>
2using namespace std;
3
4int main() {
5    int num1 = 5, num2 = 3;
6
7    // Bitwise AND
8    int andResult = num1 & num2;
9    cout << "Bitwise AND Result: " << andResult << endl;
10
11    // Bitwise OR
12    int orResult = num1 | num2;
13    cout << "Bitwise OR Result: " << orResult << endl;
14
15    // Bitwise XOR
16    int xorResult = num1 ^ num2;
17    cout << "Bitwise XOR Result: " << xorResult << endl;
18
19    return 0;
20}

1Bitwise AND Result: 1
2Bitwise OR Result: 7
3Bitwise XOR Result: 6

Assignment Operators

1// Example of the assignment operator
2int variable = 42;
3

Unary Operators

• Unary operators operate on a single operand.
• An example is the unary minus (-) operator, which negates a value.

1// Example of unary operator
2int number = 10;
3int negatedNumber = -number; // -10
4

Ternary or Conditional Operators

• The ternary operator (? :) is a concise way to write conditional statements.
• It evaluates a condition and returns one of two values based on whether the condition is true or false.

1#include <iostream>
2using namespace std;
3
4int main() {
5    int num = 10;
6    string result = (num > 5) ? "Greater" : "Smaller";
7    cout << "Result: " << result << endl;
8
9    return 0;
10}

1Result: Greater

Miscellaneous Operators

• There are several other operators in C++, such as the address-of operator (&) and the pointer dereference operator (*), which are often used in more advanced programming scenarios.
• However, for beginners, understanding the operators mentioned above is a great starting point.