Operators in C/C++ languages
Operators are actions that run over operands, giving a particular result. Expressions are arbitrarily complex compositions of operand and operator. Operators can be applied to one operand (unary operator) or to two operands (binary operators).
There is also one operator with three operands, which is ? : (explained later).
-
There is also one operator with three operands, which is ? : (explained later).
-
Aritmetics operators
They are used for expressions with basic computational operations. The table below gives an overview of arithmetic operators
The following table provides an overview of the arithmetic data.
| Operator | Using | Description |
|---|---|---|
| + | op1+op2 | addition of two numbers |
| - | op1-op2 | subtraction two numbers |
| * | op1*op2 | Multiple op1 width op2 |
| / | op1/op2 | Division two numbers |
| % | op1%op2 | Calculates the rest of division of two numbers |
Solution:
double R1, R2, Re;
scanf(" %lf%lf ", &R1, &R2); //The user enters R1 and R2
Re=R1*R2 / (R1+R2); // The solution obtained is given by the equation
printf("%f",Re);
scanf(" %lf%lf ", &R1, &R2); //The user enters R1 and R2
Re=R1*R2 / (R1+R2); // The solution obtained is given by the equation
printf("%f",Re);
If operations of the same priority are executed from left to right. Multiplication and division have the same priority, and greater than the sums and subtractions that are again, among themselves, the same priority. If you want to give priority to a low-priority computational operation, brackets should be used, as is done in the example.
The rest of the division of two numbers. Operator "%"
Suppose we want to divide two cell numbers: 7 & 3
If we write 7/3 we get for result 2. The result is an integer because we have divided two integer constants
If we want to get the rest of the division then we would use the operator %
7 % 3 = 1
Example: Load time in minutes and print as mm: ss
Solution: From the data we need the time in seconds (Vr), and at the output for printing minutes (mm) and seconds (ss)
int Vr, mm, ss;
scanf(" %d ", &Vr); //The user inputs time in seconds
/*Suppose the user entered during the 132s. Since one minute has 60s,
of these 132s we will convert 2 * 60s in two minutes, and what remains to be put as a second, in this
example it's 132- (2 * 60) = 12s. This calculation can be obtained using the division operator and the remainder of the division, "/" and "%". */
mm=Vr / 60; // mm=132/60=2
ss=Vr % 60; // mm=132%60=12
printf("%2d : %2d",mm,ss);
scanf(" %d ", &Vr); //The user inputs time in seconds
/*Suppose the user entered during the 132s. Since one minute has 60s,
of these 132s we will convert 2 * 60s in two minutes, and what remains to be put as a second, in this
example it's 132- (2 * 60) = 12s. This calculation can be obtained using the division operator and the remainder of the division, "/" and "%". */
mm=Vr / 60; // mm=132/60=2
ss=Vr % 60; // mm=132%60=12
printf("%2d : %2d",mm,ss);
When the values in an arithmetic operation use an integer value and a real number, the result is a real number. The integer is implicitly converted to a real number before the calculation itself. The table below shows the types of data that are returned from arithmetic operations, based on the types of values. The necessary conversions are made before the operation is performed.
| The data type for the result | Data type for values |
|---|---|
| long | None of the values is float or double (whole number artifacts), a At least one of the operators is long type |
| int | None of the values is float or double (integer arithmetic). No operand is long. |
| double | At least one value is double type |
| float | At least one value is a float type. None is double type |
Unary operators "++", "-"
There are also two operators that allow for a short calculation. These are the operator ++ (increment) that increases the operand by 1 and the operator (decrement) which operand decreases by 1. Both operators can appear in front of the operand (prefix) and behind the operand (postfix). For version prefix, ++ op / - op, the first operand increases by 1, so this result is used further in the expressions. For the postfix version, the first operand is applied to the expression (old value), and only after that value is changed.
Relational and conditional operators
The relational operator compares two values and determines the value between them. For example,!! = Returns exactly if two operands are not equal. The following table lists the relational operators:
| Operator | Using | Return true if |
|---|---|---|
| > | op1>op2 | op1 greater then op2 |
| >= | op1 >= op2 | op2 greater then or equal to op1 |
| < | op1 < op2 | op1 Less then op2 |
| <= | op1 <= op2 | op1 less then or equal to op2 |
| == | op1 == op2 | op1 equal to op2 |
| != | op1 != op2 | op1 different to op2 |
Relational operators are often used together with logical operators, which are obtained with complex expressions. In Java there are the following logical operators:
| Operator | using | return true if |
|---|---|---|
| && | op1 && op2 | both op1 and op2 are true. op2 is calculated only if necessary |
| || | op1 || op2 | either op1 or op2 are true or both. op2 is calculated only if necessary |
| ! | !op | op is false |
| & | op1 & op2 | both op1 and op2 are true. Always calculate op1 and op2 |
| | | op1 | op2 | either op1 or op2 are true or both. Always calculate op1 and op2. |
| ^ | op1 ^ op2 | if op1 and op2 are different, or if one has the value true, but not both |
What is the difference between the && and &? The difference is in program execution speed. With the operator & the value of the second operator is always calculated, while with the operator && the value of the first operand is calculated, and if it is sufficient to calculate the value of the whole expression, the second operand is not calculated.
Example: For the set values of integer variables a, b, c, determine the values of logical expressions:
a=4,b=7, c=11
- a>b
- ! a > b && !(b<c)
- a !=0 || !(a>(b>c))
The values of the logical expressions in the C language are in fact integers and this expression value has a value of 1 if the logical expression is true, that is, value 0, if the expression logically is false. If 3 integers are defined whose values are in the order of 4,7 and 11, the values of the required logical expressions will be:
Solution of this example:
- a > b, have value 0,
because 4 is no greater than 7 - ! (a > b && !(b<c)), have value 1.
If we replace the expression for a, b and c we get
! ((4 > 7) && !(7<11)) = !((0) && (1)) = !(0)=1The displayed brackets show which operators will be executed in the order. First, those operators with the highest priority (see the last table below) are executed. Therefore, the operators ">" and "<" have a higher priority than the operator "&&", so the phrases 4> 7 whose value is 0 (false) and 7 <11 whose value is 1 (true) are calculated first. Then 0 && 1 is calculated, giving 0 (false). In the end, a negation is performed! which will convert this value to 1 (true). - a !=0 || !(a>(b>c)) have value 1
4 != 0 || (4> (7 > 11)) =
(4 != 0) || (4> (7 > 11)) =
(0) || (4> (0))=
0 || 1=
1
Solution of this example:
using namespace std;
int main()
{
int a,b,c;
bool e,f,g;
a=4;
b=7;
c=11;
//Calculating Logical Expressions
e=a > b;
f = !(a > b && !(b < c));
g = a!=0 || !(a > (b > c));
//Print the expression value
cout << "e=" << e << endl;
cout << "f=" << f << endl;
cout << "g="<< g << endl;
return 0;At the standard output, i.e. Console:
Operators by bit
Bitwise operators allow the execution of bits-level operations within integer data. There are two groups of operators per bits:
- operators to perform logical operations between pairs of bits on the same positions within their operands
- shift operators
- ~ It performs complementing (negating) the value of its operand by bit. Thus, it converts from state 0 to state 1 and vice versa
- & Logical "and" for bit operations.
- | Logic included "or" for bit operations.
- ^ Logic exclusively "or" for bit operations.
- << It moves the left operand for as many binary places as the right-hand value of the right operand
- >> Moving the left operand for as many binary places to the right is the value of the right operand. Moving to the right of the n position is equivalent to dividing the number with 2 ^ n
Examples for operators by bits
For example. for data type int having 16 bits of memory:
0000000000000001
0000000000011101
0000000000011100
0000000000000011
- 25 & 5 = 1 0000000000011001 &
0000000000000001
- 25 | 5 = 29 0000000000011001 |
0000000000011101
- 25 ^ 5 = 28 0000000000011001 ^
0000000000011100
- 25 << 2 = 100 0000000000011001 <<2 =
- 25 >> 3 = 3 0000000000011001 &
0000000000000011
Assignment operator
The basic operator is the operator =, by which one value is assigned to another. In C, C ++ there are also allocation operators that perform multiple operations at once. Suppose you want to assemble the value of a variable with a number and assign the result to the same variable. You would write: i = i + 2; Abbreviated this can be written using the operator + = as follows: i + = 2; The two previous terms are equivalent. The following table provides some of the operators of this type:
| Operator | Using | Equivalent to: |
|---|---|---|
| += | op1 += op2 | op1 = op1 + op2 |
| -= | op1 -= op2 | op1 = op1 - op2 |
| *= | op1 *= op2 | op1 = op1 * op2 |
| /= | op1 /= op2 | op1 = op1 / op2 |
| %= | op1 %= op2 | op1 = op1 % op2 |
| &= | op1 &= op2 | op1 = op1 & op2 |
| |= | op1 |= op2 | op1 = op1 | op2 |
| ^= | op1 ^= op2 | op1 = op1 ^ op2 |
Bitstream operators can be combined with allocation operators:
For instance:
int N=28;
N=N<<3;
The starting number 28 will be transformed to number 224 and this value is assigned to the same memory N.
For instance:
int N=28;
N=N<<3;
The starting number 28 will be transformed to number 224 and this value is assigned to the same memory N.
- 28 << 3 = 224 0000000000011100 <<2 =
The other operators in C, C++
Conditional expression: ? :
Let's look at the following problem:
For entered integers a and b, specify a greater number.
We reserve the memory for 3 data, and b and larger than the two will be placed in the new variable maxAB.
int a,b,maxAB;
The user then enters a and b from the console:
scanf("%d%d", &a, &b);
To assign a value of maxAB, two variants are possible:
maxAB = a; if a >= b or
maxAB = b, if a < b
If you put both variants, the first value of the maxAB would be, and later it would change to b and it would always be b.
It is first necessary to ask whether a> b, and if it is true then maxAB = a is executed, otherwise maxAB = b;
For this, the conditional expression is used:
maxAB=(a>b) ? a : b;
Finally, this value should be displayed:
printf("maxAB=%d", maxAB);
For entered integers a and b, specify a greater number.
We reserve the memory for 3 data, and b and larger than the two will be placed in the new variable maxAB.
int a,b,maxAB;
The user then enters a and b from the console:
scanf("%d%d", &a, &b);
To assign a value of maxAB, two variants are possible:
maxAB = a; if a >= b or
maxAB = b, if a < b
If you put both variants, the first value of the maxAB would be, and later it would change to b and it would always be b.
It is first necessary to ask whether a> b, and if it is true then maxAB = a is executed, otherwise maxAB = b;
For this, the conditional expression is used:
maxAB=(a>b) ? a : b;
Finally, this value should be displayed:
printf("maxAB=%d", maxAB);
SIZEOF operator
With this operator, the size of the data in bytes can be determined. The following example demonstrates:
#include < stdio.h >
#include < stdlib.h >
int main(int argc, char *argv[])
{
#include < stdlib.h >
int main(int argc, char *argv[])
{
int a;
char b;
short c;
long d;
long long e;
unsigned long int f;
printf("\nEnter the integer value a="); scanf("%d",&a);
printf("\nEnter the integer value b="); scanf("%d",&b);
printf("\nEnter the integer value c="); scanf("%d",&c);
printf("\nEnter the integer value d="); scanf("%d",&d);
printf("\nEnter the integer value e="); scanf("%d",&e);
printf("\nEnter the integer value f="); scanf("%d",&f);
printf("\nLength of data int is %d byte and this is equal a=%d bajta",sizeof(int),sizeof(a));
printf("\nLength of data char is %d byte and this is equal b=%d bajta",sizeof(char),sizeof(b));
printf("\nLength of data short is %d byte and this is equal c=%d bajta",sizeof(short),sizeof(c));
printf("\nLength of data long is %d byte and this is equal d=%d bajta",sizeof(long),sizeof(d));
printf("\nLength of data long long is %d byte and this is equal e=%d bajta",sizeof(long long),sizeof(e));
printf("\nLength of data unsigned long int is %d bajta byte and this is equal f=%d bajta",sizeof(unsigned long int),sizeof(d));
return 0;
char b;
short c;
long d;
long long e;
unsigned long int f;
printf("\nEnter the integer value a="); scanf("%d",&a);
printf("\nEnter the integer value b="); scanf("%d",&b);
printf("\nEnter the integer value c="); scanf("%d",&c);
printf("\nEnter the integer value d="); scanf("%d",&d);
printf("\nEnter the integer value e="); scanf("%d",&e);
printf("\nEnter the integer value f="); scanf("%d",&f);
printf("\nLength of data int is %d byte and this is equal a=%d bajta",sizeof(int),sizeof(a));
printf("\nLength of data char is %d byte and this is equal b=%d bajta",sizeof(char),sizeof(b));
printf("\nLength of data short is %d byte and this is equal c=%d bajta",sizeof(short),sizeof(c));
printf("\nLength of data long is %d byte and this is equal d=%d bajta",sizeof(long),sizeof(d));
printf("\nLength of data long long is %d byte and this is equal e=%d bajta",sizeof(long long),sizeof(e));
printf("\nLength of data unsigned long int is %d bajta byte and this is equal f=%d bajta",sizeof(unsigned long int),sizeof(d));
return 0;
If you enter arbitrarily six integers (the value does not affect the size of the data) at the output we will get:
Size of data - output:
We see that we apply the sizeof operator to the data type sizeof (int) or to the data sizeof (a) we get the data size in bytes
Comma operator ","
Is a binary operator that evaluates its first operand and rejects the result, then estimates another operand and returns this value (and type). The notch operator has the lowest priority of any C operator. Comma acts as an operator and a separator
Other operators
Other operators in the C / C ++ language are given in the following table:
| Operator | description of operators |
|---|---|
| [] | Indexing |
| () | call function |
| . | access to the member (element) of the structure |
| -> | access to the member (element) of the structure using pointers |
| *(unary) | access to data by pointers (indirect addressing) |
| &(unary) | variable address |
Operator Priority Table
When there are multiple operators in the expression then higher priority operations are performed first. If operators are of the same priority, then the execution will be left-to-right in most cases (See the column Grouping direction in the table below).
The table below describes the order of priorities and association of operators in C / C ++. The advantage of the operator decreases from top to bottom.
The table below describes the order of priorities and association of operators in C / C ++. The advantage of the operator decreases from top to bottom.
| Priority | Number of operands | Grouping Direction: | Operators: |
|---|---|---|---|
| 15 | 2 | -> | [] () . -> |
| 14 | 1 | -> | ! ~ ++ -- + - * & (tip) sizeof |
| 13 | 2 | -> | * / % |
| 12 | 2 | -> | + - |
| 11 | 2 | -> | << >> |
| 10 | 2 | -> | < <= > >= |
| 9 | 2 | -> | == != |
| 8 | 2 | -> | & |
| 7 | 2 | -> | ^ |
| 6 | 2 | -> | | |
| 5 | 2 | -> | && |
| 4 | 2 | -> | || |
| 3 | 2 | -> | ?: |
| 2 | 2 | -> | = += -= *= /= %= &= ^= |= <<= >>= |
| 1 | 2 | -> | , |
|
Previous
|< Data in languages C/C++ |
Next
Selection statements >| |