大数的加法和乘法，高精度

自学了c++primer第五版后，第一次写c++11标准的代码，表示好激动，我竟然搞定了，用了两个下午，大数的加法和乘法，减法和除法不打算写了，以后有空了再把她们补上。

//HugeNum.h
#pragma once

#include <iostream>
#include <string>
#include <utility>
#include <vector>

using std::cout;
using std::cin;
using std::istream;
using std::ostream;
using std::string;

class HugeNum
{
    friend istream &operator >> (istream &,HugeNum &);
    friend ostream &operator << (ostream &,const HugeNum &);
    friend HugeNum operator+(const HugeNum&,const HugeNum&);
    friend HugeNum operator*(const HugeNum&,const HugeNum&);
public:
    HugeNum();
    ~HugeNum();



private:
    string data;
    string::size_type length;
    static const char zeroCh = '0';

    HugeNum &operator+=(const HugeNum&);
    HugeNum &operator*=(const HugeNum&);
    char &operator[](signed);
    size_t GetNum(signed) const;
    HugeNum &InsertFront(size_t &);
};

inline istream & operator>> (istream &in,HugeNum &item)
{
    in >> item.data;

    size_t zeroPos = 0;
    size_t len = item.data.size();

    while (zeroPos < len && item.data[zeroPos] == '0')
    {
        zeroPos++;
    }

    zeroPos = zeroPos == len ? zeroPos - 1 : zeroPos;

    item.data.erase(0,zeroPos);

    item.length = item.data.size();
    return  in;
}

inline ostream & operator<< (ostream &out,const HugeNum &item)
{
    out << item.data;
    return out;
}

inline HugeNum operator+ (const HugeNum &lhn,const HugeNum &rhn)
{
    HugeNum ret;
    if(lhn.length > rhn.length) {
        ret = lhn;
        ret += rhn;
    }
    else
    {
        ret = rhn;
        ret += lhn;
    }

    return ret;
}

inline HugeNum operator* (const HugeNum &lhn,const HugeNum &rhn)
{
    HugeNum ret = lhn;
    ret *= rhn;
    return ret;
}

//HugeNum.cpp
#include "HugeNum.h"

using std::to_string;
using std::vector;

HugeNum::HugeNum()
{
}

HugeNum::~HugeNum()
{
}

HugeNum & HugeNum::operator+=(const HugeNum &rhn)//默认*this是长度较长的那一个
{
    size_t overflow = 0;
    signed lpos = length,rpos = rhn.length;
    while (lpos > 0 || rpos > 0)
    {       
        --lpos,--rpos;     

        size_t lv = lpos < 0 ? 0 : this->GetNum(lpos);
        size_t rv = rpos < 0 ? 0 : rhn.GetNum(rpos);

        size_t tempSum = lv + rv + overflow;

        if (tempSum < 10) {
            operator[](lpos) = (char)tempSum + zeroCh;
            overflow = 0;
        }
        else
        {
            operator[](lpos) = char(tempSum % 10) + zeroCh;
            overflow = tempSum / 10;
        }
    }

    if (overflow != 0) {
        InsertFront(overflow);
    }

    return *this;
}

HugeNum & HugeNum::operator*=(const HugeNum &rhn)
{
    size_t overflow = 0;
    size_t llen = length,rlen = rhn.length;
    size_t vlen = llen + rlen - 1;

    vector<size_t> slots(vlen,0);//槽的概念
    string ret(llen + rlen,'0');//结果string

    for (size_t i = 0; i < llen; i++)
    {
        for (size_t j = 0; j < rlen; j++)
        {
            slots[i + j] += this->GetNum(i) * rhn.GetNum(j);
        }
    }

    for (signed it = vlen - 1; it >= 0; it--)
    {

        size_t temp = slots[it] + overflow;
        ret[it + 1] = temp % 10 + zeroCh;
        overflow = temp / 10;
    }

    if (overflow != 0) {
        ret[0] = overflow + zeroCh;
    }

    size_t zeroPos = 0;
    size_t len = ret.size();

    while (zeroPos < len && ret[zeroPos] == zeroCh)
    {
        zeroPos++;
    }

    zeroPos = zeroPos == len ? zeroPos - 1 : zeroPos;

    ret.erase(0,zeroPos);

    data = std::move(ret);

    return *this;
}

char &HugeNum::operator[](signed n)
{
    return data[n];
}

size_t HugeNum::GetNum(signed n) const
{
    size_t ret = data[n] - zeroCh;

    return ret;
}

HugeNum & HugeNum::InsertFront(size_t &num)
{
    data = std::move(to_string(num) + data);
    return *this;
}

那啥，复制走可以，但是用的时候能不能注释一下来源【手动害羞】

（编辑：上海站长网）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!