Strings Debugging Exercises (10)

← Module home · Work each in the debugging protocol: reproduce → form hypotheses → instrument → fix → reflect. Every bug is from the mistakes gallery or a lesson trap.

Format. Each program compiles (unless stated) but misbehaves. Hint ladders are in collapsible sections — expand one rung at a time. All solutions at the end.

D1 — The disappearing first word (skip)

int main() {
    std::string title;
    std::cout << "Title: ";
    std::cin >> title;              // user types: The Silent Sea
    std::getline(std::cin, title);
    std::cout << "You said: [" << title << "]\n";
}
// Output: You said: [ The Silent Sea]   -- wait, where did "The" go?

Expected: the whole line. Observed: the line minus its first word (and maybe a leading space).

Reflection. The bug isn’t in getline — it’s in what getline found in the buffer. The cin lesson’s §2.5 rule: know what each reader consumes.

D2 — Never equal, no matter what you type (compare)

std::string cmd;
std::cin >> cmd;
if (cmd == "add")  { /* ... */ }
else if (cmd == "ADD") { /* ... */ }
// typing "Add", " ADD", "add " all fall through to "unknown command"

Expected: case-insensitive command matching. Observed: only exact-case matches work.

Reflection. Comparison compares text, not meaning. Decide the equality policy first (“case-insensitive, surrounding spaces ignored”), then normalize to it.

D3 — Searching for what isn’t there (npos)

std::string bio;
std::getline(std::cin, bio);
std::size_t p = bio.find('@');
std::cout << "Email part: " << bio.substr(p + 1) << '\n';
// no '@' typed -> p == npos -> substr(npos+1) ... crash or total garbage

Expected: a graceful “no email found” message. Observed: crash (or prints the whole string).

Reflection. find has two return meanings; substr assumes one. Every find→slice chain needs the npos checkpoint.

D4 — The erase that eats words (drift)

std::string s = "banana";
for (int i = 0; i < s.length(); i = i + 1) {
    if (s[i] == 'a') s.erase(i, 1);
}
std::cout << s << '\n';
// Expected: "bnn"   Observed: "bnn"?? Run it. (Some runs: "bna" or worse.)

Expected: all as removed. Observed: an a survives (trace it!).

Reflection. Mutate-while-traversing is index-hostile: erasure shifts everything left under your feet. Build-new turns a mutation problem into a traversal problem.

D5 — stoi’s quiet exception (convert)

std::string ageText;
std::cin >> ageText;
int age = std::stoi(ageText);
std::cout << "In 5 years: " << age + 5 << '\n';
// typing "abc" -> terminate called after throwing an exception 'std::invalid_argument'

Expected: a re-prompt or an error message. Observed: the program dies with a thrown exception.

Reflection. stoi is a trusting converter. Wrap it in validation you wrote — that’s the S25 reader pattern.

D6 — The password that accepts anything (predicate + prompt)

bool hasUpper = false, hasDigit = false;
std::string pw;
std::cin >> pw;
for (int i = 0; i < pw.length(); i = i + 1) {
    if (isupper(pw[i])) hasUpper = true;
    if (isdigit(pw[i])) hasDigit = true;
    if (hasUpper && hasDigit) break;   // D6's real bug is elsewhere though
}
if (hasUpper && hasDigit) std::cout << "OK\n";
else std::cout << "Weak\n";
// "Abc123" -> OK. "Abc" -> Weak. "abc123" -> Weak. All fine!
// ...but "Xy9" with a trailing space typed via getline -> "Weak"?

Expected: Xy9 (trailing space, from getline) accepted. Observed: Weak.

Reflection. A multi-clause rule needs one flag per clause — a flag you never set is a clause you silently dropped.

D7 — The acronym that isn’t (boundary + state)

std::string name = "muhammad ali jinnah";
std::string initials;
for (int i = 0; i < name.length(); i = i + 1) {
    if (isspace(name[i])) initials += name[i + 1];
}
std::cout << initials << '\n';
// Expected: "maj"   Observed: "al" + garbage? (and crashes on names ending in a space)

Expected: maj (uppercased). Observed: wrong chars and a potential crash.

Reflection. i+1 lookups need the next-box guard — the same bounds discipline as arrays D3. Plus: predicates do the class-checking so the builder stays clean.

D8 — The compare that changed (normalize in place)

std::string a = "Apple", b = "apple";
if (a == b) { /* unreachable */ }
// fix: lowercase both... but this program lowercases a and PRINTS it later:
std::for_each(a.begin(), a.end(), ...);  // ... pretend a is now lowercased in place
std::cout << a;   // "apple" -- the user's original capitalization is gone!

(Compile-note: the for_each line is pseudocode — your real fix uses a loop.) Expected: case-insensitive comparison without destroying a’s display form. Observed: comparison works but the report prints the mangled name.

std::string la = toLower(a), lb = toLower(b);   // your helper
if (la == lb) ...
std::cout << a;   // original preserved

Reflection. Never mangle data to compare it — normalize a copy. Data you display and data you compare on are different needs.

D9 — The int that isn’t (int-cast)

std::string digits = "2051";
int sum = 0;
for (int i = 0; i < digits.length(); i = i + 1) {
    sum = sum + digits[i];          // intended: add the numeric value
}
std::cout << sum << '\n';
// Expected: 8    Observed: 249

Expected: 8. Observed: 249.

Reflection. A char is a number wearing a costume — '2' is 50. Arithmetic on digit chars needs the offset subtraction first.

D10 — The cctype that wasn’t (namespace)

#include <iostream>
#include <string>
// note: no <cctype>
int main() {
    std::string s = "Hello";
    int upper = 0;
    for (int i = 0; i < s.length(); i = i + 1)
        if (isupper(s[i])) upper += 1;
    std::cout << upper << '\n';
}
// Compiles and prints 1... sometimes. On another machine: compile error.

Expected: portable. Observed: works on some compilers, fails on others.

Reflection. “It compiles on my machine” is not portability — incidental includes are luck, not design.

Solutions summary