C++ offers powerful ways to handle and process textual data using strings. Understanding how to manipulate strings is fundamental for tasks ranging from user input validation to data parsing.

In this article, you will learn how to declare, initialize, combine, access, search, and modify strings efficiently in C++.

Problem Statement

Working with text is a core part of many applications. Whether you're processing user input, reading from files, or generating reports, you'll constantly need to perform operations like combining pieces of text, extracting specific words, or changing parts of a sentence. C++ provides the std::string class to make these tasks straightforward and safe.

You should have knowledge of the following topics in C++ to understand these programs:

• C++ main() function
• C++ for loop
• C++ while loop
• Basic data types (e.g., int, char)
• #include directive
• using namespace std;

Use Case Studies or Examples

Imagine you're building:

• A chat application: You'd need to combine usernames with messages, extract commands from user input, or search for keywords.
• A file parser: You'd read lines of text and need to split them into parts, convert specific numeric strings to integers, or replace outdated text.
• A user registration form: You'd validate email formats, ensure passwords meet length requirements, or capitalize names.

 

These scenarios all rely heavily on string manipulation techniques.

Solution Approaches with Code Snippets

Let's explore common string manipulation techniques in C++ with practical examples.

1. Declaration, Initialization, and Basic Output

Strings can be declared and initialized in various ways, and then easily printed to the console.

// String Declaration and Output
#include 
#include  // Required for std::string
using namespace std;

int main() {
    // Step 1: Declare an empty string
    string greeting;

    // Step 2: Initialize a string using direct assignment
    string name = "Alice";

    // Step 3: Initialize with another string
    string message = "Hello, " + name + "!";

    // Step 4: Initialize using constructor (can specify length and char)
    string stars(10, '*'); // Creates a string with 10 asterisks

    // Step 5: Output strings
    cout << "Greeting: " << greeting << endl; // Will be empty
    cout << "Name: " << name << endl;
    cout << "Message: " << message << endl;
    cout << "Stars: " << stars << endl;

    return 0;
}

Run

2. Concatenation (Joining Strings)

Concatenation is the process of joining two or more strings together to form a single string. The + operator and the append() method are commonly used.

// String Concatenation
#include 
#include 
using namespace std;

int main() {
    // Step 1: Declare two strings
    string part1 = "C++ ";
    string part2 = "Programming";

    // Step 2: Concatenate using the '+' operator
    string fullString = part1 + part2;
    cout << "Concatenated with '+': " << fullString << endl;

    // Step 3: Concatenate using the append() method
    string anotherString = "Hello";
    anotherString.append(", World!");
    cout << "Concatenated with append(): " << anotherString << endl;

    // Step 4: Concatenate a character literal
    string text = "Number: ";
    text += '5'; // Appends character '5'
    cout << "Concatenated with += char: " << text << endl;

    return 0;
}

Run

3. Accessing Characters and String Length

You can access individual characters within a string using array-like indexing ([]) or the at() method. The length() or size() methods return the number of characters in the string.

// Accessing Characters and Length
#include 
#include 
using namespace std;

int main() {
    // Step 1: Declare a sample string
    string myString = "Example";

    // Step 2: Get the length of the string
    cout << "String: " << myString << endl;
    cout << "Length: " << myString.length() << endl; // Or myString.size()

    // Step 3: Access characters using [] operator
    cout << "First character: " << myString[0] << endl;   // 'E'
    cout << "Last character: " << myString[myString.length() - 1] << endl; // 'e'

    // Step 4: Access characters using at() method (provides bounds checking)
    cout << "Character at index 2 (at()): " << myString.at(2) << endl; // 'a'

    // Step 5: Iterate through the string using a for loop
    cout << "Characters in string: ";
    for (int i = 0; i < myString.length(); ++i) {
        cout << myString[i] << " ";
    }
    cout << endl;

    return 0;
}

Run

4. Finding and Extracting Substrings

The find() method helps locate the position of a substring, and substr() extracts a portion of the string.

// Finding and Extracting Substrings
#include 
#include 
using namespace std;

