C++编程中到底要怎么存一个大数啊 比如很大的数相加减！！！！请给出说明 谢谢了！！~~

Question

能给出字符串贮存的还能数组INT贮存的最好 谢谢了！！！

Answer 1

这得自己写大数类了，我给你一个模板，用数组的

头文件[code]/*大数运算库头文件：Integer.h
说明：适用于MFC，1024位RSA运算
*/

//允许生成1120位（二进制）的中间结果
#ifndef BI_MAXLEN
#define BI_MAXLEN 35
#define DEC 10
#define HEX 16

class CInteger
{
public:
//大数在0x100000000进制下的长度
unsigned m_nLength;
//用数组记录大数在0x100000000进制下每一位的值
unsigned long m_ulValue[BI_MAXLEN];

CInteger();
~CInteger();

/*基本操作与运算
Mov，赋值运算，可赋值为大数或普通整数，可重载为运算符“=”
Cmp，比较运算，可重载为运算符“==”、“!=”、“>=”、“<=”等
Add，加，求大数与大数或大数与普通整数的和，可重载为运算符“+”
Sub，减，求大数与大数或大数与普通整数的差，可重载为运算符“-”
Mul，乘，求大数与大数或大数与普通整数的积，可重载为运算符“*”
Div，除，求大数与大数或大数与普通整数的商，可重载为运算符“/”
Mod，模，求大数与大数或大数与普通整数的模，可重载为运算符“%”
*/
void Mov(unsigned __int64 A);
void Mov(CInteger& A);
CInteger Add(CInteger& A);
CInteger Sub(CInteger& A);
CInteger Mul(CInteger& A);
CInteger Div(CInteger& A);
CInteger Mod(CInteger& A);
CInteger Add(unsigned long A);
CInteger Sub(unsigned long A);
CInteger Mul(unsigned long A);
CInteger Div(unsigned long A);
unsigned long Mod(unsigned long A);
int Cmp(CInteger& A);

/*输入输出
Get，从字符串按10进制或16进制格式输入到大数
Put，将大数按10进制或16进制格式输出到字符串
*/
void Get(const CString& str, unsigned int system=HEX);
void Put(CString& str, unsigned int system=HEX);
};
#endif[/code]实现文件[code]/*大数运算库源文件：Integer.cpp
说明：适用于MFC，1024位RSA运算
*/
#include "stdafx.h"
#include "Integer.h"

//构造大数对象并初始化为零
CInteger::CInteger()
{
m_nLength=1;
for(int i=0;i<BI_MAXLEN;i++)m_ulValue[i]=0;
}

//解构大数对象
CInteger::~CInteger()
{
}

/*大数比较
调用方式：N.Cmp(A)
返回值：若N<A返回-1；若N=A返回0；若N>A返回1
*/
int CInteger::Cmp(CInteger& A)
{
if(m_nLength>A.m_nLength)return 1;
if(m_nLength<A.m_nLength)return -1;
for(int i=m_nLength-1;i>=0;i--)
{
if(m_ulValue[i]>A.m_ulValue[i])return 1;
if(m_ulValue[i]<A.m_ulValue[i])return -1;
}
return 0;
}

/*
大数赋值
调用方式：N.Mov(A)
返回值：无，N被赋值为A
*/
void CInteger::Mov(CInteger& A)
{
m_nLength=A.m_nLength;
for(int i=0;i<BI_MAXLEN;i++)m_ulValue[i]=A.m_ulValue[i];
}

void CInteger::Mov(unsigned __int64 A)
{
if(A>0xffffffff)
{
m_nLength=2;
m_ulValue[1]=(unsigned long)(A>>32);
m_ulValue[0]=(unsigned long)A;
}
else
{
m_nLength=1;
m_ulValue[0]=(unsigned long)A;
}
for(int i=m_nLength;i<BI_MAXLEN;i++)m_ulValue[i]=0;
}

/*
大数相加
调用形式：N.Add(A)
返回值：N+A
*/
CInteger CInteger::Add(CInteger& A)
{
CInteger X;
X.Mov(*this);
unsigned carry=0;
unsigned __int64 sum=0;
if(X.m_nLength<A.m_nLength)X.m_nLength=A.m_nLength;
for(unsigned i=0;i<X.m_nLength;i++)
{
sum=A.m_ulValue[i];
sum=sum+X.m_ulValue[i]+carry;
X.m_ulValue[i]=(unsigned long)sum;
carry=(unsigned)(sum>>32);
}
X.m_ulValue[X.m_nLength]=carry;
X.m_nLength+=carry;
return X;
}

