# C Rapidfire 3

Look at the code, figure out the output, and then read the explanation to see if you got it right.

Here are 10 additional challenging C code examples that demonstrate tricky aspects of the language:

1. **Logical vs Bitwise Operators:**
    

```c
int x = 1, y = 0;
if (x & y)
    printf("True\n");
else
    printf("False\n");
```

**Output:** `False` **Explanation:** The bitwise AND (`&`) of `1` and `0` is `0`, hence the else branch is executed.

1. **Array Decay to Pointer:**
    

```c
int arr[] = {10, 20, 30};
int *p = arr;
printf("%d\n", sizeof(arr) / sizeof(arr[0]));
```

**Output:** `3` **Explanation:** `sizeof(arr)` gives the total size of the array, divided by the size of one element yields the number of elements.

1. **Sign Extension with Bit Fields:**
    

```c
struct {
    signed int x: 3;
} s;
s.x = 7;
printf("%d\n", s.x);
```

**Output:** `-1` on many systems **Explanation:** Assigning `7` (`111` in binary) to a 3-bit signed int can result in sign extension, interpreting it as `-1`.

1. **Character Pointer and String Literal:**
    

```c
char *str = "Hello";
printf("%s\n", str);
```

**Output:** `Hello` **Explanation:** `str` points to a string literal. String literals are stored in read-only memory.

1. **Integer Overflow:**
    

```c
unsigned int a = 4294967295; // Maximum value for a 32-bit unsigned int
a += 1;
printf("%u\n", a);
```

**Output:** `0` **Explanation:** Adding `1` to the maximum value of an unsigned int causes it to wrap around to `0`.

1. **Function Pointer Syntax:**
    

```c
void greet() { printf("Hello\n"); }
void (*func_ptr)() = greet;
func_ptr();
```

**Output:** `Hello` **Explanation:** `func_ptr` is a pointer to the function `greet` and is used to call the function.

1. **Struct Initialization:**
    

```c
struct Point { int x, y; };
struct Point p = {.y = 20, .x = 10};
printf("%d %d\n", p.x, p.y);
```

**Output:** `10 20` **Explanation:** The struct `Point` is initialized with named members out of order, but they are correctly assigned.

1. **Implicit Type Conversion:**
    

```c
short s = 32767;
s += 1;
printf("%d\n", s);
```

**Output:** `-32768` **Explanation:** Adding `1` to the maximum value of a short results in overflow, wrapping around to its minimum value.

1. **Macro Trick:**
    

```c
#define SQUARE(x) x*x
int a = 6 / SQUARE(2);
printf("%d\n", a);
```

**Output:** `3` **Explanation:** The macro expands to `6 / 2*2`, which is evaluated as `(6 / 2) * 2` due to operator precedence.

1. **Enum Constants:**
    

```c
enum { RED, GREEN, BLUE } color;
color = BLUE;
printf("%d\n", color);
```

**Output:** `2` **Explanation:** Enum constants `RED`, `GREEN`, `BLUE` are automatically assigned values `0`, `1`, `2` respectively.