C++ std::string — Erasing While Iterating Forward

Every meaningful program deals with text. A login form reads a username. A game stores a player's name. A web server parses a URL. Text is everywhere — and how your language handles it determines whether working with it is a joy or a nightmare. In C++, the STL string (short for Standard Template Library string) is the modern, safe, and powerful way to work with text. It ships with the language, costs nothing to use, and handles dozens of common text tasks with a single method call.

Before STL string existed, C++ programmers used raw character arrays — essentially a row of boxes in memory, each holding one letter. You had to manually track how long your text was, manually allocate memory, and manually clean it up. Forget one step and your program crashed or corrupted memory. The STL string class was built specifically to eliminate that pain. It manages its own memory, knows its own length, and gives you a rich toolkit of methods for everything from finding a word to replacing a substring.

By the end of this article you'll be able to declare and initialise STL strings confidently, use the most important string methods (length, find, substr, replace, append, and more), compare strings correctly, avoid the two biggest beginner mistakes, and answer the string questions that show up in technical interviews. No prior C++ experience is assumed — we'll build everything from the ground up.

What Is an STL String and How Do You Create One?

Think of std::string as a smart, resizable box of characters. Unlike a plain C-style char array where you declare 'char name[50]' and hope 50 is enough, std::string expands automatically as you add more text. You never manage the memory yourself.

To use std::string you need two things at the top of your file: '#include <string>' to bring in the string class, and 'using namespace std;' (or you write 'std::string' every time). While experienced developers often avoid 'using namespace std' in large headers to prevent naming collisions, it is standard practice in educational examples and competitive programming.

You can create a string in several ways: start empty and build it up, initialize it from a literal, or use the fill constructor to repeat characters. Because std::string is a dynamic object, it lives on the heap but follows RAII (Resource Acquisition Is Initialization) principles, meaning it cleans itself up automatically when the variable goes out of scope.

#include <iostream>
#include <string>

namespace io_thecodeforge {
    void demonstrateCreation() {
        // Method 1: Default constructor (Empty string)
        std::string emptyGreeting;
        emptyGreeting = "Hello";

        // Method 2: Direct initialisation
        std::string playerName = "Aria";

        // Method 3: Fill constructor — Creates "--------------------"
        std::string dividerLine(20, '-');

        // Method 4: Partial initialisation from literal
        std::string city("New York City", 8); // Result: "New York"

        std::cout << "Player: " << playerName << "\n" << dividerLine << "\n";
    }
}

int main() {
    io_thecodeforge::demonstrateCreation();
    return 0;
}

The Essential String Methods — Your Everyday Toolkit

STL string ships with a vast API, but a core set of methods handles nearly all production scenarios. Understanding these is essential for technical interviews, especially those involving string parsing or palindrome logic.

'length()' and 'size()' are synonyms returning character count. 'at(index)' is the 'safe' version of the subscript operator []; it performs bounds-checking and throws an std::out_of_range exception if you access an invalid index. 'find()' is the workhorse for searching; it returns string::npos if the search fails. 'substr(pos, len)' allows you to extract segments without manual looping. Finally, for modification, 'append()', 'replace()', and 'erase()' provide powerful ways to mutate text in-place.

#include <iostream>
#include <string>
#include <stdexcept>

namespace io_thecodeforge {
    void validateUsername(std::string rawInput) {
        // 1. Check for empty input using .empty()
        if (rawInput.empty()) return;

        // 2. find() returns size_t. Always compare against string::npos
        size_t forbidden = rawInput.find("admin");
        if (forbidden != std::string::npos) {
            std::cout << "Forbidden word found at index: " << forbidden << "\n";
        }

        // 3. substr() - extract exactly 4 chars starting from index 0
        if (rawInput.length() >= 4) {
            std::string prefix = rawInput.substr(0, 4);
            std::cout << "Prefix extracted: " << prefix << "\n";
        }

        // 4. Safe access with .at() vs dangerous access with []
        try {
            char first = rawInput.at(0);
            std::cout << "First character: " << first << "\n";
        } catch (const std::out_of_range& e) {
            std::cerr << "Caught index error: " << e.what() << "\n";
        }
    }
}

int main() {
    io_thecodeforge::validateUsername("aria_admin_42");
    return 0;
}

Comparing Strings: The Power of Operator Overloading

In C, comparing strings required strcmp(), which returns 0 for equality—a counter-intuitive pattern. C++ simplifies this by overloading comparison operators. == checks for exact character equality, while < and > perform lexicographical (dictionary-style) comparisons based on ASCII values.

This makes std::string compatible with standard algorithms like std::sort(). Note that comparison is case-sensitive: 'Z' (65) comes before 'a' (97). For robust applications, you should normalize strings to a single case before comparison.

#include <iostream>
#include <string>
#include <algorithm>
#include <vector>

namespace io_thecodeforge {
    void sortCities() {
        std::vector<std::string> cities = {"Tokyo", "Berlin", "New York", "London"};
        
        // std::sort uses the overloaded < operator of std::string
        // Comparison is lexicographical: 'B' < 'L' < 'N' < 'T'
        std::sort(cities.begin(), cities.end());

        for (const std::string& city : cities) {
            std::cout << " - " << city << "\n";
        }
    }
}

int main() {
    io_thecodeforge::sortCities();
    return 0;
}

Input, Conversion, and Production Patterns

