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

Recall & Review

beginner

What is a string in programming?

A string is a sequence of characters stored together. It represents text like words or sentences.

beginner

How is a string stored in memory in C++?

In C++, a string is stored as an array of characters ending with a special character called the null terminator '\0' to mark the end.

beginner

What is the purpose of the null terminator '\0' in C++ strings?

The null terminator '\0' tells the program where the string ends in memory, so it doesn't read extra characters beyond the string.

intermediate

Explain the difference between a C-style string and a C++ std::string.

A C-style string is a character array ending with '\0'. A std::string is a C++ class that manages strings safely and easily, handling memory and size automatically.

intermediate

Why is it important to know how strings are stored in memory?

Knowing string memory helps avoid errors like reading past the end, memory leaks, or incorrect string length calculations.

What character marks the end of a C-style string in memory?

A '\n' (newline)

B ' ' (space)

C '\0' (null terminator)

D ';' (semicolon)

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

Which of these is true about std::string in C++?

A It is a class that manages strings automatically.

B It is a fixed-size character array.

C It does not store the string length.

D It requires manual memory management.

std::string is a class that handles string storage and size automatically.

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

A The string will be empty.

B The program may read garbage data beyond the string.

C The string will be automatically fixed.

D The string length will be zero.

Without '\0', the program doesn't know where the string ends and may read extra memory.

How is the length of a C-style string determined?

A By counting spaces.

B By a stored length variable.

C By the size of the array.

D By counting characters until the null terminator '\0'.

The length is found by counting characters until '\0' is found.

Which is safer to use in C++ for strings?

A std::string

B C-style char arrays

C Raw pointers

D Manual memory allocation

std::string manages memory and size safely, reducing errors.

Describe how a C-style string is stored in memory and why the null terminator is important.

Think about how the program knows where the string ends.

Explain the advantages of using std::string over C-style strings in C++.

Consider what problems std::string solves compared to char arrays.

Practice

1. What does the following C++ code represent?
char str[] = "hello";

easy

A. An array of characters ending with a null character

B. A pointer to a constant string literal

C. A string object from the C++ standard library

D. A dynamically allocated string

Solution

1. Step 1: Understand the declaration type

   The code declares str as a character array initialized with the string "hello".

2. Step 2: Recognize the null terminator in C-style strings

   In C++, character arrays initialized with string literals automatically include a null character '\0' at the end to mark the string's end.

3. Final Answer:

   An array of characters ending with a null character -> Option A

4. Quick Check:

   C-style string = char array + '\0' [OK]

Hint: Remember C strings always end with '\0' null character [OK]

Common Mistakes:

• Confusing array with pointer
• Forgetting the null terminator
• Thinking it's a C++ string object

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

easy

A. char *str = "hello";

B. char str = "hello";

C. char str[] = 'hello';

D. string str = 'hello';

Solution

1. Step 1: Check pointer declaration syntax

   char *str = "hello"; declares a pointer to a string literal correctly.

2. Step 2: Identify errors in other options

   char str = "hello"; uses a single char variable for a string literal, which is invalid.
   char str[] = 'hello'; uses single quotes for multiple characters, which is invalid.
   string str = 'hello'; uses single quotes with string type, which requires double quotes.

3. Final Answer:

   char *str = "hello"; -> Option A

4. Quick Check:

   Pointer to string literal uses char * and double quotes [OK]

Hint: String literals need char* with double quotes [OK]

Common Mistakes:

• Using single quotes for strings
• Assigning string literal to char variable
• Confusing char array and pointer syntax

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

char str[] = "abc";
std::cout << sizeof(str) << std::endl;

medium

A. 3

B. Undefined behavior

C. 5

D. 4

Solution

1. Step 1: Understand sizeof on char array initialized with string

   The array str contains characters 'a', 'b', 'c' plus a null terminator '\0'. So total 4 characters.

2. Step 2: sizeof returns total bytes of array

   Since each char is 1 byte, sizeof(str) returns 4.

3. Final Answer:

   4 -> Option D

4. Quick Check:

   sizeof(char array with "abc") = 4 [OK]

Hint: Count characters plus null terminator for sizeof [OK]

Common Mistakes:

• Ignoring null terminator in size
• Confusing sizeof with string length
• Expecting runtime output instead of compile-time size

4. Identify the error in the following code snippet:

char *str = "hello";
str[0] = 'H';
std::cout << str << std::endl;

medium

A. Output will be empty string

B. Pointer str is not initialized

C. Modifying a string literal causes undefined behavior

D. Syntax error in assignment

Solution

1. Step 1: Understand string literal immutability

   String literals are stored in read-only memory. Modifying them causes undefined behavior.

2. Step 2: Analyze the code's modification attempt

   The code tries to change the first character of the string literal via pointer, which is not allowed.

3. Final Answer:

   Modifying a string literal causes undefined behavior -> Option C

4. Quick Check:

   String literals are immutable in C++ [OK]

Hint: Never modify string literals through pointers [OK]

Common Mistakes:

• Assuming string literals are modifiable arrays
• Ignoring const correctness
• Confusing pointer initialization with mutability

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

char str1[] = "abc";
char *str2 = str1;
str2[1] = 'z';
std::cout << str1 << std::endl;

hard

A. abc

B. azc

C. a\0c

D. Runtime error

Solution

1. Step 1: Understand array and pointer relationship

   str1 is a modifiable character array. str2 points to the same array.

2. Step 2: Modify character via pointer

   Changing str2[1] changes the second character of str1 from 'b' to 'z'.

3. Step 3: Print the modified array

   Printing str1 outputs "azc" reflecting the change.

4. Final Answer:

   azc -> Option B

5. Quick Check:

   Pointer modifies array content directly [OK]

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

Common Mistakes:

• Thinking string literals are modifiable
• Confusing pointer and array copy
• Expecting original string unchanged