String Basics and Memory Representation in DSA C++ - Build from Scratch

String Basics and Memory Representation

📖 Scenario: Imagine you are working with a simple text editor that stores and processes words. Understanding how strings are stored and accessed in memory helps you manage text efficiently.

🎯 Goal: You will create a string variable, check its length, access characters by index, and print the string to see how it looks in memory representation.

📋 What You'll Learn

Create a string variable with a specific word

Create an integer variable to store the string length

Use a loop to access each character of the string by index

Print the string and its characters one by one

💡 Why This Matters

🌍 Real World

Text editors, word processors, and many software use strings to store and manipulate text data.

💼 Career

Understanding string basics is essential for programming tasks like parsing input, formatting output, and handling user data.

1

Create a string variable

Create a std::string variable called word and set it to the exact value "hello".

DSA C++

# Your code here

Hint

Use std::string to create the variable and assign the word "hello" exactly.

2

Create a length variable

Add an int variable called length and set it to the length of word using word.length().

DSA C++

#include 
#include 

int main() {
    std::string word = "hello";
    // Create an int variable length and assign word.length()
    
    return 0;
}

Hint

Use word.length() to get the number of characters in the string.

3

Access characters by index

Write a for loop using int i = 0; i < length; i++ to access each character of word by index word[i].

DSA C++

#include 
#include 

int main() {
    std::string word = "hello";
    int length = word.length();
    // Use a for loop to access each character by index
    
    return 0;
}

Hint

Use a for loop from 0 to length - 1 and access characters with word[i].

4

Print the string and its characters

Print the full word using std::cout. Then inside the loop, print each character c on a new line.

DSA C++

#include 
#include 

int main() {
    std::string word = "hello";
    int length = word.length();
    // Print the full word
    std::cout << word << std::endl;
    // Print each character on a new line inside the loop
    for (int i = 0; i < length; i++) {
        char c = word[i];
        
    }
    return 0;
}

Hint

Use std::cout << word << std::endl; to print the full string, then print each character inside the loop with std::cout << c << std::endl;.

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