大数四则运算

大数四则运算用C++来实现，一般就可以看出一个人的编程能力了，以下是我实现的大数四则运算，还没写完，只是写了个大概思路，如下：

主文件：

#include "Arithmetic.h"
using namespace std;

int main(int argc,char *argv[])
{
    CArithmetic Arith1;
    CArithmetic Arith2;
    cout << "please input data1: ";
    cin >> Arith1;
    cout << "please input data2: ";
    cin >> Arith2;
//    CArithmetic Arith =  Arith1 + Arith2;
//    cout << Arith << endl;
    CArithmetic Arith = Arith1 * Arith2;
    cout << Arith << endl;
    return 0;
}

实现头文件

#include <vector>
#include <iostream>
using namespace std;

class CArithmetic
{
public:
    CArithmetic();
    ~CArithmetic();

public:
    int size() const { return m_vecData.size(); }

public:
    friend ostream& operator << (ostream &os,const CArithmetic &data);
    friend istream& operator >> (istream &is,CArithmetic &data);

public:
    char operator [] (int nIndex) const;
    CArithmetic operator + (const CArithmetic &data);
    CArithmetic operator - (CArithmetic &data);
    CArithmetic operator * (const CArithmetic &data);
    CArithmetic& operator = (const CArithmetic &data);

private:
    vector<char> m_vecData;
};

#include "Arithmetic.h"

CArithmetic::CArithmetic()
{
}

CArithmetic::~CArithmetic()
{
}

ostream& operator << (ostream &os,const CArithmetic &data)
{
    vector<char>::const_iterator itVec = data.m_vecData.begin();
    for (; itVec != data.m_vecData.end(); ++itVec)
    {
        os << *itVec;
    }
    return os;
}

istream& operator >> (istream &is,CArithmetic &data)
{
    while (1)
    {
        char c = is.get();
        if (' ' == c || 'r' == c || 'n' == c)
        {
            break;
        }
        if (c < '0' || c > '9')
        {
            data.m_vecData.clear();
            cerr << "not accept" << endl;
            break;
        }
        data.m_vecData.push_back(c);
    }
    return is;
}

char CArithmetic::operator [] (int nIndex) const
{
    if (nIndex < 0 || nIndex >= m_vecData.size())
    {
        cerr << "error occur in operator [] function";
        return ' ';
    }
    return m_vecData[nIndex];
}

CArithmetic CArithmetic::operator + (const CArithmetic &data)
{
    int nCarry = 0;
    CArithmetic Arith;
    vector<char>& vecTemp = Arith.m_vecData;

    int i = data.size()      - 1;
    int j = m_vecData.size() - 1;
    for (; i >= 0 || j >= 0; i--,j--)
    {
        char a = i >= 0 ? data[i]      - '0' : 0;
        char b = j >= 0 ? m_vecData[j] - '0' : 0;
        char c = a + b + nCarry;
        nCarry = c / 10;
        vecTemp.push_back(c % 10 + '0');
    }

    // process carry
    if (nCarry != 0)
    {
        vecTemp.push_back(nCarry + '0');
    }

    // store result
    for (i = 0,j = vecTemp.size() - 1; i < j; i++,j--)
    {
        char cTemp = vecTemp[i];
        vecTemp[i] = vecTemp[j];
        vecTemp[j] = cTemp;
    }
    return Arith;
}

CArithmetic CArithmetic::operator - (CArithmetic &data)
{
    return *this;
}

CArithmetic CArithmetic::operator * (const CArithmetic &data)
{
    int nCarry = 0;
    
    CArithmetic Arith;
    CArithmetic ArithTemp;
    vector<char>& vecTemp = ArithTemp.m_vecData;

    int i = data.size() - 1;
    for (; i >= 0; i--)
    {
        char a = data[i] - '0';
        int j = m_vecData.size() - 1;
        for (; j >= 0; j--)
        {
            char b = m_vecData[j] - '0';
            char c = b * a + nCarry;
            nCarry = c / 10;
            vecTemp.push_back(c % 10 + '0');
        }
        if (nCarry != 0)
        {
            vecTemp.push_back(nCarry + '0');
            nCarry = 0;
        }
        
        // store result
        int n = 0;
        int m = vecTemp.size() - 1;
        for (; n < m; n++,m--)
        {
            char cTemp = vecTemp[n];
            vecTemp[n] = vecTemp[m];
            vecTemp[m] = cTemp;
        }

        for (int t = data.size() - 1; t > i; t--)
        {
            vecTemp.push_back('0');
        }

        Arith = Arith + ArithTemp;
        vecTemp.clear();
    }

    return Arith;
}

CArithmetic& CArithmetic::operator = (const CArithmetic &data)
{
    m_vecData.clear();
    vector<char>::const_iterator itVec = data.m_vecData.begin();
    for (; itVec != data.m_vecData.end(); ++itVec)
    {
        m_vecData.push_back(*itVec);
    }
    return *this;
}

main: main.o Arithmetic.o 
	g++ -o main main.o Arithmetic.o
main.o: main.cpp Arithmetic.h
	g++ -c main.cpp
Arithmetic.o: Arithmetic.h Arithmetic.cpp
	g++ -c Arithmetic.cpp
clean:
	rm main.o Arithmetic.o main