std::string Class

Learn how to work with text safely and efficiently using C++'s powerful std::string class.

A Simple Example

#include <iostream>
#include <string>

int main() {
    // Creating strings
    std::string greeting{"Hello"};
    std::string name{"World"};

    // Concatenation with +
    std::string message{greeting + " " + name};
    std::cout << message << "\n";  // Hello World

    // Easy comparison
    if (greeting == "Hello") {
        std::cout << "Greetings!" << "\n";
    }

    // Automatic resizing
    message += "!!!";  // Now: "Hello World!!!"
    std::cout << message << "\n";

    return 0;
}

Breaking It Down

Creating and Initializing Strings

• What it does: std::string creates a safe, managed text container
• Use braces {} for initialization: std::string name{"Alice"};
• Automatically manages memory - no manual allocation needed
• Remember: Must include <string> header to use std::string

String Concatenation

• What it does: Combine strings using the + operator
• Works intuitively: str1 + " " + str2 joins strings together
• Use += to append: message += "more text"; adds to existing string
• Remember: At least one operand must be a std::string when concatenating

String Comparison

• What it does: Compare strings using ==, !=, <, >, <=, >= operators
• Works like numbers: str1 == str2 checks if strings are identical
• Lexicographic ordering: < and > compare alphabetically
• Remember: Much simpler than C-style strcmp() function

Common String Methods

• .length() or .size(): Returns number of characters in string
• .empty(): Returns true if string has no characters
• .clear(): Removes all characters from string
• .at(index): Safely accesses character at position (with bounds checking)
• [index]: Fast access to character (no bounds checking)

Why This Matters

• While C-style strings require manual memory management and are prone to buffer overflows, std::string handles all the complexity for you.
• It automatically manages memory, grows as needed, provides intuitive operators, and offers dozens of useful methods. It's the standard way to work with strings in modern C++.

Critical Insight

Unlike arrays, std::string can change size dynamically! When you concatenate or modify strings, they automatically grow or shrink as needed. You never worry about buffer overflows or manual memory management.

Think of it like a rubber band - it stretches to fit whatever text you put in it, and shrinks back down when you remove characters. The class handles all the memory allocation behind the scenes.

Best Practices

Always include <string> header: std::string requires #include <string> to use. The compiler will give errors without it.

Use std::string for all text handling: Prefer std::string over C-style char arrays for safety and convenience.

Use .empty() to check for empty strings: More readable than comparing length to 0.

Use .at() for safe access: When accessing characters, use .at(index) during development to catch out-of-bounds errors.

Common Mistakes

Forgetting to include <string>: You must #include <string> to use std::string. Missing this header causes compiler errors.

Concatenating two string literals: You cannot do "Hello" + "World" directly. At least one operand must be a std::string.

Accessing out of bounds with []: Using [] does not check bounds. Use .at() or ensure your index is valid.

Comparing with C-style strings incorrectly: std::string uses == for comparison, but mixing with char* requires care.

Debug Challenge

This code tries to concatenate string literals but won't compile. Click the highlighted line to fix it:

1 #include <iostream>

2 #include <string>

3

4 int main() {

5 std::string result{"Hello" + " World"};

6 std::cout << result << "\n";

7 return 0;

8 }

std::string result{"Hello" + " World"}; std::string result{std::string{"Hello"} + " World"}; std::string result{"Hello" - " World"}; std::string result{"Hello" * " World"};

Quick Quiz

1. What does str.length() return for the string "Hello World"?

11

10

5

"Hello" has 5 characters, the space is 1 character, and "World" has 5 characters, totaling 11.

2. Which is the preferred way to check if a string is empty?

if (str.empty())

if (str.length() == 0)

if (str == "")

While all three work, .empty() is the most readable and efficient way to check if a string is empty. It clearly expresses intent.

3. What is the difference between [] and .at() for accessing characters?

.at() provides bounds checking and throws exception if out of bounds, [] does not

No difference

[] is always safer

The .at() method checks if the index is valid and throws an exception if out of bounds. The [] operator does not check bounds, which is faster but potentially unsafe.

Check Answers Try Again

Practice Playground

Time to try out what you just learned! Play with the example code below, experiment by making changes and running the code to deepen your understanding.

Run Code Reset

Output:

Error:

Lesson Progress

• Fix This Code
• Quick Quiz
• Practice Playground - run once

Complete Lesson