An operator is a symbol that tells the compiler to perform a specific mathematical or logical operation. C + + has a rich operator built into it and provides the following types of operators:

- Arithmetic operators
- Relational operators
- logical operators
- Bitwise operators
- Assignment operator
- Miscellaneous operators

This article introduces the arithmetic, relational, logical, bitwise, assignment, and other operators one by one.

**Arithmetic operators**

The following table shows all the arithmetic operators supported by C + +.

Assuming the value of variable A is 10, and the value of variable B is 20, then:

Operator |
Describe |
Instance |

+ |
Adds two operands |
A + B will get 30 |

- |
Subtract the second operand from the first operand |
A-b will get-10 |

* |
Multiply two operands |
A * B will get 200 |

/ |
Numerator divided by the denominator |
B/A will get 2 |

% |
Modulo operator, the remainder of the divide |
B% A will get 0 |

++ |
Self-increasing operator with integer value increased by 1 |
a++ will get 11 |

-- |
Self-subtraction operator, integer value reduced by 1 |
a--will get 9 |

Instance

Take a look at the example below to find out all the arithmetic operators available in C + +.

Copy and paste the following C + + program into the Test.cpp file and compile and run the program.

#include <iostream>
using namespace std;
Main ()
{
int a =;
int B = Ten;
int C;
c = a + B;
cout << "line 1-c value is" << c << Endl;
c = a-b;
cout << "line 2-c value is" << c << Endl;
c = A * b;
cout << "line 3-c value is" << c << Endl;
c = A/b;
cout << "line 4-c value is" << c << Endl;
c = a% B;
cout << "line 5-c value is" << c << Endl;
c = a++;
cout << "line 6-c value is" << c << Endl;
c = a--;
cout << "line 7-c value is" << c << Endl;
return 0;
}

When the above code is compiled and executed, it produces the following results:

Line 1-c is the value of line 2-c is line 3-c value is 210 line 4-c value is 2 line 5-c
The value is 1 line
6- The value of C is the value of line
7-c is 22

**Relational operators**

The following table shows all the relational operators supported by C + +.

Assuming the value of variable A is 10, and the value of variable B is 20, then:

Operator |
Describe |
Instance |

== |
Checks whether the values of two operands are equal, and if they are equal, the condition is true. |
(A = = B) is not true. |

!= |
Checks whether the values of two operands are equal, and if not, the condition is true. |
(A!= B) is true. |

> |
Check that the value of the left operand is greater than the value of the right operand, and if so, the condition is true. |
(A > B) is not true. |

< |
Check the value of the left operand to be less than the right operand, and if so, the condition is true. |
(A < B) is true. |

>= |
Check that the value of the left operand is greater than or equal to the value of the right operand, and if so, the condition is true. |
(A >= B) is not true. |

<= |
Check that the value of the left operand is less than or equal to the value of the right operand, and if so, the condition is true. |
(A <= B) is true. |

Instance

Take a look at the example below to see all the relational operators available in C + +.

Copy and paste the following C + + program into the Test.cpp file and compile and run the program.

#include <iostream>
using namespace std;
Main ()
{
int a =;
int B = Ten;
int C;
if (a = = b)
{
cout << "line 1-a equals B" << Endl;
}
else
{
cout << "line 1-a not equal to B" << Endl;
}
if (a < b)
{
cout << "line 2-a less than B" << Endl;
}
else
{
cout << "line 2-a not less than B" << Endl;
}
if (a > B)
{
cout << "line 3-a greater than B" << Endl;
}
else
{
cout << "line 3-a not more than B" << Endl;
}
/* Change the value of a and B */
a = 5;
b =;
if (a <= b)
{
cout << "line 4-a less than or equal to B" << Endl;
}
if (b >= a)
{
cout << "line 5-b greater than or equal to B" << Endl;
}
return 0;
}

When the above code is compiled and executed, it produces the following results:

Line 1-a Not equal to B line
2-a not less than B line
3-a greater than B line
4-a less than or equal to B line
5-b greater than or equal to B

**logical operators**

The following table shows all the relational logical operators supported by C + +.

Assuming the value of variable A is 1, and the value of variable B is 0, then:

Operator |
Describe |
Instance |

&& |
Called Logic and operators. If all two operands are non-zero, the condition is true. |
(A && B) is false. |

|| |
Called the logic or operator. If there are any nonzero zeros in the two operands, the condition is true. |
(A | | B) is true. |

! |
is called a logical non operator. Used to reverse the logical state of the operand. If the condition is true, the logical non-operator makes it false. |
! (A && B) is true. |

Instance

Take a look at the example below to find out all the logical operators available in C + +.

Copy and paste the following C + + program into the Test.cpp file and compile and run the program.

