STRINGS IN C++

Lesson Content: Strings in C++

Welcome to the lesson dedicated to strings in C++! In this lesson, you will learn what strings are, how to use them, and why they are one of the most important data types when working with text.

This lesson is structured from basic concepts to more advanced techniques, so you can gradually build a strong understanding of string manipulation.

We will cover:

• basic concepts of working with text
• the char data type
• C-style strings (arrays of characters)
• modern C++ strings using std::string
• input, processing, and transformation of text
• real-world string manipulation techniques

What you will learn

Introduction to Strings in C++

Strings in C++ represent sequences of characters used to store and manipulate textual data.

There are two main approaches to working with strings:

• C-style strings: arrays of characters terminated by a null character ('\0'). They require manual memory management and are more error-prone.
• C++ strings (std::string): a modern and safer solution from the standard library (<string>). They automatically manage memory and provide many useful functions.

In this lesson, you will learn how to create, modify, and analyze strings, as well as how to avoid common mistakes when working with text.

Data Type char in C++

The char data type stores a single character. Internally, it is represented as a number (most commonly ASCII code).

It is actually an integer type that occupies 8 bits of memory and is mainly used for storing character codes.

// Example: char stores both character and number
#include <cstdio>

int main() {
    char c = 'A';

    printf("%d, %c\n", c, c);
    // %d → prints numeric value (ASCII code)
    // %c → prints character

    return 0;
}

// Output:
// 65, A

First, the integer value representing the character code of 'A' is displayed, followed by the character itself.

The format specifier "%d" is used for printing the numeric value, while "%c" is used for displaying the character.

ASCII table example

// Print uppercase letters and their ASCII codes
#include <cstdio>

int main() {
    for(char c = 'A'; c <= 'Z'; c++) {
        printf("%c = %d\n", c, c);
    }
    return 0;
}

Special characters

// Apostrophe and escape characters
#include <iostream>
using namespace std;

int main() {
    char a = '\'';   // apostrophe
    char n = '\n';   // new line
    char t = '\t';   // tab

    cout << "Apostrophe: " << a << endl;
    cout << "New line test:" << n << "Next line" << endl;
    cout << "Tab test:" << t << "text" << endl;

    return 0;
}

C-style string

C-style strings originate from the C language and are still supported in C++. They are arrays of characters that must end with a null character '\0'.

// Manual definition
char text[9] = {'G','r','e','e','t','i','n','g','\0'};

A simpler and safer way:

// Automatic null-termination
char text[] = "Greeting";

Connection between char and strings

// Accessing characters inside a string
#include <iostream>
using namespace std;

int main() {
    char text[] = "Hello";

    cout << text[0] << endl; // H
    cout << text[1] << endl; // e

    return 0;
}

Text data in C++

In modern C++, text is stored using the std::string type. It is part of the standard library and represents an object (class), not just a simple array.

You can declare a string in two ways:

// Option 1: using namespace std
using namespace std;

string s = "This is some text.";

// Option 2: without using namespace
std::string s = "This is some text.";

Accessing characters

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

int main() {
    string s = "Hello";

    cout << s[0] << endl; // H
    cout << s[4] << endl; // o

    return 0;
}

Inputting strings from standard input

To read text from input, we use cin and cout from the <iostream> library.

Reading words (cin)

The cin command reads input until the first space.

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

int main() {
    string firstName, lastName;

    cin >> firstName >> lastName; // reads two words

    cout << firstName << " " << lastName << endl;

    return 0;
}

Reading full lines (getline)

To read a full line (including spaces), we use getline().

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

int main() {
    string fullName;

    getline(cin, fullName); // reads entire line

    cout << fullName << endl;

    return 0;
}

Common mistake: cin + getline

int age;
string name;

cin >> age;
getline(cin, name); // problem!

// name will be empty

// Correct solution
int age;
string name;

cin >> age;
cin.ignore(); // remove leftover newline

getline(cin, name);

Entering a complete line of text

To read an entire line of text (including spaces), we use the getline() function.

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

int main() {
    string text;

    getline(cin, text); // reads entire line from input

    cout << text << endl;

    return 0;
}

