大きい整数の4則演算

前に「大実数」のアルゴリズムを書いたことがありますが、そのアルゴリズムはC++、加算と乗算のみ、注釈が不完全です(Δεν ξέρω καν τι γράφω).やはり責任ある態度でソースコードをリセットしましょう.
前作:線形順序表(配列)で大実数加算と大実数乗算を計算する

/**
 * @(#) BigInteger.h
 *   ：Legend_1949
 *     ：2019 1 9 
 *   ：C
 **/
#pragma once
#include 
#include 

 //        
#define PRECISION (25)

//      
typedef struct
{
    int valueArray[PRECISION];
} BigInteger;
typedef const char * String;

//     
BigInteger setValue(String _string)
{
    //            ，        0
    BigInteger temp = { {0} };
    //            
    int length = strlen(_string);
    for (int i = length - 1, j = PRECISION - 1; i >= 0; i--, j--)
    {
        //                ，        
        temp.valueArray[j] = (int)(_string[i] - '0');
    }
    return temp;
}

//     
String getValue(BigInteger _bigInteger)
{
    char *string = (char *)calloc(PRECISION + 1, sizeof(char));
    string[PRECISION] = '\0';
    for (int i = 0; i < PRECISION; i++)
    {
        //                    
        string[i] = (char)(_bigInteger.valueArray[i] + '0');
    }
    //         （          0），             
    char *temp = string;
    //           
    while (*temp == '0')
    {
        temp++;
    }
    //   C               ，              
    return temp;
}

//      
BigInteger add(BigInteger _param1, BigInteger _param2)
{
    //      
    BigInteger result = { {0} };
    //     
    int extra = 0;
    //        （ ）   （ ）  
    for (int i = PRECISION - 1; i >= 0; i--)
    {
        int sum = _param1.valueArray[i] + _param2.valueArray[i] + extra;
        result.valueArray[i] = sum % 10;
        extra = sum / 10;
    }
    return result;
}

//      
BigInteger minus(BigInteger _param1, BigInteger _param2)
{
    //      
    BigInteger result = { {0} };
    //     
    int borrow = 0;
    //        （ ）   （ ）  
    for (int i = PRECISION - 1; i >= 0; i--)
    {
        //         ，     
        if (_param1.valueArray[i] < _param2.valueArray[i])
        {
            result.valueArray[i] = 10 + _param1.valueArray[i] - _param2.valueArray[i] - borrow;
            borrow = 1;
        }
        //       
        else
        {
            result.valueArray[i] = _param1.valueArray[i] - _param2.valueArray[i] - borrow;
            borrow = 0;
        }
    }
    return result;
}

//      
BigInteger multipy(BigInteger _param1, BigInteger _param2)
{
    //      
    //              ，          ，      
    int temp[2 * PRECISION] = { {0} };
    //      ，      
    //  1 ，        ，       
    for (int i = PRECISION - 1; i >= 0; i--)
    {
        for (int j = PRECISION - 1; j >= 0; j--)
        {
            // ★  ：                 
            temp[i + j + 1] = temp[i + j + 1] + _param1.valueArray[j] * _param2.valueArray[i];
        }
    }
    //  2 ，         
    int extra = 0;
    for (int i = PRECISION - 1; i >= 0; i--)
    {
        int sum = temp[i] + extra;
        temp[i] = sum % 10;
        extra = sum / 10;
    }
    //       
    BigInteger result = { {0} };
    //               
    for (int i = 0; i < PRECISION; i++)
    {
        result.valueArray[PRECISION - i - 1] = temp[2 * PRECISION - i - 1];
    }
    return result;
}

//      
int compare(BigInteger _param1, BigInteger _param2)
{
    //    （ ）   （ ），    
    for (int i = 0; i < 25; i++)
    {
        //    -1
        if (_param1.valueArray[i] < _param2.valueArray[2])
        {
            return -1;
        }
        //    1
        else if (_param1.valueArray[1] > _param2.valueArray[2])
        {
            return 1;
        }
    }
    //       0
    return 0;
}

//      
BigInteger divide(BigInteger _param1, BigInteger _param2)
{
    //    ，           
}