#include <iostream>
using namespace std;
Main ()
{
int a = 5;
int b =;
int C;
if (a && b)
{
cout << "Line 1-condition is true" << Endl;
}
if (A | | b)
{
cout << "Line 2-condition is true" << Endl;
}
/* Change the value of a and B */
a = 0;
b = Ten;
if (a && b)
{
cout << "Line 3-condition is true" << Endl;
}
else
{
cout << "line 4-condition not true" << Endl;
}
if (!) ( A && b)
{
cout << "line 5-condition is true" << Endl;
}
return 0;
}

When the above code is compiled and executed, it produces the following results:

Line 1-The condition is true line
2-The condition is true line
3-The condition is not true line
4-The condition is true

**Bitwise operators**

The bitwise operator acts on a bit and performs the operation bit-by-byte. &, | and ^ 's truth table looks like this:

P |
Q |
P & Q |
p | q |
p ^ Q |

0 |
0 |
0 |
0 |
0 |

0 |
1 |
0 |
1 |
1 |

1 |
1 |
1 |
1 |
0 |

1 |
0 |
0 |
1 |
1 |

Suppose that if A = 60 and B = 13 are now represented in binary format, they are as follows:

A = 0011 1100
B = 0000 1101
-----------------
a&b = 0000
1100 a| B = 0011 1101
a^b = 0011 0001
~a = 1100 0011

The following table shows the bitwise operators supported by C + +. Assuming the value of variable A is 60, and the value of variable B is 13, then:

Operator |
Describe |
Instance |

& |
If the same exists in two operands, the binary and operator replicates one to the result. |
(A & B) will receive 12, that is 0000 1100 |

| |
If present in any operand, the binary OR operator replicates one to the result. |
(A | B) will receive 61, that is 0011 1101 |

^ |
If present in one of the operands but not in the same two operands, the binary XOR or operator replicates one to the result. |
(A ^ B) will be 49, that is 0011 0001 |

~ |
The binary complement operator is a unary operator with a "flip" bit effect. |
(~a) will get 61, that is, 1100 0011,2 complement form, signed binary number. |

<< |
Binary left-shift operator. The value of the left operand shifts the number of digits specified by the right-hand operand. |
A << 2 will get 240, that is 1111 0000 |

>> |
Binary right shift operator. The value of the left operand shifts the number of digits specified by the right-hand operand to the right. |
A >> 2 will get 15, that is 0000 1111 |

Instance

Take a look at the example below to find out all the bitwise operators available in C + +.

Copy and paste the following C + + program into the Test.cpp file and compile and run the program.

#include <iostream>
using namespace std;
Main ()
{
unsigned int a = 0011 1100
unsigned int b = n; = 0000 1101
int c = 0;
c = A & B; The
value of 0000 1100 cout << "line 1-c is" << c << Endl;
c = A | b; 1101 = 0011
cout << "line 2-c value is" << c << Endl;
c = a ^ B; 0011 = 0001
cout << "line 3-c value is" << c << Endl;
c = ~a; -61 = 1100 0011
cout << "line 4-c value is" << c << Endl;
c = a << 2; The value of the 1111 0000
cout << "line 5-c is" << c << Endl;
c = a >> 2; The
value of 0000 1111 cout << "line 6-c is" << c << Endl;
return 0;
}

When the above code is compiled and executed, it produces the following results:

The value of line 1-c is the value of line 2-c is the value of line 3-c is the value of line
4-c is -61 line 5-c is
the value of
the ' line ' line 6-c The value is 15

**Assignment operator**

The following table lists the assignment operators supported by C + +:

Operator |
Describe |
Instance |

= |
A simple assignment operator that assigns the value of the right-hand operand to the left-hand operand |
c = A + B assigns the value of A + B to c |

+= |
Plus and assignment operators, assigning the right-hand operand to the left-hand operand with the result of the left-hand operand |
C + + a equals c = C + A |

-= |
Minus and assignment operators, assigning the left-hand operand minus the right-hand operand to the left-hand operand |
c-= A equals c = c-a |

*= |
Multiply and assign operators, multiply the right-hand operand by the result of the left-hand operand to the left operand |
c *= a equals c = C *A |

/= |
In addition to the assignment operator, assigns the left-hand operand to the left operand by dividing the result of the right-hand operand |
C/= A equals C = c/a |

%= |
Modulo and assignment operators, asking for modulo assignment of two operands to left operand |
C%= a equals c = c% A |

<<= |
Move left and assignment operator |
C <<= 2 equals c = C << 2 |

>>= |
Move right and assignment operator |
C >>= 2 equals c = C >> 2 |

&= |
Bitwise AND and assignment operators |
C &= 2 equals c = C & 2 |

^= |
Bitwise XOR and Assignment operators |
C ^= 2 equals c = c ^ 2 |

|= |
bitwise OR and assignment operators |
C |= 2 equals c = C | 2 |

Instance

Take a look at the example below to learn all the assignment operators available in C + +.

Copy and paste the following C + + program into the Test.cpp file and compile and run the program.