Real-world apps rarely work with hardcoded strings. You need to handle user input and convert between types. cin >> is sufficient for single-word inputs, but it stops at the first whitespace. For full sentences, getline() is mandatory.

Modern C++ (C++11 and later) provides simplified conversion utilities: to_string() for numeric-to-string conversion, and stoi() / stod() for parsing strings into numbers. These parsing functions are safer than the old C atoi() because they throw exceptions if the input is malformed, allowing for cleaner error handling in production code.

#include <iostream>
#include <string>
#include <stdexcept>

namespace io_thecodeforge {
    void processInput() {
        std::string fullName;
        std::string ageStr;

        std::cout << "Enter Full Name: ";
        std::getline(std::cin, fullName);

        std::cout << "Enter Age: ";
        std::cin >> ageStr;

        try {
            // Production-grade string parsing with exception safety
            int age = std::stoi(ageStr);
            std::string message = "User: " + fullName + " | Future Age: " + std::to_string(age + 5);
            std::cout << message << "\n";
        } catch (const std::invalid_argument& e) {
            std::cerr << "Error: Numeric conversion failed. Input was not a number.\n";
        } catch (const std::out_of_range& e) {
            std::cerr << "Error: Numeric value is out of range for an integer.\n";
        }
    }
}

int main() {
    io_thecodeforge::processInput();
    return 0;
}

Performance, Capacity, and the Small String Optimization

Not all std::string objects allocate on the heap. Modern C++ implementations use a technique called Small String Optimization (SSO). Strings shorter than a certain threshold (typically 15-22 characters, compiler-specific) are stored directly inside the string object itself — in a small internal buffer. This avoids heap allocation entirely for the vast majority of everyday strings.

When a string grows beyond the SSO threshold, it switches to dynamic heap allocation. The string object maintains both a size (number of characters) and a capacity (total allocated memory, including unused space). When you append and the capacity is exhausted, the string reallocates a larger buffer — usually doubling in size — and copies the old content over. This is why repeated appends can be O(n) in the number of characters copied across all reallocations.

To avoid reallocation overhead, use .reserve(n) to pre-allocate sufficient capacity before a series of appends. Call .shrink_to_fit() when you're done appending and want to release unused memory (though the request is non-binding).

#include <iostream>
#include <string>

namespace io_thecodeforge {
    void demonstrateCapacity() {
        std::string s;
        std::cout << "Initial size: " << s.size() << ", capacity: " << s.capacity() << "\n";

        s = "Hello, World!"; // short enough for SSO
        std::cout << "After assignment: size=" << s.size() << ", capacity=" << s.capacity() << "\n";

        // Reserve space to avoid multiple reallocations
        s.reserve(100);
        for (int i = 0; i < 50; ++i) {
            s += "x";
        }
        std::cout << "After 50 appends: size=" << s.size() << ", capacity=" << s.capacity() << "\n";

        // Shrink to fit
        s.shrink_to_fit();
        std::cout << "After shrink_to_fit: size=" << s.size() << ", capacity=" << s.capacity() << "\n";
    }
}

int main() {
    io_thecodeforge::demonstrateCapacity();
    return 0;
}

Why You Should Never Use C-Style String Functions on std::string

Every month I see a junior dev pass &str[0] to strlen or strcpy. It works until it doesn't. std::string is not guaranteed to be null-terminated in all implementations, and C functions ignore the internal length tracking. The moment you mutate a string via a C pointer, you corrupt the SSO buffer or leak a heap allocation. Use .c_str() for C interop, but only when you must. And never write to the pointer it returns. If you need raw character access, use .data() with the non-const overload — but prefer iterators or operator[] for safety. The STL gave you a proper string class so you could stop thinking about null terminators. Stop fighting it.

#include <iostream>
#include <cstring>
#include <string>

int main() {
    std::string s = "Hello";
    s.resize(3);  // s now holds "Hel" with capacity 5

    // BAD: assumes null termination, reads into old data
    std::cout << strlen(s.c_str()) << '\n';  // may print 5, not 3

    // CORRECT: use .size()
    std::cout << s.size() << '\n';  // 3
    
    s.shrink_to_fit();  // force reallocation for safety
    std::cout << strlen(s.c_str()) << '\n';  // now reliably 3
}

Substring Extraction: The Hidden O(n) Trap in std::string::substr

You write str.substr(pos, n) thinking it’s O(1). It’s not. The standard guarantees a new string allocation and a linear copy. On a 100KB JSON payload, that’s instant — on a 100MB log line, you just killed your latency budget. Use string_view when you only need to inspect or iterate. std::string_view is a non-owning reference: zero copy, O(1) creation. If you must own the substring for mutation, accept the copy but reserve capacity first. Even better: use std::string::copy(char*, n) if you want to fill a preallocated buffer. Production code that parses streams or handles large text should treat substr like malloc — necessary but expensive.

#include <iostream>
#include <string>
#include <string_view>

int main() {
    std::string huge = std::string(100'000'000, 'A');
    // bad: allocates + copies 50MB
    auto sub_owned = huge.substr(50'000'000, 10);
    
    // good: zero-copy view, O(1)
    std::string_view sv = huge;
    auto sub_view = sv.substr(50'000'000, 10);
    
    std::cout << "Owned: " << sub_owned.size() << '\n';
    std::cout << "View: " << sub_view.size() << '\n';
}