Exercises — Structures — declaration, accessing members (. and - - )

p is a plain variable — you hold the object. Object → dot. Answer: p.x. Writing p->x would give "invalid type argument of '->' (have 'struct Point')" because -> demands a pointer.

q holds an address, not the object. Address → arrow. Answer: q->y. q.y would give "request for member 'y' in something not a structure".

By definition $q\to y\equiv (\ast q).y$. Answer: q->y. Same meaning, no parentheses needed.

struct Point { int x, y; };
struct Point a;
a.x = 5;              // a is object → dot
a.y = 9;
struct Point *p = &a; // p holds the ADDRESS of a
printf("%d", p->x);   // p is pointer → arrow

Prints 5. p->x walks to a then grabs x.

p points at the same object a (because of &a). So p->x = 10 edits a.x itself.

• a.x is now 10.
• p->y reads a.y, still 4. Prints 10 4.

An array name is not assignable — you cannot overwrite the whole array with =. You must copy the characters in:

strcpy(s.name, "Asha");

Answer: use strcpy(s.name, "Asha"); (needs #include <string.h>).

(a) e is an object → dot into when (also an object) → dot into y: e.when.y (b) pe is a pointer → arrow to reach .when, which is a value, then dot: pe->when.y Rule: the first hop depends on e vs pe; once you land on the inner value when, every further hop is a dot.

• b = a makes an independent copy. Editing b.x never touches a.
• p = &a makes an alias — same object. p->y = 200 edits a.y. So a.x stays 1, a.y becomes 200. Prints 1 200.

. binds tighter than *, so the compiler reads it as *(p.x). But p is a pointer, so p.x is already illegal (member access on a non-struct). It does not compile. To dereference-then-access you must write (*p).x, or simply p->x. This precedence rule is exactly why the arrow operator exists.

void grow(struct Point *q) {
    q->x += 1;   // q is a pointer → arrow
    q->y += 1;
}
struct Point a = {3, 4};
grow(&a);        // pass the ADDRESS so changes stick

Trace: q points at a. q->x += 1 → a.x becomes 4. q->y += 1 → a.y becomes 5. After the call, a is (4, 5). Had we written void grow(struct Point q) (by value), grow would edit a copy and a would stay (3,4).

Here we take points by value — we only read them, so no pointers needed.

int distSq(struct Point p1, struct Point p2) {
    int dx = p2.x - p1.x;   // dot: p1, p2 are values
    int dy = p2.y - p1.y;
    return dx*dx + dy*dy;
}

For (0,0) and (3,4): $dx=3,dy=4$, so $3^2+4^2=9+16=25$. Returns 25. (We compute squared distance to stay in integers and avoid sqrt.)

a is an object → dot to next. a.next is a pointer (to b) → arrow to reach val: a.next->val, which is 20. This is exactly how you walk a linked list: each ->next hops to the next node.

Walk the chain a → b → c → NULL:

• p = &a: sum = 0 + 10 = 10, then p = a.next = &b.
• p = &b: sum = 10 + 20 = 30, then p = b.next = &c.
• p = &c: sum = 30 + 30 = 60, then p = c.next = NULL.
• p == NULL → loop ends. Prints 60.

void increment(struct Node *n) { n->val += 5; }
increment(a.next);   // a.next is ALREADY a pointer (= &b)

a.next is itself an address (it holds &b), so it already matches the struct Node * parameter — no extra & needed. Inside, n aliases b, so n->val += 5 edits b. After the call, b.val = 25. Contrast: to pass the object a you'd write increment(&a); to pass an existing pointer field you pass it as-is.

Given X, which operator? X is a pointer ::: use -> Given X, which operator? X is a plain variable/value ::: use . a.next->val — why dot then arrow? ::: a is a value (dot), a.next is a pointer (arrow) Modify caller's struct from a function — pass what? ::: the address &a, parameter is struct Node * b = a between two structs does what? ::: an independent value copy, not a link