项目：大数的运算

项目背景：数据的范围超过long long等整型类型所能存储的范围。
项目简介：实现大数的输入和输出以及对它进行加、减、乘和除运算。
开发平台：Visual Studio 2012
技术要点：C++类和对象，string
代码实现：

//CalOfBigData.h

#pragma once

#include <string>
#include <iostream>
#include <cassert>
using namespace std;

#define UN_INIT 0xcccccccccccccccc
#define MAX_INT64 0x7fffffffffffffff
#define MIN_INT64 0x8000000000000000

typedef long long INT64;

int index = 0;

class BigData
{
public:
    BigData(INT64 data = UN_INIT);
    BigData(const char *pData);

    BigData operator+(BigData& bigData);
    BigData operator-(const BigData& bigData);
    BigData operator*(const BigData& bigData);
    BigData operator/(const BigData& bigData);

    friend std::ostream& operator<<(std::ostream& _cout, const BigData& bigData);
    friend std::istream& operator>>(std::istream& _cin, BigData bigData);
    bool IsINT64Overflow()const;

private:
    std::string Add(std::string left, std::string right);
    std::string Sub(std::string left, std::string right);
    std::string Mul(std::string left, std::string right);
    std::string Div(std::string left, std::string right);
    void INT64ToString();
    bool IsLeftStrBig(char *pLeft, size_t LSize, char *pRight, size_t RSize);
    char SubLoop(char *&pLeft, int& LSize, char *pRight, size_t RSize);
private:
    INT64 Data;
    std::string strData; 
};

//CalOfBigData.cpp 

#include "BigData.h"

BigData::BigData(INT64 data)
: Data(data)
, strData("")
{
    INT64ToString();
}

BigData::BigData(const char *_pdata)
{
    assert(_pdata);
    char csymbol = _pdata[0];
    char* pdata = (char*)_pdata;
    if (csymbol == '+' || csymbol == '-')
    {
        pdata++;
    }
    else if (*pdata >= '0'&& *pdata <= '9')
    {
        csymbol = '+';
    }
    else
    {
        Data = 0;
        strData = '0';
        return;
    }
    while (*pdata == '0')
    {
        pdata++;
    }
    strData.resize(strlen(pdata) + 1);
    Data = 0;
    strData[0] = csymbol;
    int count = 1;
    while (pdata)
    {
        if (*pdata >= '0' && *pdata <= '9')
        {
            Data = Data * 10 + *pdata - '0';
            strData[count++] = *pdata++;
        }
        else
        {
            break;
        }
    }

    if ('-' == csymbol)
    {
        Data = 0 - Data;
    }
}

BigData BigData::operator+(BigData& bigData)
{
    if (!IsINT64Overflow() && !bigData.IsINT64Overflow())
    {
        if (strData[0] != bigData.strData[0])
        {
            return BigData(Data + bigData.Data);
        }
        else
        {
            if ((strData[0] == '+' && MAX_INT64 - Data >= bigData.Data
                || (strData[0]) == '-' && MIN_INT64 - Data <= bigData.Data))
            {
                return BigData(Data + bigData.Data);
            }
        }
    }
    std::string strret; 
    if (strData[0] == bigData.strData[0])
    {
        strret = Add(strData, bigData.strData);
    }
    else
    {
        strret = Sub(strData, bigData.strData);
    }
    return BigData(strret.c_str());
}

BigData BigData::operator-(const BigData& bigData)
{
    if (!IsINT64Overflow() && !bigData.IsINT64Overflow())
    {
        if (strData[0] == bigData.strData[0])
        {
            return BigData(Data - bigData.Data);
        }
        else
        {   
            if ((strData[0] == '+' && MAX_INT64 + bigData.Data>= Data)
                || (strData[0] == '-' && MIN_INT64 + bigData.Data <= Data))
            {
                return BigData(Data - bigData.Data);
            }
        }
    }
    std::string strret;
    if (strData[0] != bigData.strData[0])
    {
        strret = Add(strData, bigData.strData);
    }
    else
    {
        strret = Sub(strData, bigData.strData);
    }
    return BigData(strret.c_str());
}

