C++ 大数模板 持续更新中...

第一次更新博客(2017/5/3)...

目前只有正整数的加减法和乘法。

使用STL里的string来存大数字符，真的是无比好用...

加法...

减法...

乘法...

然后是完整代码...

#include <iostream>
#include <string>
#include <vector>
using namespace std;
string sum(string ans, string b);
string subtract(string ans, string b);
string multiply(string a, string b);
int main(){
	string a, b;
	int c;
	while(cin >> a >> b){
		cin >> c;
		if(c == 0) cout << sum(a, b) << endl;
		if(c == 1) cout << subtract(a, b) << endl;
		if(c == 2) cout << multiply(a, b) << endl;
	}
	return 0;
}
string sum(string ans, string b){
	if(ans.length() < b.length()) ans.swap(b);
	for(int i = ans.length()-1, j = b.length()-1; i >= 0; --i, --j){
		ans[i] = ans[i] + (j >= 0? b[j]-'0': 0); 
		if(ans[i] > '9'){
			ans[i] -= 10;
			if(i > 0) ++ans[i-1];
			else ans.insert(0, "1");
		}
	}
	return ans;
}
string subtract(string ans, string b){
	if(ans.length() < b.length() || ans.length() == b.length() && ans < b) ans.swap(b);
	for(int i = ans.length()-1, j = b.length()-1; i >= 0; --i, --j){
		ans[i] = ans[i] - (j >= 0? b[j]-'0': 0);
		if(ans[i] < '0'){
			ans[i] += 10;
			--ans[i-1];
		}
	}
	while(ans.length() && ans[0] == '0') ans.erase(ans.begin());
	if(ans.empty()) ans = "0";
	return ans;
}
string multiply(string a, string b){
	int m = a.length(), n = b.length();
	//一个m位数乘以一个n位数，结果至少是m+n-1位	
	vector<int> tmp(m+n-1);		//vector预分配内存，初始值为0
	//进行笛卡尔乘积
	for(int i = 0; i < m; ++i)	//string 0位为高位
	for(int j = 0; j < n; ++j)
		tmp[i+j] += (a[i]-'0')*(b[j]-'0');
	for(int i = tmp.size()-1; i > 0; --i){	//由低位到高位进位
		tmp[i-1] += tmp[i]/10;
		tmp[i] %= 10;
	}
	while(tmp[0] > 9){						//最高位仍能进位
		tmp.insert(tmp.begin(), tmp[0]/10);
		tmp[1] %= 10;
	}
	string ans;
	for(int i = 0, len = tmp.size(); i < len; ++i) ans += tmp[i] + '0';
	if(ans[0] == '0') return "0";
	return ans;
}

待更新...继续加油~

2017/07/23 (完整模板)

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

class DividedByZeroException {};
class BigInteger
{
private:
    vector<char> digits;
    bool sign;          // true for positive, false for negitive
    void trim();        // remove zeros in tail, but if the value is 0, keep only one:)
public:
    BigInteger(int);    // construct with a int integer
    BigInteger(string&) ;
    BigInteger();
    BigInteger (const BigInteger&);
    BigInteger operator=(const BigInteger& op2);

    BigInteger abs() const;
    BigInteger pow(int a);

    //binary operators
    friend BigInteger operator+=(BigInteger&,const BigInteger&);
    friend BigInteger operator-=(BigInteger&,const BigInteger&);
    friend BigInteger operator*=(BigInteger&,const BigInteger&);
    friend BigInteger operator/=(BigInteger&,const BigInteger&) throw(DividedByZeroException);
    friend BigInteger operator%=(BigInteger&,const BigInteger&) throw(DividedByZeroException);

    friend BigInteger operator+(const BigInteger&,const BigInteger&);
    friend BigInteger operator-(const BigInteger&,const BigInteger&);
    friend BigInteger operator*(const BigInteger&,const BigInteger&);
    friend BigInteger operator/(const BigInteger&,const BigInteger&) throw(DividedByZeroException);
    friend BigInteger operator%(const BigInteger&,const BigInteger&) throw(DividedByZeroException);

    //uniary operators
    friend BigInteger operator-(const BigInteger&);   //negative

    friend BigInteger operator++(BigInteger&);        //++v
    friend BigInteger operator++(BigInteger&,int);    //v++
    friend BigInteger operator--(BigInteger&);        //--v
    friend BigInteger operator--(BigInteger&,int);    //v--

