C Programming

GATE CS & UGC NET JRF Core Subject Exam Weightage: 2–3 Direct Questions on operator precedence/associativity, tricky increment/decrement side-effects, signed vs unsigned implicit promotions, and sequence point evaluation.

1. Technical Jargon & ISO C Standards Taxonomy#

In competitive exams like GATE and UGC NET, precise technical terminology is essential. ISO C categorizes behavior into four distinct tiers:

                                  C Execution Behaviors
                                            │
        ┌───────────────────┬───────────────┴───────────────┬───────────────────┐
        ▼                   ▼                               ▼                   ▼
    Well-Defined     Implementation-Defined            Unspecified          Undefined (UB)
  Guaranteed by C    Compiler must document           Compiler chooses       ANYTHING can happen
  Standard across    (e.g., sizeof(int),              valid options          (Crash, corrupt data,
  all platforms      sign of integer div)             (e.g., arg order)      wrong output, pass)

1. L-Value vs. R-Value:
   • L-Value (Locator Value): An expression that designates an addressable memory location (e.g., variable identifier x, dereferenced pointer *p, array element a[i]). An l-value can appear on the left side of an assignment operator (=).
   • R-Value (Read Value): A transient data value without a persistent addressable storage location (e.g., literals 42, expressions a + b). It cannot appear on the left side of an assignment.
2. Undefined Behavior (UB): Behavior upon use of a nonportable or erroneous program construct (e.g., signed integer overflow, division by zero, reading uninitialized memory, modifying a variable twice between sequence points like i = i++). The compiler is free to do anything.
3. Unspecified Behavior: Behavior where the standard provides two or more possibilities and imposes no requirement on which is chosen in any instance (e.g., order of evaluation of function arguments: in f(g(), h()), either g() or h() may run first).
4. Implementation-Defined Behavior: Unspecified behavior where the compiler author is required to document the choice (e.g., whether char is signed or unsigned by default, size of int, behavior of right-shifting negative integers).
5. Sequence Point: A point in the program's execution sequence at which all previous side-effects are guaranteed to have completed and no subsequent side-effects have yet taken place (pre-C11 terminology; C11 uses the relation "sequenced before").
6. Side Effect: A change in the state of the execution environment (e.g., modifying an object in memory, accessing a volatile object, modifying a file).

2. Integer Representation, Limits & Promotion Rules#

2.1 Two's Complement Range & Overflow#

Most modern systems represent signed integers using Two's Complement:

$\text{Range for } n\text{-bit signed integer: } [-2^{n-1}, 2^{n-1} - 1]$ $\text{Range for } n\text{-bit unsigned integer: } [0, 2^n - 1]$

For an 8-bit integer (char):

• Signed: $[-128, +127]$
• Unsigned: $[0, 255]$

[!CRITICAL] GATE Trap: Signed vs. Unsigned Overflow!

• Unsigned integer overflow is WELL-DEFINED: It wraps around modulo $2^n$ (e.g., in 8-bit unsigned: $255 + 1 = 0$).
• Signed integer overflow is UNDEFINED BEHAVIOR (UB): Compilers can optimize away loops assuming signed integers never overflow!

2.2 Integer Promotion Rules (The Usual Arithmetic Conversions)#

Before executing any binary arithmetic or bitwise operator, C applies Integer Promotion:

1. Any integer type smaller than int (such as char, signed char, unsigned char, short, unsigned short, and bitfields) is automatically promoted to int if int can represent all values of the original type; otherwise, it is promoted to unsigned int.
2. Once promoted, if operands still differ in type, the Usual Arithmetic Conversions hierarchy applies: $\text{long double} > \text{double} > \text{float} > \text{unsigned long long} > \text{long long} > \text{unsigned long} > \text{long} > \text{unsigned int} > \text{int}$

// Tricky GATE Example:
char a = 100;
char b = 50;
char c = a * b / b; // a * b promotes to int (5000), does NOT overflow char!
// Result: 100

2.3 The Classic Signed vs. Unsigned Comparison Trap#

When a signed integer and an unsigned integer of the same rank are compared:

• The signed operand is implicitly converted to unsigned!
• Negative numbers become huge positive numbers!

#include <stdio.h>

int main(void) {
    int a = -1;
    unsigned int b = 1;

    // sizeof operator returns type size_t (which is an unsigned integer type!)
    if (a < sizeof(int)) {
        printf("True\n");
    } else {
        printf("False\n"); // PRINTS "False"!
    }

    if (a < b) {
        printf("Less\n");
    } else {
        printf("Greater or Equal\n"); // PRINTS "Greater or Equal"!
    }
    return 0;
}

