# `std::string` in C++ ## 0. Where `std::string` Fits in the Course You already know: - stack vs heap - pointers / references - C-arrays and C-strings - why null-termination and missing bounds are dangerous `std::string` is the standard C++ solution for “owning a string safely”. It provides: - ownership (manages memory for you) - size tracking (length is stored) - convenient methods (search, replace, insert, etc.) - interoperability with C-strings when needed It does **not** automatically solve: - character encoding issues (UTF-8 vs UTF-16, etc.) - all performance pitfalls - dangling views (that’s `string_view` territory) --- ## 1. What Is `std::string`? `std::string` is a typedef (alias) for: - `std::basic_string` It represents: - a dynamically-sized sequence of `char` - owned by the object (it manages its own buffer) - contiguous in memory - usually null-terminated for interoperability (but you should not rely on that as a “length mechanism”) Key properties: - stores its length (`size()`) - can contain `'\0'` inside (yes, it can contain zero bytes) - grows and shrinks dynamically - supports value semantics (copying, moving, assignment) Header: ```cpp #include ```` --- ## 2. `std::string` vs C-string C-string: * pointer + `'\0'` terminator * length computed by scanning * no bounds checking * no ownership convention built in `std::string`: * length stored (O(1) access) * owns its memory * supports safe operations * still allows access to raw C-string when needed --- ## 3. Basic Creation ### 3.1 Default construction ```cpp std::string s; ``` Meaning: * empty string * `s.size() == 0` --- ### 3.2 From string literal ```cpp std::string s = "hello"; ``` --- ### 3.3 Copy construction ```cpp std::string a = "abc"; std::string b = a; ``` --- ### 3.4 Move construction ```cpp std::string a = "abc"; std::string b = std::move(a); ``` After move: * `b` owns the data * `a` is valid but unspecified (usually empty) --- ### 3.5 Fill constructor ```cpp std::string s(5, 'x'); // "xxxxx" ``` --- ### 3.6 From substring of another string ```cpp std::string base = "hello world"; std::string sub(base, 6, 5); // "world" ``` Parameters: * source string * start position * count --- ### 3.7 From pointer + length ```cpp const char* p = "hello world"; std::string s(p, 5); // "hello" ``` This is very important for handling data that might contain `'\0'`. --- ## 4. Size, Capacity, and Memory Model ### 4.1 `size()` and `length()` ```cpp std::string s = "hello"; s.size(); // 5 s.length(); // 5 ``` These are identical for `std::string`. Both are O(1). --- ### 4.2 `empty()` ```cpp if (s.empty()) { // ... } ``` Equivalent to `s.size() == 0`, but expresses intent. --- ### 4.3 `capacity()` `capacity()` is how many characters can be stored **without reallocating**. ```cpp std::string s; auto cap = s.capacity(); ``` Capacity can be >= size. --- ### 4.4 `reserve(n)` `reserve(n)` asks the string to allocate enough capacity for at least `n` chars. ```cpp std::string s; s.reserve(1000); ``` Why: * reduce reallocations when building a large string incrementally --- ### 4.5 `shrink_to_fit()` A non-binding request to reduce capacity to size. ```cpp s.shrink_to_fit(); ``` Important: * may do nothing * not guaranteed --- ### 4.6 `resize(n)` and `resize(n, ch)` If you grow the string: * new characters are value-initialized (`'\0'`) unless you provide `ch` ```cpp std::string s = "abc"; s.resize(5); // "abc\0\0" (contains zeros) s.resize(7, '!'); // "abc\0\0!!" ``` If you shrink it: * extra characters are removed ```cpp std::string s = "abcdef"; s.resize(3); // "abc" ``` --- ### 4.7 Small String Optimization (SSO) Most implementations store small strings without heap allocation. This is called SSO. What you should take away: * `std::string` may or may not allocate for small values * do not assume allocation happens * do not assume it doesn’t --- ## 5. Accessing Characters ### 5.1 `operator[]` ```cpp std::string s = "hello"; char c = s[1]; // 'e' ``` Important: * no bounds checking * out-of-range access is undefined behavior --- ### 5.2 `at() ```cpp char c = s.at(1); ``` If index is invalid: * throws an exception (`std::out_of_range`) Use `at()` when you want safety. --- ### 5.3 `front()` and `back()` ```cpp std::string s = "abc"; char f = s.front(); // 'a' char b = s.back(); // 'c' ``` Precondition: * string must not be empty --- ### 5.4 Modifying characters via accessors ```cpp std::string s = "abc"; s[0] = 'X'; // "Xbc" s.at(1) = 'Y'; // "XYc" ``` --- ## 6. Iteration ### 6.1 Range-based for loop ```cpp std::string s = "abc"; for (char ch : s) { // use ch } ``` --- ### 6.2 Iterators ```cpp auto it = s.begin(); auto end = s.end(); ``` You can modify through non-const iterators: ```cpp for (auto it = s.begin(); it != s.end(); ++it) { *it = std::toupper(static_cast(*it)); } ``` (We cast to `unsigned char` for safety with `toupper`.) --- ### 6.3 Reverse iteration ```cpp for (auto it = s.rbegin(); it != s.rend(); ++it) { // *it } ``` --- ### 6.4 Const iteration ```cpp const std::string s = "abc"; for (auto it = s.cbegin(); it != s.cend(); ++it) { // read-only } ``` --- ## 7. Modifiers ### 7.1 `clear()` ```cpp std::string s = "hello"; s.clear(); ``` Now: * `s.size() == 0` * capacity may remain --- ### 7.2 `push_back(ch)` and `pop_back()` ```cpp std::string s = "ab"; s.push_back('c'); // "abc" s.pop_back(); // "ab" ``` Precondition for `pop_back()`: * not empty --- ### 7.3 `append(...)` Append another string: ```cpp std::string s = "hello"; s.append(" world"); // "hello world" ``` Append a substring: ```cpp std::string s = "hello"; std::string t = "ABCDE"; s.append(t, 1, 3); // appends "BCD" ``` Append repeated char: ```cpp std::string s = "x"; s.append(5, '!'); // "x!!!!!" ``` --- ### 7.4 `operator+=` ```cpp std::string s = "hello"; s += " "; s += "world"; ``` --- ### 7.5 `operator+` ```cpp std::string a = "hello"; std::string b = "world"; std::string c = a + " " + b; ``` Note: * `+` allocates a new string * chaining may allocate multiple times if not optimized * for large concatenations, `reserve()` or `append()` can be better --- ### 7.6 `insert(pos, ...)` Insert a C-string: ```cpp std::string s = "helo"; s.insert(2, "l"); // "hello" ``` Insert a substring: ```cpp std::string s = "hello"; std::string t = "ABCDE"; s.insert(1, t, 2, 2); // inserts "CD" at pos 1 ``` Insert repeated character: ```cpp std::string s = "abc"; s.insert(1, 3, '_'); // "a___bc" ``` --- ### 7.7 `erase(pos, count)` ```cpp std::string s = "hello world"; s.erase(5, 1); // remove space => "helloworld" ``` Erase by iterator: ```cpp std::string s = "abc"; s.erase(s.begin()); // remove first char => "bc" ``` Erase a range: ```cpp std::string s = "abcdef"; s.erase(s.begin() + 2, s.begin() + 5); // removes cde => "abf" ``` --- ### 7.8 `replace(pos, count, ...)` Replace with a C-string: ```cpp std::string s = "hello world"; s.replace(6, 5, "C++"); // "hello C++" ``` Replace range: ```cpp std::string s = "abcXYZdef"; s.replace(3, 3, "___"); // "abc___def" ``` --- ### 7.9 `swap(other)` ```cpp std::string a = "short"; std::string b = "a very very long string"; a.swap(b); ``` Swap is typically O(1). --- ## 8. Search Operations All search functions typically return: * index (`size_type`) * or `std::string::npos` if not found Important constant: ```cpp std::string::npos ``` --- ### 8.1 `find(...)` Find substring: ```cpp std::string s = "hello world"; auto pos = s.find("world"); // 6 ``` Find starting from an index: ```cpp auto pos = s.find("o", 5); // finds 'o' at or after index 5 ``` Find a character: ```cpp auto pos = s.find('w'); // 6 ``` Check not found: ```cpp if (pos == std::string::npos) { // not found } ``` --- ### 8.2 `rfind(...)` Search from the end (but returns position from start): ```cpp std::string s = "one two one"; auto pos = s.rfind("one"); // 8 ``` --- ### 8.3 `find_first_of(...)` Find first position that matches any character from a set: ```cpp std::string s = "abc123"; auto pos = s.find_first_of("0123456789"); // 3 ``` --- ### 8.4 `find_last_of(...)` ```cpp std::string s = "abc123"; auto pos = s.find_last_of("0123456789"); // 5 ``` --- ### 8.5 `find_first_not_of(...)` ```cpp std::string s = " hello"; auto pos = s.find_first_not_of(' '); // 3 ``` Useful for trimming. --- ### 8.6 `find_last_not_of(...)` ```cpp std::string s = "hello "; auto pos = s.find_last_not_of(' '); // 4 ``` --- ## 9. Substrings ### 9.1 `substr(pos, count)` ```cpp std::string s = "hello world"; auto a = s.substr(0, 5); // "hello" auto b = s.substr(6); // "world" ``` Notes: * creates a new `std::string` * may allocate --- ### 9.2 Safe usage with `npos` Many methods accept `npos` as “until end”: ```cpp auto tail = s.substr(6, std::string::npos); ``` --- ## 10. Comparing Strings ### 10.1 `==`, `!=`, `<`, `>`, `<=`, `>=` ```cpp std::string a = "abc"; std::string b = "abd"; bool eq = (a == b); // false bool lt = (a < b); // true (lexicographical) ``` Lexicographical means: * compare first char * if equal, compare next * shorter prefix is smaller if all equal so far --- ### 10.2 `compare(...)` ```cpp std::string a = "abc"; std::string b = "abd"; int r = a.compare(b); ``` Return: * <0 if a < b * 0 if equal * > 0 if a > b Compare substrings: ```cpp std::string s = "hello world"; int r = s.compare(6, 5, "world"); // 0 if matches ``` --- ## 11. Checking Prefixes and Suffixes (C++20+) If your standard library supports it (C++20): * `starts_with` * `ends_with` ```cpp std::string s = "hello.cpp"; bool a = s.starts_with("he"); bool b = s.ends_with(".cpp"); ``` If unavailable, you can emulate with `compare` or `rfind`. --- ## 12. `c_str()` and `data()` ### 12.1 `c_str()` ```cpp std::string s = "hello"; const char* p = s.c_str(); ``` Guarantees: * null-terminated * pointer remains valid until you modify the string (or it is destroyed) Common use: * pass to C APIs expecting `const char*` --- ### 12.2 `data()` Historically: * `data()` returned `const char*` (C++11/14) In modern C++: * `data()` returns `char*` for non-const strings (C++17+) ```cpp std::string s = "hello"; char* p = s.data(); // if allowed by your standard/version ``` Important: * `data()` is for raw access to the internal buffer * still invalidated by modifications that reallocate --- ### 12.3 Pointer invalidation rule The following may invalidate `c_str()` / `data()` pointers: * appending * inserting * erasing * replacing * resizing bigger * reserving larger capacity * any operation that triggers reallocation Example of a bug: ```cpp std::string s = "hello"; const char* p = s.c_str(); s += " world"; std::cout << p; // p may be dangling (invalid) ``` Correct approach: * reacquire after modifications ```cpp s += " world"; p = s.c_str(); ``` --- ## 13. Contiguity and Indexing Safety `std::string` stores characters contiguously. That means: * `&s[0]` points to a contiguous buffer (if non-empty) * indexing works like array indexing But bounds checking differs: * `operator[]` has none * `at()` checks bounds For defensive code: * use `at()` when correctness matters more than speed --- ## 14. Inserting and Removing Without Losing Track of Indices Many editing operations shift indices. Example: ```cpp std::string s = "abcXYZdef"; auto pos = s.find("XYZ"); // 3 s.erase(pos, 3); // now "abcdef" ``` After erasing: * any stored indices beyond the erased region may change meaning When writing code that does multiple edits: * recalculate positions * or edit from end to start to avoid shifting issues --- ## 15. Building Strings Efficiently ### 15.1 Repeated concatenation can be expensive ```cpp std::string s; for (int i = 0; i < 100000; ++i) { s += "x"; // may reallocate many times } ``` Better: ```cpp std::string s; s.reserve(100000); for (int i = 0; i < 100000; ++i) { s.push_back('x'); } ``` --- ### 15.2 `append` often reads clearer than `+=` ```cpp s.append("hello"); s.append(" "); s.append("world"); ``` --- ## 16. Parsing with `std::string` ### 16.1 Splitting by a delimiter (simple manual approach) ```cpp std::string s = "a,b,c"; std::size_t start = 0; while (true) { auto pos = s.find(',', start); if (pos == std::string::npos) { auto token = s.substr(start); // use token break; } auto token = s.substr(start, pos - start); // use token start = pos + 1; } ``` This is common and demonstrates: * `find` * `substr` * `npos` --- ### 16.2 Trimming spaces Left trim: ```cpp std::string s = " hello"; auto first = s.find_first_not_of(' '); if (first != std::string::npos) { s.erase(0, first); } else { s.clear(); // all spaces } ``` Right trim: ```cpp std::string s = "hello "; auto last = s.find_last_not_of(' '); if (last != std::string::npos) { s.erase(last + 1); } else { s.clear(); } ``` --- ## 17. Numeric Conversions `std::string` itself is not a number, but you can convert. ### 17.1 `std::stoi`, `std::stol`, `std::stoll` ```cpp int x = std::stoi("123"); long y = std::stol("456"); long long z = std::stoll("789"); ``` They: * skip leading spaces * parse sign * stop at first invalid character Example: ```cpp int x = std::stoi("42abc"); // x == 42 ``` If parsing fails: * throws an exception (`std::invalid_argument` or `std::out_of_range`) --- ### 17.2 Floating conversions: `std::stof`, `std::stod`, `std::stold` ```cpp double d = std::stod("3.14159"); ``` Also throws on errors. --- ### 17.3 Converting numbers to strings: `std::to_string` ```cpp std::string s1 = std::to_string(123); std::string s2 = std::to_string(3.14); ``` Note: * formatting is implementation-defined-ish (especially trailing zeros) * for advanced formatting, use formatting utilities (later: `std::format` / `std::print`) --- ## 18. `std::getline` and `std::string` Very common: ```cpp #include #include std::string line; std::getline(std::cin, line); ``` Why it matters: * reads spaces * avoids fixed buffers and overflow risks * stores length safely --- ## 19. Embedded `'\0'` Inside `std::string` Unlike C-strings, `std::string` can contain zero bytes: ```cpp std::string s("abc\0def", 7); ``` Now: * `s.size()` is 7 * printing with `std::cout << s` may stop at `'\0'` depending on overloads and how output is performed (stream insertion for `std::string` uses size, so it will typically print full content, but the console may not show the zero byte) * `s.c_str()` will expose a null-terminated view, but the embedded null still exists Important: * treating string data as C-string when it contains `'\0'` is dangerous --- ## 20. Common Pitfalls and Misconceptions ### 20.1 “`c_str()` is always valid forever” False. It becomes invalid after many modifications. --- ### 20.2 “`std::string` is always null-terminated” `c_str()` is guaranteed to return a null-terminated pointer. Internally, you should treat it as: * size-managed container of chars Do not rely on null termination for logic. --- ### 20.3 “`operator[]` is safe” It is not bounds-checked. Out-of-range is UB. --- ### 20.4 “Appending is always cheap” Appending can trigger reallocation. Use `reserve()` for building big strings. --- ### 20.5 “Comparing strings compares pointers” No. `std::string` compares content lexicographically. --- ## 21. A Tour of Many Common Methods (Quick Index) Construction and assignment: * constructors * `operator=` * `assign(...)` Capacity: * `size()`, `length()` * `empty()` * `capacity()` * `reserve()` * `shrink_to_fit()` * `resize()` Element access: * `operator[]` * `at()` * `front()`, `back()` * `data()` * `c_str()` Modifiers: * `clear()` * `push_back()`, `pop_back()` * `append()` * `operator+=` * `insert()` * `erase()` * `replace()` * `swap()` Search: * `find()`, `rfind()` * `find_first_of()`, `find_last_of()` * `find_first_not_of()`, `find_last_not_of()` Operations: * `substr()` * `compare()` (C++20+): * `starts_with()` * `ends_with()` --- ## 22. Many Small Examples ### 22.1 `assign` ```cpp std::string s; s.assign("hello"); s.assign(3, 'x'); // "xxx" ``` --- ### 22.2 `append` with numbers ```cpp std::string s = "value="; s.append(std::to_string(123)); ``` --- ### 22.3 Insert at beginning / middle / end ```cpp std::string s = "world"; s.insert(0, "hello "); // "hello world" s.insert(5, ","); // "hello, world" s.insert(s.size(), "!"); // "hello, world!" ``` --- ### 22.4 Erase a word ```cpp std::string s = "hello cruel world"; auto pos = s.find("cruel "); if (pos != std::string::npos) { s.erase(pos, 6); // remove "cruel " } // "hello world" ``` --- ### 22.5 Replace all occurrences ```cpp std::string s = "a-b-c-d"; std::size_t pos = 0; while (true) { pos = s.find('-', pos); if (pos == std::string::npos) break; s.replace(pos, 1, "_"); pos += 1; } // "a_b_c_d" ``` --- ### 22.6 Find first digit ```cpp std::string s = "ID: X42"; auto pos = s.find_first_of("0123456789"); if (pos != std::string::npos) { // pos points to '4' } ``` --- ### 22.7 Trim both sides ```cpp std::string s = " hello "; auto left = s.find_first_not_of(' '); if (left == std::string::npos) { s.clear(); } else { auto right = s.find_last_not_of(' '); s = s.substr(left, right - left + 1); } ``` --- ## 23. Safety and Boundaries Compared to C-strings: * no missing `'\0'` problems (string knows its size) * no `strlen` scanning needed for length * appending grows the buffer safely * operations are generally safe if you stay within indices * you still must avoid out-of-range indices But: * `operator[]` still has UB on invalid indices * you can still write bugs with incorrect indices * pointer invalidation rules can create dangling pointers So it’s “safer”, not “impossible to misuse”. --- ## 24. Interoperability Rules ### 24.1 Passing to a C API ```cpp extern "C" void c_api(const char*); std::string s = "hello"; c_api(s.c_str()); ``` Rule: * do not modify `s` while C code keeps that pointer --- ### 24.2 Receiving a `const char*` from a C API ```cpp const char* p = get_c_string(); std::string s = p; // copies content ``` This is usually safe because: * `std::string` copies the bytes until `'\0'` But if the input might not be properly terminated: * you need a pointer + length, not a C-string (You often don’t have that in C APIs, which is why such APIs are dangerous.) --- ## 25. Summary * `std::string` is an owning, dynamic, contiguous character sequence * it stores length and manages memory * it supports many safe operations for editing and searching * it still requires correct indexing and lifetime awareness * `c_str()`/`data()` pointers can be invalidated by modifications * it is the foundation for modern string work in C++