    friend bool operator>(const BigInteger&,const BigInteger&);
    friend bool operator<(const BigInteger&,const BigInteger&);
    friend bool operator==(const BigInteger&,const BigInteger&);
    friend bool operator!=(const BigInteger&,const BigInteger&);
    friend bool operator>=(const BigInteger&,const BigInteger&);
    friend bool operator<=(const BigInteger&,const BigInteger&);

    friend ostream& operator<<(ostream&,const BigInteger&);    //print the BigInteger
    friend istream& operator>>(istream&, BigInteger&);         // input the BigInteger

public:
    static const BigInteger ZERO;
    static const BigInteger ONE;
    static const BigInteger TEN;
};

// BigInteger.cpp
const BigInteger BigInteger::ZERO=BigInteger(0);
const BigInteger BigInteger::ONE =BigInteger(1);
const BigInteger BigInteger::TEN =BigInteger(10);

BigInteger::BigInteger()
{
    sign=true;
}

BigInteger::BigInteger(int val) // construct with a int integer
{
    if (val >= 0)
        sign = true;
    else
    {
        sign = false;
        val *= (-1);
    }
    do
    {
        digits.push_back( (char)(val%10) );
        val /= 10;
    }
    while ( val != 0 );
}

BigInteger::BigInteger(string& def)
{
    sign=true;
    for ( string::reverse_iterator iter = def.rbegin() ; iter < def.rend();  iter++)
    {
        char ch = (*iter);
        if (iter == def.rend()-1)
        {
            if ( ch == '+' )
                break;
            if(ch == '-' )
            {
                sign = false;
                break;
            }
        }
        digits.push_back( (char)((*iter) - '0' ) );
    }
    trim();
}

void BigInteger::trim()
{
    vector<char>::reverse_iterator iter = digits.rbegin();
    while(!digits.empty() && (*iter) == 0)
    {
        digits.pop_back();
        iter=digits.rbegin();
    }
    if( digits.size()==0 )
    {
        sign = true;
        digits.push_back(0);
    }
}


BigInteger::BigInteger(const BigInteger& op2)
{
    sign = op2.sign;
    digits=op2.digits;
}


BigInteger BigInteger::operator=(const BigInteger& op2)
{
    digits = op2.digits;
    sign = op2.sign;
    return (*this);
}


BigInteger BigInteger::abs() const
{
    if(sign)  return *this;
    else      return -(*this);
}

BigInteger BigInteger::pow(int a)
{
    BigInteger res(1);
    for(int i=0; i<a; i++)
        res*=(*this);
    return res;
}

//binary operators
BigInteger operator+=(BigInteger& op1,const BigInteger& op2)
{
    if( op1.sign == op2.sign )
    {
        //只处理相同的符号的情况，异号的情况给-处理
        vector<char>::iterator iter1;
        vector<char>::const_iterator iter2;
        iter1 = op1.digits.begin();
        iter2 = op2.digits.begin();
        char to_add = 0;        //进位
        while ( iter1 != op1.digits.end() && iter2 != op2.digits.end())
        {
            (*iter1) = (*iter1) + (*iter2) + to_add;
            to_add = ((*iter1) > 9);    // 大于9进一位
            (*iter1) = (*iter1) % 10;
            iter1++;
            iter2++;
        }
        while ( iter1 != op1.digits.end() )
        {
            (*iter1) = (*iter1) + to_add;
            to_add = ( (*iter1) > 9 );
            (*iter1) %= 10;
            iter1++;
        }
        while ( iter2 != op2.digits.end() )
        {
            char val = (*iter2) + to_add;
            to_add = (val > 9) ;
            val %= 10;
            op1.digits.push_back(val);
            iter2++;
        }
        if( to_add != 0 )
            op1.digits.push_back(to_add);
        return op1;
    }
    else
    {
        if (op1.sign)
            return op1 -= (-op2);
        else
            return op1= op2 - (-op1);
    }

}