BigData BigData::operator*(const BigData& bigData)
{
    if (Data == 0 || bigData.Data == 0)
    {
        return BigData(INT64(0));
    }
    if (!IsINT64Overflow() && !bigData.IsINT64Overflow())
    {
        if (strData[0] == bigData.strData[0])
        {
            if ((strData[0] == '+' && MAX_INT64 / Data >= bigData.Data)
                || (strData[0] == '-' && MAX_INT64 / Data <= bigData.Data))
            {
                return BigData(Data * bigData.Data);
            }
        }
        else
        {
            if ((strData[0] == '+' && MIN_INT64 / Data <= bigData.Data)
                || (strData[0] == '-' && MIN_INT64 / Data >= bigData.Data))
            {
                return BigData(Data * bigData.Data);
            }
        }
    }
    return BigData(Mul(strData, bigData.strData).c_str());
}

BigData BigData::operator/(const BigData& bigData)
{
    if (bigData.Data == 0)
    {
        assert("除数不可以为0");
        return BigData(INT64(0));
    }
    if (!IsINT64Overflow() && bigData.IsINT64Overflow())
    {
        return BigData(Data / bigData.Data);
    }
    return BigData(Div(strData, bigData.strData).c_str());
}

std::string BigData::Add(std::string left,std::string right)
{
    int lsize = left.size();
    int rsize = right.size();
    char ch = left[0];
    if (lsize < rsize)
    {
        std::swap(left,right);
        std::swap(lsize,rsize);
    }
    std::string strret;
    strret.resize(lsize + 1);
    strret[0] = ch;
    char cstep = 0;
    int n = 1;
    while (n < lsize)
    {
        char cret = left[lsize - n] - '0' + cstep;
        if (n < rsize)
        {
            cret += right[rsize - n] - '0';
        }
        strret[lsize - n + 1] = (cret % 10 + '0');
        cstep = cret / 10;
        n++;
    }
    strret[1] = cstep + '0';

    return strret;
}

std::string BigData::Sub(std::string left, std::string right)
{
    int lsize = left.size();
    int rsize = right.size();
    char csymbol = left[0];
    if ((lsize < rsize) ||
        (lsize == rsize && left < right))
    {
        std::swap(left, right);
        std::swap(lsize, rsize);
        if (csymbol == '+')
        {
            csymbol = '-';
        }
        else
        {
            csymbol = '+';
        }
    }
    std::string strret;
    strret.resize(lsize);
    strret[0] = csymbol;
    int n = 1;
    while (n < lsize)
    {
        char cret = left[lsize - n] - '0';
        if (n < rsize)
        {
            cret -= right[rsize - n] - '0';
        }
        if (cret < 0)
        {
            left[lsize - n - 1] -= 1;
            cret += 10;
        }
        strret[lsize - n] = (cret + '0');
        n++;
    }
    return strret;
}

std::string BigData::Mul(std::string left, std::string right)
{
    int lsize = left.size();
    int rsize = right.size();
    if (lsize > rsize)
    {
        swap(left, right);
        swap(lsize, rsize);
    }
    char csymbol = '+';
    if (left[0] != right[0])
    {
        csymbol = '-';
    }
    string strret;
    strret.assign(lsize + rsize - 1, '0');
    strret[0] = csymbol;
    int datalen = strret.size();
    int ioffset = 0;
    for (int lidx = 1; lidx < lsize; lidx++)
    {
        char cleft = left[lsize - lidx] - '0';
        char cstep = 0;
        if (cleft == 0)
        {
            ioffset++;
            continue;
        }
        for (int ridx = 1; ridx < rsize; ridx++)
        {
            char cret = cleft*(right[rsize - ridx]-'0');
            cret += cstep;
            cret += (strret[datalen - ioffset - ridx] - '0');
            strret[datalen - ioffset - ridx] = (cret % 10 + '0');
            cstep = cret / 10;
        } 
        strret[datalen - ioffset - rsize] += cstep;
        ioffset++;
    }
    return strret;
}

