C++ String Manipulation for Interviews: The Definitive Guide

C++ gives you more string tools than you'll ever need in an interview, and exactly enough traps to tank an offer you spent three months preparing for. The bugs that hurt the most don't produce compiler warnings. They compile cleanly, run silently, and produce wrong answers at 11pm the night before you interview. This guide covers what each method costs, where the quiet landmines sit, and the three patterns that crack most string problems.

---

Which String Type Are You, Actually?

You have three options. Each has a moment.

std::string owns its memory, manages its lifetime, and supports mutation. Use it for almost everything in interviews. When you write string s = "hello", the constructor copies those bytes into a heap allocation the object controls.

std::string_view (C++17) is a read-only, non-owning view into an existing sequence of characters. It carries a pointer and a length. It never allocates. Use it for function parameters when you only need to read, and use it to avoid the copy cost of substr(). The critical caveat: a string_view must not outlive the string it points into. This is the part everyone forgets.

const char* is a pointer to a null-terminated array. You will encounter it when calling C APIs or when a string literal like "hello" hasn't been wrapped yet. Avoid it in interview code unless you are forced to interface with something that requires it. You are not impressing anyone with raw pointer arithmetic at this stage.

The interview default is std::string. Reach for string_view when you want to call out a performance optimization.

---

Memorize These, Ignore the Rest

The full std::string API runs to dozens of overloads. These are the ones that matter.

Method	What it does	Cost
s.size() / s.length()	Number of characters	O(1)
s[i]	Access character at index, no bounds check	O(1)
s.at(i)	Access with bounds check, throws out_of_range	O(1)
s.find(t)	First position of substring t, or npos	O(n·m) worst case
s.rfind(t)	Last position of substring t	O(n·m) worst case
s.substr(pos, len)	Copy of len characters starting at pos	O(len)
s.replace(pos, len, t)	Replace len chars at pos with t	O(n)
s.erase(pos, len)	Remove len chars starting at pos	O(n)
s.insert(pos, t)	Insert t before pos	O(n)
s += t	Append t in place	Amortized O(len of t)
s.compare(pos, len, t)	Lexicographic compare without creating a copy	O(len)
s.reserve(n)	Pre-allocate capacity for n chars	O(1) or O(n)
s.empty()	True if size is zero	O(1)

substr() copies. That is not optional. Every call allocates a new string. If you want to compare a slice without copying, use s.compare(pos, len, t) or wrap the range in a string_view. Your interviewer will notice if you call substr in a tight loop.

---

The size_t Trap Nobody Warns You About

s.size() returns size_t, which is an unsigned integer type. On 64-bit systems it is uint64_t. This produces a specific class of bugs that compile without warnings and produce wrong answers in a way that will make you question your entire career.

string s = "hello";

// WRONG: size_t underflow
for (size_t i = s.size() - 1; i >= 0; i--) {
    // When i reaches 0 and you decrement, i wraps to ~0ULL.
    // This is an infinite loop. You will never see i < 0.
}

When i reaches zero and you decrement an unsigned integer, it wraps around to the maximum value of uint64_t. Which is 18,446,744,073,709,551,615. Your loop will run until the heat death of the universe, or until your interviewer politely asks why the program hasn't terminated. Cast to int whenever you do arithmetic on size() in a loop.

for (int i = (int)s.size() - 1; i >= 0; i--) { }

The same wrapping behavior affects find(). It returns size_t, and string::npos is defined as (size_t)-1, the maximum unsigned value. The correct pattern:

if (s.find('x') != string::npos) { /* found */ }

The size_t underflow compiles. It runs. It loops forever. You start print-debugging. You check the logic three times. It's the cast.

---

tolower, isalpha, and the Signed Char Landmine

The <cctype> functions like isalpha, isdigit, tolower, and toupper take int arguments. The C standard says their behavior is undefined if you pass a value outside the range of unsigned char or the value EOF. On platforms where char is signed (most of them), characters above 127 produce negative values when treated as int, which is exactly that undefined range.

Most interview problems use ASCII, so this rarely bites you in practice. But if your interviewer asks "is this safe for non-ASCII input?" and you don't know the answer, that's a missed signal.

// CORRECT
char c = s[i];
if (isalpha(static_cast<unsigned char>(c))) { }

// ALSO CORRECT for ASCII-only interview problems (most are)
if (c >= 'a' && c <= 'z') { }   // unambiguous, no cast needed
if (c >= 'A' && c <= 'Z') { }

For case conversion on a whole string, use std::transform with the cast baked in:

transform(s.begin(), s.end(), s.begin(),
          [](unsigned char c) { return tolower(c); });

---

stoi Throws. to_string Rounds. Know Both.

stoi, stol, stoll, stod, and their siblings all throw exceptions on failure. In interviews where you control the input, that is usually fine. Know what throws and what doesn't so you can explain it if asked.

