std::string Operations — Use std::string and common operations (length, substr, find, concatenation)

Before the C++ Standard Library introduced std::string, programmers manipulated text using C-style strings — null-terminated character arrays managed through functions like strlen, strcpy, and strcat from <cstring>. This approach was notoriously fragile: buffer overflows were commonplace, memory management was entirely the programmer's responsibility, and off-by-one errors lurking around the null terminator plagued even experienced developers. The evolution of std::string tracks directly with the broader movement in C++ toward type-safe, resource-managing abstractions that leverage RAII (Resource Acquisition Is Initialization).

The central question that std::string answers is deceptively simple: how can a language provide a dynamically-sized, mutable sequence of characters that manages its own memory, supports intuitive operations like concatenation with +, and integrates cleanly with the rest of the standard library — all while remaining efficient enough for systems programming? Understanding the core operations of std::string is foundational: virtually every non-trivial C++ program uses strings, and fluency with length, substr, find, and concatenation enables effective text processing, parsing, and data transformation.

The std::string class is a type alias for std::basic_string<char>, a class template defined in <string>. It owns a dynamically allocated buffer of characters, automatically grows that buffer when needed, and releases the memory when the string is destroyed. This RAII-based ownership model means you never call malloc or free for string data. The following principles underpin everyday usage.

The diagram illustrates the fundamental architecture of std::string. The object itself — typically 24 or 32 bytes on a 64-bit platform — lives wherever you declare it (stack, heap, or static storage). It contains three essential fields: a data pointer to the character buffer, the current size (the number of characters logically in the string, returned by length() or size()), and the capacity (the total allocated space, which may be larger than size to allow efficient appending). When you call substr(7, 5) on this string, you extract characters at indices 7 through 11 — the substring "World". When you call find(','), you perform a linear scan and find the comma at index 5.

length() and size()

Both s.length() and s.size() return the same value — the number of char elements in the string. The dual naming exists because size() is the generic STL container interface (consistent with vector::size()), while length() is the domain-specific name that predates the STL unification. Both run in O(1) since the size is cached in the object.

substr(pos, count)

The substr member function returns a new std::string containing count characters starting at position pos. If count is omitted or exceeds the remaining length, the substring extends to the end. If pos > s.size(), it throws std::out_of_range. Because it returns a new string, it involves an allocation — an important performance consideration in tight loops.

find(target, pos)

The find function searches for the first occurrence of a character, C-string, or std::string within the invoking string, starting the search at position pos (default 0). It returns the index of the first character of the match, or std::string::npos if no match is found. The search is case-sensitive and uses a straightforward linear scan in most implementations.

Concatenation

C++ provides multiple ways to concatenate strings. The + operator creates a new string containing the characters of both operands. The += operator and append() member function modify the string in place, which is generally more efficient because it avoids constructing a temporary. When building a string incrementally in a loop, prefer += or append(); calling reserve() beforehand can eliminate repeated reallocations.

Suppose you receive a single line of comma-separated data and need to extract the second field. We will use find to locate the delimiters and substr to extract the field, while length helps us validate inputs.

Choosing the right string representation depends on the context: ownership, mutability, encoding, and performance all matter. The following table compares std::string with common alternatives you will encounter in production C++ codebases.

The operations covered here — length, substr, find, and concatenation — form the basis for more sophisticated text processing techniques. As you advance, you will encounter regular expressions (<regex>), string streams (std::istringstream / std::ostringstream), and C++20's std::format for type-safe formatted output. Understanding the fundamental operations prepares you to evaluate when these higher-level abstractions are warranted versus when simple find/substr parsing suffices.

Additionally, be aware of encoding considerations. The std::string class stores bytes, not Unicode code points. For UTF-8 encoded text — now the de facto standard — length() returns the number of bytes, not the number of visible characters. Multi-byte characters mean that substr may split a character if called naïvely. Libraries such as ICU or C++23's <text_encoding> proposal address this, but awareness of the byte-oriented nature of std::string is essential for writing correct internationalized software.