C++ is very rich in operators. When a value is generated from an expression,operators are used to get appropriate value.Most languages use the special characters ‘+’ (plus) and ‘‘ (minus) to represent the two basic arithmetic operations, but there is no uniformity in others. In general, there are four types of operators.
Types of C++ Operators
 Arithmetic Operators
 Relational Operators
 Logical Operators
 Assignment Operators
Arithmetic Operators
The Arithmetic operators in C++ deal with Addition (+), Subtraction (), Multiplication (*), Division (/) and Modulus (%). All these operators are binary arithmetic operators, because they accept two operands (the things being operated). There is unary minus () and unary plus (+). They are applied to only one operand.
Usage of Arithmetic operators
a+b, ab, a/b, a%b, a, a
The division of integer by integer terminates fractional part. The expression such as a%b produces the remainder zero during exact division; otherwise the order of evaluation is performed as per precedence rule.
Arithmetic Operators
Operator 
Description

+ 
Addition OR Unary Plus 
– 
Subtraction OR Unary Minus 
* 
Multiplication OR Indirection 
/ 
Division 
% 
Modulus (Remainder of a division

Relational Operators
They are used to compare two values, which may be variables, constants or expressions. All the Relational operators have lower precedence then the Arithmetic operators.
Usage of Relational Operators
The expressions such as I > m, I >= m, I < m, I <= m, I !=m are all examples of Relational operators.
Relational Operators
Operator 
Description 
Example 
Purpose 
Result 
> 
Greater Than 
4 > 1 
Test if 3 > 1 
Yes 
>= 
Greater Than or Equal 
4 >= 4 
Test if 4 >=4 
Yes 
< 
Less Than 
4 < 6 
Test if 4 < 6 
Yes 
<= 
Less Than or Equal 
4 <= 4 
Test if 4 <=4 
Yes 
== 
Equal 
4 == 4 
Test if 4 == 4 
Yes 
!= 
Not Equal 
4 != 5 
Test if 4 != 5 
Yes 
The above expressions can be any C++ expression, which can include a variable, litereal or a combination of these. It should also to be noted that the result of applying a comparison operator to two operands is a bool value that is either true or false (T/F).
Logical Operators
The logical connectives ‘&&’ (and) and ‘’ (or) are very useful operators. They are used with relational operators.
For Example
(i>5) && (i<10)
Means the expression is true if i>5 and i<10, otherwise false.
Logical Operators
Operator 
Description 
Example 
&& 
Perform Boolean (Logical) AND 
(x > 5) && (x < 10) 
 
Perform Boolean (Logical) OR 
(x > 5)  (x < 10) 
! 
Perform Boolean (Logical) NOT 
x != 10 
Assignment Operators
An expression such as x = x + 10, means add the contents of ‘x’ with ‘10’ and assign the result into ‘I’ where ‘=’ is the assignment operator. In layman words, first add whatever is stored in x with 10 and then the ‘=’ signs means to assign the new number to x. C++ offers a compressed for, which is a very convenient way by placing the operator immediately (no space between the two operators) before the assignment operator. These two operators are known as the compound assignment operator.
I+=5
The general form of a compound assignment operator is;
Expression 1 operator = expression 2
Where operator is one of the following.
+ – * / % << >> & ^ 
If E1 is expression 1 and E2 is expression 2 then
E1 op=E2
e1 = (e1)op(e2)
a *= b + 1
is actually
a = a * (b+1)
rather than a = a * b + 1
Additional Operators in C++
Conditional Operators
The conditional operator is also known as ternary operator, because it makes three expressions such as
Expression1 ? expression2 : expression3
Actually the ternary operator “?”, provides an alternative way to ifelse contructions. The expression1 is evaluated first. If it is true, then execute expression2, otherwise expression3.
Increment and Decrement Operators
As mentioned earlier that C++ language is very rich in operators. Here we discuss the two unusal operators for incrementing and decrementing variable. C++ uses not only the infix operator such as x = x + 1 but also the postfix and prefix operators. The operator ‘++’ adds 1 to its operand, operator ‘ ‘ subtracts 1 from its operand.
For Example
++x, –x,
The use of “++”, and “ “before the variable is called prefix and postfix operators. The inverse of both the operators is also true. The effect is the same but x = i++ and x = ++I are different in result.
If i = 10, then x = i++ menas set x to 10 and increment i by 1. This is called postincrement because the operator is placed after the variable.
If i = 10, then x = ++I, means set x to 11 that is first increment ‘i’ by 1 and then assign the result into ‘x’. this is called preincrement because the operator is placed before the variable. The same is true for –.
In a context where no value is wanted, the effect of prefix, and postfix operators is the same. In many cases, preferable in for loop, we will see the extensive use of these two notations.
Bitwise Logical Operators
There are lot of operators for bit manipulations, such as
Bitwise Logical Operators
Operators 
Description 
& 
Bitwise AND 
 
Bitwise OR 
^ 
Bitwise Exclusive OR 
<< 
Left Shift 
>> 
Right Shift 
~ 
One’s complement (unary) 
Sizeof Operator
It is a unary operator that gives the size of a variable or a data type. In either case, it must be within the parentheses.
Sizeof(int)
This return the value 2, since type int occupies 2 bytes in memory.
Char ch
Sizeof(ch)
This will return the value ‘1’ because type of ‘ch’ is char.
C++ Operators Precedence and Associativity
When priority of two operators is the same, the evaluation starts from left to right. For example, when addition and subtraction appears together in one expression, the expression is evaluated from left to right because of the same priority. Another good example is the use of multiplication and division. Operators can be applied to an expression to generate a value on one of these unary operator (one operand), binary (two operands) and ternary operator (three operands).
The precedence of each operator is strictly predefined that how the expression is evaluated containing different operators. The evaluation of expression is performed on two ways, left to right and right to left. This is known as operator Associativity.