The first argument of getline() is the input stream (usually cin), and the second argument is the variable where the text will be stored.

Splitting words from input text

Sometimes we need to split a sentence into individual words. This can be done using stringstream.

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

int main() {
    string text;
    getline(cin, text); // read full line

    stringstream ss(text); // create stream from string
    string word;
    int count = 0;

    // extract words separated by space
    while (getline(ss, word, ' ')) {
        cout << word << endl;
        count++;
    }

    cout << "The text contains " << count << " words" << endl;

    return 0;
}

Alternative: reading directly from input

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

int main() {
    string word;
    int count = 0;

    // reads words one by one from input
    while (getline(cin, word, ' ')) {
        cout << word << endl;
        count++;
    }

    cout << "There are " << count << " words" << endl;

    return 0;
}

Basic string operations

Assigning one string to another

We can assign the value of one string to another.

#include <string>
using namespace std;

string str1 = "Hello!";
string str2;

str2 = str1; // copy value from str1 to str2

We can also initialize a string directly from another:

string str1 = "Hello!";
string str2 = str1;

Concatenating strings

Strings can be joined using the + operator.

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

int main() {
    string first_name = "Nenad";
    string last_name = "Milenkovic";

    string full_name = first_name + " " + last_name;

    cout << full_name << endl;

    return 0;
}

String length

To get the number of characters in a string, use length().

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

int main() {
    string city_name;

    cout << "Enter city name: ";
    getline(cin, city_name);

    int length = city_name.length();

    cout << "City: " << city_name << endl;
    cout << "Length: " << length << endl;

    return 0;
}

String comparison

Strings can be compared using standard operators:

• == equal
• != not equal
• <, > lexicographical order

bool b;

b = ("abak" == "abak"); // true
b = ("Ab" < "AA");      // false

Password example

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

int main() {
    string password;

    cin >> password;

    if (password == "@n0nimus_@n0nimus") {
        cout << "Correct password" << endl;
    } else {
        cout << "Incorrect password" << endl;
    }

    return 0;
}

Testing characters using <cctype>

When working with characters in C++, we often need to check their type: whether they are letters, digits, spaces, or special characters.

Instead of writing complex conditions, we can use ready-made functions from the <cctype> header.

Common functions from <cctype>

• isalnum(ch) → letter or digit
• isalpha(ch) → letter
• isdigit(ch) → digit
• islower(ch) → lowercase letter
• isupper(ch) → uppercase letter
• isspace(ch) → whitespace (space, tab, newline)
• ispunct(ch) → punctuation
• iscntrl(ch) → control character
• tolower(ch) → convert to lowercase
• toupper(ch) → convert to uppercase

Example: Character analysis program

This program reads one character and analyzes its properties.

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

int main() {
    char ch;

    cout << "Enter a character: ";
    cin >> ch;

    // letter or digit
    if (isalnum(ch)) {
        cout << ch << " is a letter or digit.\n";
    }

    // letter
    if (isalpha(ch)) {
        cout << ch << " is a letter.\n";
    }

    // digit
    if (isdigit(ch)) {
        cout << ch << " is a digit.\n";
    }

    // lowercase
    if (islower(ch)) {
        cout << ch << " is lowercase.\n";
        cout << "Uppercase: " << (char)toupper(ch) << '\n';
    }

    // uppercase
    if (isupper(ch)) {
        cout << ch << " is uppercase.\n";
        cout << "Lowercase: " << (char)tolower(ch) << '\n';
    }

    // whitespace
    if (isspace(ch)) {
        cout << "Whitespace character detected.\n";
    }

    // punctuation
    if (ispunct(ch)) {
        cout << ch << " is punctuation.\n";
    }

    // control character
    if (iscntrl(ch)) {
        cout << "Control character detected.\n";
    }

    return 0;
}

How this works

• Each function checks one property of the character
• Multiple conditions can be true at the same time
• Example: 'A' is both isalpha and isupper

Task: Split the text into two parts using a comma as a separator.

Expected output:

Masarikova 18
Belgrade

Step-by-step solution

• read the entire line (getline)
• find the position of the comma (find())
• extract the parts (substr())

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