CInteger CInteger::Add(unsigned long A)
{
CInteger X;
X.Mov(*this);
unsigned __int64 sum;
sum=X.m_ulValue[0];
sum+=A;
X.m_ulValue[0]=(unsigned long)sum;
if(sum>0xffffffff)
{
unsigned i=1;
while(X.m_ulValue[i]==0xffffffff){X.m_ulValue[i]=0;i++;}
X.m_ulValue[i]++;
if(m_nLength==i)m_nLength++;
}
return X;
}

/*
大数相减
调用形式：N.Sub(A)
返回值：N-A
*/
CInteger CInteger::Sub(CInteger& A)
{
CInteger X;
X.Mov(*this);
if(X.Cmp(A)<=0){X.Mov(0);return X;}
unsigned carry=0;
unsigned __int64 num;
unsigned i;
for(i=0;i<m_nLength;i++)
{
if((m_ulValue[i]>A.m_ulValue[i])||((m_ulValue[i]==A.m_ulValue[i])&&(carry==0)))
{
X.m_ulValue[i]=m_ulValue[i]-carry-A.m_ulValue[i];
carry=0;
}
else
{
num=0x100000000+m_ulValue[i];
X.m_ulValue[i]=(unsigned long)(num-carry-A.m_ulValue[i]);
carry=1;
}
}
while(X.m_ulValue[X.m_nLength-1]==0)X.m_nLength--;
return X;
}

CInteger CInteger::Sub(unsigned long A)
{
CInteger X;
X.Mov(*this);
if(X.m_ulValue[0]>=A){X.m_ulValue[0]-=A;return X;}
if(X.m_nLength==1){X.Mov(0);return X;}
unsigned __int64 num=0x100000000+X.m_ulValue[0];
X.m_ulValue[0]=(unsigned long)(num-A);
int i=1;
while(X.m_ulValue[i]==0){X.m_ulValue[i]=0xffffffff;i++;}
X.m_ulValue[i]--;
if(X.m_ulValue[i]==0)X.m_nLength--;
return X;
}

/*
大数相乘
调用形式：N.Mul(A)
返回值：N*A
*/
CInteger CInteger::Mul(CInteger& A)
{
if(A.m_nLength==1)return Mul(A.m_ulValue[0]);
CInteger X;
unsigned __int64 sum,mul=0,carry=0;
unsigned i,j;
X.m_nLength=m_nLength+A.m_nLength-1;
for(i=0;i<X.m_nLength;i++)
{
sum=carry;
carry=0;
for(j=0;j<A.m_nLength;j++)
{
if(((i-j)>=0)&&((i-j)<m_nLength))
{
mul=m_ulValue[i-j];
mul*=A.m_ulValue[j];
carry+=mul>>32;
mul=mul&0xffffffff;
sum+=mul;
}
}
carry+=sum>>32;
X.m_ulValue[i]=(unsigned long)sum;
}
if(carry){X.m_nLength++;X.m_ulValue[X.m_nLength-1]=(unsigned long)carry;}
return X;
}

CInteger CInteger::Mul(unsigned long A)
{
CInteger X;
unsigned __int64 mul;
unsigned long carry=0;
X.Mov(*this);
for(unsigned i=0;i<m_nLength;i++)
{
mul=m_ulValue[i];
mul=mul*A+carry;
X.m_ulValue[i]=(unsigned long)mul;
carry=(unsigned long)(mul>>32);
}
if(carry){X.m_nLength++;X.m_ulValue[X.m_nLength-1]=carry;}
return X;
}

/*
大数相除
调用形式：N.Div(A)
返回值：N/A
*/
CInteger CInteger::Div(CInteger& A)
{
if(A.m_nLength==1)return Div(A.m_ulValue[0]);
CInteger X,Y,Z;
unsigned i,len;
unsigned __int64 num,div;
Y.Mov(*this);
while(Y.Cmp(A)>=0)
{
div=Y.m_ulValue[Y.m_nLength-1];
num=A.m_ulValue[A.m_nLength-1];
len=Y.m_nLength-A.m_nLength;
if((div==num)&&(len==0)){X.Mov(X.Add(1));break;}
if((div<=num)&&len){len--;div=(div<<32)+Y.m_ulValue[Y.m_nLength-2];}
div=div/(num+1);
Z.Mov(div);
if(len)
{
Z.m_nLength+=len;
for(i=Z.m_nLength-1;i>=len;i--)Z.m_ulValue[i]=Z.m_ulValue[i-len];
for(i=0;i<len;i++)Z.m_ulValue[i]=0;
}
X.Mov(X.Add(Z));
Y.Mov(Y.Sub(A.Mul(Z)));
}
return X;
}