#include <iostream> using namespace std;
Main () {int a = 21;
int C;
c = A;
cout << "Line 1-= operator instance, value of c =:" <<c<< Endl;
C + A;
cout << "Line 2-+ = operator instance, value of c =:" <<c<< Endl;
c-= A;
cout << "Line 3-= operator instance, value of c =:" <<c<< Endl;
C *= A;
cout << "Line 4-*= operator instance, value of c =:" <<c<< Endl;
C/= A;
cout << "Line 5-/= operator instance, value of c =:" <<c<< Endl;
c = 200;
C%= A;
cout << "line 6-%= operator instance, value of c =:" <<c<< Endl;
C <<= 2;
cout << "Line 7-<<= operator instance, value of c =:" <<c<< Endl;
C >>= 2;
cout << "Line 8->>= operator instance, value of c =:" <<c<< Endl;
C &= 2;
cout << "Line 9-&= operator instance, value of c =:" <<c<< Endl;
C ^= 2;
cout << "Line 10-^= operator instance, value of c =:" <<c<< Endl;
C |= 2; cout << "line 11-|= operator instance, value of c =:" <<c<< ENDL;
return 0;
}

When the above code is compiled and executed, it produces the following results:

Line 1-= operator instance, the value of C = Line
2-+ = operator instance, the value of C = Line
3-= operator instance, C's value = Line
4-*= operator instance, C's value = 44 1 line
5-/= operator instance, C's value = line
6-%= operator instance, C's value = line
7-<<= operator instance, C's value = line
8-> >= operator instance, the value of C = one line
9-&= operator instance, the value of C = 2 line
10-^= operator instance, the value of c = 0 Line
11-|= operator instance, the value of C = 2

**Miscellaneous operators**

The following table lists some of the other important operators supported by C + +.

operator |
Description |

sizeof |
The sizeof operator returns the size of the variable. For example, sizeof (a) returns 4, where A is an integer. |

Condition? X:y |
The conditional operator. What if Condition is true? The value is X: Otherwise the value is Y. |

, |
The comma operator performs a series of operations sequentially. The value of the entire comma expression is the value of the last expression in a comma-delimited list. |

. (points) and-> (arrows) |
A member operator is used to refer to a member of a class, struct, and shared body. |

Cast |
The cast operator converts a data type to another data type. For example, int (2.2000) will return 2. |

& |
Pointer operator & return the address of a variable. For example &a; The actual address of the variable is given. |

* |
The pointer operator * points to a variable. For example, *var; will point to variable var. |

**operator Precedence in C + +**
The precedence of an operator determines the combination of items in an expression. This affects how an expression is evaluated. Some operators have higher precedence than other operators, for example, the multiplication and division operators have higher precedence than the addition and subtraction operators.

For example x = 7 + 3 2, where x is assigned 13 instead of 20 because the operator has a higher precedence than +, so first compute the multiplication 3*2 and then add 7.

The following table lists the operators by operator precedence from highest to lowest, with higher precedence operators appearing above the table, with lower precedence operators appearing below the table. In an expression, higher-priority operators are evaluated preferentially.

Category |
Operator |
Combination of |

Suffix |
() []->. ++ - - |
From left to right |

One dollar |
+ - ! ~ + +--(type) * & sizeof |
From right to left |

Multiplication |
* / % |
From left to right |

Add and Subtract |
+ - |
From left to right |

Shift |
<< >> |
From left to right |

Relationship |
< <= > >= |
From left to right |

Equal |
== != |
From left to right |

Bit and |
& |
From left to right |

Bitwise exclusive OR XOR |
^ |
From left to right |

Bit OR OR |
| |
From left to right |

Logic and |
&& |
From left to right |

Logical OR OR |
|| |
From left to right |

Conditions |
?: |
From right to left |

assigning values |
= + = = *=/=%=>>= <<= &= ^= |= |
From right to left |

Comma |
, |
From left to right |

Instance

Consider the following example to learn about the precedence of operators in C + +.

Copy and paste the following C + + program into the Test.cpp file and compile and run the program.

Compare the differences between parentheses and no parentheses, which will produce different results. Because (),/, *, and + have different priorities, high priority operators will be evaluated first.

#include <iostream>
using namespace std;
Main ()
{
int a =;
int B = Ten;
int c =;
int d = 5;
int e;
E = (A + b) * C/D; (*)/5
cout << "(A + B) * C/D value is" << e << Endl;
E = ((A + b) * c)/D; (*)/5
cout << "((A + b) * C)/d is" << e << Endl;
E = (A + b) * (C/D); (d) * (15/5)
cout << "(A + B) * (C/D) The value is" << e << Endl;
E = a + (b * c)/D; The value of + (150/5)
cout << "A + (b * c)/d is" << e << Endl;
return 0;
}

When the above code is compiled and executed, it produces the following results:

(A + B) * The value of C/D (
(A + b) * C)/d is the value of (
A + b) * (C/D) is the value of
A + (b * c)/d is 50