String Basics and Memory Representation in DSA C++

Mental Model

A string is a sequence of characters stored one after another in memory, ending with a special marker to show where it stops.

Analogy: Think of a string like a row of mailboxes, each holding one letter, lined up in a street. The last mailbox has a special flag to show the end of the street.

S -> t -> r -> i -> n -> g -> \0
↑
start pointer

Dry Run Walkthrough

Input: string: "Hi!" stored in memory

Goal: Understand how each character is stored in order and how the string ends with a special marker

Step 1: Store 'H' at the first memory cell

H -> null
↑
start pointer

Why: We start storing the first character at the beginning

Step 2: Store 'i' in the next memory cell

H -> i -> null
↑

Why: Characters are stored one after another in order

Step 3: Store '!' in the next memory cell

H -> i -> ! -> null
↑

Why: Continue storing characters sequentially

Step 4: Store '\0' (null terminator) to mark end of string

H -> i -> ! -> \0
↑

Why: Null terminator shows where the string ends in memory

Result:

H -> i -> ! -> \0
String ends with null terminator to mark end

Annotated Code

DSA C++

#include <iostream>
using namespace std;

class SimpleString {
public:
    char data[10]; // fixed size array to hold characters

    void setString(const char* input) {
        int i = 0;
        while (input[i] != '\0' && i < 9) {
            data[i] = input[i]; // copy each character
            i++;
        }
        data[i] = '\0'; // add null terminator
    }

    void printString() {
        int i = 0;
        while (data[i] != '\0') {
            cout << data[i]; // print each character
            i++;
        }
        cout << "\n";
    }
};

int main() {
    SimpleString s;
    s.setString("Hi!");
    s.printString();
    return 0;
}

while (input[i] != '\0' && i < 9) {

copy characters one by one until null terminator or array limit

data[i] = input[i];

store current character in data array

data[i] = '\0';

add null terminator to mark end of string

while (data[i] != '\0') {

print characters until null terminator is reached

cout << data[i];

output current character

Output

Hi!

Complexity Analysis

Time: O(n) because we copy and print each character once, where n is string length

Space: O(n) because we store each character plus one for the null terminator

vs Alternative: Compared to dynamic strings, fixed arrays use constant space but limit length; dynamic strings use more space but can grow

Edge Cases

Empty string input ""

Stores only the null terminator, prints nothing

DSA C++

while (input[i] != '\0' && i < 9) {

String longer than array size (e.g., "HelloWorld!")

Copies only up to array limit minus one, then adds null terminator to avoid overflow

DSA C++

while (input[i] != '\0' && i < 9) {

When to Use This Pattern

When you see problems about storing or manipulating text character by character, think about how strings are stored in memory with a null terminator.

Common Mistakes

Mistake: Forgetting to add the null terminator at the end of the string
Fix: Always add '\0' after copying characters to mark the string end

Mistake: Copying characters beyond the array size causing overflow
Fix: Limit copying to array size minus one to leave space for null terminator

Summary

A string is a sequence of characters stored in memory ending with a special null character.

Use this when you need to store or process text in low-level memory structures.

Remember the null terminator marks where the string ends so operations know when to stop.

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