int main() {

    string inputLine;
    string leftPart, rightPart;

    cout << "Enter a line of text: ";
    getline(cin, inputLine);

    // Find the position of the comma
    size_t sepIndex = inputLine.find(',');

    // Check if the comma exists
    if (sepIndex != string::npos) {

        // Left side (before the comma)
        leftPart = inputLine.substr(0, sepIndex);

        // Right side (after the comma)
        rightPart = inputLine.substr(sepIndex + 1);

        cout << leftPart << endl;
        cout << rightPart << endl;

    } else {
        cout << "Comma not found!" << endl;
    }

    return 0;
}

To search for a character or substring inside a larger string, we use the find() function.

Example:

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

int main() {
    string str = "This is a simple example string.";

    // First occurrence of "is"
    size_t pos1 = str.find("is");

    // Search starting from index 5
    size_t pos2 = str.find("is", 5);

    // Last occurrence (search from the end)
    size_t pos3 = str.rfind("is");

    cout << pos1 << " " << pos2 << " " << pos3 << endl;

    return 0;
}

The find() function returns the position of the first occurrence of the given substring.

• find("text") → searches from the beginning
• find("text", pos) → searches starting from position pos
• rfind("text") → searches from the end of the string

To extract a part of a string, we use the substr() function.

Example 1:

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

int main() {
    string text = "Hello world";
    
    // Extract "world"
    string sub = text.substr(6, 5);

    cout << sub << endl;

    return 0;
}

Example 2 (without length):

string text = "Hello world";

// From index 6 to the end
string sub = text.substr(6);

Edge cases:

string text = "012345";

// Valid
string a = text.substr(2, 3); // "234"

// Starting index out of range → throws exception (modern C++)
// string b = text.substr(10, 2);

// Length too large → returns available characters
string c = text.substr(3, 100); // "345"

Useful helper functions for working with strings

In practice, we often need additional operations that are not directly part of the std::string interface, such as:

• splitting a string (split)
• removing whitespace (trim)

Split function (string splitting)

The split function divides a string into multiple parts based on a separator.

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

/*
INPUT:
    inputString = "Ana,Marko,Jovan"
    delimiter = ','

OUTPUT:
    vector containing: ["Ana", "Marko", "Jovan"]
*/

vector<string> split(const string& inputString, char delimiter) {

    vector<string> tokens;   // result container (output)
    size_t startIndex = 0;   // starting position of current token
    size_t delimiterPos;     // position of delimiter in string

    // Loop until no more delimiters are found
    while ((delimiterPos = inputString.find(delimiter, startIndex)) != string::npos) {

        // Extract substring from startIndex to delimiter position
        string token = inputString.substr(startIndex, delimiterPos - startIndex);

        tokens.push_back(token); // store token

        // Move startIndex after the delimiter
        startIndex = delimiterPos + 1;
    }

    // Add the last part (after the final delimiter)
    tokens.push_back(inputString.substr(startIndex));

    return tokens; // return all extracted parts
}

int main() {

    // INPUT STRING (what we want to split)
    string names = "Ana,Marko,Jovan";

    // CALL FUNCTION → OUTPUT is stored in vector
    vector<string> result = split(names, ',');

    // PRINT RESULT
    // Expected output:
    // Ana
    // Marko
    // Jovan
    for (string name : result) {
        cout << name << endl;
    }

    return 0;
}

Trim function (removing whitespace)

The trim function removes whitespace from the beginning and the end of a string.

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

/*
INPUT:
    inputString = "   C++ is awesome!   "

OUTPUT:
    "C++ is awesome!"  (without leading/trailing spaces)
*/

string trim(const string& inputString) {

    size_t startIndex = 0;
    size_t endIndex = inputString.length();

    // Remove leading whitespace
    while (startIndex < endIndex && isspace(inputString[startIndex])) {
        startIndex++;
    }

    // Remove trailing whitespace
    while (endIndex > startIndex && isspace(inputString[endIndex - 1])) {
        endIndex--;
    }

    // Return cleaned substring
    return inputString.substr(startIndex, endIndex - startIndex);
}

