61 lines
1.9 KiB
Markdown
61 lines
1.9 KiB
Markdown
> **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 = ▭
|
|
```
|
|
|
|
---
|
|
|
|
> **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 |