Handling Large Numbers in C: A Comprehensive Guide to Addition, Subtraction, and Multiplication Using Character Strings

When dealing with numbers that exceed the limits of standard data types like int or long long in the C programming language, it becomes necessary to use character strings to represent these numbers. This article provides a step-by-step guide on how to perform basic operations such as addition, subtraction, and multiplication on large numbers represented as strings.

1. Addition

Objective: To add two large numbers represented as character strings.

#include stdio.h
#include string.h
#include stdlib.h
void addLargeNumbers(char num1[], char num2[], char result[])
{
    int len1  strlen(num1);
    int len2  strlen(num2);
    int carry  0, sum, i, j, k;
    // Initialize result index
    result[k  len1   len2   1]  0;
    k--;
    // Add from the end of both strings
    for (i  len1 - 1, j  len2 - 1; i > 0 || j > 0 || carry ! 0; i--, j--)
    {
        int digit1  (i > 0) ? num1[i] - '0' : 0;
        int digit2  (j > 0) ? num2[j] - '0' : 0;
        sum  digit1   digit2   carry;
        result[k--]  sum % 10   '0';
        carry  sum / 10;
    }
    // Move result to the front if necessary
    memmove(result, result   1, k   2);
}
int main() {
    char num1[]  "12345678901234567890";
    char num2[]  "98765432109876543210";
    char result[200]; // Make sure its large enough
    addLargeNumbers(num1, num2, result);
    printf("%s
", result);
    return 0;
}

2. Subtraction

Objective: To subtract one large number from another, represented as character strings, where the first number is always greater than or equal to the second number.

#include stdio.h
#include string.h
#include stdlib.h
void subtractLargeNumbers(char num1[], char num2[], char result[])
{
    int len1  strlen(num1);
    int len2  strlen(num2);
    int borrow  0, diff, i, j, k;
    // Assuming num1  num2 for simplicity
    for (i  len1 - 1, j  len2 - 1; i > 0; i--, j--)
    {
        int digit1  num1[i] - '0';
        int digit2  (j > 0) ? num2[j] - '0' : 0;
        diff  digit1 - digit2 - borrow;
        if (diff  0)
        {
            diff   10;
            borrow  1;
        }
        else
        {
            borrow  0;
        }
        result[k--]  diff   '0';
    }
    // Null terminate result
    result[k   1]  0;
}
int main() {
    char num1[]  "12345678901234567890";
    char num2[]  "98765432109876543210";
    char result[200]  "";
    subtractLargeNumbers(num1, num2, result);
    printf("%s
", result);
    return 0;
}

3. Multiplication

Objective: To multiply two large numbers represented as character strings.

#include stdio.h
#include string.h
#include stdlib.h
void multiplyLargeNumbers(char num1[], char num2[], char result[])
{
    int len1  strlen(num1);
    int len2  strlen(num2);
    int tempResult[len1 * len2];
    memzero(tempResult, sizeof(tempResult)); // Initialize all zeros
    // Reverse both numbers for easier calculation
    for (int i  len1 - 1; i  0; i--)
    {
        for (int j  len2 - 1; j  0; j--)
        {
            int mul  (num1[i] - '0') * (num2[j] - '0');
            int sum  (i   j   1)  3 | 1; // Position of sum in tempResult
            tempResult[sum]   mul;
        }
    }
    // Convert result to string
    k  0;
    while (k  len1   len2  tempResult[k]  0) k; // Skip leading zeros
    if (k  len1   len2)
    {
        strcpy(result, "0");
    }
    else
    {
        for (int i  0; i  len1   len2 - k; i  )
        {
            result[i]  tempResult[i   k] % 10   '0';
        }
        result[len1   len2 - k]  0;
    }
}
int main() {
    char num1[]  "1234567890";
    char num2[]  "9876543210";
    char result[200]  "";
    multiplyLargeNumbers(num1, num2, result);
    printf("%s
", result);
    return 0;
}

Explanation

Addition: The function adds digits from the rightmost end while keeping track of the carry. It handles different lengths of numbers by treating missing digits as zeros.

Subtraction: This function assumes the first number is greater than or equal to the second. It processes from the rightmost digit, borrowing as necessary.

Multiplication: The multiplication function uses a temporary array to store intermediate results. Each digit of the first number is multiplied by each digit of the second number, and the results are accumulated in the correct positions.

Notes

Result Array Size: Ensure that the result arrays are large enough to hold the results of the operations. Error Handling: Error handling like checking if the first number is smaller than the second in subtraction is minimal for simplicity. Libraries: For very large numbers, consider using libraries like GMP (GNU Multiple Precision Arithmetic Library) for more efficient and comprehensive handling.