int main() {
    // Step 1: Declare a source string
    string sentence = "The quick brown fox jumps over the lazy dog.";

    // Step 2: Find the position of a substring
    string searchWord = "fox";
    size_t foundPos = sentence.find(searchWord); // size_t is an unsigned type

    if (foundPos != string::npos) { // string::npos indicates not found
        cout << "'" << searchWord << "' found at position: " << foundPos << endl;

        // Step 3: Extract a substring starting from the found position
        // Syntax: substr(start_index, length)
        string extractedWord = sentence.substr(foundPos, searchWord.length());
        cout << "Extracted word: " << extractedWord << endl;

        // Step 4: Extract a substring from a specific point to the end
        string restOfString = sentence.substr(foundPos);
        cout << "Rest of the string from 'fox': " << restOfString << endl;

        // Step 5: Extract a specific range (e.g., "quick brown")
        size_t startQ = sentence.find("quick");
        string quickBrown = sentence.substr(startQ, 11); // "quick brown" has 11 chars
        cout << "Extracted 'quick brown': " << quickBrown << endl;

    } else {
        cout << "'" << searchWord << "' not found." << endl;
    }

    return 0;
}

Run

5. Replacing Substrings

The replace() method allows you to substitute a part of a string with another string.

// Replacing Substrings
#include 
#include 
using namespace std;

int main() {
    // Step 1: Declare an initial string
    string original = "I like apples and bananas.";
    cout << "Original string: " << original << endl;

    // Step 2: Replace a substring
    // Syntax: replace(start_index, length_to_replace, replacement_string)
    size_t pos = original.find("apples");
    if (pos != string::npos) {
        original.replace(pos, 6, "oranges"); // Replace "apples" (6 chars) with "oranges"
        cout << "After replacing 'apples': " << original << endl;
    }

    // Step 3: Replace a substring with something shorter
    original = "The quick brown fox.";
    pos = original.find("brown");
    if (pos != string::npos) {
        original.replace(pos, 5, "red"); // Replace "brown" (5 chars) with "red"
        cout << "After replacing 'brown': " << original << endl;
    }

    // Step 4: Replace a substring with something longer
    original = "Hello World!";
    original.replace(6, 5, "C++ Community"); // Replace "World" (5 chars) with "C++ Community"
    cout << "After replacing 'World': " << original << endl;

    return 0;
}

Run

6. User Input with getline()

When reading user input that might contain spaces, std::cin stops at the first whitespace. std::getline() is essential for reading entire lines of text.

// Reading Entire Lines of User Input
#include 
#include 
using namespace std;

int main() {
    // Step 1: Declare a string to store user input
    string fullName;
    string city;

    // Step 2: Prompt for full name and read it using getline()
    cout << "Please enter your full name: ";
    // getline(input_stream, string_variable)
    getline(cin, fullName);
    cout << "Hello, " << fullName << "!" << endl;

    // Step 3: Be careful with mixed cin and getline
    // If there's a leftover newline character in the buffer from a previous cin >>,
    // getline might read it immediately as an empty line.
    int age;
    cout << "Enter your age: ";
    cin >> age;

    // Clear the newline character from the input buffer
    cin.ignore(); // Discards characters up to and including the next newline

    cout << "Enter your city: ";
    getline(cin, city); // Now it will correctly read the city
    cout << "You are " << age << " years old and live in " << city << "." << endl;

    return 0;
}

Run

Conclusion

Manipulating strings is a cornerstone of C++ programming. The std::string class provides a rich set of methods that make handling textual data intuitive and robust. From basic declaration and concatenation to advanced finding and replacing operations, these tools empower you to process and transform text effectively in your applications.

Summary

• std::string is the standard way to handle text in C++.
• Strings can be initialized directly, copied, or constructed with repeating characters.
• The + operator and append() concatenate strings.
• Individual characters are accessed using [] or at().
• length() or size() return the string's length.
• find() locates substrings, returning string::npos if not found.
• substr() extracts portions of a string.
• replace() substitutes parts of a string.
• getline(cin, yourString) is crucial for reading entire lines of user input, including spaces.

Test Your Knowledge!

1. What is the main advantage of using std::string over C-style character arrays (char[])?
2. How would you combine the strings "Good" and "Morning" into a single string "GoodMorning"? Provide two different ways.
3. If you have a string std::string s = "C++ Programmer";, how would you extract the word "Programmer" into a new string?
4. Why is std::getline() preferred over std::cin >> for reading a user's full name?

Share your answers or experiment with these concepts in your own C++ compiler!