int n = stoi("42");         // works
int n = stoi("  42  ");     // works: leading whitespace is skipped
int n = stoi("42abc");      // works: stops at 'a', returns 42
int n = stoi("abc");        // throws std::invalid_argument
int n = stoi("9999999999"); // throws std::out_of_range

The third case ("42abc") surprises people. It returns 42 and silently ignores everything after the first non-digit. Whether that is what you want depends entirely on the problem.

Going the other direction:

string s = to_string(42);     // "42"
string s = to_string(3.14);   // "3.140000" (6 decimal digits by default)

If you need hex or binary, to_string will not help you. Use stringstream with manipulators.

stringstream ss;
ss << hex << 255;
string hex_str = ss.str();  // "ff"

---

String Concatenation and the O(n²) Tax

Each += may trigger a reallocation and copy. In practice, std::string grows geometrically, so amortized performance is fine. But "fine on average" is not the same as "optimal," and calling that distinction out is the difference between a 3 and a 4 on the coding dimension.

If you know the final length in advance, call reserve() first.

string result;
result.reserve(total_length);
for (const string& piece : pieces) {
    result += piece;
}

Without reserve(), you're relying on the growth factor. With it, you guarantee no reallocation. That one extra line signals that you understand what's happening underneath the abstraction, which is exactly what interviewers at systems-heavy companies want to see.

If you need fine-grained formatting, stringstream is cleaner than repeated concatenation:

stringstream ss;
for (int i = 0; i < n; i++) {
    ss << i << ",";
}
string result = ss.str();

---

Three Patterns That Win String Problems

Most string interview problems reduce to one of three setups. Recognize which one you're in before you write a single line.

Two pointers. Palindrome checks, reversals, and partitioning all fall here. Set left = 0 and right = s.size() - 1, advance toward each other, compare in the middle. Cast s.size() - 1 to int if you need to handle empty strings safely.

bool isPalindrome(const string& s) {
    int l = 0, r = (int)s.size() - 1;
    while (l < r) {
        if (s[l] != s[r]) return false;
        l++; r--;
    }
    return true;
}

Sliding window. Longest substring without repeating characters, minimum window substring, and all their variants. Maintain a start index and expand end one character at a time. The key insight: you never need to shrink the window from both sides simultaneously.

int lengthOfLongestSubstring(const string& s) {
    unordered_map<char, int> lastSeen;
    int maxLen = 0, start = 0;
    for (int end = 0; end < (int)s.size(); end++) {
        if (lastSeen.count(s[end]) && lastSeen[s[end]] >= start) {
            start = lastSeen[s[end]] + 1;
        }
        lastSeen[s[end]] = end;
        maxLen = max(maxLen, end - start + 1);
    }
    return maxLen;
}

Character frequency. When the problem is about counts rather than positions, an int freq[26] = {} beats unordered_map<char, int> in both constant factor and clarity. If the problem guarantees lowercase English letters, a 26-element array is O(1) space and faster than any hash map.

bool isAnagram(const string& s, const string& t) {
    if (s.size() != t.size()) return false;
    int freq[26] = {};
    for (char c : s) freq[c - 'a']++;
    for (char c : t) if (--freq[c - 'a'] < 0) return false;
    return true;
}

Knowing the pattern is half the battle. Explaining it out loud while coding it under time pressure is the other half, and that gap is exactly what a tool like SpaceComplexity is designed to close.

---

C++ String Interview Cheat Sheet

Task	What to write	What to avoid
Access character	s[i]	s.at(i) unless you want bounds checking
Compare a slice	s.compare(pos, len, t)	s.substr(pos, len) == t (unnecessary copy)
Check find result	pos != string::npos	pos != -1 (works but bad style)
Iterate backwards	for (int i = (int)s.size() - 1; i >= 0; i--)	size_t counter with i >= 0
Lowercase whole string	transform + static_cast<unsigned char>	tolower(c) without cast on non-ASCII input
Build string	reserve() then +=	+= in a loop without reserve
Convert to int	stoi(s)	Manual parsing unless format is unusual
Read-only parameter	string_view s (C++17)	const string& s (fine, but copies happen for string literals)
Lexicographic compare	s < t	Assuming it is numeric

---

Further Reading

• std::basic_string reference (cppreference)
• std::string_view reference (cppreference)
• std::string::npos (cppreference)
• Character classification functions (cppreference)
• Numeric conversions: stoi, stod, to_string (cppreference)

---

Internal links:

• C++ for Coding Interviews: The STL Toolkit That Actually Matters
• C++ STL Time Complexity: The Interview Cheat Sheet
• C++ Coding Interview Gotchas: The Traps That Cost You the Offer
• String Internals, Immutability, and the Patterns That Win Coding Interviews