Adding Extraordinarily Large Numbers in C++

Hello and welcome! Today, we'll delve deep into a captivating problem involving large numbers -- specifically, adding extraordinarily large numbers. As you may have noticed, traditional calculators and even some programming languages struggle when dealing with excessively large numbers. To handle such scenarios efficiently, we'll simulate this process manually using strings. By the end of this discussion, you'll be able to add together numbers that have thousands or even tens of thousands of digits. Intriguing, right? Let's get started!

In today's task, we'll venture into the realm of large numbers, in which we are given two exceedingly large positive integers. However, these aren't your average, everyday large numbers. They are so enormous they're represented as strings that can be up to 10,000 digits long!

Your mission, should you choose to accept it, is to write a C++ function that adds these two "string-numbers" together. The challenge is to perform the addition without converting these entire strings into integers.

At the end, your function should return the resulting sum, represented as a string. At first glance, this might seem daunting, but don't worry -- we'll break it down step by step, emulating the way we manually add numbers.

Before we dive into the code, let's first discuss the strategy we're going to follow. Remember that every digit in a number carries value, and the position of the digit determines its influence on the total value of the number. This system is known as place-value notation.

The first step involves initializing our variables. We'll use two ints, i and j, to point to the current digit in num1 and num2, respectively. We'll also need a carry int variable to hold the carryovers from each addition operation. Lastly, we'll use a vector of chars, named result, to store our resultant number, where each digit from the addition is appended to the front.

std::string addLargeNumbers(std::string num1, std::string num2) {
    int i = num1.size() - 1;
    int j = num2.size() - 1;
    int carry = 0;
    std::vector<char> result;

After initializing our variables, it's time to move on to the next step. Here, we'll scan through num1 and num2 from right to left, moving from the least significant digit to the most significant one.

For each iteration, we extract the digits n1 from num1 and n2 from num2. If i or j is less than 0, that means we've processed all the digits in one of the numbers. Therefore, we treat any additional digits as 0.

std::string addLargeNumbers(std::string num1, std::string num2) {
    int i = num1.size() - 1;
    int j = num2.size() - 1;
    int carry = 0;
    std::vector<char> result;
    
    while(i >= 0 || j >= 0 || carry) {
        int n1 = (i >= 0) ? num1[i] - '0' : 0;
        int n2 = (j >= 0) ? num2[j] - '0' : 0;
        i--;
        j--;