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

String Basics and Memory Representation

📖 Scenario: Imagine you are working on a simple program that stores and displays a person's name. Understanding how strings are stored in memory is important for managing text data efficiently.

🎯 Goal: You will create a string variable to hold a name, set a maximum length for the string, copy the name into the string, and then print the stored name to see how strings work in C.

📋 What You'll Learn

Create a character array to hold a name

Define a constant for the maximum length of the string

Copy a given name into the character array safely

Print the stored name

💡 Why This Matters

🌍 Real World

Understanding string basics and memory representation is essential for working with text data in low-level programming, embedded systems, and performance-critical applications.

💼 Career

Many programming jobs require knowledge of how strings are stored and manipulated in memory, especially in systems programming, firmware development, and software optimization roles.

1

Create a character array for the name

Create a character array called name with space for 20 characters.

DSA C

# Your code here

Hint

Use char name[20]; to create space for 20 characters.

2

Define the maximum length constant

Define a constant integer called MAX_LENGTH and set it to 20.

DSA C

char name[20];
# Your code here

Hint

Use const int MAX_LENGTH = 20; to define the maximum length.

3

Copy the name into the character array

Use strncpy to copy the string "Alice" into name using MAX_LENGTH as the limit.

DSA C

char name[20];
const int MAX_LENGTH = 20;
// Your code here

Hint

Use strncpy(name, "Alice", MAX_LENGTH - 1); and then set name[MAX_LENGTH - 1] = '\0'; to ensure the string ends properly.

4

Print the stored name

Use printf to print the string stored in name.

DSA C

#include 
#include 

char name[20];
const int MAX_LENGTH = 20;

strncpy(name, "Alice", MAX_LENGTH - 1);
name[MAX_LENGTH - 1] = '\0';

// Your code here

Hint

Use printf("%s\n", name); to print the string.

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