String Basics and Memory Representation in DSA C - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is a string in C?

A string in C is an array of characters ending with a special character called the null terminator '\0' which marks the end of the string.

beginner

Why do C strings end with a null terminator '\0'?

The null terminator '\0' tells functions where the string ends in memory since C does not store string length separately.

beginner

How is a string stored in memory in C?

A string is stored as a sequence of characters in consecutive memory locations, followed by a null terminator '\0'.

intermediate

What happens if a string in C does not have a null terminator?

Without a null terminator, functions that process strings may read beyond the intended end, causing undefined behavior or errors.

beginner

How can you declare and initialize a string in C?

You can declare a string as a char array with initialization like: char str[] = "hello"; which automatically adds the null terminator.

What character marks the end of a string in C?

A ' ' (space)

B '\n' (newline)

C '\0' (null terminator)

D '\t' (tab)

The null terminator '\0' marks the end of a string in C.

How is a string stored in memory in C?

A As a sequence of characters in contiguous memory with a null terminator

B As a number representing the string length

C As a linked list of characters

D As a pointer to a string object

Strings in C are stored as contiguous characters followed by a null terminator.

What happens if a C string is missing the null terminator?

A Functions may read beyond the string causing errors

B The string is treated as empty

C The string length is calculated correctly anyway

D The string is automatically fixed by the compiler

Without a null terminator, string functions may read memory beyond the string causing undefined behavior.

Which of these is a correct way to declare a string in C?

A char str = "hello";

B char str[] = "hello";

C string str = "hello";

D char str[5] = 'hello';

char str[] = "hello"; declares a char array initialized with the string and null terminator.

What is the size in memory of the string "cat" in C?

A Depends on the system

B 3 bytes

C 5 bytes

D 4 bytes

The string "cat" has 3 characters plus 1 null terminator, so 4 bytes total.

Explain how strings are represented and stored in memory in C.

Think about how C knows where the string ends.

Describe the importance of the null terminator in C strings and what can go wrong if it is missing.

Consider how string functions find the string length.

Practice

1. Which of the following correctly describes how strings are stored in C?

easy

A. As an array of characters ending with a null character '\0'.

B. As a linked list of characters.

C. As a single integer representing the string length.

D. As a floating-point number encoding characters.

Solution

1. Step 1: Understand C string storage

   In C, strings are stored as arrays of characters with a special null character '\0' marking the end.

2. Step 2: Compare options with this knowledge

   Only As an array of characters ending with a null character '\0'. correctly states this; others describe different data structures or types.

3. Final Answer:

   As an array of characters ending with a null character '\0'. -> Option A

4. Quick Check:

   C strings end with '\0' = A [OK]

Hint: Remember C strings always end with '\0' to mark their end [OK]

Common Mistakes:

• Thinking strings are linked lists in C
• Assuming strings store length explicitly
• Confusing string storage with other data types

2. Which of the following is the correct way to declare and initialize a string literal in C?

easy

A. char str = "hello";

B. char str[5] = 'hello';

C. char str[] = "hello";

D. char str[] = {'h','e','l','l','o'};

Solution

1. Step 1: Check string declaration syntax

   In C, to store a string literal, use an array of chars with double quotes and square brackets.

2. Step 2: Evaluate each option

   A uses char (single char) with double quotes (wrong). B uses single quotes for multiple chars (wrong). D misses null terminator '\0'. C correctly declares and initializes with null terminator.

3. Final Answer:

   char str[] = "hello"; -> Option C

4. Quick Check:

   Use char array with double quotes = C [OK]

Hint: Use char array with double quotes for string literals [OK]

Common Mistakes:

• Using single quotes for strings
• Not including null terminator
• Declaring char variable instead of array

3. What will be the output of the following C code?

char str[] = "abc";
printf("%c", str[3]);

medium

A. c

B. \0 (null character, prints nothing visible)

C. a

D. Runtime error

Solution

1. Step 1: Understand string indexing and null terminator

   The string "abc" is stored as {'a','b','c','\0'}. Index 3 is the null character '\0'.

2. Step 2: Determine printf output for str[3]

   Printing '%c' with '\0' prints nothing visible (null character), no error occurs.

3. Final Answer:

   \0 (null character, prints nothing visible) -> Option B

4. Quick Check:

   Index 3 is '\0' = A [OK]

Hint: Remember string ends with '\0' at last index + 1 [OK]

Common Mistakes:

• Assuming str[3] is 'a' or 'c'
• Expecting runtime error for accessing null char
• Confusing null char with printable character

4. Identify the error in the following C code snippet:

char str[5] = "hello";
str[5] = '!';

medium

A. Array index out of bounds when assigning str[5].

B. Incorrect use of single quotes for string.

C. Missing null terminator in string initialization.

D. No error, code runs fine.

Solution

1. Step 1: Analyze array size and indexing

   Array str has size 5, valid indices are 0 to 4. Accessing str[5] is out of bounds.

2. Step 2: Check string initialization and assignment

   "hello" fits exactly 5 chars including '\0'? No, 'hello' needs 6 chars including '\0'. But main error is str[5] assignment which is invalid index.

3. Final Answer:

   Array index out of bounds when assigning str[5]. -> Option A

4. Quick Check:

   Index 5 invalid for size 5 array = D [OK]

Hint: Array indices go from 0 to size-1 only [OK]

Common Mistakes:

• Ignoring out of bounds access
• Confusing array size with string length
• Thinking str[5] is valid index

5. Given the code below, what will be the output?

char str1[] = "abc";
char *str2 = str1;
str2[1] = 'z';
printf("%s", str1);

hard

A. abc

B. Runtime error

C. a\0c

D. azc

Solution

1. Step 1: Understand pointer and array relation

   str2 points to str1 array. Changing str2[1] changes str1[1].

2. Step 2: Apply the character change and print

   str2[1] = 'z' changes 'b' to 'z'. Printing str1 shows "azc".

3. Final Answer:

   azc -> Option D

4. Quick Check:

   Pointer modifies original array = B [OK]

Hint: Pointer to array modifies original string content [OK]

Common Mistakes:

• Thinking str1 remains unchanged
• Expecting null character insertion
• Assuming runtime error due to pointer