std::string BigData::Div(std::string left, std::string right)
{
    char lsize = left.size();
    char rsize = right.size();
    char csymbol = '+';
    if (left[0] != right[0])
    {
        csymbol = '-';
    }
    if ((lsize < rsize) || 
        (lsize == rsize && strcmp(left.c_str() + 1, right.c_str() + 1) < 0))
    {
        return "0";
    }
    else
    {
        if (right == "-1" || right == "+1")
        {
            left[0] = csymbol;
            return left;
        }
    }
    string strret;
    strret.append(1, csymbol);
    char *pleft = (char*)(left.c_str() + 1);
    char *pright = (char*)(right.c_str() + 1);
    int datalen = 1;
    lsize -= 1;
    for (index = 0; index< lsize;)
    {
        if (*pleft == '0')
        {
            strret.append(1, '0');
            pleft++;
            index++;
            continue;
        }
        if (!IsLeftStrBig(pleft, datalen, pright, rsize - 1))
        {
            strret.append(1, '0');
            datalen++;
            if (index + datalen > lsize)
            {
                break;
            }
            continue;
        }  
        else
        {
            strret.append(1,SubLoop(pleft, datalen, pright ,rsize - 1));
            datalen++;
        }
    }
    return strret;
}

void BigData::INT64ToString()
{
    char csymbol = '+';
    INT64 tmp = Data;
    if (tmp < 0)
    {
        csymbol = '-';
        tmp = 0 - tmp;
    }
    strData.append(1, csymbol);

    while (tmp)
    {  
        strData.append(1,tmp%10 + '0');
        tmp /= 10;
    }
    char *left = (char*)(strData.c_str() + 1);
    char *right = (char*)(strData.c_str() + strData.size() - 1);
    while (left < right)
    {
        char ctmp = *left;
        *left++ = *right;
        *right-- = ctmp;
    }
}

bool BigData::IsINT64Overflow()const 
{
    std::string tmp;
    if ('+' == strData[0])
    {
        tmp = "+9223372036854775807";
    }
    else
    {
        tmp = "-9223372036854775808";
    }
    if ((strData.size() > tmp.size()) ||
        ((strData.size() == tmp.size())&&(strData > tmp)))
    {
        return true;
    }

    return false;
}

bool BigData::IsLeftStrBig(char *pLeft, size_t LSize, char *pRight, size_t RSize)
{
    assert(pLeft != NULL && pRight != NULL);
    if ((LSize > RSize) ||(LSize == RSize && strncmp(pLeft,pRight,LSize) >= 0))
    {
        return true;
    }
    return false;
}

char BigData::SubLoop(char *&pLeft, int& LSize, char *pRight, size_t RSize)
{
    assert(pLeft != NULL && pRight != NULL);
    char cret = '0';
    while (true)
    {
        if (!IsLeftStrBig(pLeft, LSize, pRight, RSize))
        {
            break;
        }
        int ldatalen = LSize - 1;
        int rdatalen = RSize - 1;
        while (ldatalen >= 0 && rdatalen >= 0)
        {
            if (pLeft[ldatalen] < pRight[rdatalen])
            {
                pLeft[ldatalen - 1] -= 1;
                pLeft[ldatalen] += 10;
            }
            pLeft[ldatalen] = pLeft[ldatalen] - pRight[rdatalen] + '0';
            ldatalen--;
            rdatalen--;
        }
        while ((*pLeft == '0') && (LSize > 0))
        {
            pLeft++;
            LSize--;
            index++;
        }
        cret++;
    }
    return cret;
}

std::ostream& operator<<(std::ostream& _cout, const BigData& bigData)
{
    if (!bigData.IsINT64Overflow()) 
    {
        _cout << bigData.Data;
    }
    else
    {
        char* pData = (char*)bigData.strData.c_str();
        if (pData[0] == '+')
        {
            pData++;
        }
        _cout << pData;
    }
    return _cout;
}