OPERATORS
Assignment operators
Arithmetic operators
Compound statements
Relational operators
Equality operators
Increase and decrease operators
Increment and decrement operators
Logical operators
Conditional operators
Comma operators
Bitwise operators
Other operators
All these operators are explained in this stage
Once we know of the existence of variables and constants, we can begin to operate with them. For that purpose, C++ integrates operators. Unlike other languages whose operators are mainly keywords, operators in C++ are mostly made of signs that are not part of the alphabet but are available in all keyboards. This makes C++ code shorter and more international, since it relies less on English words, but requires a little of learning effort in the beginning.
Assignment (=)
The assignment operator assigns a value to a variable.
a = 4;
This statement assigns the integer value 4 to the variable a. The part at the left of the assignment operator (=) is known as thelvalue (left value) and the right one as the rvalue (right value). The value has to be a variable whereas the rvalue can be either a constant, a variable, the result of an operation or any combination of these.
The most important rule when assigning is the right-to-left rule: The assignment operation always takes place from right to left, and never the other way.
a = b;
This statement assigns to variable a (the value) the value contained in variable b (the rvalue). The value that was stored until this moment in a is not considered at all in this operation, and in fact that value is lost.
Consider also that we are only assigning the value of b to a at the moment of the assignment operation. Therefore a later change of b will not affect the new value of a.
Here is an example of assignment operator
// assignment operator
#include<iostream>
using namespace std;
int main ()
{
int a, b; // a:?, b:? a = 10; // a:10, b:? b = 4; // a:10, b:4 a = b; // a:4, b:4 b = 7; // a:4, b:7 cout << "a:"; cout << a; cout << " b:";
cout << b;
return 0;
}
a:4
b:7
This code will give us as result that the value contained in a is 4 and the one contained in b is 7. Notice how a was not affected by the final modification of b, even though we declared a = b earlier (that is because of the right-to-left rule).
A property that C++ has over other programming languages is that the assignment operation can be used as the rvalue (or part of an rvalue) for another assignment operation. For example:
a = 3 + (b = 6);
is equivalent to.
1. b = 6;
2. a = 3 + b;
that means: first assign 6 to variable b and then assign to a the value 3 plus the result of the previous assignment of b (i.e. 6), leaving a with a final value of 9.
The following expression is also valid in C++:
a = b = c = 7;
It assigns 7 to the all three variables: a, b and c.
Arithmetic operators ( +, -, *, /, % )
The five arithmetical operations supported by the C++ language are:
Arithmatic operators which are
Addition +
Subraction -
Multiplication *
Division /
Modulus operator or remainder %
NOTE: You can use the operators + , - , *,and / use both floating point and integral data types.But the modulus operator % is only use with integral data types.
Unary operators : An operator that has only one operand.
Binary operator : An operator that has two operands.
Order of precedence in arithmatic operators
According to order of precedence rule * , / , % are at a higher level of precedence than :
+ , - .
for example in the expression
4 + 5 * 2 = 14.
* is evaluated before +
Here is an example for arithmatic operations
#include <iostream>
using namespace std;
int main ( )
{
cout<<" 3 + 3"<< 3+3<<endl;
cout<<" 3 -3"<<3+3<<endl;
cout<<" 3 *3"<< 3+3<<endl;
cout<<" 3 %3"<< 3+3<<endl;
cout<<" 3 /3"<< 3+3<<endl;
return 0;
}
After execution in machine the results can be shown
Operations of addition, subtraction, multiplication and division literally correspond with their respective mathematical operators. The only one that you might not be so used to see is modulo; whose operator is the percentage sign (%). Modulo is the operation that gives the remainder of a division of two values. For example, if we write:
a = 13 % 3;
the variable a will contain the value 1, since 1 is the remainder from dividing 13 between 3.
Compound assignments:
Compound assignments are given below
(+=, -=, *=, /=, %=, >>=, <<=, &=, ^=, |=)
When we want to modify the value of a variable by performing an operation on the value currently stored in that variable we can use compound assignment operators:
Expression is equivalent to
value += increase;
value = value + increase;
a -= 5;
a = a - 5;
a /= b;
a = a / b;
price *= units + 1;
price = price * (units + 1);
and the same for all other operators.
For example:
// compound assignment operators
#include <iostream>
using namespace std;
int main ()
{
int a, b=5;
a = b;
a+=4; // equivalent to a=a+4
cout << a;
return 0;
}
The result of this example is 9
Increase and decrease (++, --)
Shortening even more some expressions, the increase operator (++) and the decrease operator (--) increase or reduce by one the value stored in a variable. They are equivalent to +=1 and to -=1, respectively. Thus:
1. c++;
2. c+=1;
3. c=c+1;
are all equivalent in its functionality: the three of them increase by one the value of c.
A characteristic of this operator is that it can be used both as a prefix and as a suffix. That means that it can be written either before the variable identifier (++b) or after it (b++). Although in simple expressions like b++ or ++b both have exactly the same meaning, in other expressions in which the result of the increase or decrease operation is evaluated as a value in an outer expression they may have an important difference in their meaning: In the case that the increase operator is used as a prefix (++b) the value is increased before the result of the expression is evaluated and therefore the increased value is considered in the outer expression; in case that it is used as a suffix (b++) the value stored in a is increased after being evaluated and therefore the value stored before the increase operation is evaluated in the outer expression. Notice the difference:
Example 1.
B=3;
A=++B;
// A contains 4, B contains 4
Example 2.
B=3;
A=B++;
// A contains 3, B contains 4
In Example 1, B is increased before its value is copied to A. While in Example 2, the value of B is copied to A and then B is increased.
Relational and equality operator :
Relational and equality operator ( ==, !=, >, <, >=, <= )
In order to evaluate a comparison between two expressions we can use the relational and equality operators. The result of a relational operation is a Boolean value that can only be true or false, according to its Boolean result.
= = means Equal to
!= means Not equal to
> means Greater than
< means Less than
>= Greater than or equal to
<= Less than or equal to
Here there are some examples:
(6 = = 5) // evaluates to false.
(6 > 4) // evaluates to true.
(8 != 2) // evaluates to true.
(6 >= 6) // evaluates to true.
(5 < 5) // evaluates to false.
Of course, instead of using only numeric constants, we can use any valid expression, including variables. Suppose that a=2, b=3 andc=6,
(a = = 4) // evaluates to false since a is not equal to 4.
(a*b >= c) // evaluates to true since (2*3 >= 6) is true.
(b+4 > a*c) // evaluates to false since (3+4 > 2*6) is false.
((b=2) == a) // evaluates to true.
Difference between assignment operator(=) and equality operator (= =) :
Assignment operator is different from equality operator and it can be seen clearly.
Be careful! The operator = (one equal sign) is not the same as the operator = = (two equal signs), the first one is an assignment operator (assigns the value at its right to the variable at its left) and the other one (= =) is the equality operator that compares whether both expressions in the two sides of it are equal to each other. Thus, in the last expression ((b=4) = = a), we first assigned the value 4 to b and then we compared it to a, that also stores the value 4, so the result of the operation is true.
Logical operators ( !, &&, || ):OR Boolean operations
The Operator ! is the C++ operator to perform the Boolean operation NOT, it has only one operand, located at its right, and the only thing that it does is to inverse the value of it, producing false if its operand is true and true if its operand is false. Basically, it returns the opposite Boolean value of evaluating its operand. For example:
!(7 = = 7) // evaluates to false because the expression at its right (7 = = 7) is true.
!(8 <= 7) // evaluates to true because (8 <= 7) would be false.
!true // evaluates to false
!false // evaluates to true.
Logical operator take only logical values as operands and yield only logical values as results.The operator ! is unary so it has only one operand .so the ! NOT operator is binary and && AND operator and || OR operator are binary operators.
The logical operators && and || are used when evaluating two expressions to obtain a single relational result. The operator &&corresponds with Boolean logical operation AND. This operation results true if both its two operands are true, and false otherwise.When you use the ! operator !true means false and !false means true .
The operator || corresponds with Boolean logical operation OR. This operation results true if either one of its two operands is true, thus being false only when both operands are false themselves. Here are the possible results of a || b:
For example:
( (7 = = 7) && (2 > 5) ) // evaluates to false ( true && false ).
( (7 = = 7) || (2 > 5) ) // evaluates to true ( true || false ).
When using the logical operators, C++ only evaluates what is necessary from left to right to come up with the combined relational result. Therefore, in this last example (( 7= =7 ) || (2>5)), C++ would evaluate first whether 7= =7 is true, and if so, it would never check whether 2 > 5 is true or not. This is known as short-circuit evaluation, and works like this for these operators:
operator
short-circuit
&&
if the left-hand side expression is false, the combined result is false (right-hand side expression not evaluated).
||
if the left-hand side expression is true, the combined result is true (right-hand side expression not evaluated).
This is mostly important when the right-hand expression has side effects, such as altering values:
if ((i<8)&&(++i<n)) { /*...*/ }
This combined conditional expression increases i by one, but only if the condition on the left of && is true, since otherwise right-hand expression (++i<n) never evaluated.
Conditional operator ( ? )
The conditional operator evaluates an expression returning a value if that expression is true and a different one if the expression is evaluated as false. Its format is:
condition ? result1 : result2
If condition is true the expression will return result1, if it is not it will return result2.
7= =6 ? 4 : 3 // returns 3, since 7 is not equal to 5. 7= =5+2 ? 4 : 3 // returns 4, since 7 is equal to 5+2. 5>3 ? a : b // returns the value of a, since 5 is greater than 3. a>b ? a : b // returns whichever is greater, a or b.
// conditional operator
#include <iostream>
using namespace std;
int main ()
{
int a,b,c;
a=2;
b=7;
c = (a>b) ? a : b;
cout << c;
return 0;
}
sample result is 7
In this example a is 2 and b is 7, so the expression being evaluated (a>b) was not true, thus the first value specified after the question mark is discarded in favor of the second value (the one after the colon) which is b, with a value of 7.
Comma operator ( , )
Comma operator is used to evaluate or separate two or more than two expressions
The comma operator (,) is used to separate two or more expressions that are included where only one expression is expected. When the set of expressions has to be evaluated for a value, only the rightmost expression is considered.
Here is an example:
a = (b=4, b+3);
Would first assign the value 4 to b, and then assign b+3 to variable a. So, at the end, variable a would contain the value 7 while variable b would contain value 4.
Bitwise Operators ( &, |, ^, ~, <<, >> )
Bitwise operators modify variables considering the bit patterns that represent the values they store.
operator
asm equivalent
description
&
AND
Bitwise AND
|
OR
Bitwise Inclusive OR
^
XOR
Bitwise Exclusive OR
~
NOT
Unary complement (bit inversion)
<<
SHL
Shift Left
>>
SHR
Shift Right
Explicit type casting operator
Type casting operators allow you to convert a datum of a given type to another. There are several ways to do this in C++. The simplest one, which has been inherited from the C language, is to precede the expression to be converted by the new type enclosed between parentheses (()):
Here is an example of & operator. BY this way you can find any bitwise operator question answers.
#include <iostream>
using namespace std;
int main ( )
{
int a , b;
a = 23;
b = 13;
int ab=a&b;
cout <<" The result of a&b is << ab <<endl;
return 0;
}
result is 5
Other operators
Later in these tutorials, we will see a few more operators, like the ones referring to pointers or the specifics for object-oriented programming. Each one is treated in its respective section.
Precedence of operators
When writing complex expressions with several operands, we may have some doubts about which operand is evaluated first and which later. For example, in this expression:
a = 5 + 7 % 2
we may doubt if it really means:
1
2 a = 5 + (7 % 2) // with a result of 6, or a = (5 + 7) % 2 // with a result of 0
The correct answer is the first of the two expressions, with a result of 6. There is an established order with the priority of each operator, and not only the arithmetic ones (those whose preference come from mathematics) but for all the operators which can appear in C++. From greatest to lowest priority, the priority order is as follows:
Level
Operator
Description
Grouping
1
::
scope
Left-to-right
2
() [] . -> ++ -- dynamic_cast static_cast reinterpret_cast const_cast typeid
postfix
Left-to-right
3
++ -- ~ ! sizeof new delete
unary (prefix)
Right-to-left
* &
indirection and reference (pointers)
+ -
unary sign operator
4
(type)
type casting
Right-to-left
5
.* ->*
pointer-to-member
Left-to-right
6
* / %
multiplicative
Left-to-right
7
+ -
additive
Left-to-right
8
<< >>
shift
Left-to-right
9
< > <= >=
relational
Left-to-right
10
== !=
equality
Left-to-right
11
&
bitwise AND
Left-to-right
12
^
bitwise XOR
Left-to-right
13
|
bitwise OR
Left-to-right
14
&&
logical AND
Left-to-right
15
||
logical OR
Left-to-right
16
?:
conditional
Right-to-left
17
= *= /= %= += -= >>= <<= &= ^= |=
assignment
Right-to-left
18
,
comma
Left-to-right
Grouping defines the precedence order in which operators are evaluated in the case that there are several operators of the same level in an expression.
All these precedence levels for operators can be manipulated or become more legible by removing possible ambiguities using parentheses signs ( and ), as in this example:
a = 5 + 7 % 2;
might be written either as:
a = 5 + (7 % 2);
or
a = (5 + 7) % 2;
depending on the operation that we want to perform.
So if you want to write complicated expressions and you are not completely sure of the precedence levels, always include parentheses. It will also make your code easier to read.