3. Operator Precedence & Associativity Hierarchy#

C features 15 precedence levels. Memorizing the relative priorities of unary, arithmetic, shift, relational, equality, bitwise, logical, conditional, and assignment operators is tested every year in GATE.

4. Syntax Awareness: Pointer Dereference & Increment Traps#

The interaction between unary * (dereference) and ++ / -- is the single most tested syntax construct in C.

Four Combinations with Pointer p:

Expression  | Precedence Parse | Meaning / Effect
------------+------------------+-------------------------------------------------------------
*p++        | *(p++)           | Yields *p (current value), THEN increments pointer p itself
(*p)++      | (*p)++           | Yields *p, THEN increments the integer value stored at *p
*++p        | *(++p)           | Increments pointer p first, THEN dereferences new address
++*p        | ++(*p)           | Increments integer value stored at *p, yields incremented value

Detailed Code Walkthrough#

#include <stdio.h>

int main(void) {
    int arr[] = {10, 20, 30, 40, 50};
    int *p = arr;

    printf("%d\n", *p++);   // Prints 10. p now points to arr[1] (address of 20).
    printf("%d\n", (*p)++); // Prints 20. arr[1] becomes 21. p still points to arr[1].
    printf("%d\n", *++p);   // p moves to arr[2] (30), then dereferences. Prints 30.
    printf("%d\n", ++*p);   // arr[2] (30) is incremented to 31, then prints 31.

    // Final array state: {10, 21, 31, 40, 50}
    return 0;
}

5. Sequence Points & Undefined Evaluation Order#

5.1 The Rule of Sequence Points#

Between the previous and next sequence point:

1. An object's stored value shall be modified at most once by the evaluation of an expression.
2. The prior value shall be accessed only to determine the value to be stored.

Violating either condition results in UNDEFINED BEHAVIOR (UB)!

// ILLEGAL: Undefined Behavior Examples
i = i++;            // UB: modified twice without sequence point
i = ++i;            // UB: modified twice without sequence point
a[i] = i++;         // UB: i accessed to determine address AND modified without sequence point
func(i++, i++);     // UB: order of argument evaluation is unspecified, modified without seq point
printf("%d %d", ++i, i++); // UB: modifies and reads i without sequence point

5.2 Guaranteed Sequence Points in C#

A sequence point occurs at:

1. End of a full expression: The semicolon (;) ending a statement.
2. The Logical AND operator (&&): Evaluates left operand. If false, stops immediately. Sequence point occurs after left operand.
3. The Logical OR operator (||): Evaluates left operand. If true, stops immediately. Sequence point occurs after left operand.
4. The Ternary Conditional operator (? :): Evaluates first operand before ?. Sequence point occurs after condition.
5. The Comma operator (,): Evaluates left expression, performs all side effects, then evaluates right expression.
6. Function Call: Evaluates all argument expressions, then a sequence point occurs before entering the function body.

// Tricky GATE Question on Short-Circuiting:
#include <stdio.h>

int main(void) {
    int a = 0, b = 1, c = 2;

    // In a && (++b), since a is 0 (false), (++b) is NEVER EVALUATED!
    // b remains 1.
    int res = a && (++b);
    printf("res=%d, b=%d\n", res, b); // res=0, b=1

    // In (b || ++c), since b is 1 (true), (++c) is NEVER EVALUATED!
    // c remains 2.
    int res2 = b || (++c);
    printf("res2=%d, c=%d\n", res2, c); // res2=1, c=2

    return 0;
}

6. Bitwise Manipulation Formulas & Idioms#

Bitwise operations operate directly on binary representations and are heavily tested in GATE CS:

7. Best Practices & Defensive Coding in C#

1. Explicit Parentheses for Bitwise Operators: Always write if ((x & MASK) == 0) instead of if (x & MASK == 0). Precedence of == is higher than &!
2. Never Mutate a Variable Multiple Times in One Statement: Avoid code like i = ++i + 2. Keep assignments atomic and sequential.
3. Use Unsigned Constants for Bitwise Shifts: Write 1U << 31 rather than 1 << 31. Shifting into the sign bit of a signed integer causes signed overflow (UB in C99/C11).
4. Guard Comparisons against Signed-Unsigned Pitfalls: Cast or explicitly ensure both sides share matching signedness before comparing.