Intuition The ONE core idea of this whole topicA C "string" is not a special type — it is just a row of memory boxes (a char array) with an
invisible STOP box ('\0') marking the end. Every string function walks that row box by box
until it meets the STOP; if the STOP is missing or you write into a box you don't own, C never
warns you.
Before you can read strlen, strcpy, or sprintf in the parent note , every tiny symbol on those lines must first mean something. This page builds each one from absolute zero, in the order they lean on each other.
char
A char is the smallest storage box in C. It holds exactly one byte — a whole number from
0 255 pretend that number is a letter using a lookup table called ASCII .
The letter 'A' is not really stored as a shape. It is stored as the number 65 'A' are C's way of saying "give me the ASCII number for this letter" so you don't have to memorise
that 'A' is 65
Intuition Why a box that is really a number?A computer only stores numbers. Letters are a human idea. ASCII is the agreed dictionary that turns
the number 72 H on your screen and back. So char c = 'H'; and char c = 72; store the
exact same byte — the topic needs this because the STOP box is really the number zero , written
'\0', and you must see it is a number to understand why counting stops there.
Reveal check:
'0' (the digit) versus '\0' (the terminator) — same or different?Totally different: '0' is the number 48 , '\0' is the number 0 .
An array is several boxes of the same kind placed next to each other in memory , so we can
reach them by a number of steps from the front . char s[6]; means "6 char boxes in a row."
The number in s[i] is the index — how many boxes to walk from the start. It begins at 0 s[0], not s[1]. So a 6-box array has valid indices s[0] through s[5] — the last
index is always size minus one .
Intuition Why start counting at 0?The index is really "how far to move," and the first box needs zero movement . This is why the
topic keeps warning "size = length + 1": box s[5] in a size-6 array is the last legal box, and the
STOP must fit inside it.
Common mistake Off-by-one: the last index is size − 1Why it feels right: "6 boxes, so s[6] is the sixth box." The trap: s[6] is the seventh
box — one past the end. Touching it is writing into your neighbour's mailbox. Legal indices are
s[0] … s[5].
Reveal check:
In char s[6], what is the highest legal index? s[5] (size − 1).
Definition Null terminatorThe null terminator is one char box holding the number 0 '\0'. It is the
invisible marker that says "the word ends here." It is not printed; it is a signal.
A row of boxes has no built-in sign telling you where the word stops. So C plants a STOP box right
after the last real letter. Every string function's job is: walk forward until you meet the STOP.
Intuition Why the topic can't work without itWithout the STOP, strlen would count forever into random memory; strcpy would never know when to
stop copying. The whole topic is "manage this one byte correctly." Miss it and you get
Undefined Behaviour in C .
Reveal check:
Why can't a program tell where a string ends without '\0'? A bare row of char boxes stores no length; the '\0' is the only end marker.
Definition String literalDouble quotes "Hi" are a string literal : C lays out the boxes H, i, and — for free — a
'\0' at the end. Single quotes 'H' are just one char, no STOP added.
So "Hi" silently occupies 3 boxes even though you typed 2 letters. This hidden extra box is the
+1 you keep hearing about.
Reveal check:
How many boxes does the literal "cat" need? 4 — three letters plus one '\0'.
char *)
A pointer is a box that holds an address — the location of the first char box, like a house
number on a street. char *p means "p remembers where a row of chars begins."
Crucially, a pointer holds only the starting address . It does not remember how many boxes follow.
That is exactly why C needs the '\0' — the pointer alone can't tell you where to stop. Deep dive:
Pointers in C .
sizeof on a pointer lies about the buffer
Why it feels right: sizeof buf worked to get the array size. The trap: once buf becomes a
char * (e.g. a function parameter), sizeof buf gives the pointer's size (often 8 Arrays vs Pointers for why an array "decays" to a pointer. Fix: pass the size
across function boundaries.
Reveal check:
Does a char * remember how many characters follow its address? No — only the start; the '\0' marks the end instead.
size_t
size_t is the type C uses for sizes and indices — a whole number that is never negative
(you can't have a negative box count). The loop variables n, i, j in the parent's code are
this type.
Reveal check:
Why use size_t and not int for a length? A length or index is never negative; size_t is the unsigned counting type.
Definition The two symbols people confuse= means store this value ("put the right side into the left box"). != means is not equal
to — a yes/no question. while (test) body means repeat the body as long as the test is true .
The parent's core line is while (s[n] != '\0') n++; — read it as: "while the box I'm looking at is
not the STOP box, count it and step to the next." This is the shape of every string routine.
(dst[i] = src[i]) != '\0' is one clever line
The inner dst[i] = src[i] copies a box and hands back the copied value; the outer != '\0'
then tests that value. So the terminator is copied first, then the test fails — the STOP lands
safely in dst before we stop.
Reveal check:
What is the difference between = and !=? = stores a value; != asks "are these unequal?".
O ( n ) O ( n ) the work grows in step with the size n strlen must touch every box up to the STOP — n n Time Complexity .
This is why calling strlen (or strcat, which secretly scans to find the end) inside a loop can
become slow: each call re-walks the whole row.
Reveal check:
Why is strlen O ( n ) With no stored length it must scan box by box until '\0' — that is n
Definition Buffer overflowA buffer overflow is when you write past the last legal box of an array. Because C never
checks bounds, the extra bytes spill into neighbouring memory. The consequence is
Buffer Overflow & Memory Safety / Undefined Behaviour in C — crashes or exploits.
The classic cause is forgetting the STOP box's +1: char buf[5]; strcpy(buf, "Hello"); needs 6
boxes into 5.
Reveal check:
What happens in C if you write one box past an array's end? Undefined behaviour — no bounds check; may corrupt memory, crash, or be exploited.
null terminator zero byte
string literal adds STOP for free
pointer holds only the start address
while loop walks until STOP
buffer overflow if no room
Do you already have each piece? Reveal only after you answer aloud.
A char really stores what? One byte — a number 0 255
The first element of char s[6] is written how, and the last? s[0] first, s[5] last (index = size − 1).
What is '\0' and its numeric value? The null terminator, a char holding the number 0
How many boxes does "cat" occupy? 4 — three letters plus the '\0'.
Difference between '0' and '\0'? '0' is 48 '\0' is 0
What does a char * store, and what does it NOT store? It stores the start address; it does NOT store the length.
Why can sizeof buf be wrong? If buf is a pointer, sizeof gives pointer size, not the buffer's size.
Read while (s[n] != '\0') n++; in plain words. While this box is not the STOP box, count it and step forward.
Why is strlen O ( n ) No stored length, so it scans every box up to '\0'.
What is a buffer overflow in one line? Writing past the last legal box of an array — undefined behaviour in C.