CInteger CInteger::Div(unsigned long A)
{
CInteger X;
X.Mov(*this);
if(X.m_nLength==1){X.m_ulValue[0]=X.m_ulValue[0]/A;return X;}
unsigned __int64 div,mul;
unsigned long carry=0;
for(int i=X.m_nLength-1;i>=0;i--)
{
div=carry;
div=(div<<32)+X.m_ulValue[i];
X.m_ulValue[i]=(unsigned long)(div/A);
mul=(div/A)*A;
carry=(unsigned long)(div-mul);
}
if(X.m_ulValue[X.m_nLength-1]==0)X.m_nLength--;
return X;
}

/*
大数求模
调用形式：N.Mod(A)
返回值：N%A
*/
CInteger CInteger::Mod(CInteger& A)
{
CInteger X,Y;
unsigned __int64 div,num;
unsigned long carry=0;
unsigned i,len;
X.Mov(*this);
while(X.Cmp(A)>=0)
{
div=X.m_ulValue[X.m_nLength-1];
num=A.m_ulValue[A.m_nLength-1];
len=X.m_nLength-A.m_nLength;
if((div==num)&&(len==0)){X.Mov(X.Sub(A));break;}
if((div<=num)&&len){len--;div=(div<<32)+X.m_ulValue[X.m_nLength-2];}
div=div/(num+1);
Y.Mov(div);
Y.Mov(A.Mul(Y));
if(len)
{
Y.m_nLength+=len;
for(i=Y.m_nLength-1;i>=len;i--)Y.m_ulValue[i]=Y.m_ulValue[i-len];
for(i=0;i<len;i++)Y.m_ulValue[i]=0;
}
X.Mov(X.Sub(Y));
}
return X;
}

unsigned long CInteger::Mod(unsigned long A)
{
if(m_nLength==1)return(m_ulValue[0]%A);
unsigned __int64 div;
unsigned long carry=0;
for(int i=m_nLength-1;i>=0;i--)
{
div=m_ulValue[i];
div+=carry*0x100000000;
carry=(unsigned long)(div%A);
}
return carry;
}

/*
从字符串按10进制或16进制格式输入到大数
调用格式：N.Get(str,sys)
返回值：N被赋值为相应大数
sys暂时只能为10或16
*/
void CInteger::Get(const CString& str, unsigned int system)
{
int len=str.GetLength(),k;
Mov(0);
for(int i=0;i<len;i++)
{
Mov(Mul(system));
if((str[i]>='0')&&(str[i]<='9'))k=str[i]-48;
else if((str[i]>='A')&&(str[i]<='F'))k=str[i]-55;
else if((str[i]>='a')&&(str[i]<='f'))k=str[i]-87;
else k=0;
Mov(Add(k));
}
}

/*
将大数按10进制或16进制格式输出为字符串
调用格式：N.Put(str,sys)
返回值：无，参数str被赋值为N的sys进制字符串
sys暂时只能为10或16
*/
void CInteger::Put(CString& str, unsigned int system)
{
if((m_nLength==1)&&(m_ulValue[0]==0)){str="0";return;}
str="";
CString t="0123456789ABCDEF";
int a;
char ch;
CInteger X;
X.Mov(*this);
while(X.m_ulValue[X.m_nLength-1]>0)
{
a=X.Mod(system);
ch=t[a];
str.Insert(0,ch);
X.Mov(X.Div(system));
}
}[/code]

Answer 2

如果你是练ACM的话，就找找模板！会有很多……
大数相加减，有很多方法，要看多大的数，超过int64就用字符串把，整体很简单，就是操作稍微麻烦一哦点！
给你一个思路。告诉你答案就没意义了！
首先定义两个数组，一个字符串数组，一个整数数组。char[]和int[]
接着扫描char[]，重头扫到尾，将所有字符都转换为int，转换公式很简单char - '0' （提示从后面扫描）
然后就可以操作两个你转换后的int数组相加，注意进位，（如果上个你是从后往前，现在就从前往后，自己想想，哪边是个位，哪边是高位）
加完就可以输出了，后者再给他们转成字符串，直接输出！！简单吧！o(∩_∩)o 哈哈！

参考资料：http://iiacm.net

Answer 3

unsigned long long a;
超长变量a（正数）