C. Operators

Read time: 7 minutes

An operator is a thing with which you can perform an operation (addition, subtraction, etc.)

There are two kinds of operators:

• Unary – for operations on a single variable
• Binary – for operations on two variables

There is also a ternary one (with three variables), but we will remember about it when we talk about conditions (if, else).

Binary operators

Let’s start with binary ones, because they are closer and more understandable:

• Build: +
• Subtraction:-
• Multiplication: *
• Division: /
• Remainder of the division: %

Be aware that operators have different application precedence – for example, the classic example:

2 + 2 * 2 = ?

If your answer is 8, then you forgot that multiplication is performed before addition. Here everything is exactly the same - first * / % are executed from left to right, and then + - are also executed.

However, just like in math, you can use parentheses to change the order of operations:

(2 + 2) * 2 = 8

Operators can be used in a variety of ways:

• With integer values
• With real values
• With mixed values
• With cast
• With assignment operation
• For villains

Yes, the C language has a lot of subtleties with operators, but it will all be remembered over time - just try to catch the main points.

With integer values

Here are examples of using operations on integer values:

int a = 15, b = 8;
int result;
result = a+b; // Assign 23
result = a - b; // Set to 7
result = a*b; // Assign 120
result = a/b; // Set to 1 because it's 1.875, and since it's an integer (int) -- the fractional part will just be discarded
result = a % b; // Assigned to 7 because dividing 15 by 8 gives 1 whole part, and 7 is the remainder
result = a + b * 2; // Assign 31
result = (a + b) * 2; // Assign 46

With real values

Here are examples of using operations on real values:

float a = 7., b = 4.4;
float result;
result = a+b; // Assigned to 11.4
result = a - b; // Assigned to 2.6
result = a*b; // Assign 30.800001
// Why 30.800001 and not 30.8? Because float calculations are accurate to a certain point.
// sign -- beyond this sign, madness can begin. This is due to the nature of storage.
// real numbers in memory. If you use double instead of float, then the precision will increase and
// will increase to the farthest decimal place.
result = a/b; // Assign 1.590909
result = a % b; // !!! ERROR, operation "%" cannot be used with real numbers!!!

Note that the % operator cannot be used with real numbers.

With mixed values

Okay, operations separately with integers, separately with real values are clear - but what if you mix integers and real values in one operation?

In this case, the result will turn into a real:

int a = 5;
float b = 4.5;
float floatResult = a + b; // Assigned 9.5
// Set to 9 because the result of 9.5 is pushed into
// an integer variable, and the fractional part is discarded
int intResult = a + b;
// This is true for all other operations: - * /

With cast

In some cases, it may turn out like this, you have only integer variables in your hands, but you need to divide them into each other, and get a real result. Here is an example situation:

int a, b;
float result;
scanf("%d", &a); // Entered 6
scanf("%d", &b); // Entered 4
// Integer result 1 will be written to a real variable,
// because of which the integer value is implicitly converted to real 1.000000
result = a / b;
print("%f\n", result); // Outputs 1.000000

Note that in this case we have written an integer value to a real variable. In this case, the integer value is implicitly converted to a real value.

What can I do to get the correct division result of 1.5?

To do this, there is an explicit cast type operation - with its help, you can change the type of the variable value directly in the expression. Here’s what it looks like:

int a, b;
float result;
scanf("%d", &a);
scanf("%d", &b);
// You can cast not only the dividend, but in general any variable or number in the expression,
// and not only to double, but to any type in general.
result = (double) a / b;
print("%f\n", result);

In this case, 1.500000 will be printed, because one of the variables becomes real, and as we know from the previous section “With mixed values” - “the result will turn into a real”.

I have shown the most useful use case for type casting, but there may be other exotic cases.

With assignment operator

Binary operators can be beautifully combined with the assignment operator:

int a = 3;
// Here is the entry:
a = a + 10;
// Equivalent to this:
a += 10;
// This is true for all other operations: -= *= /= %=

For villains

Just so you know, there is a use case for assignment with operators for villains that you don’t have to use (but you can):

int a = 2, b = 3, c = 4, d = 5;
a += (b += 5) * (c = 10) + d;
// Rewrite the same, but not in a villainous way:
b = b + 5; // Execute first parenthesis first
c = 10; // Then the second
a = a + b * c + d; // Then we substitute the variables in the original expression

Task for fixing

For now, I’ll give you a couple of simple tasks to stretch your fingers. I won’t invent any complicated equations - just if you need to calculate something complicated in the future, then you just return to this material. After a couple of times, it itself will sit in the subcortex.

Tasks:

• Write a program that takes a student number from the keyboard (scanf) and prints (printf) the number of his version. The total number of options is from 0 to 14. For example, if the student has number 0 or 15, then he will have option 0. If the student has number 2 or 17, then option 2. Hint: %
• Write a program that takes three real numbers from the keyboard and prints the sum of the first two numbers multiplied by the third.

Unary operators

You probably didn’t see them before, since they are used only in programming:

• Increment (increases the value of a variable by 1): ++
• Decrement (decreases the value of a variable by 1): –

This is how they are used:

int x = 5;
x++; // After that, x will be equal to 6
x--; // And now x is 5 again

There is a tricky point with these operators - it matters which side the operator is on. If the operator stands:

• Left – the operation occurs until the value of the variable is received
• Right – operation occurs after getting the value of the variable

It’s easier to show with an example:

int x, result;

x = 3;
// After this line, result will be 3 and x will be 4:
// that is, we first performed the assignment operation, and then incremented the variable x
result = x++;

// Reset x value to 3
x = 3;
// After this line, result is 4 instead of 4:
// that is, we first made an increment, and then performed an assignment operation
result = ++x;

// Reset x value to 3
x = 3;
// After this line, result is 8 and x is 4:
// that is, we first performed the addition operation, and then did the increment
result = x++ + 5;

// Reset x value to 3
x = 3;
// After this line, result is 9 and x is 4:
// that is, we first made an increment, and then performed an assignment operation
result = ++x + 5;

Conclusion

In total, you have learned:

• Binary operators
• With integer values
• With real values
• With mixed values
• With cast
• With assignment operation
• For villains
• Unary operators

If anything - write, I will help and try to explain better.

Next in line are conditions.