> **4.** Suppose that the following declarations are in effect:
```c
struct point {int x, y; };
struct rectangle { struct point upper_left, lower_right; };
struct rectangle *p;
```
> Assume that we want `p` to point to a rectangle structure whose upper left corner is at $(10, 25)$, and whose lower right corner is at $(20, 15)$. Write a series of statements that allocate such a structure and initialize it as indicated.

```c
struct rectangle rect = { { 10, 25 }, { 20, 15 } };
p = &rect;
```

---

> **5.** Suppose that `f` and `p` are declared as follows:
```c
struct {
	union {
		char a, b;
		int c;
	} d;
	int e[5];
} f, *p = &f;
```
> Which of the following statements are legal?

(a) `p->b = ' ';`
(b) `p->e[3] = 10;` - **Legal**
(c) `(*p).d.a = '*';` - **Legal**
(d) `p->d->c = 20;`

---

> **7.** The following loop is supposed to delete all nodes from a linked list and release the memory that they occupy. Unfortunately, the loop is incorrect. Explain what's wrong with it and show how to fix the bug.
```c
for (p = first; p != NULL; p = p->next)
	free(p);
```

The above loop won't function because it deallocates the entry, then attempts to access the pointer to the next item, *after* it's already been freed.

A functional example might look like this:
```c
struct entry *p = first;
while (p != NULL) {
	void *current = p;
	p = p->next;
	free(p);
}
```

---

> **9.** True or false: If `x` is a structure and `a` is a member of that structure, then `(&x)->a` is the same as `x.a`. Justify your answer.

**True**: The arrow operator is used to access a member of a struct through a pointer. `(&x)` creates a pointer to the `x` struct, therefore the arrow operator can be used to access fields on `x`.

---

> **13.** The following function is supposed to insert a new node into its proper place in an ordered list, returning a pointer to the first node in the modified list. Unfortunately, the function doesn't work correctly in all cases. Explain what's wrong with it and show how to fix it. Assume that the `node` structure is the one defined in Section 17.5.
```c
struct node *insert_into_ordered_list(struct node *list, struct node *new_node) {
	struct node *cur = list, *prev = NULL;
	while (cur->value <= new_node->value) {
		prev = cur;
		cur = cur->next;
	}
	prev->next = new_node;
	new_node->next = cur;
	return list;
}
```

In the above code, if the new item needs to be inserted at the *end* of the list, it breaks, because `cur` is set to `NULL`, then it attempts to access `cur->value`.
```c
struct node *insert_into_ordered_list(struct node *list, struct node *new_node) {
	struct node *cur = list, *prev = NULL;
	while (cur->value <= new_node->value) {
		prev = cur;
		cur = cur->next;
		if (cur->next == NULL) {
			break;
		}
	}
	prev->next = new_node;
	new_node->next = cur;
	return list;
}
```