Arithmetic operators in C are symbols that perform mathematical calculations such as addition, subtraction, multiplication, division, and modulus on numeric operands. They are fundamental to expression evaluation in C programs and support both integer and floating-point data types.
These operators appear in expressions like a + b or x * y, where the operator acts on two operands. The result depends on the operand types and the operator's behavior. For example, dividing two integers using / produces an integer result, truncating any fractional part.
The five primary arithmetic operators in C are + (addition), - (subtraction), * (multiplication), / (division), and % (modulus). They follow standard operator precedence: multiplication, division, and modulus occur before addition and subtraction. Parentheses can override this order.
C evaluates arithmetic expressions left to right, respecting operator precedence. For example, in 5 + 3 * 2, multiplication happens first, yielding 5 + 6, then addition gives 11. Without parentheses, the order is enforced by the C language specification.
When operands differ in type, C promotes the smaller type to match the larger one. Adding an int and a double results in a double. This automatic promotion prevents data loss during mixed-type operations.
Division with integers truncates toward zero. So 7 / 3 equals 2, not 2.333. To get a floating-point result, cast one operand: (double)7 / 3 yields approximately 2.333.
Each arithmetic operator behaves differently based on operand types and context. The table below summarizes their roles:
| Operator | Name | Operation | Example | Result Type |
|---|---|---|---|---|
+ |
Addition | Sum of operands | 4 + 5 |
Same as operands |
- |
Subtraction | Difference of operands | 10 - 3 |
Same as operands |
* |
Multiplication | Product of operands | 6 * 7 |
Same as operands |
/ |
Division | Quotient of operands | 15 / 4 |
Integer if both operands are int |
% |
Modulus | Remainder of division | 17 % 5 |
Same as operands (must be integers) |
Modulus (%) is unique because it only applies to integer types. Using it with floating-point numbers causes a compilation error. For example, 10.5 % 3 is invalid syntax in C.
Understanding operator precedence avoids unexpected results. For instance, 10 - 2 * 3 evaluates to 4, not 24, because multiplication takes priority. Always use parentheses to clarify intent in complex expressions.
A frequent mistake is assuming that / always returns a floating-point result. In reality, when both operands are integers, the result is truncated to an integer. For example, 1 / 2 yields 0, not 0.5. This behavior is consistent with C's type system and integer arithmetic rules.
Another misconception is that % always returns a positive remainder. In C, the sign of the result follows the dividend. So -7 % 3 gives -1, not 2. This differs from some other languages like Python, which return a positive remainder. C's behavior is defined by the standard and ensures predictable results across platforms.
Some developers assume that arithmetic operations are atomic. However, in multi-threaded environments, concurrent access to shared variables during arithmetic can lead to race conditions. For example, multiple threads incrementing a global counter using counter++ may miss updates due to read-modify-write sequences. Use atomic operations or mutexes to prevent data races.
Consider a program calculating the average of three integers: 85, 92, and 78. A naive implementation might look like this:
#include <stdio.h>
int main() {
int a = 85, b = 92, c = 78;
int sum = a + b + c;
int avg = sum / 3;
printf("Average: %d\n", avg);
return 0;
}This outputs Average: 85. The result is correct as an integer, but it loses precision. To preserve decimal accuracy, declare avg as double and cast the sum:
double avg = (double)(a + b + c) / 3;Now the result is 85.000000. The cast ensures floating-point division occurs. Without it, integer division truncates the fraction.
I tested this in GCC 13.2 on Linux. The original version produced 85, while the cast version gave 85.000000. This demonstrates how type conversion affects arithmetic outcomes.
As noted in the C Standard (ISO/IEC 9899:2018), arithmetic operations on integer types are defined to truncate toward zero. The WG14 committee confirms that modulus behavior aligns with the dividend's sign, ensuring consistency across implementations.
Use arithmetic operators in C to build expressions that manipulate numeric data. Their behavior is predictable when you understand type promotion, precedence, and the difference between integer and floating-point division. Always test edge cases like division by zero or overflow to avoid runtime errors.