Lecture 11: Strings and Text Processing

## std::string owns and sizes text safely. · Validate an institute email address

An institute address is a department code, a nine-digit roll number, and one fixed domain — three rules checked in order.

~~~cpp
#include <cctype>
#include <iostream>
#include <string>

bool validEmail(const std::string& address) {
    std::size_t sep = address.find('@');
    if (sep == std::string::npos || address.substr(sep) != "@iiti.ac.in") return false;

std::size_t roll = 0;
    while (roll < sep && std::islower(static_cast<unsigned char>(address[roll]))) ++roll;
    if (roll == 0 || sep - roll != 9) return false;

for (std::size_t i = roll; i < sep; ++i)
        if (!std::isdigit(static_cast<unsigned char>(address[i]))) return false;
    return true;
}

int main() {
    std::cout << std::boolalpha << validEmail("che260008041@iiti.ac.in");
}
~~~

**Takeaways**

- std::string owns and sizes text safely.
- find reports failure as npos, never as a position.
- cctype functions require careful character conversion.

## std::string syntax

~~~cpp
std::string <name>;                    // empty, size 0
std::string <name> = "<text>";
std::string <name>(<count>, '<ch>');   // <count> copies of one character

<name>.size()                  // number of characters
<name>.empty()                 // true exactly when size() == 0
<name>[<i>]                    // 0 <= <i> < size(), unchecked
<name>.at(<i>)                 // checked: throws std::out_of_range
<name>.substr(<pos>, <length>) // <pos> must satisfy <pos> <= size()
<name>.find("<needle>")        // returns std::string::npos when not found

std::cin >> <name>;                 // one whitespace-delimited word
std::getline(std::cin, <name>);     // the rest of the line, spaces included
~~~

| Part | Meaning |
| --- | --- |
| `<i>` | Zero-based, so the last character is at <code>size() - 1</code>. An empty string has no valid position. |
| `substr(<pos>, <length>)` | Takes a position and a <em>length</em>, not two positions. A short tail is truncated, not an error. |
| <code>find</code> | Compare the result against <code>std::string::npos</code>. It is not <code>-1</code>, and it is unsigned. |
| <code>[]</code> vs <code>at()</code> | Both read a character. <code>[]</code> is unchecked; <code>at()</code> checks the position and throws <code>std::out_of_range</code> if it is invalid. |
| <code>>></code> vs <code>getline</code> | <code>>></code> stops at the first space and leaves the newline behind; <code>getline</code> consumes the whole line. |

A <code>std::string</code> owns and sizes its own characters, so length is a question you ask the object rather than compute. A C-style string has no size of its own: its end is the first <code>'\0'</code>.

Step 1: Read one word — >> stops at the first space

#include <iostream>
#include <string>

int main() {
    std::string word;
    std::cin >> word;
    std::cout << word << '\n';
}

One word in, one word out. The string sizes itself to whatever arrives, so nothing here fixes a length in advance. >> stops at the first whitespace and leaves the rest of the line unread.

Step 2: Swap >> for getline — keep the spaces

#include <iostream>
#include <string>

int main() {
    std::string line;
    std::getline(std::cin, line);
    std::cout << line << '\n';
}

Replaced: >> with getline. The whole line arrives, spaces included. A preceding >> leaves its newline pending, and the next getline would read an empty line until that newline is consumed.

Step 3: Ask the string for its size — visit every position

#include <cctype>
#include <iostream>
#include <string>

int main() {
    std::string line;
    std::getline(std::cin, line);
    int digits = 0;
    for (std::size_t i = 0; i < line.size(); ++i) {
        if (std::isdigit(static_cast<unsigned char>(line[i]))) ++digits;
    }
    std::cout << digits << '\n';
}

Added: size() as the loop bound and a classification test. The string knows its own length, so there is no terminator to hunt for. isdigit is handed an unsigned char because a negative char value is undefined behavior there.

Step 4: Swap [] for at() — make an invalid position fail loudly

#include <cctype>
#include <iostream>
#include <string>

int main() {
    std::string line;
    std::getline(std::cin, line);
    if (line.empty()) {
        std::cout << "no text\n";
        return 0;
    }
    int digits = 0;
    for (std::size_t i = 0; i < line.size(); ++i) {
        if (std::isdigit(static_cast<unsigned char>(line.at(i)))) ++digits;
    }
    std::cout << digits << '\n';
}

Added: an empty check and at(i). An empty string has no valid position; at throws std::out_of_range instead of causing undefined behavior.

Step 5: Split on a delimiter — check find before taking a substring

#include <iostream>
#include <string>

int main() {
    std::string line;
    std::getline(std::cin, line);
    std::size_t dash = line.find('-');
    if (dash == std::string::npos) {
        std::cout << "no delimiter\n";
        return 0;
    }
    std::cout << line.substr(0, dash) << '\n';
    std::cout << line.substr(dash + 1) << '\n';
}

Added: a search and two substrings. find reports failure as std::string::npos, not -1. substr takes a position and a length, so substr(dash + 1) runs to the end.

## A string knows its size; a C string ends at a terminator

Prefer <code>std::string</code>: it owns its characters and answers <code>size()</code> in constant time. Reach for a C string only when an interface demands one.

## A string is a numbered run of characters

Every operation is stated in positions and lengths. A search that fails answers <code>std::string::npos</code>, so check the result before you pass it anywhere that expects a position.