超长整数类HugeInterger

### 实现 HugeInteger 类用于处理大整数运算

#### 构造函数与初始化
为了确保 `HugeInteger` 对象能够正确表示任意大小的正整数值，构造函数需要负责初始化内部存储结构。通常采用动态数组来保存每一位上的数字。

class HugeInteger {
private:
    std::vector<int> digits; // 使用向量代替固定长度数组以支持更灵活的数据管理
    
public:
    HugeInteger() : digits(1, 0) {} // 默认构造函数设置初始值为零
};

#### 输入功能
提供一种机制让用户可以输入自定义的大整数值。考虑到可能存在的前置零情况，在实际操作前应去除这些不必要的字符[^1]。

void input(std::string numStr) {
    while (!numStr.empty() && numStr.front() == '0') {
        numStr.erase(numStr.begin());
    }
    
    if (numStr.empty()) {
        *this = HugeInteger();
        return;
    }

    for (auto it = numStr.rbegin(); it != numStr.rend(); ++it) {
        digits.push_back(*it - '0');
    }
}

#### 输出显示
当对象被打印出来时，应该按照常规方式展示其代表的实际数值而不是底层数据结构的内容。

void output() const {
    auto nonZeroIt = find_if(digits.rbegin(), digits.rend(),
                             [](int d){return d!=0;} );
    if(nonZeroIt==digits.rend()){
        std::cout << "0";
    }else{
        copy(nonZeroIt,digits.rend(),std::ostream_iterator<int>(std::cout));
    }
}

#### 加法运算
加法规则遵循基本算术原则，逐位相加并考虑进位问题。这里实现了两种形式：一是加上单个整数，二是与其他 `HugeInteger` 进行相加。

void add(int singleDigit){
    int carry=0;
    for(auto& digit:digits){
        int sum=digit+singleDigit+carry;
        digit=sum%10;
        carry=sum/10;
        singleDigit=0;
    }
    if(carry||singleDigit){
        digits.insert(digits.end(),{singleDigit+carry});
    }
}

void add(const HugeInteger &other){
    size_t maxSize=max(this->digits.size(), other.digits.size());
    this->digits.resize(maxSize);
    int carry=0;

    for(size_t i=0;i<maxSize;++i){
        int a=(i<this->digits.size()?this->digits[i]:0);
        int b=(i<other.digits.size()?other.digits[i]:0);

        int sum=a+b+carry;
        if(i<this->digits.size())
            this->digits[i]=sum%10;
        else
            this->digits.push_back(sum%10);
        
        carry=sum/10;
    }
    if(carry)
        this->digits.push_back(carry);
}

#### 减法运算
减法则需要注意借位的情况，并且要特别注意负数的结果处理。同样提供了针对单一整数以及另一个 `HugeInteger` 的重载版本。

bool substract(int singleDigit){
    bool borrow=false;
    for(auto&digit:this->digits){
        int diff=borrow?(digit-1):digit;
        if(diff>=singleDigit){
            digit=diff-singleDigit;
            break;
        }else{
            digit=10+(diff-singleDigit);
            borrow=true;
            continue;
        }
    }
    removeLeadingZeros();
    return !borrow;
}

bool substract(HugeInteger other){
    bool resultIsPositive=true;
    if(!isGreaterThan(other)){
        swap(*this,other);
        resultIsPositive=false;
    }
    reverse(begin(this->digits),end(this->digits));
    reverse(begin(other.digits),end(other.digits));

    for(size_t i=0;i<other.digits.size();++i){
        if(this->digits[i]<other.digits[i]){
            for(size_t j=i;j<this->digits.size()-1;++j){
                if(this->digits[j]==0)this->digits[j]=9;
                else{
                    --this->digits[j];
                    break;
                }
            }
            this->digits[i]+=10-other.digits[i];
        }else{
            this->digits[i]-=other.digits[i];
        }
    }
    reverse(begin(this->digits),end(this->digits));
    removeLeadingZeros();

    return resultIsPositive;
}

#### 比较操作符
比较两个 `HugeInteger` 是否相同或其中一个大于另外一个是非常重要的基础功能之一。这可以通过对比各自位数及对应位置上数字大小完成判断逻辑。

bool isEqual(const HugeInteger &other)const{
    return this->digits==other.digits;
}

bool isGreaterThan(const HugeInteger &other)const{
    if(this->digits.size()>other.digits.size())return true;
    if(this->digits.size()<other.digits.size())return false;
    return lexicographical_compare(rbegin(other.digits),
                                   rend(other.digits),
                                   rbegin(this->digits),
                                   rend(this->digits)) ;
}