Wrong precedence, integer division, or confusing && with & can spoil an output answer. C operator precedence, a program trace to 39, and the distinction between defined output and undefined behaviour are central to solving output questions.
C operators and operands: read the expression before calculating it
An operator acts on an operand to form an expression. In total = a + b * 2, =, +, and * are operators; total, a, b, and 2 are operands. C evaluates the right side before storing it.
Operators may be unary (-5, !0), binary (17 + 5, 10 & 6), or ternary (condition ? 39 : 0). In context, -x negates, x - y subtracts, &x takes an address, and x & y is bitwise AND.
Family | Example | Result |
|---|---|---|
Arithmetic |
|
|
Relational |
|
|
Equality |
|
|
Logical |
|
|
Bitwise |
|
|
Assignment |
|
|
Conditional |
|
|
See Coding & DSA Courses for Placements for a wider problem-solving route.
Arithmetic, relational and logical operators produce different answers
With positive integers, 17 + 5 = 22, 17 - 5 = 12, 17 * 5 = 85, 17 / 5 = 3, and 17 % 5 = 2. Integer division discards the fraction; 17 = 3 * 5 + 2 verifies the quotient and remainder. % requires integers.
Comparisons return integers: 17 > 5 is 1, 17 < 5 is 0, 17 != 5 is 1, and 17 == 5 is 0. Zero is false, non-zero is true; comparisons and logical operators produce 0 or 1.
For a = 10 (1010) and b = 6 (0110), a && b is 1 because both are non-zero, but a & b is 2 because 1010 & 0110 = 0010. Likewise, a || 0 is 1, while a | 0 is 10. Use Number Systems and Base Conversions Explained to check binary traces.
C operator precedence and associativity: parse one expression exactly
Consider:
int answer;
answer = 8 + 12 / 3 * 2 > 14 && 7 % 4 == 3;Evaluate by precedence: 12 / 3 = 4, then 4 * 2 = 8 because division and multiplication associate left to right. Next, 8 + 8 = 16 and 16 > 14 gives 1. Also, 7 % 4 = 3, then 3 == 3 gives 1. Finally, 1 && 1 gives 1, assigned to answer.
For this assignment, the participating precedence levels, from tightest to loosest, are multiplicative * / %, additive + -, relational < <= > >=, equality == !=, logical AND &&, and assignment. Associativity resolves ties. Assignment is right-to-left, so x = y = 5 stores 5 in y, then x.
Its grouping is (((8 + ((12 / 3) * 2)) > 14) && ((7 % 4) == 3)). A blanket left-to-right rule fails.
Fully worked C operator example: arithmetic, masks and a conditional result
#include <stdio.h>
int main(void) {
unsigned int a = 29, b = 6, mask = 10;
unsigned int quotient = a / b;
unsigned int remainder = a % b;
unsigned int flags = (mask << 1) | 1;
int eligible = (a > 4 * b) && ((mask & 2) != 0);
unsigned int score = eligible
? (quotient + remainder) * 2 + flags
: 0;
printf("%u %u %u %d %u\n",
quotient, remainder, flags, eligible, score);
return 0;
}29 / 6 = 4 and 29 % 6 = 5. Mask 10 is 1010; 10 << 1 = 20 (10100), then 20 | 1 = 21 (10101), so flags = 21.
For eligibility, 4 * 6 = 24, so 29 > 24 gives 1. Also, 10 & 2 is 1010 & 0010 = 0010 = 2; 2 != 0 gives 1. Thus 1 && 1 sets eligible = 1.
The true branch computes (quotient + remainder) * 2 + flags = (4 + 5) * 2 + 21 = 9 * 2 + 21 = 18 + 21 = 39; : 0 is not selected. The exact output is 4 5 21 1 39.
Types, integer division and short-circuit evaluation change the result
In double x = 7 / 2;, integer division gives x the value 3.0. In double y = 7 / 2.0;, floating-point division yields 3.5; (double)7 / 2 also produces 3.5. The destination type cannot change the earlier evaluation.
Short-circuiting can guard an unsafe operation:
int den = 0;
int safe = den != 0 && 42 / den > 3;The left operand is 0, so && skips 42 / den, avoiding division by zero, and safe becomes 0. With den = 6, the left side is 1, 42 / 6 = 7, 7 > 3 gives 1, and safe becomes 1. || skips its right operand when the left is true.
Bitwise & and | do not short-circuit, so replacing && with & reaches the zero divisor. Propositional and Predicate Logic Explained supports truth-condition practice; short-circuiting is a C rule.
Increment, compound assignment and undefined-behaviour traps
Keep increments in separate, sequenced expressions:
int x = 5;
int before = x++;
int after = --x;
int total = before + 2 * after;After before = x++, before = 5 and x = 6. Prefix --x changes it first, so after = 5 and x = 5. Thus total = 5 + 2 * 5 = 15. Postfix yields the old value.
Start compound assignment with int score = 7;. In score += 3 * 2;, multiplication gives 6, then score becomes 13. += updates; == only compares. Do not duplicate a complicated left operand when expanding an assignment.
Do not calculate int y = i++ + ++i;. The modifications of i are unsequenced, so behaviour is undefined. Other red flags are division by zero, an invalid shift count, signed overflow, and implementation-dependent negative signed right shift. Portable bit traces use positive or unsigned operands.
How operator questions test understanding, not symbol recognition
Typical tasks evaluate mixed operators, distinguish division types, follow &&, ||, or ?:, trace a mask, compare increments, or spot undefined behaviour. These are practice patterns, not weightage claims.
Use this five-step routine:
Write each operand's type and value.
Add parentheses using precedence and associativity.
Evaluate sequenced operations only.
Apply integer promotions and conversions.
Check short-circuiting and undefined behaviour before choosing an output.
For two rapid checks, 5 + 18 / 4 becomes 5 + 4 = 9 with integer operands. With unsigned int bits = 10, (bits & 2) && !(bits & 1) becomes 2 && !0, then 1 && 1, so it yields 1. Use Boolean Algebra and K-map Minimization Guide for nearby practice; C logical and bitwise operations remain distinct.
C operators: key rules and next step
Recall the family and types, precedence, sequencing, short-circuiting, and undefined behaviour. The complete trace reached quotient = 4, remainder = 5, flags = 21, eligible = 1, and score = 39.
Keep a = 29 and b = 6, but set mask = 8 (1000). Then flags = (8 << 1) | 1 = 16 | 1 = 17. Since 8 & 2 = 0, eligible = 0, the false branch sets score = 0. The exact output becomes 4 5 17 0 0.
Continue with C Language: Concepts, MCQs, Coding Questions for C practice. For broader preparation, use GATE Guidance by Sanchit Sir. Trace every expression before trusting its output.
