String Basics and Memory Representation in DSA C++ - Practice Problems & Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of String Concatenation and Size

What is the output of the following C++ code snippet?

DSA C++

std::string s1 = "Hello";
std::string s2 = "World";
std::string s3 = s1 + " " + s2;
std::cout << s3 << " " << s3.size();

A Hello World 11

B HelloWorld 10

C Hello World 10

D HelloWorld 11

💡 Hint

Remember that adding a space " " between s1 and s2 increases the length by 1.

The string s3 is formed by concatenating s1, a space, and s2. So s3 is "Hello World" which has 11 characters including the space.

🧠 Conceptual

intermediate

Understanding String Memory Layout

Which statement correctly describes how a std::string stores its characters in memory?

A std::string stores characters in a contiguous memory block with a null terminator at the end.

B std::string stores characters in a linked list of nodes, each holding one character.

C std::string stores characters in a hash map with indices as keys.

D std::string stores characters in a contiguous memory block but does not guarantee a null terminator.

💡 Hint

Think about how std::string differs from C-style strings.

std::string stores characters contiguously but does not guarantee a null terminator. It manages size internally and may or may not have a null terminator for compatibility.

🔧 Debug

advanced

Identify the Error in String Initialization

What error does the following C++ code produce?

DSA C++

char* s = "Hello";
s[0] = 'h';

A Compilation error: cannot assign to string literal

B No error, output will be 'hello'

C Runtime error: segmentation fault due to modifying read-only memory

D Compilation error: missing semicolon

💡 Hint

String literals are stored in read-only memory in modern C++.

The pointer s points to a string literal which is stored in read-only memory. Modifying it causes a runtime segmentation fault.

❓ Predict Output

advanced

Output of String Substring and Comparison

What is the output of this C++ code?

DSA C++

std::string s = "datastructures";
std::string sub = s.substr(4, 6);
if (sub == "struct") std::cout << "Match"; else std::cout << "No Match";

A No Match

B Match

C Compilation error

D Runtime error

💡 Hint

Check the substring starting at index 4 with length 6.

The substring from index 4 with length 6 is "struct", so the comparison is true and prints "Match".

🧠 Conceptual

expert

String Copy and Memory Sharing in C++

Which statement about copying std::string objects is true in modern C++ implementations?

A Copying a std::string always creates a new independent copy of the characters in memory.

B Copying a std::string shares the same character buffer between copies until one is modified (copy-on-write).

C Copying a std::string creates a shallow copy that can cause dangling pointers.

D Copying a std::string is not allowed and causes a compilation error.

💡 Hint

Modern C++ std::string implementations do not use copy-on-write.

Modern C++ std::string implementations create a new copy of the characters when copied to avoid sharing mutable state.

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