Introduction to C++ Strings

The first is a string type that the standard library provides.

Programming

Why Programs Keep Returning to Text

Almost every useful program handles text at some point. A program may read a name a user typed, combine pieces of a message, search a file for a keyword, or reformat a line of data before printing it. Operations like these are what programmers call text manipulation, and text manipulation is a major part of most programs. Handling text well is therefore a basic skill in C++.

As you read, keep one question in mind: when a program needs to change or search text, what kind of tool does it reach for? In C++, the answer has two main parts. The first is a string type that the standard library provides. The second is regular expression matching, which is offered to help find patterns in text. This article follows both tools, starting from the older way of handling text and working toward the newer one.

Two Tools for Text in C++

The two tools solve different halves of the same problem. The string type is for holding text and changing it, so the program can build, extend, and measure a piece of text. Regular expression matching is for asking questions about text, such as whether it contains a certain shape. Many programs use both: they build a string, then check it against a pattern before deciding what to do next.

Key point

One tool changes text and the other checks text. Keeping that split in mind makes the rest of this article easier to follow.

The Burden of Character Arrays

Text in C++ can be held as an array of characters. Working with that kind of array directly means handling the characters through pointers, which is the style of text handling that C programmers relied on. Every change, from reading a character to building a longer message, is done by the programmer at the level of positions and pointers.

The C++ standard library offers a string type specifically to save most users from that C-style manipulation. The main point is not that it makes text possible, since character arrays already did that. The point is that it removes a layer of careful, low-level work from everyday tasks, so the programmer can focus on what the text should become rather than on how the characters are laid out and reached.

Read the diagram as a contrast rather than a sequence. It shows which work the programmer has to do under each approach. The source does not describe the internal workings of the string type, so the diagram stays at the level of who carries the work, not how the characters are stored underneath.

Extending Text Without Pointers

The following small program uses the standard library string type. It creates a string, extends it, and then prints the result along with its length. Read it first, then try to predict its output before looking at the reveal.

cpp

#include <iostream>
#include <string>

int main() {
    std::string message = "Hello";
    message += ", world";
    std::cout << message << " " << message.length() << "\n";
}

#include <iostream>
#include <string>

int main() {
    std::string message = "Hello";
    message += ", world";
    std::cout << message << " " << message.length() << "\n";
}

Notes on the code

std::string holds the text and lets the program change it directly
The += operator extends the text in place without any pointer arithmetic
length() reports how many characters the string currently holds

What do you think happens?

What does the program print?

Hello, world
Hello, world 12
Hello 5
Hello, world 5

Reveal answer

Answer:

Hello, world 12

message starts as Hello, then += adds , world to give Hello, world, which has 12 characters including the space. The program prints the text, a space, then the length.

Worked example

Tracing the string through the program

Follow the value of message from its creation to the final printed line.

1
Initialize
message is created holding Hello, which is 5 characters.
2
Extend
The += operator appends , world, so message now holds Hello, world.
3
Print
The program prints the text, a space, and the length, which is 12.

Result

Output: Hello, world 12

Notice what the program does not do. It never computes positions with pointers and never manages the memory of the characters by hand. The += operator extends the text, and the programmer describes the change at the level of the text itself. This is the everyday benefit the string type is meant to provide.

Matching Patterns Instead of Changing Text

Sometimes a program does not need to change text at all. It needs to know whether a certain shape appears in it. Regular expression matching is the tool for that job. The source says it is offered to help find patterns in text, so you describe the pattern you care about and ask whether the text contains something that fits it.

The regular expressions in C++ are provided in a form similar to what is common in most modern languages. If you have seen pattern matching elsewhere, the core idea carries over: a pattern is written once, and the matching machinery checks text against it. The source does not describe the full pattern syntax, so this article focuses on the purpose and the basic workflow rather than on every symbol.

Consider a simple question: does this line contain at least one digit? The pattern for that question matches any single character from zero through nine, one or more times in a row. In the code below, the pattern is written inside a string literal, which is a common point of confusion.

cpp

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::string line = "Order 66 shipped";
    std::regex digits("[0-9]+");
    if (std::regex_search(line, digits)) {
        std::cout << "Line contains a digit\n";
    }
}

#include <iostream>
#include <regex>
#include <string>

