C++ Strings: std::string Basics, Methods, and Gotchas

std::string: Text That Manages Itself

On the previous page you saw how smart pointers let an object own a resource and clean it up automatically. std::string is that same idea applied to text: it owns a buffer of characters, grows it when you append, and frees it when the string goes out of scope. You never call new, never count bytes, and never worry about a missing null terminator.

To use it, include <string>. The class lives in the std namespace.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string name = "Ada";
    string greeting = "Hello, " + name + "!";

    cout << greeting << "\n";          // Hello, Ada!
    cout << "Length: " << name.size() << "\n";  // 3
    return 0;
}

That + operator is doing real work - it allocates a new buffer big enough for both pieces and copies them in. With a raw char* - a plain pointer into a character buffer - you would be reaching for strcpy and strcat and hoping your buffer was large enough. std::string makes that whole class of mistakes disappear.

Building and Joining Strings

You can concatenate with +, but the workhorse for growing a string in place is +=. It appends to the existing buffer instead of producing a brand-new string each time, which matters inside loops.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string sentence;                  // starts empty
    string words[] = {"the", "quick", "brown", "fox"};

    for (const string& w : words) {
        sentence += w;
        sentence += " ";
    }

    cout << sentence << "\n";         // the quick brown fox
    return 0;
}

A common surprise: + needs at least one operand to already be a std::string. Two string literals are just const char*, so "a" + "b" does not compile - there is no operator+ for two raw pointers. Make one of them a string first:

string s = "a" + "b";              // error: can't add two const char*
string s = string("a") + "b";      // fine - left side is a std::string
string s = "a"s + "b";             // fine in C++14+, the "s" literal suffix

Note that last form uses the s suffix from <string> (using namespace std::string_literals;), which turns a literal directly into a std::string.

Reaching Into a String

A std::string behaves like a container of char, so you can index it, loop over it, and ask for pieces of it.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string word = "hello";

    cout << word[0] << "\n";          // h  - indexing with []
    cout << word.front() << " " << word.back() << "\n";  // h o
    cout << word.substr(1, 3) << "\n"; // ell - 3 chars starting at index 1

    for (char c : word) {
        cout << c << '-';             // h-e-l-l-o-
    }
    cout << "\n";
    return 0;
}

substr(pos, len) returns a brand-new string copied from the original; it does not modify the source. Watch the bounds: word[10] on a 5-character string is undefined behavior - it won't throw, it just reads garbage. If you want a checked access that throws std::out_of_range, use word.at(10) instead of word[10].

Another classic trap: .size() returns an unsigned type (size_t). Writing a backward loop like for (size_t i = word.size() - 1; i >= 0; --i) never ends, because an unsigned i can never go below zero - it wraps around to a huge number. Loop with a signed index or restructure the condition when you need to walk a string in reverse.

Searching and Replacing

find locates a substring or character and returns the starting index. When the target isn't present, it returns the special constant std::string::npos - always compare against that rather than assuming find returns -1.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string path = "report.final.pdf";

    size_t dot = path.find('.');               // 6 - first dot
    size_t lastDot = path.rfind('.');          // 12 - last dot

    if (lastDot != string::npos) {
        cout << "Extension: " << path.substr(lastDot + 1) << "\n"; // pdf
        cout << "Base: " << path.substr(0, lastDot) << "\n";       // report.final
    }
    return 0;
}

To change text in place, replace(pos, len, text) swaps a span for new content (which can be a different length), and insert/erase add or remove pieces:

#include <iostream>
#include <string>
using namespace std;

int main() {
    string msg = "I like cats";

    msg.replace(7, 4, "dogs");   // replace 4 chars at index 7
    cout << msg << "\n";          // I like dogs

    msg.insert(0, "Honestly, "); // add at the front
    cout << msg << "\n";          // Honestly, I like dogs

    msg.erase(0, 10);            // remove the first 10 chars
    cout << msg << "\n";          // I like dogs
    return 0;
}

Strings and Numbers

Text and numbers don't convert by themselves - "42" is three characters, not the integer 42. The standard library gives you conversion functions both ways. Use stoi, stod, and friends to parse text into numbers, and to_string to go the other direction.

#include <iostream>
#include <string>
using namespace std;

int main() {
    string countText = "42";
    int count = stoi(countText) + 8;     // 50

    double price = 3.99;
    string label = "Price: $" + to_string(price);

    cout << count << "\n";               // 50
    cout << label << "\n";               // Price: $3.990000
    return 0;
}

Two gotchas here. First, stoi("abc") throws std::invalid_argument, so guard untrusted input with a try/catch block. Second, to_string(3.99) gives the full 3.990000 - if you need control over precision and formatting, that's a job for string streams, which is exactly where we head next.

try {
    int n = std::stoi(userInput);
} catch (const std::invalid_argument&) {
    std::cout << "That wasn't a number.\n";
}

Next: Input and Output

You've been printing strings with cout all along, but reading them back from the user has its own surprises - cin >> name stops at the first space, so a full line like "Ada Lovelace" needs std::getline instead. The next page covers C++ input and output properly: stream operators, reading whole lines, and mixing >> with getline without tripping over leftover newlines.