How Strings Work Differently Across Languages in DSA C - Visual Walkthrough

Concept Flow - How Strings Work Differently Across Languages

Declare string variable

↓

Allocate memory for characters

↓

Store characters in memory

↓

Add null terminator '\0'

↓

Use pointer to access characters

↓

Modify characters via pointer (if mutable)

↓

Read characters until '\0' to print or process

This flow shows how C strings are arrays of characters ending with a null character, accessed via pointers.

Execution Sample

DSA C

char str[] = "Hi";
printf("%s", str);

Declares a string as a char array with 'H', 'i', and '\0', then prints it.

Execution Table

Step	Operation	Memory Allocation	Pointer State	Visual State
1	Declare char array str	Allocate 3 bytes	str points to first byte	[ ][ ][ ]
2	Store 'H' at str[0]	Memory unchanged	Pointer unchanged	[H][ ][ ]
3	Store 'i' at str[1]	Memory unchanged	Pointer unchanged	[H][i][ ]
4	Store '\0' at str[2]	Memory unchanged	Pointer unchanged	[H][i][\0]
5	printf reads from str	Memory unchanged	Pointer moves from str[0] to str[2]	Output: Hi
6	End of string reached at '\0'	No change	Pointer stops	String fully read

💡 Execution stops after null terminator '\0' is found, marking string end.

Variable Tracker

Variable	Start	After Step 2	After Step 3	After Step 4	Final
str	Uninitialized	Points to [H][ ][ ]	Points to [H][i][ ]	Points to [H][i][\0]	Points to [H][i][\0]
Pointer in printf	Not used	Not used	Not used	Not used	Moves from str[0] to str[2] reading chars

Key Moments - 3 Insights

Why does the string end at '\0' and not at the array length?

Because C strings use the null character '\0' to mark the end, so functions like printf stop reading when they find '\0' (see execution_table step 6).

Can we change characters in the string after declaration?

Yes, if the string is declared as a char array like here, characters can be modified via the pointer. This differs from immutable strings in some other languages.

Why do we need to allocate one extra byte for '\0'?

Because the null terminator '\0' marks the end of the string, so the array must have space for all characters plus this extra byte (see execution_table step 1).

Visual Quiz - 3 Questions

Look at the execution_table, what character is stored at str[1] after step 3?

A 'H'

B 'i'

C '\0'

D Uninitialized

💡 Hint

Check the 'Visual State' column at step 3 in the execution_table.

At which step does the pointer used by printf reach the end of the string?

A Step 4

B Step 5

C Step 6

D Step 2

💡 Hint

Look at the 'Pointer State' and 'Operation' columns in execution_table steps 5 and 6.

If we declared str as a pointer to a string literal instead of a char array, what would change?

A The string would be immutable and modifying characters causes undefined behavior

B The string would not have a '\0' terminator

C We could modify characters freely

D The pointer would not point to memory

💡 Hint

Recall that string literals in C are stored in read-only memory and cannot be safely modified.

Concept Snapshot

C strings are arrays of chars ending with '\0'.
They require memory allocation for all chars plus '\0'.
Accessed via pointers, reading stops at '\0'.
Strings declared as arrays are mutable; string literals are not.
This differs from immutable strings in other languages.

Full Transcript

In C, strings are arrays of characters ending with a special null character '\0'. When you declare a string like char str[] = "Hi";, memory is allocated for each character plus one extra byte for '\0'. The pointer str points to the first character. Functions like printf read characters starting at str until they find '\0', which marks the end. Unlike some languages where strings are immutable, C strings declared as arrays can be modified by changing characters via the pointer. This flow and memory layout differ from other languages where strings may be objects or immutable sequences.