int main() {
    std::string line = "Order 66 shipped";
    std::regex digits("[0-9]+");
    if (std::regex_search(line, digits)) {
        std::cout << "Line contains a digit\n";
    }
}

Output

Line contains a digit

Notes on the code

The pattern [0-9]+ describes one or more characters from zero through nine
The pattern is written once as a string literal and then used for the check
The program never prints the digits themselves, only whether a match was found

The program does not print the digits. It only confirms that a pattern was found. If the line contained no digits, the check would fail and the message would be skipped. This shows the split of responsibilities regular expression matching offers: you describe the shape, and the library checks the text against it.

Character Types and Unicode

Both string objects and regex objects are not limited to a single kind of character. The source states that they can use a variety of character types, and it gives Unicode as an example. Text in a program is not always simple English letters, so this flexibility matters when a program handles text from many languages or from a wide range of symbols.

The practical point is that choosing a character type is part of working with text, and the string and regex tools are designed to accommodate more than one of them. The source does not list the full set of character types or explain how to select one. Treat Unicode as the example the source gives, and check the library documentation for the specific types available in your environment.

What String Implementation Covers

This article introduces string implementation in C++. A string is a sequence of text, and this chapter's focus is on how strings are implemented in C++, meaning the internal details behind how the language represents and handles them. Implementation is distinct from usage, which is how code works with a string. When a lesson moves from using a string to explaining how it works underneath, it is shifting from usage to implementation.

The section this article draws on is titled string Implementation and is described as containing information about string implementation in C++. Its concept entry is named C++ String Implementation and covers the implementation details of strings in C++.

Questions to Ask Before Reading Internals

A useful way to learn an internal topic is to turn the heading into concrete questions before reading the details. Asking the questions first gives you a way to check whether the details actually answer what you wanted to know. These questions are generated for study purposes. They are not statements of fact about C++ strings, and each should be answered by the detailed source you use.

How is the text itself held, and where does the stored text start and end?
Where does the end of a C-style character array get marked, and how does a string type mark its own end?
What is stored alongside the characters, such as a length, and where does that information live?
What happens to the memory when text is appended to a string?
What happens to the memory when a string is copied?
How does a string type parameterized on a character type relate to the different character types it can use?

MEDIUM

Choose two of the questions above. For each, write one sentence describing what you would expect the answer to be, then write down which section of a fuller reference you would check to confirm it. Do not treat your expectation as a fact until you have checked it.

Hints

Start with the question about appending, since the source's example uses += to extend text.
The question about end markers can be answered only from the detailed internal account, not from this article.

Your attempt (not saved)

Common Mistakes with C++ Strings

Common mistake
Thinking the string type is what makes text possible in C++
Why it fails
The source states that text was already possible with character arrays. The string type removes low-level work rather than adding a capability.
Do this instead
Describe the string type as a way to spare everyday tasks from pointer-level handling.
Common mistake
Writing a regex pattern with a single backslash inside a C++ string literal
What it looks like
std::regex bad("\d+"); written with a single backslash in the literal
Why it fails
A backslash in a string literal begins an escape sequence, and the d in this case does not form a valid one, so the pattern never reaches the regex engine as intended.
Do this instead
Write the backslash doubled, as in the two-backslash form of \d+, or use an explicit character range such as [0-9]+ as in the example above.
Common mistake
Assuming the source explains how the string type is laid out internally
Why it fails
The source covers string implementation only at the level of a heading and short description.
Do this instead
Frame your questions here, then take the detailed internal account from a fuller reference.
Common mistake
Assuming regular expressions and string objects only handle plain English letters
Why it fails
The source says both can use a variety of character types, with Unicode given as an example.
Do this instead
Check the library documentation for which character types your environment supports.

Key Takeaways

Text manipulation is a major part of most programs, so handling text well is a basic skill in C++.
The C++ standard library string type exists to spare most users from pointer-level handling of character arrays, not to make text possible.
Regular expression matching finds patterns in text: you describe the shape and the library checks the text against it, and both string and regex objects can use a variety of character types, with Unicode as the source's example.
String implementation is about the internal details of how strings are represented and managed; the available source covers only its heading and short description, so detailed internals must come from a fuller reference.
Framing specific questions before reading the internals makes it easier to check whether the details actually answer what you wanted to know.

Related concepts

Character Arrays and Pointers in C++

More concepts starting with I