BigInteger operator-=(BigInteger& op1,const BigInteger& op2)
{
    if( op1.sign == op2.sign )
    {
        //只处理相同的符号的情况，异号的情况给+处理
        if(op1.sign)
        {
            if(op1 < op2)  // 2 - 3
                return  op1=-(op2 - op1);
        }
        else
        {
            if(-op1 > -op2)  // (-3)-(-2) = -(3 - 2)
                return op1=-((-op1)-(-op2));
            else             // (-2)-(-3) = 3 - 2
                return op1= (-op2) - (-op1);
        }
        vector<char>::iterator iter1;
        vector<char>::const_iterator iter2;
        iter1 = op1.digits.begin();
        iter2 = op2.digits.begin();

        char to_substract = 0;  //借位

        while ( iter1 != op1.digits.end() && iter2 != op2.digits.end())
        {
            (*iter1) = (*iter1) - (*iter2) - to_substract;
            to_substract = 0;
            if( (*iter1) < 0 )
            {
                to_substract=1;
                (*iter1) += 10;
            }
            iter1++;
            iter2++;
        }
        while ( iter1 != op1.digits.end() )
        {
            (*iter1) = (*iter1) - to_substract;
            to_substract = 0;
            if( (*iter1) < 0 )
            {
                to_substract=1;
                (*iter1) += 10;
            }
            else break;
            iter1++;
        }
        op1.trim();
        return op1;
    }
    else
    {
        if (op1 > BigInteger::ZERO)
            return op1 += (-op2);
        else
            return op1 = -(op2 + (-op1));
    }
}
BigInteger operator*=(BigInteger& op1,const BigInteger& op2)
{
    BigInteger result(0);
    if (op1 == BigInteger::ZERO || op2==BigInteger::ZERO)
        result = BigInteger::ZERO;
    else
    {
        vector<char>::const_iterator iter2 = op2.digits.begin();
        while( iter2 != op2.digits.end() )
        {
            if(*iter2 != 0)
            {
                deque<char> temp(op1.digits.begin() , op1.digits.end());
                char to_add = 0;
                deque<char>::iterator iter1 = temp.begin();
                while( iter1 != temp.end() )
                {
                    (*iter1) *= (*iter2);
                    (*iter1) += to_add;
                    to_add = (*iter1) / 10;
                    (*iter1) %= 10;
                    iter1++;
                }
                if( to_add != 0)
                    temp.push_back( to_add );
                int num_of_zeros = iter2 - op2.digits.begin();
                while(  num_of_zeros--)
                    temp.push_front(0);
                BigInteger temp2;
                temp2.digits.insert( temp2.digits.end() , temp.begin() , temp.end() );
                temp2.trim();
                result = result + temp2;
            }
            iter2++;
        }
        result.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
    }
    op1 = result;
    return op1;
}

BigInteger operator/=(BigInteger& op1 , const BigInteger& op2 ) throw(DividedByZeroException)
{
    if( op2 == BigInteger::ZERO )
        throw DividedByZeroException();
    BigInteger t1 = op1.abs(), t2 = op2.abs();
    if ( t1 < t2 )
    {
        op1 = BigInteger::ZERO;
        return op1;
    }
    //现在 t1 > t2 > 0
    //只需将 t1/t2的结果交给result就可以了
    deque<char> temp;
    vector<char>::reverse_iterator iter = t1.digits.rbegin();

    BigInteger temp2(0);
    while( iter != t1.digits.rend() )
    {
        temp2 = temp2 * BigInteger::TEN + BigInteger( (int)(*iter) );
        char s = 0;
        while( temp2 >= t2 )
        {
            temp2 = temp2 - t2;
            s = s + 1;
        }
        temp.push_front( s );
        iter++;
    }
    op1.digits.clear();
    op1.digits.insert( op1.digits.end() , temp.begin() , temp.end() );
    op1.trim();
    op1.sign = ( (op1.sign && op2.sign) || (!op1.sign && !op2.sign) );
    return op1;
}

BigInteger operator%=(BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException)
{
    return op1 -= ((op1 / op2)*op2);
}

BigInteger operator+(const BigInteger& op1,const BigInteger& op2)
{
    BigInteger temp(op1);
    temp += op2;
    return temp;
}

BigInteger operator-(const BigInteger& op1,const BigInteger& op2)
{
    BigInteger temp(op1);
    temp -= op2;
    return temp;
}

BigInteger operator*(const BigInteger& op1,const BigInteger& op2)
{
    BigInteger temp(op1);
    temp *= op2;
    return temp;

}

