C++ Array & String Decoding Tutorial: Master File I/O with Real-World Examples

Introduction: Why Array & String Skills Matter in 2026

In today's data-driven world – from AI chatbots parsing user queries to gaming leaderboards processing millions of scores – understanding arrays and string manipulation is fundamental. This tutorial will guide you through a practical C++ problem: decoding encoded ID strings from files and filtering them based on commands. By the end, you'll be comfortable with array management, string handling, and basic file operations.

Understanding the Problem: Decoding Encoded IDs

Imagine you're working on a system that receives encoded user IDs from a data source. Each ID consists of a character set (mapping letters to numbers) and an ID string containing letters, digits, and hash signs. Your task is to decode each ID by replacing letters with their numeric equivalents from the character set, then replacing hash signs with their index positions in the string. After decoding, you'll filter IDs based on commands like first4 or last4.

Example Walkthrough

Given input: a:123;b:456;c:789;id:c11ba3#2b#a

1. Replace letters: c→789, b→456, a→123 → 789114561233#2456#123
2. Replace hash signs with their indices: first # at index 12, second at 17 → 78911456123312245617123

Step 1: Reading and Cleaning Input

Your program must read from a file that may contain empty lines and spaces. Use ifstream to read line by line, and erase or remove_if to strip whitespace. Store valid entries in an array of strings.

#include <iostream>
#include <fstream>
#include <string>
#include <algorithm>

using namespace std;

const int MAX_ENTRIES = 100;

int main() {
    ifstream inputFile("input.txt");
    string entries[MAX_ENTRIES];
    int count = 0;
    string line;
    while (getline(inputFile, line)) {
        line.erase(remove_if(line.begin(), line.end(), ::isspace), line.end());
        if (line.empty()) continue;
        // Check if entry has both char set and id part
        size_t pos = line.find(";id:");
        if (pos != string::npos) {
            entries[count++] = line;
        }
    }
    return 0;
}

Step 2: Parsing the Character Set

Each entry has two parts: the character set and the ID string. The character set contains mappings like a:123;b:456;c:789. Use stringstream or manual parsing to extract each mapping into a separate array or map. For simplicity, we'll store mappings in two parallel arrays: one for letters, one for numbers.

char letters[10];
string numbers[10];
int mapCount = 0;

// Assume entry string is stored in 'entry'
size_t idPos = entry.find(";id:");
string setPart = entry.substr(0, idPos);
string idPart = entry.substr(idPos + 4); // skip ";id:"

stringstream ss(setPart);
string mapping;
while (getline(ss, mapping, ';')) {
    size_t colon = mapping.find(':');
    letters[mapCount] = mapping[0];
    numbers[mapCount] = mapping.substr(2);
    mapCount++;
}

Step 3: Decoding the ID String

Now replace each letter in the ID string with its corresponding number. Iterate through the ID string, and for each character that is a letter, find its mapping and replace. Also, keep track of the current index to replace hash signs later.

string decoded = "";
int index = 0;
for (char ch : idPart) {
    if (isalpha(ch)) {
        // Find mapping
        for (int i = 0; i < mapCount; i++) {
            if (letters[i] == ch) {
                decoded += numbers[i];
                index += numbers[i].length();
                break;
            }
        }
    } else if (ch == '#') {
        // Replace with current index as string
        decoded += to_string(index);
        index += to_string(index).length();
    } else {
        decoded += ch;
        index++;
    }
}

Step 4: Handling Commands and Filtering

The command file contains lines like first4:1234 or last4:6789. Read all commands into arrays, then for each decoded ID, check if it matches any of the criteria. If both first4 and last4 commands exist, the ID must satisfy at least one value from each category.

string first4Cmds[10];
int firstCount = 0;
string last4Cmds[10];
int lastCount = 0;

// Read commands from file
ifstream cmdFile("commands.txt");
string cmd;
while (getline(cmdFile, cmd)) {
    cmd.erase(remove_if(cmd.begin(), cmd.end(), ::isspace), cmd.end());
    if (cmd.empty()) continue;
    size_t colon = cmd.find(':');
    string type = cmd.substr(0, colon);
    string value = cmd.substr(colon + 1);
    if (type == "first4") {
        first4Cmds[firstCount++] = value;
    } else if (type == "last4") {
        last4Cmds[lastCount++] = value;
    }
}

// For each decoded ID, check if it matches criteria
for (int i = 0; i < decodedCount; i++) {
    string id = decodedIDs[i];
    bool matchFirst = (firstCount == 0); // if no first4 commands, treat as match
    if (!matchFirst) {
        for (int j = 0; j < firstCount; j++) {
            if (id.substr(0,4) == first4Cmds[j]) {
                matchFirst = true;
                break;
            }
        }
    }
    bool matchLast = (lastCount == 0);
    if (!matchLast) {
        for (int j = 0; j < lastCount; j++) {
            if (id.substr(id.length()-4) == last4Cmds[j]) {
                matchLast = true;
                break;
            }
        }
    }
    if (matchFirst && matchLast) {
        outputFile << id << endl;
    }
}

Putting It All Together: Complete Program Structure

Combine all steps into a main function that reads input, decodes each entry, reads commands, and writes filtered results to an output file. Remember to handle edge cases: empty entries, invalid formats, and empty command files (print all valid IDs).

Trend Connection: How This Applies to AI and Gaming

In 2026, AI systems often process encoded data streams – like decoding tokens from a language model or parsing game telemetry. This assignment mirrors real-world tasks: handling messy input, extracting structured data, and applying filters. For example, a gaming platform might decode player IDs to match them with tournament brackets based on first/last digits. Understanding these fundamentals prepares you for more advanced topics like data structures and algorithms.

Common Pitfalls and Tips

• Whitespace removal: Always clean input lines before processing to avoid errors.
• Index tracking: When replacing letters with numbers of variable length, update the index correctly for hash sign replacements.
• Command logic: If no commands exist, output all valid IDs. If both first4 and last4 commands exist, apply AND logic.
• Array bounds: Use constants for maximum sizes and validate counts to avoid overflow.

Conclusion

You've now built a C++ program that demonstrates core skills: array management, string manipulation, and file I/O. This foundation is essential for more complex assignments like linked lists (HW2) and beyond. Practice by extending the program to handle additional command types or larger datasets.