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

Recall & Review

beginner

What is a string in C#?

A string in C# is a sequence of characters stored as an object. It is immutable, meaning once created, it cannot be changed.

beginner

What does it mean that strings are immutable in C#?

Immutability means that once a string is created, its content cannot be changed. Any modification creates a new string object.

intermediate

How is a string stored in memory in C#?

Strings are stored as a sequence of UTF-16 characters in the managed heap. Each character uses 2 bytes, and the string object includes metadata like length.

intermediate

What is the role of the string pool in C#?

The string pool is a special area in memory where identical string literals are stored once to save memory. When a string literal is used multiple times, it references the same object in the pool.

intermediate

Why should you use StringBuilder instead of string for many modifications?

Because strings are immutable, modifying them repeatedly creates many new objects. StringBuilder allows efficient modifications by using a mutable buffer.

What happens when you change a character in a C# string?

A The string is deleted

B The original string is modified in place

C The string becomes mutable

D A new string object is created with the change

Strings are immutable, so any change creates a new string object.

Where are string literals stored in C#?

A On the stack

B In the string pool in managed heap

C In CPU registers

D In unmanaged memory

String literals are stored in the string pool, a special area in the managed heap.

How many bytes does each character in a C# string use?

A 2 bytes

B 4 bytes

C 1 byte

D Depends on the character

C# strings use UTF-16 encoding, so each character uses 2 bytes.

Why is StringBuilder preferred for many string changes?

A It stores strings on the stack

B It is immutable

C It uses less memory by modifying in place

D It automatically pools strings

StringBuilder uses a mutable buffer to efficiently modify strings without creating new objects.

What does immutability of strings help with?

A Thread safety and predictable behavior

B Faster string modifications

C Reducing string length

D Changing characters directly

Immutability ensures strings cannot change unexpectedly, making code safer and easier to understand.

Explain how strings are stored and managed in memory in C#.

Think about how characters are encoded and where string objects live.

Describe why strings are immutable in C# and how this affects string manipulation.

Consider what happens when you try to change a string.

Practice

1. What does the string type in C# represent in memory?

easy

A. A list of integers representing ASCII codes

B. A sequence of characters stored as Unicode values

C. A mutable array of bytes

D. A pointer to a memory address without data

Solution

1. Step 1: Understand string storage in C#

   C# strings store characters as Unicode, allowing international text.

2. Step 2: Compare options with string behavior

   Only A sequence of characters stored as Unicode values correctly describes strings as sequences of Unicode characters.

3. Final Answer:

   A sequence of characters stored as Unicode values -> Option B

4. Quick Check:

   string = Unicode characters [OK]

Hint: Remember C# strings are Unicode sequences, not byte arrays [OK]

Common Mistakes:

• Thinking strings are mutable arrays
• Confusing ASCII with Unicode
• Assuming strings are just pointers

2. Which of the following is the correct way to declare and initialize a string in C#?

easy

A. string s = "hello";

B. string s = hello;

C. string s = 'hello';

D. string s = "hello";
char[] arr = s;

Solution

1. Step 1: Check string literal syntax

   In C#, string literals use double quotes, so "hello" is correct.

2. Step 2: Validate each option

   string s = 'hello'; uses single quotes (for chars), B misses quotes, D tries to assign string to char array directly (invalid).

3. Final Answer:

   string s = "hello"; -> Option A

4. Quick Check:

   Strings use double quotes in C# [OK]

Hint: Use double quotes for strings, single quotes for chars [OK]

Common Mistakes:

• Using single quotes for strings
• Forgetting quotes around text
• Assigning string directly to char array

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

string s1 = "hello";
string s2 = "hello";
Console.WriteLine(object.ReferenceEquals(s1, s2));

medium

A. true

B. false

C. Compilation error

D. Runtime exception

Solution

1. Step 1: Understand string interning in C#

   String literals with same content are interned and share the same reference.

2. Step 2: Check ReferenceEquals for s1 and s2

   Since both are "hello" literals, ReferenceEquals returns true.

3. Final Answer:

   true -> Option A

4. Quick Check:

   String literals share references = true [OK]

Hint: String literals with same text share references [OK]

Common Mistakes:

• Assuming ReferenceEquals returns false for equal strings
• Confusing value equality with reference equality
• Expecting runtime errors

4. Identify the error in the following C# code snippet:

string s = "test";
s[0] = 'T';
Console.WriteLine(s);

medium

A. Runtime error: index out of range

B. Syntax error: missing semicolon

C. Strings are immutable; cannot assign to s[0]

D. No error; output is "Test"

Solution

1. Step 1: Check string mutability in C#

   Strings are immutable; individual characters cannot be changed by index.

2. Step 2: Analyze assignment to s[0]

   Assigning to s[0] causes a compile-time error because strings cannot be modified this way.

3. Final Answer:

   Strings are immutable; cannot assign to s[0] -> Option C

4. Quick Check:

   Strings immutable = assignment error [OK]

Hint: Remember strings cannot be changed character-by-character [OK]

Common Mistakes:

• Trying to modify string characters directly
• Expecting runtime error instead of compile error
• Assuming strings behave like char arrays

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

string s = "hello";
string t = s + " world";
Console.WriteLine(s);
Console.WriteLine(t);

Choose the correct output representation.

hard

A. hello world
hello

B. hello world
hello world

C. hello
world

D. hello
hello world

Solution

1. Step 1: Understand string concatenation and immutability

   Concatenation creates a new string; original string s remains unchanged.

2. Step 2: Trace the output statements

   Console.WriteLine(s) prints hello; Console.WriteLine(t) prints hello world.

3. Final Answer:

   hello hello world -> Option D

4. Quick Check:

   Original string unchanged, new string created [OK]

Hint: Concatenation creates new string; original stays same [OK]

Common Mistakes:

• Assuming original string changes after concatenation
• Mixing order of printed strings
• Confusing string references with values