BigInteger operator/(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException)
{
    BigInteger temp(op1);
    temp /= op2;
    return temp;
}

BigInteger operator%(const BigInteger& op1,const BigInteger& op2) throw(DividedByZeroException)
{
    BigInteger temp(op1);
    temp %= op2;
    return temp;
}

//uniary operators
BigInteger operator-(const BigInteger& op)    //negative
{
    BigInteger temp = BigInteger(op);
    temp.sign = !temp.sign;
    return temp;
}

BigInteger operator++(BigInteger& op)     //++v
{
    op += BigInteger::ONE;
    return op;
}

BigInteger operator++(BigInteger& op,int x)   //v++
{
    BigInteger temp(op);
    ++op;
    return temp;
}

BigInteger operator--(BigInteger& op)     //--v
{
    op -=  BigInteger::ONE;
    return op;
}

BigInteger operator--(BigInteger& op,int x)   //v--
{
    BigInteger temp(op);
    --op;
    return temp;
}

bool operator<(const BigInteger& op1,const BigInteger& op2)
{
    if( op1.sign != op2.sign )
        return !op1.sign;
    else
    {
        if(op1.digits.size() != op2.digits.size())
            return (op1.sign && op1.digits.size()<op2.digits.size())
            	|| (!op1.sign && op1.digits.size()>op2.digits.size());
        vector<char>::const_reverse_iterator iter1,iter2;
        iter1 = op1.digits.rbegin();
        iter2 = op2.digits.rbegin();
        while( iter1 != op1.digits.rend() )
        {
            if(  op1.sign &&  *iter1 < *iter2 ) return true;
            if(  op1.sign &&  *iter1 > *iter2 ) return false;
            if( !op1.sign &&  *iter1 > *iter2 ) return true;
            if( !op1.sign &&  *iter1 < *iter2 ) return false;
            iter1++;
            iter2++;
        }
        return false;
    }
}

bool operator==(const BigInteger& op1,const BigInteger& op2)
{
    if( op1.sign != op2.sign  || op1.digits.size() != op2.digits.size() )
        return false;
    vector<char>::const_iterator iter1,iter2;
    iter1 = op1.digits.begin();
    iter2 = op2.digits.begin();
    while( iter1!= op1.digits.end() )
    {
        if( *iter1 != *iter2 )  return false;
        iter1++;
        iter2++;
    }
    return true;
}

bool operator!=(const BigInteger& op1,const BigInteger& op2)
{
    return !(op1==op2);
}

bool operator>=(const BigInteger& op1,const BigInteger& op2)
{
    return (op1>op2) || (op1==op2);
}

bool operator<=(const BigInteger& op1,const BigInteger& op2)
{
    return (op1<op2) || (op1==op2);
}

bool operator>(const BigInteger& op1,const BigInteger& op2)
{
    return !(op1<=op2);
}

ostream& operator<<(ostream& stream,const BigInteger& val)//print the BigInteger
{
    if (!val.sign)
        stream << "-";
    for ( vector<char>::const_reverse_iterator iter = val.digits.rbegin(); iter != val.digits.rend(); iter++)
        stream << (char)((*iter) + '0');
    return stream;
}

istream& operator>>(istream& stream, BigInteger& val)
{
    //Input the BigInteger
    string str;
    stream >> str;
    val=BigInteger(str);
    return stream;
}

int main()
{
    BigInteger bt = 100;
    cout << bt << endl;
    bt = 101;
    cout << bt << endl;
    
    BigInteger a = BigInteger(30);
	cout << a << endl; 
	
	string s = "-33333333";
	BigInteger x = BigInteger(s);
	cout << x << endl;
	cout << x.abs() << endl;
	
	BigInteger q = a;
	cout << q << endl;
	cout << q.pow(2) << endl;
	cout << q.TEN << endl; 
    
    BigInteger arry[105];
    arry[0] = 4831;
    cout << arry[0] << endl;
    
    BigInteger p;
	while(cin >> p) break;		//可读至文件结束 
	cout << "操作：" << endl;
	cout << "运算：+ - * / %";
	cout << "+= -= *= /= %=";
	cout << "自运算：-- ++"; 
	cout << "输入>> 输出<<";
	cout << "比较：> < >= <= == !="; 

    return 0;
}

Copy自：链接