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

Before you can read a single line of the parent note, you need to already "own" a small pile of symbols and words. The parent quietly assumes you know them. This page builds every one of them from zero, in an order where each brick rests on the brick below it.

0. The starting picture: a labelled slot in memory

Look at the figure: the pale-yellow box is a house at address 1000. We nicknamed it age, and inside it the value 19 lives. The name is a human label; the address is where it actually is. Hold this apart in your head — the whole . vs -> distinction is born from it.

1. Type — "what shape of thing fits in the box"

Why does the topic need this? Because a structure's whole selling point is mixing types — a name (char[20]), a roll number (int), and marks (float) in one package. If every value had to be the same type, you'd just use an array. So "type" is the first idea we must own.

2. Array — "many same-type boxes in a row, reached by number"

The figure shows name[20] as 20 chalk-blue cells in a row. You point at one with a number: name[3]. This is the cousin of a structure — see Arrays vs Structures. Contrast:

The parent's char name[20] member is an array living inside a structure — that's why you write strcpy(s.name, "Asha") and not s.name = "Asha" (you can't reassign a whole array by name).

3. The address-of operator & — "give me the house number"

Why does the topic need &? Because the parent's Example 2 calls grow(&a) — it passes the address of a so the function can reach back and edit the original. Without &, the function would only get a copy and its edits would vanish.

4. Pointer & the dereference * — "a note that says where"

In the figure, the pink box p sits at address 2000 but stores the number 1000 — and an arrow drawn from p reaches over to the box at 1000. That drawn arrow is why the operator is literally written ->.

So & and * are opposites:

$\ast (\&x)=x$

Take the address of x (&x), then follow it back (*), and you land on x again — you went there and came home.

This is the single most important derivation the parent uses — and now every symbol in it (*, ., the parentheses, the arrow) has been earned from zero.

5. The dot . — "open THIS box, grab THAT compartment"

The figure shows one Student box with three stacked compartments — name at offset 0, roll a bit further along, marks further still. The dot is you reaching into a box already in your hands. No travelling, no arrow.

6. Braces { } and the semicolon ; — "the box's blueprint ends here"

Prerequisite map

Read it bottom-up: houses → variables → types → (arrays + structs) → address-of → pointers → dereference → the arrow, all feeding the parent topic. See also Pointers in C for the pointer half and Linked Lists for where -> becomes unavoidable.

Equipment checklist

Test yourself — you're ready for the parent note only if each of these comes instantly.

Connections

• Pointers in C — the &, *, and arrow machinery lives here in full.
• Arrays vs Structures — same-type-by-number vs mixed-type-by-name.
• Linked Lists — the first place -> becomes essential.
• typedef — lets you drop the word struct when naming the type.
• Memory Alignment & Padding — why offsets have gaps.
• Passing Structures to Functions — why &a matters for editing.