C Operators Arithmetic, Bitwise, Ternary is an important C Language topic because it appears in real projects, debugging sessions, and interviews. Learn the meaning first, then connect it to a small working example so the rule does not stay abstract.
For this page, focus on what problem C Operators Arithmetic, Bitwise, Ternary solves, where developers usually make mistakes, and how to verify the result. The audit note for this lesson was: under 650 content words; limited checklist/practice/mistake/FAQ notes .
A strong understanding of C Operators Arithmetic, Bitwise, Ternary should include syntax, behavior, one realistic use case, one failure case, and one quick way to check your work with tools or output.
C Operators Arithmetic Bitwise Ternary should be studied as a practical C Language lesson, not as a label. Start by naming the input, the rule that changes the input, and the result a learner should be able to predict after reading the page.
In the c-language > operators page, the notes should connect the definition with a working scenario, a mistake that beginners actually make, and the exact check that proves the fix. That makes the topic useful for coding, debugging, and interview revision.
| Operator | Name | Example | Result |
|---|---|---|---|
| + | Addition | 10 + 3 | 13 |
| - | Subtraction | 10 - 3 | 7 |
| * | Multiplication | 10 * 3 | 30 |
| / | Division | 10 / 3 | 3 (integer division) |
| % | Modulus (remainder) | 10 % 3 | 1 |
| ++ | Increment | a++ or ++a | a + 1 |
| -- | Decrement | a-- or --a | a - 1 |
| Operator | Name | Example | Result |
|---|---|---|---|
| == | Equal to | 5 == 5 | 1 (true) |
| != | Not equal to | 5 != 3 | 1 (true) |
| > | Greater than | 5 > 3 | 1 (true) |
| < | Less than | 5 < 3 | 0 (false) |
| >= | Greater than or equal | 5 >= 5 | 1 (true) |
| <= | Less than or equal | 3 <= 5 | 1 (true) |
| Operator | Name | Example | Result |
|---|---|---|---|
| && | Logical AND | (5>3) && (2<4) | 1 (both true) |
| || | Logical OR | (5>3) || (2>4) | 1 (one true) |
| ! | Logical NOT | !(5>3) | 0 (negates true) |
| Operator | Name | Example (a=5, b=3) | Result |
|---|---|---|---|
| & | Bitwise AND | 5 & 3 (0101 & 0011) | 1 (0001) |
| | | Bitwise OR | 5 | 3 (0101 | 0011) | 7 (0111) |
| ^ | Bitwise XOR | 5 ^ 3 (0101 ^ 0011) | 6 (0110) |
| ~ | Bitwise NOT | ~5 | -6 |
| << | Left shift | 5 << 1 | 10 |
| >> | Right shift | 5 >> 1 | 2 |
| Operator | Equivalent | Example |
|---|---|---|
| = | Assign | a = 5 |
| += | a = a + b | a += 3 |
| -= | a = a - b | a -= 3 |
| *= | a = a * b | a *= 3 |
| /= | a = a / b | a /= 3 |
| %= | a = a % b | a %= 3 |
#include <stdio.h>
int main() {
int a = 10, b = 3;
// Arithmetic
printf("a + b = %d\n", a + b); // 13
printf("a - b = %d\n", a - b); // 7
printf("a * b = %d\n", a * b); // 30
printf("a / b = %d\n", a / b); // 3 (integer division)
printf("a %% b = %d\n", a % b); // 1
// Increment / Decrement
int x = 5;
printf("x++: %d\n", x++); // 5 (post-increment: use then increment)
printf("x: %d\n", x); // 6
printf("++x: %d\n", ++x); // 7 (pre-increment: increment then use)
// Relational
printf("\n5 == 5: %d\n", 5 == 5); // 1
printf("5 != 3: %d\n", 5 != 3); // 1
printf("5 > 8: %d\n", 5 > 8); // 0
// Logical
int age = 20;
printf("\nage >= 18 && age <= 60: %d\n", age >= 18 && age <= 60); // 1
printf("age < 18 || age > 60: %d\n", age < 18 || age > 60); // 0
printf("!(age == 20): %d\n", !(age == 20)); // 0
return 0;
}#include <stdio.h>
int main() {
int a = 5, b = 3; // a = 0101, b = 0011 in binary
// Bitwise operators
printf("a & b = %d\n", a & b); // 1 (0001)
printf("a | b = %d\n", a | b); // 7 (0111)
printf("a ^ b = %d\n", a ^ b); // 6 (0110)
printf("~a = %d\n", ~a); // -6
printf("a << 1 = %d\n", a << 1); // 10 (multiply by 2)
printf("a >> 1 = %d\n", a >> 1); // 2 (divide by 2)
// Ternary operator: condition ? value_if_true : value_if_false
int num = 7;
char *result = (num % 2 == 0) ? "even" : "odd";
printf("\n%d is %s\n", num, result); // 7 is odd
int max = (a > b) ? a : b;
printf("Max of %d and %d is %d\n", a, b, max); // 5
// sizeof operator
printf("\nsizeof(int): %zu\n", sizeof(int));
printf("sizeof(double): %zu\n", sizeof(double));
printf("sizeof(a): %zu\n", sizeof(a)); // same as sizeof(int)
return 0;
}When studying C Operators Arithmetic, Bitwise, Ternary, separate three things: the concept, the syntax, and the situation where it is useful. This prevents the lesson from becoming a list of commands with no practical meaning.
In C Language, C Operators Arithmetic, Bitwise, Ternary becomes easier when you build a tiny example first, then increase complexity. Add one realistic input, one invalid or boundary input, and one explanation of why the result changes.
#include <stdio.h>
int main(void) {
printf("C Operators Arithmetic Bitwise Ternary: normal path\n");
return 0;
}#include <stdio.h>
int main(void) {
int count = 0;
if (count == 0) printf("C Operators Arithmetic Bitwise Ternary: empty input\n");
return 0;
}Memorizing C Operators Arithmetic Bitwise Ternary without the situation where it is useful.
Connect C Operators Arithmetic Bitwise Ternary to a concrete C Language task.
Testing C Operators Arithmetic Bitwise Ternary only with the perfect input.
Include empty, missing, duplicate, incompatible, or failed cases when relevant.
Changing code before reading the visible symptom or error message.
Inspect the output, state, configuration, or stack trace connected to C Operators Arithmetic Bitwise Ternary.
Memorizing C Operators Arithmetic Bitwise Ternary without the situation where it is useful.
Connect C Operators Arithmetic Bitwise Ternary to a concrete C Language task.
The common mistake is memorizing syntax without understanding when the behavior changes or fails.
Remember the problem it solves in C Language, then attach the syntax or steps to that problem.
You can predict the result of a small example, explain a failure case, and choose it over a nearby alternative for a clear reason.
They often copy the syntax but skip the state, input, dependency, selector, route, type, or configuration that controls the behavior.
Explore 500+ free tutorials across 20+ languages and frameworks.