C Programming Advanced Concepts

The expression i++ uses post-increment, meaning the current value of i is assigned to a[i], then i is incremented. First iteration: a[0]=0, i becomes 1. Second: a[1]=1, i becomes 2. Third: a[2]=2, i becomes 3. But wait - after i=2, we assign a[2]=2, then i becomes 3, so loop exits. However, when i=0, a[0]=0, then i becomes 1. When i=1, a[1]=1, then i becomes 2. When i=2, a[2]=2, then i becomes 3. Actually, the issue is that the loop condition is checked BEFORE the increment in the for statement. Let me reconsider: for(i=0; i<3; i++) - the increment happens AFTER each iteration. So: i=0, assign a[0]=0, then i++ makes i=1; i=1, assign a[1]=1, then i++ makes i=2; i=2, assign a[2]=2, then i++ makes i=3. But there's undefined behavior here because i is modified twice in the same expression (a[i]=i++). In practice, the assignment happens before the increment, so a[0]=0, a[1]=1, a[2]=2. However, option A says '0 Garbage Value 2' which suggests something else is happening. The key is that after i becomes 3, the loop exits, but a[3] is never set. However, the array only has 3 elements (indices 0,1,2). The answer '0 Garbage Value 2' suggests that a[1] contains garbage. This is due to the undefined behavior of i++ where the assignment and increment order is not guaranteed. The most likely outcome is indeed that a[1] ends up with garbage because of the sequence point violation.

This XOR swap algorithm exchanges values without a temporary variable. a ^= b means a = a XOR b. The chained XOR operations work because XOR is reversible. Let's trace: Initially a=123, b=456. After all operations, a becomes 456 and b becomes 123. The XOR-swap technique correctly swaps the values.

The ternary operator (a>b) evaluates to 1 (true) since 5>4, so &a is selected. The assignment *((a>b) ? &a : &b) becomes *&a, which assigns to a. The expression (a+b>c) is 5+4>10 = 9>10 = 0 (false in C). So a becomes 0, b remains 4. Hence output is '0 4'.

The line int *array = &realarray[-1] uses negative array indexing, which is undefined behavior. However, it typically works by pointing before the array start. When the loop runs, *array accesses realarray[-1] (garbage/previous memory), then array++ makes it point to realarray[0]=1. So output is garbage value followed by 1.

The nested ternary evaluates as: !a ? (b ? !c : !d) : a. Since a=1, !a=0 (false), so we take the rightmost branch and return a, which is 1. The nested ternarys on the left side (!c and !d) are never evaluated due to short-circuiting.

The compound assignment evaluates right-to-left: e%=5 gives e=4, then d/=e gives d=10, then c*=d gives c=300, then b-=c gives b=-200, finally a+=b gives a=300. The final values are: a=300, b=-200, c=300, d=10, e=4.

The variable i is declared as extern but never defined anywhere in the program. This causes a linker error because the linker cannot find the definition of i to satisfy the external declaration. The inner block's int i=20 is a separate local variable and doesn't resolve the extern.

The for loop initializes i=5, then checks ++i which makes i=6 (true, so loop runs), prints 6. Then i-=3 makes i=3. Check ++i: i=4 (true), prints 4. Then i-=3 makes i=1. Check ++i: i=2 (true), prints 2. Then i-=3 makes i=-1. Check ++i: i=0 (false), loop exits. Output: 6 4 2.

The printf statement has *ptr++ as the second argument. The post-increment operator means the current value (*ptr=1234) is used for printf, then ptr is incremented. So printf receives val=1234 and *ptr=1234, printing "1234 1234". The pointer increment happens after the value is fetched.

The line func; is a statement that evaluates the function name but doesn't call it - it's essentially a no-op that gets discarded. Then func(); is called normally and prints "Testing...Done". The first func; is valid but useless, not an error.

A 1-bit signed integer can represent two distinct values. In two's complement representation, a 1-bit signed bitfield can hold 0 and -1 (since the single bit acts as the sign bit, representing negative numbers or zero). Thus, the valid values are 0 and -1.

The code contains a comma operator quirk in the assignment expression, but more importantly, integer division i/10.0 promotes the result to float. For i from 0 to 4, i/10.0 evaluates to 0.0, 0.1, 0.2, 0.3, and 0.4 respectively. Printing these floats with format %.1f produces the expected sequence.

The underscore _ is a valid variable name in C. The code declares int _, assigns 100 to it, then prints it. This is perfectly valid C code and outputs 100. Underscore is a legal identifier character.

The macro big(a,b) returns the larger value, so big(3,5) returns 5. The condition (3+5)>5 evaluates to true (8>5). When swap(a,b) expands, it executes temp=a; a=b; b=temp; making a=5 and b=3. The printf outputs "5 3". The key point is that the swap macro lacks braces, but it still executes sequentially.

Trace the recursion: fn(7) calls fn(6)+3. fn(6) calls fn(3)+2. fn(3) calls fn(2)+3. fn(2) calls fn(1)+2. fn(1) returns 1 (base case). Working backward: fn(2)=1+2=3, fn(3)=3+3=6, fn(6)=6+2=8, fn(7)=8+3=11. The function uses different increments for even (divide by 2, add 2) and odd (subtract 1, add 3) paths.

The function afunction receives a pointer to v but immediately reassigns x to point to newly allocated memory (x=new int). This does NOT change the original pointer in main - it only changes the local copy x. The *x=12 assigns to the new memory, not to v. When printf prints v in main, v still has its original value 10. The new int is leaked (memory not freed).

The break statement can only be used inside loops (for, while, do-while) or switch statements. Using break inside an if statement that is not inside a loop or switch causes a compilation error. The compiler will reject this code because break has no valid target to break out of.

A switch statement cannot have more than one default case. This code has two default labels (at the beginning and end), which violates C syntax rules. The compiler will report an error for duplicate default cases. The presence of the second default makes this code invalid.

The macro floatptr expands to float *, so floatptr f1,f2 becomes float f1,f2. Due to precedence, this declares f1 as float but f2 as float (only f1 gets the asterisk). For intptr (defined as int *), intptr p1,p2 becomes int p1,p2, declaring p1 as int and p2 as int. Therefore f2 is float and p2 is int.

The macro SQR(x) expands to xx. When called as SQR(b+2), it becomes b+2b+2, NOT (b+2)(b+2). Due to operator precedence, multiplication happens first: 3+23+2 = 3+6+2 = 11. The macro lacks parentheses around x and around the entire expression, causing this common pitfall.

The switch statement has choice=4. There is no case 4, so execution goes to default. The default prints "A" but has NO break statement. Without break, execution falls through to case 1, which prints "B". The output is "AB". Looking at the options, none of A, B, C ("All the above") match "AB". Therefore D (None of the above) is correct.