Editing c/basic arithmetics

{{c title|Basic Arithmetics}}
Just about every program is going to need to do some '''basic arithmetics''' - the ability to manipulate values using basic math operations such as addition and subtraction. The [[C]] programming language provides a set of operations to perform such basic operations.

== Expressions & Operators ==
Once a variable has been {{C|Variables#Variable Declaration|declared}} and assigned some value, it is possible to use that variable in various arithmetic operations. '''Expressions''', among other things, is the combination of arithmetic operators, values, and variables, that are combined together to produce a single value.

C provides the following basic arithmetic operators:

{| class="wikitable"
|-
! Operator !! Description
|-
| + || Addition of both operands
|-
| - || Subtraction of 2nd operand from 1st
|-
| * || Multiplication of both operands
|-
| / || Division of 1st operand from 2nd
|-
| % || Remainder of a division of 1st operand from 2nd
|}

One very simple expression can be <code>3 * 5</code>, another is <code>3 + 6 * 2</code>. Math operations follow the order of operations, however, parentheses can also be used to change it. For example <code>((4 + 6 + 2) * 4)</code>

For example, a basic program might look like this:

<source lang="C">
#include <stdio.h>
int main()
{
    int a, b;
    printf("Please enter two integer, comma-separated: ");
    scanf("%d,%d", &a, &b);
    printf("%d + %d = %d\n", a, b, a + b);
    printf("%d - %d = %d\n", a, b, a - b);
    printf("%d * %d = %d\n", a, b, a * b);
    printf("%d / %d = %d\n", a, b, a / b);
    printf("%d %% %d = %d\n", a, b, a % b);
    return 0;
}
</source>

One possible output for the program above is:
 Please enter two integer, comma-separated: 23,5
 23 + 5 = 28
 23 - 5 = 18
 23 * 5 = 115
 23 / 5 = 4
 23 % 5 = 3

The math expressions above can be assigned to and mixed with other variables, for example, we can perform <code>(c % ((a + 4) * b))</code> if we had three variables of type int. Consider the example below:

<source lang="C">
#include <stdio.h>
int main()
{
    int length, width, area;
    printf("Please enter the length and width of a rectangle, comma-separated: ");
    scanf("%d,%d", &length, &width);
    
    area = length * width;
    printf("The area of the rectangle is %d\n", area);
    return 0;
}
</source>

One possible output is:
 Please enter the length and width of a rectangle, comma-separated: 5,11
 The area of the rectangle is 55

== Operations of mixed types ==
Up until now we've only shown examples that have expressions with only homogeneous types. For example the addition of two int types or multiplication of two int types. Expressions, however, can involve values of different types. When this happen, a protocol for converting them to a common type is invoked, known as the [[usual arithmetic conversions - C|usual arithmetic conversions]]. Depending on the type of the operand, and expression it generally converted to the type of the bigger range type among the two. This concept sometimes produce confusing outputs for new programmers.

Consider the following program:

<source lang="C">
#include <stdio.h>
int main()
{
    int a = 10, b = 20;
    float c;

    c = a / b;
    printf("%d / %d = %f\n", a, b, c);
    return 0;
}
</source>

Executing the program above will produce the following out:
 10 / 20 = 0.000000

It might not be exactly what you were expecting. Let's zoom in on the cause: 
<source lang="C">c = a / b;</source>

In the expression <code>a / b</code> both a and b are of type <code>int</code>. Therefore the final value is an <code>int</code>. And since 10/20 is 0 (since we cannot represent 0.5 in an <code>int</code>).

== Increment operators ==
The '''++''' ('''increment''') operator adds 1 to the value of a modifiable arithmetic or pointer data object. The operand receives the result of the increment operation. The operator can be placed before or after the operand. If the operator is applied before the operand, the operand is incremented and the result is used immediately in the expression. If the operator is applied after the operand, the value of the operand is used in the expression before the operand is incremented. When the operator is placed before the operand, it is called a '''pre-increment''' operator; when it is placed after the operand, is it called a '''post-increment''' operator.

Consider the code below:
<source lang="C">total = ++groupA;</source>

The statement above is similar to the following line
<source lang="C">
groupA  = groupA + 1;
total = groupA;
</source>

Likewise, the code
<source lang="C">total = groupA++;</source>

behaves similar to
<source lang="C">
total = groupA;
groupA  = groupA + 1;
</source>

It is important to note that the object can only be modified once in a single statement. Expressions such as <code>x = x++;</code> result in {{C|undefined behavior}} which can do just about anything.

== Decrement operators ==
Just like the increment operator, an operator to subtract a value also exist. The '''++''' ('''decrement''') operator subtracts 1 to the value of a modifiable arithmetic or pointer data object. The operand receives the result of the decrement operation. The operator can be placed before or after the operand. If the operator is applied before the operand, the operand is decremented and the result is used immediately in the expression. If the operator is applied after the operand, the value of the operand is used in the expression before the operand is decremented. When the operator is placed before the operand, it is called a '''pre-decrement''' operator; when it is placed after the operand, is it called a '''post-decrement''' operator.

<source lang="C">
#include <stdio.h>
int main()
{
    int x = 5, y = 10, z;
    z = --x + y--;
    printf("x = %d; y = %d; z = %d;\n", x, y, z);
    return 0;
}
</source>

Which will produce the following result:
 x = 4; y = 9; z = 14;

== Type conversions ==
{{main|c/type conversion|l1=type conversion}}
While many conversions are automatically performed when compatible types are assigned and operated on, some conversions are a bit more problematic because they may result in truncation or loss of value. These type of conversion are known as type-casting. Consider the following example:

<source lang="C">
#include <stdio.h>
int main()
{
    double f = 3.14;
    printf("=> %d\n", (int)(f / 2));
    return 0;
}
</source> 

Produces the following output: <code>=> 1</code>. In the example above, we've converted a <code>double</code> to an <code>int</code> by casting it. The syntax for the cast operator is:
 (<type>)<expression>

For example: <code>a / (double)x</code> will cast the variable x into a <code>double</code> before performing the division.

<source lang="C">
#include <stdio.h>
int main()
{
    double o1, o2;
    int a = 5, b = 8;
    
    o1 = a / b;
    o2 = a / (double)b;
    
    printf("a/b = %f\n", o1);
    printf("a/(double)b = %f\n", o2);
    return 0;
}
</source> 

Which produces the following output:
 a/b = 0.000000
 a/(double)b = 0.625000

[[Category:C programming language]]