int main() {

    // INPUT STRING (contains spaces)
    string text = "   C++ is awesome!   ";

    // CALL FUNCTION → OUTPUT is trimmed string
    string cleanedText = trim(text);

    // PRINT RESULT
    // Expected output: [C++ is awesome!]
    cout << "[" << cleanedText << "]" << endl;

    return 0;
}

To remove or modify parts of a string, we use functions such as erase() and replace().

Example: Deleting part of a string

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

int main() {
    string text = "This is a test";

    // Delete first 7 characters ("This is ")
    text.erase(0, 7);

    cout << text << endl; // Output: "a test"

    return 0;
}

Example: Replacing part of a string

string text = "This is a test";

// Replace "is" with "was"
text.replace(5, 2, "was");

cout << text << endl; // "This was a test"

Iterating Through a String in C++

Very often we need to process a string character by character. For example, we may want to:

• count digits in a string,
• convert letters to uppercase or lowercase,
• remove spaces,
• analyze characters in a text.

In C++, there are several ways to iterate through a string:

• using a classic for loop with an index,
• using a range-based for loop,
• using iterators.

1. Iteration using an index

This method gives full control because we know the position of each character.

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

int main() {

    string text = "Programming";

    // Loop through all characters using index
    for (size_t i = 0; i < text.length(); i++) {
        cout << "Index: " << i 
             << ", Character: " << text[i] << endl;
    }

    return 0;
}

This approach is useful when:

• we need the index (position),
• we modify characters (text[i] = 'A'),
• we compare neighboring characters.

2. Range-based for loop

This is the simplest and most readable way to iterate through a string.

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

int main() {

    string text = "Programming";

    // Loop through characters directly
    for (char c : text) {
        cout << c << " ";
    }

    return 0;
}

If you want to modify characters, use a reference:

for (char &c : text) {
    c = toupper(c); // convert to uppercase
}

3. Using iterators

Iterators are more advanced and are often used with STL algorithms.

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

int main() {

    string text = "Programming";

    for (string::iterator it = text.begin(); it != text.end(); ++it) {
        cout << *it << " ";
    }

    return 0;
}

The iterator behaves like a pointer:

• it → position
• *it → character

Practical examples

1. Counting digits in a string

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

int main() {

    string text = "a1b2c3";
    int count = 0;

    for (char c : text) {
        if (isdigit(c)) {
            count++;
        }
    }

    cout << "Number of digits: " << count << endl;

    return 0;
}

2. Removing spaces from a string

string text = "Hello World Example";
string result = "";

for (char c : text) {
    if (c != ' ') {
        result += c;
    }
}

cout << result; // "HelloWorldExample"

In practice:

• Index-based loops → when position matters
• Range-based loops → clean and readable
• Iterators → advanced usage (STL)

Advanced Operations with std::string in C++

The std::string class in C++ allows powerful text manipulation by combining multiple standard functions into more complex operations.

1. Inserting Substrings

The insert() function allows inserting text at a specific position.

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

int main() {
    string s = "Welcome!";

    s.insert(7, " to C++");

    cout << s << endl;

    return 0;
}

2. Changing Letter Case

Using transform with functions from <cctype>, we can modify all characters in a string.

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

int main() {
    string s = "Welcome to C++";

    transform(s.begin(), s.end(), s.begin(), ::toupper);

    cout << s << endl;

    return 0;
}

3. Combining Multiple Operations

Advanced tasks often require combining several functions together.

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

int main() {
    string s = "   Hello, World!   ";

    // Remove leading spaces
    size_t start = s.find_first_not_of(' ');

    // Remove trailing spaces
    size_t end = s.find_last_not_of(' ');

    // Extract cleaned string
    string trimmed = s.substr(start, end - start + 1);

    cout << trimmed << endl;

    return 0;
}

By mastering these combinations, you can handle real-world tasks like parsing input, cleaning data, and processing text efficiently.

Final Quiz: Strings in C++

Test your understanding of strings in C++. Try to answer the questions before checking the solutions.

string s = "Hello";
s += " World";
cout << s;

string s = "ABCDE";
cout << s.substr(1, 3);