{"title":"String Methods","description":null,"content":"The _std::string_ lesson covered how to build a `std::string`, concatenate it, compare it, index into it, and ask how long it is. That is enough to hold text, but real programs do more: pull a product code out of a longer label, find where a colon sits in a parsed line, replace a placeholder in a greeting, or turn `\"9.99\"` into the number `9.99`. This lesson is a working tour of the `std::string` methods that handle those jobs, grouped by purpose rather than by alphabetical order.\n\n---\n\n# A Map Before the Tour\n\n`std::string` ships with dozens of member functions. Most fall into a small number of jobs:\n\n\n| Job | Methods | Returns |\n|-----|---------|---------|\n| Find something | `find`, `rfind`, `find_first_of`, `find_last_of` | Index, or `std::string::npos` if not found |\n| Pull out a piece | `substr` | A new `std::string` |\n| Change the contents | `replace`, `insert`, `erase`, `append`, `push_back`, `pop_back` | Reference to the modified string |\n| Compare | `compare` | Negative, zero, or positive `int` |\n| Convert numbers | `std::to_string`, `std::stoi`, `std::stod` (free functions) | Either a string or a number |\n| Read each character | range-based `for` loop | n/a (just iteration) |\n\n\nThe table is a reference, not required reading. Skim the sections below, and the pieces will fall into place by the worked example at the end.\n\nFor every example in this lesson, assume the following two headers are at the top of the file:\n\n\n```cpp\n#include \n#include \n```\n\n\nThat is all `std::string` needs. The compiler line is `g++ -std=c++17 file.cpp -o file`.\n\n---\n\n# Searching: `find`, `rfind`, and Friends\n\nThe most common question about a string is \"where does this substring start?\". `find` answers it. Pass the substring to search for, and `find` returns the index where it begins, counting from zero.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string label = \"Product:Apple:Price:9.99\";\n std::size_t pos = label.find(\"Price\");\n std::cout << \"'Price' starts at index \" << pos << std::endl;\n return 0;\n}\n```\n\n\nThe return type is `std::size_t`, which is an unsigned integer type sized to hold any index into a string. It also appears as `size_t`; both names refer to the same thing.\n\nWhat if the substring is not there? `find` returns a special sentinel value called `std::string::npos`. It is a `std::size_t` constant defined as \"the largest possible value of `std::size_t`\", which in practice cannot be a real index. Compare against it to check whether the search hit anything.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string title = \"Wireless Mouse\";\n if (title.find(\"Keyboard\") == std::string::npos) {\n std::cout << \"Not a keyboard.\" << std::endl;\n } else {\n std::cout << \"Looks like a keyboard.\" << std::endl;\n }\n return 0;\n}\n```\n\n\nA common bug: treating the return value as a signed `int` and checking for `-1`. That is how some other languages report \"not found\", but in C++ the sentinel is `std::string::npos`, and storing it in a signed `int` truncates the bits in a way that does not guarantee `-1`. Compare against `std::string::npos` directly.\n\n`find` runs in O(n*m) in the worst case, where `n` is the haystack length and `m` is the needle length. For short needles this is effectively linear in the haystack. It is fine for typical product labels; it is not the right tool for scanning a megabyte log for a fixed pattern many times.\n\nThe search can start at a specific index by passing a second argument. That is useful for finding the second, third, or later occurrence.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string label = \"Product:Apple:Price:9.99\";\n std::size_t first = label.find(\":\");\n std::size_t second = label.find(\":\", first + 1);\n std::cout << \"First colon at index \" << first << std::endl;\n std::cout << \"Second colon at index \" << second << std::endl;\n return 0;\n}\n```\n\n\nPassing `first + 1` as the starting position skips past the colon we already found, so the next call locates the next one.\n\n`rfind` is `find`'s mirror image. It searches from the right and returns the index of the last match.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string email = \"alice@dev.shopmaster.com\";\n std::size_t lastDot = email.rfind(\".\");\n std::cout << \"Last '.' at index \" << lastDot << std::endl;\n std::cout << \"Top-level domain: \" << email.substr(lastDot + 1) << std::endl;\n return 0;\n}\n```\n\n\n`rfind` still returns the index from the start of the string, not from the end. The \"r\" only changes which match is returned, not how the index is counted.\n\nFor finding any one of a set of characters (rather than a specific substring), use `find_first_of` and `find_last_of`. Pass a string of characters and the function returns the index of the first (or last) position that matches any of them.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string sku = \"AX-3429/RED\";\n std::size_t sep = sku.find_first_of(\"-/\");\n std::cout << \"First separator at index \" << sep << std::endl;\n return 0;\n}\n```\n\n\nThe string `\"-/\"` here is a set, not a literal substring. `find_first_of` returns the index of whichever character from the set appears earliest in the haystack. It is a useful method when the parser does not know which separator it will hit first.\n\n---\n\n# Slicing: `substr`\n\nOnce a piece of the string is located, the next step is usually to pull it out. `substr` does that. It returns a new `std::string` containing a range of characters from the original.\n\nThere are two forms:\n\n- `s.substr(pos)` returns everything from index `pos` to the end.\n- `s.substr(pos, len)` returns at most `len` characters starting at `pos`.\n\nThe \"at most\" part of the second form matters. If `len` runs past the end of the string, `substr` stops at the end instead of crashing or reading out of bounds. That makes it forgiving for an approximate length.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string label = \"Product:Apple:Price:9.99\";\n std::cout << label.substr(8) << std::endl;\n std::cout << label.substr(8, 5) << std::endl;\n std::cout << label.substr(0, 7) << std::endl;\n std::cout << label.substr(8, 1000) << std::endl;\n return 0;\n}\n```\n\n\nThe first call grabs everything from index 8 onward. The second grabs five characters starting at 8, which is the word `Apple`. The third pulls the first seven characters. The fourth asks for a thousand characters, but `substr` stops at the end of the string instead of erroring.\n\nOne detail: passing a `pos` larger than `s.size()` throws `std::out_of_range`. Equal to `s.size()` is fine and returns an empty string. Anything past that is an error.\n\n`substr` always returns a new string. The original is untouched. This matters when extracting several pieces without modifying the source.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string fullName = \"Alice Johnson\";\n std::size_t space = fullName.find(\" \");\n std::string firstName = fullName.substr(0, space);\n std::string lastName = fullName.substr(space + 1);\n std::cout << \"First: \" << firstName << std::endl;\n std::cout << \"Last: \" << lastName << std::endl;\n std::cout << \"Full still: \" << fullName << std::endl;\n return 0;\n}\n```\n\n\nTwo slices, both safe, original string unchanged. This is the common pattern for parsing simple formatted text.\n\n`substr` copies the chosen range into a new string, so it is O(len). For read-only inspection without storage, `std::string_view` (covered in the _std::string_view_ lesson) avoids the copy entirely.\n\n---\n\n# Mutating: `replace`, `insert`, `erase`, and Character-Level Ops\n\nThe methods so far have either read the string or built a new one. The next group changes the original. Each one modifies the string in place and returns a reference to the modified string, which allows chaining.\n\n### `replace(pos, n, s)`\n\n`replace` overwrites a range of characters with a new substring. Pass it the starting position, how many characters to replace, and the replacement string. The replacement does not have to be the same length as the range it overwrites; the string resizes as needed.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string greeting = \"Hello, NAME!\";\n greeting.replace(7, 4, \"Alice\");\n std::cout << greeting << std::endl;\n return 0;\n}\n```\n\n\n`replace(7, 4, \"Alice\")` says: starting at index 7, drop the next 4 characters (which spell `NAME`), and put in `Alice` instead. The replacement is one character longer than what it replaced, so the string grew by one character.\n\nA visual of a smaller example. Replacing 3 characters starting at index 2 with the string `\"XYZ\"`:\n\n\n```mermaid\nflowchart TD\n A[\"Original: 'ABCDEFG'
indices: 0 1 2 3 4 5 6\"]:::cyan\n A --> B[\"replace(2, 3, 'XYZ')
removes 3 chars starting at 2\"]:::orange\n B --> C[\"After remove: 'AB' + 'FG'
indices: 0 1 ... 2 3\"]:::teal\n C --> D[\"Insert 'XYZ' at index 2
Result: 'ABXYZFG'\"]:::green\n\n classDef cyan fill:#00ceff,stroke:#000,color:#000\n classDef orange fill:#ffa94d,stroke:#000,color:#000\n classDef teal fill:#38d9a9,stroke:#000,color:#000\n classDef green fill:#69db7c,stroke:#000,color:#000\n```\n\n\nThe original 7-character string becomes another 7-character string in this case because `\"XYZ\"` is the same length as the slice it replaces. With a longer or shorter replacement, the final length changes accordingly.\n\n### `insert(pos, s)`\n\n`insert` slips a substring into the middle of the string, pushing later characters to the right. Pass the position where the new text should start.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string title = \"Mouse\";\n title.insert(0, \"Wireless \");\n std::cout << title << std::endl;\n return 0;\n}\n```\n\n\n`insert(0, \"Wireless \")` puts the prefix at the very start. Everything that was already there shifts right by 9 characters.\n\n`insert` at the front, like the example above, is O(n) because every existing character has to move. Appending to the end with `append` or `push_back` is amortised O(1). Code that repeatedly inserts at the start is usually better off building in reverse and reversing once at the end, or appending in the natural order.\n\n### `erase(pos, n)`\n\n`erase` is the opposite of `insert`: it removes a range of characters and pulls the rest of the string left to fill the gap.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string sku = \"AX-3429/RED\";\n sku.erase(2, 1);\n std::cout << sku << std::endl;\n return 0;\n}\n```\n\n\n`erase(2, 1)` removes one character at index 2, which was the hyphen. The rest of the string slides left to close the gap.\n\nWith no second argument, `erase(pos)` removes everything from `pos` to the end:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string s = \"Product:Apple:Price:9.99\";\n s.erase(13);\n std::cout << s << std::endl;\n return 0;\n}\n```\n\n\nThis is a quick way to truncate a string at a known position.\n\n### `append(s)` vs `+=`\n\n`append` adds characters to the end of the string. It does the same job as `+=` and is almost always interchangeable with it.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string greeting = \"Hello\";\n greeting.append(\", \");\n greeting.append(\"Alice\");\n greeting += \"!\";\n std::cout << greeting << std::endl;\n return 0;\n}\n```\n\n\nThere is no meaningful performance difference between the two. Use whichever reads more naturally at the call site. The one minor edge `append` has is that it offers overloads taking a count and a position into another string, which `+=` does not.\n\n### `push_back(ch)` and `pop_back()`\n\nThese two are character-level helpers. `push_back` adds a single character to the end. `pop_back` removes the last character.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string code = \"AX-342\";\n code.push_back('9');\n std::cout << \"After push: \" << code << std::endl;\n\n code.pop_back();\n std::cout << \"After pop: \" << code << std::endl;\n return 0;\n}\n```\n\n\n`push_back` takes a single `char` (note the single quotes), not a string. `pop_back` takes no arguments because there is only ever one \"last\" character to remove. Calling `pop_back` on an empty string is undefined behavior; check `empty()` first when the string might be empty.\n\n### `clear()` and `empty()`\n\nThe _std::string_ lesson already covered these. A quick recap: `clear()` resets the string to zero length. `empty()` returns `true` when the size is zero. Both are O(1).\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string buffer = \"scratch\";\n buffer.clear();\n std::cout << \"Empty? \" << std::boolalpha << buffer.empty() << std::endl;\n return 0;\n}\n```\n\n\n`std::boolalpha` is the formatting flag that prints `true`/`false` instead of `1`/`0`. A small detail that makes boolean output more readable.\n\n---\n\n# Comparing: `compare`\n\nThe _std::string_ lesson covered `==` and `!=` for full-string equality. `compare` is a more powerful tool. It returns an `int` that indicates not just \"equal or not\" but also \"smaller or larger\", based on lexicographic order.\n\nThe return value follows this rule:\n\n- Negative if the receiver is less than the argument.\n- Zero if they're equal.\n- Positive if the receiver is greater than the argument.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string a = \"Apple\";\n std::string b = \"Banana\";\n std::cout << a.compare(b) << std::endl;\n std::cout << b.compare(a) << std::endl;\n std::cout << a.compare(\"Apple\") << std::endl;\n return 0;\n}\n```\n\n\nThe exact magnitude is not guaranteed; only the sign is. Some implementations return `-1` or `1`, others return the difference between the first mismatching characters. Treat the result as \"negative, zero, or positive\", not as \"always -1, 0, or 1\".\n\nThe reason to use `compare` over `==` is when a three-way result is needed in one call, typically inside a custom sort comparator or a tree-style lookup. For an everyday \"are these the same?\" check, `==` is shorter and more obvious.\n\n`compare` also has overloads that take a position and length, so a slice of the string can be compared without calling `substr`:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string code = \"PRD-12345\";\n int result = code.compare(0, 3, \"PRD\");\n std::cout << \"Prefix matches: \" << std::boolalpha << (result == 0) << std::endl;\n return 0;\n}\n```\n\n\nHere `compare(0, 3, \"PRD\")` compares the first three characters of `code` with the literal `\"PRD\"`. It returns zero when they match. This is cheaper than slicing with `substr` first, because no temporary string is created.\n\nOn C++20 or later, the language also provides `starts_with` and `ends_with`, which are usually clearer when prefix or suffix matching is all that is needed. This chapter sticks to C++17, where `compare(0, 3, \"PRD\") == 0` is the idiomatic way to ask \"does it start with PRD?\".\n\n---\n\n# Numeric Conversion: `to_string`, `stoi`, `stod`\n\nPrograms often have to move between numbers and the text that represents them. Printing a price as `\"$9.99\"`, parsing a quantity from user input, building a summary line that mixes labels and totals: all of those need conversion in one direction or the other.\n\nC++ provides free functions (not member functions of `std::string`, but in the same `` header) for both directions.\n\n`std::to_string` takes any built-in numeric type and returns a `std::string` with the value written out as text:\n\n\n```cpp\n#include \n#include \n\nint main() {\n int quantity = 3;\n double price = 9.99;\n std::string line = \"Qty: \" + std::to_string(quantity)\n + \", Price: $\" + std::to_string(price);\n std::cout << line << std::endl;\n return 0;\n}\n```\n\n\nNote the trailing zeros on `9.990000`. `std::to_string` for `double` uses a default precision that is not always what is wanted for display. For tighter formatting, use `std::ostringstream` with `std::fixed` and `std::setprecision`, covered in the stream I/O section later. For now, `std::to_string` is the simplest tool, with bulky default formatting for floats.\n\nGoing the other direction, `std::stoi` (string to int) parses a string into an `int`:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string input = \"42\";\n int quantity = std::stoi(input);\n std::cout << \"Doubled: \" << quantity * 2 << std::endl;\n return 0;\n}\n```\n\n\n`std::stod` does the same for `double`:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string priceText = \"9.99\";\n double price = std::stod(priceText);\n std::cout << \"With tax: \" << price * 1.10 << std::endl;\n return 0;\n}\n```\n\n\nSibling functions exist for other integer widths: `std::stol` for `long`, `std::stoul` for `unsigned long`, `std::stoll` for `long long`, and `std::stof` for `float`. They all work the same way, with different return types.\n\nWhen the string cannot be parsed as a number, these functions throw `std::invalid_argument`. When the parsed value would overflow the target type, they throw `std::out_of_range`. So `std::stoi(\"hello\")` throws, not returns zero. Wrap calls in a `try`/`catch` block when the input might be untrusted.\n\nA quick reference table:\n\n\n| Function | Input | Output |\n|----------|-------|--------|\n| `std::to_string(n)` | `int`, `long`, `double`, etc. | `std::string` |\n| `std::stoi(s)` | `std::string` | `int` |\n| `std::stol(s)` | `std::string` | `long` |\n| `std::stoul(s)` | `std::string` | `unsigned long` |\n| `std::stoll(s)` | `std::string` | `long long` |\n| `std::stof(s)` | `std::string` | `float` |\n| `std::stod(s)` | `std::string` | `double` |\n\n\nA tiny program pulling both directions together. It takes a raw price string, increases it by a tax rate, and builds a formatted display line:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string rawPrice = \"19.99\";\n double price = std::stod(rawPrice);\n double withTax = price * 1.08;\n\n std::string display = \"Total: $\" + std::to_string(withTax);\n std::cout << display << std::endl;\n return 0;\n}\n```\n\n\nAgain the formatting is bulky because of the default `to_string` precision. The larger point is that strings and numbers can flow into and out of each other with these two function families.\n\n---\n\n# Iterating Characters with Range-Based For\n\nA `std::string` is a sequence of characters, and they can be walked with a range-based `for` loop, the same construct seen for vectors and arrays. Each element is a single `char`.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string sku = \"AX-3429\";\n int digitCount = 0;\n for (char c : sku) {\n if (c >= '0' && c <= '9') {\n digitCount++;\n }\n }\n std::cout << \"Digits in SKU: \" << digitCount << std::endl;\n return 0;\n}\n```\n\n\nThe loop variable `c` is a `char` (a single character), not a `std::string`. The check `c >= '0' && c <= '9'` works because characters compare by their numeric codes, and the digit characters `'0'` through `'9'` are contiguous in those codes.\n\nTo modify each character in place, use `char&` (a reference) instead of `char`:\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string name = \"alice\";\n for (char& c : name) {\n if (c >= 'a' && c <= 'z') {\n c = c - ('a' - 'A');\n }\n }\n std::cout << name << std::endl;\n return 0;\n}\n```\n\n\nThe reference lets the loop write back into the string. With a plain `char c`, the modification happens on a copy, and the original stays lowercase. (`` has `std::toupper` and `std::tolower` for this job in real code; the manual arithmetic above is a teaching example, not the idiomatic version.)\n\nRange-based for is the most direct way to read or transform every character. When the index is also needed, use a plain `for` loop with `i < s.size()`.\n\n---\n\n# A Worked Example: Parsing a Product Label\n\nTime to combine several methods. The label format is fixed: `Product::Price:`. The job is to pull out the name and the price separately, parse the price as a `double`, and print a clean summary line.\n\nThe plan: find the colons, then use `substr` to grab the pieces between them.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string label = \"Product:Apple:Price:9.99\";\n\n std::size_t colon1 = label.find(\":\");\n std::size_t colon2 = label.find(\":\", colon1 + 1);\n std::size_t colon3 = label.find(\":\", colon2 + 1);\n\n std::string productName = label.substr(colon2 + 1, colon3 - colon2 - 1);\n std::string priceText = label.substr(colon3 + 1);\n\n double price = std::stod(priceText);\n\n std::cout << \"Name: \" << productName << std::endl;\n std::cout << \"Price: $\" << price << std::endl;\n\n std::string summary = productName + \" costs $\" + std::to_string(price);\n std::cout << summary << std::endl;\n\n return 0;\n}\n```\n\n\nWalking the logic:\n\n1. Find the first colon. It is at index 7, between `Product` and `Apple`.\n2. Find the next colon after that, starting at index 8. It lands at index 13, between `Apple` and `Price`.\n3. Find the next colon after that. It lands at index 19, between `Price` and `9.99`.\n4. The product name lives between colons 2 and 3. The starting index is `colon2 + 1` (right after the second colon), and the length is `colon3 - colon2 - 1` (the gap between the two colons, minus one for the colon itself).\n5. The price text is everything after the last colon, so `substr(colon3 + 1)` with no length argument gives us the rest of the string.\n6. `std::stod` turns the text `\"9.99\"` into the number `9.99`.\n7. `std::to_string` turns the number back into text for the summary line.\n\nThis pattern, find-the-separator then substr-between-separators, is the common shape for simple parsing. For more complex formats (CSV with quoted fields, JSON, free-form user input), use purpose-built libraries or `std::stringstream`, both later in the course. For fixed-format strings like this one, the methods in this chapter are enough.\n\nThe same parse with a small twist: count how many colons are in the string before parsing, as a sanity check.\n\n\n```cpp\n#include \n#include \n\nint main() {\n std::string label = \"Product:Apple:Price:9.99\";\n\n int colonCount = 0;\n for (char c : label) {\n if (c == ':') {\n colonCount++;\n }\n }\n\n if (colonCount != 3) {\n std::cout << \"Bad label format.\" << std::endl;\n return 1;\n }\n\n std::size_t c1 = label.find(\":\");\n std::size_t c2 = label.find(\":\", c1 + 1);\n std::size_t c3 = label.find(\":\", c2 + 1);\n std::string name = label.substr(c2 + 1, c3 - c2 - 1);\n std::string priceText = label.substr(c3 + 1);\n\n std::cout << name << \" at $\" << priceText << std::endl;\n return 0;\n}\n```\n\n\nThe range-based for loop counts colons. If the count is anything other than three, the function bails out. That kind of guard is cheap insurance against bad input, and it shows the range-based for pattern from the previous section being useful for real work.","pageType":"cpp"}

String Methods

Get Premium