当年这个问题我做过：链表中的每个位只有一个个位数[0-9]－－－－－－－－－巨慢的原因。unsigned long 的表数范围是0－4294967296。 1.链表中的每个元素的表数范围可以是0－65535。好处是效率高，缺点是输出麻烦。 2.链表中的每个元素的表数范围可以是0－10000。好处是输出容易，缺点是效率低。我最后采用第二种方法，在P200的计算机上快的很。
写了一个测试程序，未经过优化，计算10000! 在 PIII500 上大约时 10 秒// jiechen.cpp : Defines the entry point for the console application. //#include "stdafx.h" #include <stdlib.h> // 000000000 // 000000000 #define WEISHU 10000 #define WEISHUBIT 4 #define MW ( WEISHU - 1 ) #define MAXLEN 100000int num1[MAXLEN]; int num2[MAXLEN]; int num3[MAXLEN];int resultTemp[MAXLEN]; int resultTempLen; int mulTemp[MAXLEN]; int mulTempLen;void showNum( int * num,int len ) { for(int i=len-1;i>=0;i--) { printf("%04d",num[i] ); } } int getweishu( int * num,int len ) { int i; for(i=len-1;i>=0;i--) { if ( i > 0 ) break; } if ( i == -1 ) return 1; int r1 = i * WEISHUBIT; int n2 = num[i]; if ( n2 == 0 ) return r1; r1++; while( n2 >= 10 ) { r1++; n2 /= 10; } return r1; } void showOpera( char * name1,int * num1,int len1 ) { printf("%s = ",name1); showNum( num1,len1 ); printf("\n"); } void add( int * add1,int add1num,int *add2,int add2num,int *add3num ) { // add1num >= add2num int i; //showOpera( "Add1",add1,add1num ); if ( add1num < add2num ) { for(i=add1num;i<add2num;i++) { add1[i] = 0; } add1num = add2num; } int resultLen = add1num + 1; int jinwei = 0; for(i=0;i<add2num;i++) { add1[i] += add2[i] + jinwei; if ( add1[i] > MW ) { add1[i] -= WEISHU ; jinwei = 1; } else { jinwei = 0; } } if ( jinwei == 0 ) { resultLen = add1num; } else { for(i=add2num;i<add1num;i++) { add1[i] ++; if ( add1[i] > MW ) { add1[i] = 0; } else { jinwei = 0; break; } } if ( jinwei == 0 ) { resultLen = add1num; } else { add1[ add1num ] = 1; } } *add3num = resultLen; //showOpera("Add2",add2,add2num); //showOpera("Add1 + Add2",add1,resultLen ); } void mult( int * mul1,int mul1num,int *mul2,int mul2num,int *mul3,int *mul3num ) { int i,j; int result; int jinwei = 0; int kk; resultTempLen = mul2num; for(i=0;i<mul2num+mul1num+1;i++) { resultTemp[i] = 0; } for(i=0;i<mul2num;i++) { jinwei = 0; for(j=0;j<mul1num;j++) { result = mul2[i] * mul1[j] + jinwei; if ( result > MW ) { mulTemp[j] = result % WEISHU; jinwei = result / WEISHU; } else { mulTemp[j] = result; jinwei = 0; } } if ( jinwei > 0 ) { mulTempLen = mul1num+1; mulTemp[mul1num] = jinwei; } else { mulTempLen = mul1num; } //showOpera("Mul1",mul1,mul1num); //showOpera("Nul2",mul2+i,1); //showOpera("Mul2 * Mul1",mulTemp,mulTempLen ); kk = resultTempLen; add( resultTemp+i,kk-i,mulTemp,mulTempLen,&kk ); resultTempLen = kk + i; } *mul3num = resultTempLen; for(i=0;i<resultTempLen;i++) { mul3[i] = resultTemp[i]; } } // 10! = 3628800 int ten( int num ) { int re = 1; for(int i=2;i<=num;i++) re *= i; return re; } void setNum( int num,int * n,int * len ) { int i = 0; while(num>0) { n[i] = num % WEISHU; num /= WEISHU; i++; } *len = i; } void cal(int num) { int i,j; if ( num <= 10 ) { printf("%d! = %d\n",num, ten(num)); return; } int len1,len2,len3; setNum( 3628800,num1,&len1); for(i=11;i<=num;i++) { setNum( i,num2,&len2 ); mult( num1,len1,num2,len2,num3,&len3 ); for(j=0;j<len3;j++) { num1[j] = num3[j]; } len1 = len3; } printf("%d! = ",num); showNum( num3,len3 ); printf("\nWeiShu = %d\n",getweishu(num3,len3)); } void main(int argc, char* argv[]) { if ( argc != 2 ) { printf("Usage : Jiechen number\n"); return; } int num = atoi( argv[1] ); if ( num <= 0 ) { printf("Arg %s is invalid!\n",argv[1]); return; } cal(num); }
想想1000只乘了1000个数呀，
咱们来算一下
1000！大概是10的300次方,即1后面跟300个零.
10000!则大概是10的3000次方，既1后面要跟3000个零。
所以其结果10000!大概要比1000!大10的2700次方。
且不提每次运算的复杂度，光是你的运算结果，你计算机的所有内存都已经不够了。
更别提运算速度了。
按这个比例来计算，你的代码的速度还是比较可行的。
我想bigstrong 的代码也不会有什么速度上质的变化。
如：计算5的阶乘，输出的字符串将为 “021”，即反过来为120） 计算10000的阶乘：
直接执行EXE文件需要 ：55秒；
在的编辑器下需要 ：59秒； 本人的配置为：赛扬533、128M内存、WINDOWS 2000 SERVER； 程序包含两个文件，
一个是执行窗体文件（包含组件：1个SpinEdit1，一个Edit，一个Button1，三个标签Label1，Label2，Label3），
另一个是类定义文件（Unit_factorial_class.pas），具体如下：窗体定义文件：unit Unit_Main;interfaceuses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs,
StdCtrls, Spin;type
TForm1 = class(TForm)
Button1: TButton;
SpinEdit1: TSpinEdit;
Edit1: TEdit;
Label1: TLabel;
Label2: TLabel;
Label3: TLabel;
procedure Button1Click(Sender: TObject);
private
{ Private declarations }
public
{ Public declarations }
end;var
Form1: TForm1;implementation{$R *.DFM}uses
//使用类单元
Unit_factorial_class;var
MyFactorial:TLQM_factorial_class;procedure TForm1.Button1Click(Sender: TObject);
var
time1,time2:TTime;
begin
//创建对象
MyFactorial:=TLQM_factorial_class.Create;
label3.Caption:='Number: '+IntToStr(SpinEdit1.Value);
time1:=time;
//计算
Edit1.text:=string(MyFactorial.CaculateFactorial(SpinEdit1.Value));
time2:=time;
Label1.Caption:='Length: '+IntToStr(length(Edit1.text));
Label2.Caption:='Time: '+TimeToStr(time2-time1);
//销毁对象
MyFactorial.Free;
end;end.
类定义文件（Unit_factorial_class.pas）内容为：
//-----------------------------------------------------------------------------unit Unit_factorial_class;interfacetype//数据结构-----------------------------------------------------
//------------------------------------------------------------- //用于存储结果的每一个位(十进制位)的数据结构
TLQM_Factorial_Record_p=^TLQM_factorial_record;
TLQM_Factorial_Record=record
//只需用于保存0-9的数字,
//理论上的最大计算范围为[High(Integer)/10]的取值范围
//实际鉴于系统资源而定
Value:integer;
//指向高位的指针
HighPointer:TLQM_Factorial_Record_p;
end;//类结构-------------------------------------------------------
//------------------------------------------------------------- //用于实际计算的阶乘的类
TLQM_factorial_class=class(TObject)
//头节点指针
F_Head:TLQM_factorial_record_p;
private
//将指定值与链表中的值相乘（未进行值的标准处理）
//即：结果链表中的每个位都有可能是多位数
procedure Linklist_MultiplyValue_BlindMultiply(Value:integer);
//将最高位的值扩展到新加的高位字节（递归）
procedure Linklist_MultiplyValue_ExtendTopValue(
Top_p:TLQM_factorial_record_p);
//将链表中的值进行标准处理
//即：结果链表中的每个位只有一个个位数[0-9]
procedure Linklist_MultiplyValue_Fluency;
//将指定值与链表中的值相乘，生成标准的可输出值
//即：结果链表中的每个位只有一个个位数[0-9]
procedure Linklist_MultiplyValue(Value:integer);
//输出链表(注:由低位至高位,最高位的0不算)
function Linklist_OutputString:WideString;
public
//构造函数
constructor Create;
//计算阶乘的函数(当输入错误数[如:-1阶乘]时,返回字符串'-1')
function CaculateFactorial(UserValue:integer):WideString;
//析构函数
destructor Destroy;override;
end;
implementationuses
Sysutils;//构造函数
constructor TLQM_factorial_class.Create;
var
s:TLQM_factorial_record_p;
begin
//新建头节点-------------------------------------------------
new(s); s^.Value:=0; s^.HighPointer:=nil; F_Head:=s;
//创建并设置初始节点值为1------------------------------------
new(s); s^.Value:=1; s^.HighPointer:=nil; F_Head^.HighPointer:=s;
end;//将指定值与链表中的值相乘（未进行值的标准处理）
//即：结果链表中的每个位都有可能是多位数
procedure TLQM_factorial_class.Linklist_MultiplyValue_BlindMultiply(Value:integer);
var
p:TLQM_factorial_record_p;
begin
p:=F_Head^.HighPointer;
while p<>nil do
begin
p^.Value:=p^.Value*Value;
p:=p^.HighPointer;
end;
end;//将最高位的值扩展到新加的高位字节（递归）
procedure TLQM_factorial_class.Linklist_MultiplyValue_ExtendTopValue(
Top_p:TLQM_factorial_record_p);
var
s:TLQM_factorial_record_p;
begin
//若已经无高位，则退出
if (Top_p^.Value div 10)=0 then Exit;
//创建更高位-------------------------------------------------
new(s); Top_p^.HighPointer:=s; s^.HighPointer:=nil;
//将高位值存入s
s^.Value:=Top_p^.Value div 10;
//保留个位值
Top_p^.Value:=Top_p^.Value mod 10;
//继续扩展
Linklist_MultiplyValue_ExtendTopValue(s);
end;//将链表中的值进行标准处理
//即：结果链表中的每个位只有一个个位数[0-9]
procedure TLQM_factorial_class.Linklist_MultiplyValue_Fluency;
var
s,p:TLQM_factorial_record_p;
begin
//一直循环到最高位（但最高位不在内）
p:=F_Head^.HighPointer;
//若不是最高位，则将本位的个位值保留，高位值进到高位
while p^.HighPointer<>nil do
begin
//s指向高一位
s:=p^.HighPointer;
s^.Value:=s^.Value+p^.Value div 10;
p^.Value:=p^.Value mod 10;
p:=p^.HighPointer;
end;
//将最高位的值分解到“另外扩展的”更高的位
//（注：当前指针已经指向最高位）
Linklist_MultiplyValue_ExtendTopValue(p);
end;
//将指定值与链表中的值相乘
procedure TLQM_factorial_class.Linklist_MultiplyValue(Value:integer);
begin
//将指定值与链表中的值相乘（未进行值的标准处理）
//即：结果链表中的每个位都有可能是多位数
Linklist_MultiplyValue_BlindMultiply(Value);
//将链表中的值进行标准处理
//即：结果链表中的每个位只有一个个位数[0-9]
Linklist_MultiplyValue_Fluency;
end;//输出链表(注:由低位至高位)
function TLQM_factorial_class.Linklist_OutputString:WideString;
var
p:TLQM_factorial_record_p;
begin
Result:='';
p:=F_Head^.HighPointer;
while p<>nil do
begin
Result:=Result+IntToStr(p^.Value);
p:=p^.HighPointer;
end;
end;//计算阶乘的函数
function TLQM_factorial_class.CaculateFactorial(UserValue:integer):WideString;
var
i:integer;
begin
//若为小于0的数的阶乘,返回字符串'-1'
if UserValue<0 then begin Result:='-1'; Exit; end;
//若为0或1的阶乘,返回字符串'1'
if (UserValue in [0,1]) then begin Result:='1'; Exit; end;
//计算函数的主体部分
for i:=UserValue downto 2 do
begin
Linklist_MultiplyValue(i);
end;
//输出链表(注:由低位至高位)
Result:=Linklist_OutputString;
end;
//析构函数
destructor TLQM_factorial_class.Destroy;
var
s,p:TLQM_factorial_record_p;
begin
//释放空间
p:=F_Head^.HighPointer;
while p<>nil do
begin
s:=p; p:=p^.HighPointer; Dispose(s);
end;
Dispose(F_Head);
inherited Destroy;
end;
end. 内容完毕！若有错误，望请指正！ OK？ 分数再多加点吧！要不然，起不是有点亏了...
2、链表处理太费时间了，需要对指针进行操作，我建议你换成固定大小的数组，如果是10000！，20kbytes足矣，还会多出来很多。
3、标准化操作太费时间，每一位每一次标准化都会进行一次div和mod运算，而且根据你定义的数据结构，这是必须的，省略后肯定会产生溢出。最好把他去掉，不过可能要该整个算法和结构，你看看这样行不行，咱们可以讨论讨论：
首先对数的乘法看成是一个4294967295进制的数，为什么要这样，是因为2^32=429496.....，此时可用一个(unsigned int)表示一位，对不起我是用C++的，当相乘时将它看为多位数乘一位数，当然此一位数是相对这个大进制的数来看的，上限可达4294.....，此时可参照十进制的多位数乘一位数的算法，如下
unsigned int X[4],Y,Z;
unsigned __int64 Result;
//对X[4]赋值
...
Y=10000;
Z=0;//低位的进位
for(int i=0;i<4;i++)
{
Result=X[i]*Y;//32位乘32位的结果不用__int64类型保存会产生溢出
Result+=Z;//加上进上来的数，此时应该不会溢出的，具体可以用十进制数参考
X[i]=(unsigned int)Result;
Z=(Result&0xffff0000)>>32;//给高位的进位
}
这样应该就不用标准化了，不过现实是就麻烦了，要划成十进制数，就要不停地除十取余，除法算法应该类似，可能较麻烦一些，仓促写成可能有些问题也可能有些问题我没有想到。
1.链表中的每个元素的表数范围可以是0－65535。好处是效率高，缺点是输出麻烦。
2.链表中的每个元素的表数范围可以是0－10000。好处是输出容易，缺点是效率低。我最后采用第二种方法，在P200的计算机上快的很。
//#include "stdafx.h"
#include <stdlib.h>
// 000000000
// 000000000
#define WEISHU 10000
#define WEISHUBIT 4
#define MW ( WEISHU - 1 )
#define MAXLEN 100000int num1[MAXLEN];
int num2[MAXLEN];
int num3[MAXLEN];int resultTemp[MAXLEN];
int resultTempLen;
int mulTemp[MAXLEN];
int mulTempLen;void showNum( int * num,int len )
{
for(int i=len-1;i>=0;i--)
{
printf("%04d",num[i] );
}
}
int getweishu( int * num,int len )
{
int i;
for(i=len-1;i>=0;i--)
{
if ( i > 0 )
break;
}
if ( i == -1 )
return 1;
int r1 = i * WEISHUBIT;
int n2 = num[i];
if ( n2 == 0 )
return r1;
r1++;
while( n2 >= 10 )
{
r1++;
n2 /= 10;
}
return r1;
}
void showOpera( char * name1,int * num1,int len1 )
{
printf("%s = ",name1);
showNum( num1,len1 );
printf("\n");
}
void add( int * add1,int add1num,int *add2,int add2num,int *add3num )
{
// add1num >= add2num
int i;
//showOpera( "Add1",add1,add1num );
if ( add1num < add2num )
{
for(i=add1num;i<add2num;i++)
{
add1[i] = 0;
}
add1num = add2num;
}
int resultLen = add1num + 1;
int jinwei = 0;
for(i=0;i<add2num;i++)
{
add1[i] += add2[i] + jinwei;
if ( add1[i] > MW )
{
add1[i] -= WEISHU ;
jinwei = 1;
}
else
{
jinwei = 0;
}
}
if ( jinwei == 0 )
{
resultLen = add1num;
}
else
{
for(i=add2num;i<add1num;i++)
{
add1[i] ++;
if ( add1[i] > MW )
{
add1[i] = 0;
}
else
{
jinwei = 0;
break;
}
}
if ( jinwei == 0 )
{
resultLen = add1num;
}
else
{
add1[ add1num ] = 1;
}
}
*add3num = resultLen;
//showOpera("Add2",add2,add2num);
//showOpera("Add1 + Add2",add1,resultLen );
}
void mult( int * mul1,int mul1num,int *mul2,int mul2num,int *mul3,int *mul3num )
{
int i,j;
int result;
int jinwei = 0;
int kk;
resultTempLen = mul2num; for(i=0;i<mul2num+mul1num+1;i++)
{
resultTemp[i] = 0;
}
for(i=0;i<mul2num;i++)
{
jinwei = 0;
for(j=0;j<mul1num;j++)
{
result = mul2[i] * mul1[j] + jinwei;
if ( result > MW )
{
mulTemp[j] = result % WEISHU;
jinwei = result / WEISHU;
}
else
{
mulTemp[j] = result;
jinwei = 0;
}
}
if ( jinwei > 0 )
{
mulTempLen = mul1num+1;
mulTemp[mul1num] = jinwei;
}
else
{
mulTempLen = mul1num;
}
//showOpera("Mul1",mul1,mul1num);
//showOpera("Nul2",mul2+i,1);
//showOpera("Mul2 * Mul1",mulTemp,mulTempLen );
kk = resultTempLen;
add( resultTemp+i,kk-i,mulTemp,mulTempLen,&kk );
resultTempLen = kk + i;
}
*mul3num = resultTempLen;
for(i=0;i<resultTempLen;i++)
{
mul3[i] = resultTemp[i];
}
}
// 10! = 3628800
int ten( int num )
{
int re = 1;
for(int i=2;i<=num;i++)
re *= i;
return re;
}
void setNum( int num,int * n,int * len )
{
int i = 0;
while(num>0)
{
n[i] = num % WEISHU;
num /= WEISHU;
i++;
}
*len = i;
}
void cal(int num)
{
int i,j;
if ( num <= 10 )
{
printf("%d! = %d\n",num, ten(num));
return;
} int len1,len2,len3;
setNum( 3628800,num1,&len1);
for(i=11;i<=num;i++)
{
setNum( i,num2,&len2 );
mult( num1,len1,num2,len2,num3,&len3 );
for(j=0;j<len3;j++)
{
num1[j] = num3[j];
}
len1 = len3;
} printf("%d! = ",num);
showNum( num3,len3 );
printf("\nWeiShu = %d\n",getweishu(num3,len3));
}
void main(int argc, char* argv[])
{
if ( argc != 2 )
{
printf("Usage : Jiechen number\n");
return;
} int num = atoi( argv[1] );
if ( num <= 0 )
{
printf("Arg %s is invalid!\n",argv[1]);
return;
}
cal(num);
}
我的机子是联想的笔记本，可差劲了！但我的程序在98/nt/2000平台下均可运行,且在运行中的任何过程内存耗用都只不过3M多而已！
另外请问：10000！的计算结果是不是35660位！
C366,Win2000 Server,一大堆服务，10000的阶乘用了7.5秒左右。阶乘只是调用乘法和赋值两个操作，并没有专门实现。
for(int i=1;i<=10000;i++){
A=A*MEGA(i);
}
扣除一大堆的构造和析构的内存分配开销，改进一下大一时的弱智算法，应该还可以再快点。和大家对一下答案，错了赶快告诉我！10000！＝
28462596809170545189064132121198688901480514017027992307941799942744113400037644437729907867577847758158840621423175288300423399401535187390524211613827161748198241998275924182892597878981242531205946599625986706560161572036032397926328736717055741975962099479720346153698119897092611277500484198845410475544642442136573303076703628825803548967461117097369578603670191071512730587281041158640561281165385325968425825995584688146430425589836649317059251717204276597407446133400054194052462303436869154059404066227828248371512038322178644627183822923899638992827221879702459387693803094627332292570555459690027875282242544348021127559019169425429028916907219097083690539873747452483372899521802363282741217040268086769210451555840567172555372015852132829034279989818449313610640381489304499621599999359670892980190336998484404665419236258424947163178961192041233108268651071354516845540936033009607210346944377982349430780626069422302681885227592057029230843126188497606560742586279448827155956831533440534425446648416894580425709461673613187605234982286326452921529423479870603344290737158688499178932580691483168854251956006172372636323974420786924642956012306288720122652952964091508301336630982733806353972901506581822574295475894399765113865541208125788683704239208764484761569001264889271590706306409661628038784044485191643790807186112370622133415415065991843875961023926713276546986163657706626438638029848051952769536195259240930908614471907390768585755934786981720734372093104825475628567777694081564074962275254993384112809289637516990219870492405617531786346939798024619737079041868329931016554150742308393176878366923694849025999607729684293977427536263119825416681531891763234839190821000147178932184227805135181734921901146246875769835373441456013122615221391178759688367364087207937002992038279198038702372078039140312368997608152840306051116709484722224870389199993442071395836983063962232079115624044250808919914319837120445598344047556759489212101498152454543594285414390843564419984224855478532163624030098442855331829253154206551237079705816393460296247697010388742206441536626733715428700789122749340684336442889847100840641600093623935261248037975293343928764398316390312776450722479267851700826669598389526150759007349215197592659192708873202594066382118801988854748266048342256457705743973122259700671936061763513579529821794290797705327283267501488024443528681645026165662837546519006171873442260438919298506071515390031106684727360135816706437861756757439184376479658136100599638689552334648781746143243573224864326798481981458432703035895508420534788493364582482592033288089025782388233265770205248970937047210214248413342465268206806732314214483854074182139621846870108359582946965235632764870475718351616879235068366271743711915723361143070121120767608697851559721846485985918643641716850899625516820910793570231118518174775010804622585521314764897490660752877082897667514951009682329689732000622392888056658036140311285465929084078033974900664953205873164948093883816198658850827382468034897864757116679890423568018303504133875731972630897909435710687797301633918087868474943633533893373586906405848417828065196275826434429258058422212947649402948622670761832988229004072390403733168207417413251656688443079339447019208905620788387585342512820957359307018197708340163817638278562539516825426644614941044711579533262372815468794080423718587423026200264221822694188626212107297776657401018376182280136857586442185863011539843712299107010094061929413223202773193959467006713695377097897778118288242442920864816134179562017471831609687661043140497958198236445807368209404022211181530051433387076607063149616107771117448059552764348333385744040212757031851527298377435921878558552795591028664457917362007221858143309977294778923720717942857756271300923982397921957581197264742642878266682353915687857271620146192244266266708400765665625807109474398740110772811669918806268726626565583345665007890309050656074633078027158530817691223772813510584527326591626219647620571434880215630815259005343721141000303039242866457207328473481712034168186328968865048287367933398443971236735084527340196309427697652684170174990756947982757825835229994315633322107439131550124459005324702680312912392297979030417587823398622373535054642646913502503951009239286585108682088070662734733200354995720397086488066040929854607006339409885836349865466136727880748764700702458790118046518296111277090609016152022111461543158317669957060974618085359390400067892878548827850938637353703904049412684618991272871562655001270833039950257879931705431882752659225814948950746639976007316927310831735883056612614782997663188070063044632429112260691931278881566221591523270457695867512821990938942686601963904489718918597472925310322480210543841044325828472830584297804162405108110326914001900568784396341502696521048920272140232160234898588827371428695339681755106287470907473718188014223487248498558198439094651708364368994306189650243288353279667190184527620551085707626204244509623323204744707831190434499351442625501701771017379551124746159471731862701565571266295855125077711738338208419705893367323724453280456537178514960308802580284067847809414641838659226652806867978843250660537943046250287105104929347267471267499892634627358167146935060495110340755404658170393481046758485625967767959768299409334026387269378365320912287718077451152622642548771835461108886360843272806227776643097283879056728618036048633464893371439415250259459652501520959536157977135595794965729775650902694428088479761276664847003619648906043761934694270444070215317943583831051404915462608728486678750541674146731648999356381312866931427616863537305634586626957894568275065810235950814888778955073939365341937365700848318504475682215444067599203138077073539978036339267334549549296668759922530893898086430606532961793164029612492673080638031873912596151131890359351266480818568366770286537742390746582390910955517179770580797789289752490230737801753142680363914244720257728891784950078117889336629750436804214668197824272980697579391742229456683185815676816288797870624531246651727622758295493421483658868919299587402095696000243560305289829866386892076992834030549710266514322306125231915131843876903823706205399206933943716880466429711476743564486375026847698148853105354063328845062012173302630676481322931561043551941761050712449024873277273112091945865137493190965162497691657553812198566432207978666300398938660238607357858114394715872800893374165033792965832618436073133327526023605115524227228447251463863269369763762510196714380125691227784428426999440829152215904694437282498658085205186576292992775508833128672638418713277780874446643875352644733562441139447628780974650683952982108174967958836452273344694873793471790710064978236466016680572034297929207446822322848665839522211446859572858403863377278030227591530497865873919513650246274195899088374387331594287372029770620207120213038572175933211162413330422773742416353553587977065309647685886077301432778290328894795818404378858567772932094476778669357537460048142376741194182671636870481056911156215614357516290527351224350080604653668917458196549482608612260750293062761478813268955280736149022525819682815051033318132129659664958159030421238775645990973296728066683849166257949747922905361845563741034791430771561168650484292490281102992529678735298767829269040788778480262479222750735948405817439086251877946890045942060168605142772244486272469911146200149880662723538837809380628544384763053235070132028029488392008132135446450056134987017834271106158177289819290656498688081045562233703067254251277277330283498433595772575956224703707793387146593033088629699440318332665797514676502717346298883777397848218700718026741265997158728035440478432478674907127921672898523588486943546692255101337606377915164597254257116968477339951158998349081888281263984400505546210066988792614558214565319696909827253934515760408613476258778165867294410775358824162315779082538054746933540582469717674324523451498483027170396543887737637358191736582454273347490424262946011299881916563713847111849156915054768140411749801454265712394204425441028075806001388198650613759288539038922644322947990286482840099598675963580999112695367601527173086852756572147583507122298296529564917835071750835741362282545055620270969417476799259229774888627411314587676147531456895328093117052696486410187407673296986649236437382565475022816471926815559883196629848307776666840622314315884384910519058281816740764463033300119710293036455866594651869074475250837841987622990415911793682799760654186088721626654886492344391030923256910633775969739051781122764668486791736049404393703339351900609387268397299246478483727274770977466693599784857120156789000241947269220974984127323147401549980920381459821416481176357147801554231599667838534854486406936410556913531335231184053581348940938191821898694825383960989942822027599339635206217705343572073396250574216769465101608495601439303244304271576099527308684609204422226103154229984444802110098161333824827375218998738205315164927134498105950159974800571591912202154487748750103473246190633941303030892399411985006225902184164409988173214324422108554248620896250260604398180189026317781146617454999771440665232863846363847001655618153861098188111181734191305505024860345856755585637511729774299329074944236579668332700918367338977347901759248885660379952771540569083017311723894140326159612292912225191095948743805673381278538616491842786938417556898047100859868372033615175158097022566275200160956192229925401759878522038545913771783976389811198485803291048751666921195104514896677761598249468727420663437593207852618922687285527671324883267794152912839165407968344190239094803676688707838011367042753971396201424784935196735301444404037823526674437556740883025225745273806209980451233188102729012042997989005423126217968135237758041162511459175993279134176507292826762236897291960528289675223521425234217247841869317397460411877634604625637135309801590617736758715336803958559054827361876112151384673432884325090045645358186681905108731791346215730339540580987172013844377099279532797675531099381365840403556795731894141976511436325526270639743146526348120032720096755667701926242585057770617893798231096986788448546659527327061670308918277206432551919393673591346037757083193180845929565158875244597601729455720505595085929175506510115665075521635142318153548176884196032085050871496270494017684183980582594038182593986461260275954247433376226256287153916069025098985070798660621732200163593938611475394561406635675718526617031471453516753007499213865207768523824884600623735896608054951652406480547295869918694358811197833680141488078321213457152360124065922208508912956907835370576734671667863780908811283450395784812212101117250718383359083886187574661201317298217131072944737656265172310694884425498369514147383892477742320940207831200807235326288053906266018186050424938788677872495503255424284226596271050692646071767467502337805671893450110737377034119346113374033865364675136733661394731550211457104671161445253324850197901083431641989998414045044901130163759520675715567509485243580269104077637210998671624254795385312852889930956570729218673523216666097874989635362610529821472569482799996220825775840988458484250391189447608729685184983976367918242266571167166580157914500811657192200233759765317495922397884982814705506190689275625210462185661305800255607974609726715033327032310025274640428755556546883765838802543227403507431684278620637697054791726484378174446361520570933228587284315690756255569305558818822603590006739339952504379887470935079276181116276309771257983975996526612120317495882059435754883862282508401408885720583992400971219212548074097752974278775912566026443482713647231849125180866278708626116699989634812405803684794587364820124653663228889011636572270887757736152003450102268890189101673572058661410011723664762657835396364297819011647056170279631922332294228739309233330748258937626198997596530084135383241125899639629445129082802023225498936627506499530838925632246794695960669046906686292645006219740121782899872979704859021775060092893328957272392019589994471945147360850770400725717439318148461909406269545285030526341000565022226152309364882887122046454267700577148994335147162504252365173710266068647253458120186683273953682547456536553597546685788700056988360286686450740256993087483441094086086303707908295240576731684941855810482475304758923392801571302824106234999945932390521409856559565661346003396150515164758852742214732517999548977992849522746029855666700811871200856155016457400484170210303038996339253337466556817824410737409336919294104632307731994759826307383499600770372410446285414648704116273895649834555162165685114551383822047005483996671706246467566101291382048909121117229386244253158913066987462045587244806052829378148302622164542280421757760762365459828223070815503469404938317755053305094698999476119419231280721807216964378433313606760676965187138394338772485493689061845700572043696666465080734495814495966306246698679832872586300064215220210171813917325275173672262621454945468506006334692713838311715849753092643252486960220059099802663765386225463265168414963306369548086551101256757717890616694758344043486218485369591602172030456183497524162039926441331651884768606830642004858557924473340290142588876403712518642229016333691585063273727199596362912783344786218887871009533753551054688980236378263714926913289564339440899470121452134572117715657591451734895195016800621353927175419843876163543479806920886666227099512371706241924914282576453125769939735341673046864585181979668232015693792684926999983992413571941496882273704022820805171808003400480615261792013978945186295290558440703738300533552421153903385185829366779190610116306233673144419202893857201855569596330833615450290424822309297087124788002017383072060482680156675397593789931793515799958929562156307338416294599900276730832827716595064217966523190439250543226753731811755315476780739470338931185107297724318378972674957455778183345495942317353558291046967315391275975687281861691161083156337232639968881490543943261197182274996791176628553401860198315809629981791107208804992292016062059067271273599461871634945774995805337947187105456452579396024210259136415528398395201773012712514892051061708228008339985665786646920737114269682301770416324829479409558694699089379165191006305185352102345189798127619143061864362703081977124992751056732909481202057747100687703379708934229207183903744167503493818836342229284946790660285674293251642569044363473087656797056595677285291081242733154406580199802711579126254172797452862574865921933293805915239524735518887119860391319654287576290190503964083560246277534314409155642181729459941596061979622633242715863425977947348682074802021538734729707999753332987785531053820162169791880380753006334350766147737135939362651905222242528141084747045295688647757913502160922040348449149950778743107189655725492651282693489515795075486172341394610365176616750329948642244039659511882264981315925080185126386635308622223491094629059317829408195640484702456538305432056506924422671863255307640761872086780391711356363501269525091291020496042823232628996502758951052844368177415730941874894428065427561430975828127698124936993313028946670560414084308942231140912722238148470364341019630413630736771060038159590829746410114421358321042574358350220737173219745089035573187350445827238770728271406162997919629357224104477155051652535867544109395079218369015261138440382680054150924346511711436477899444553993653667727589565713987505542990824585609510036934663100673714708029927656933435500927189854050109917474979991554392031908961967615444686048175400695689471463928245383807010444181045506171305160584355817521032338465829201071030061124283407458607006060194830551364867021020364708470807422704371893706965688795617928713045224516842027402021966415605280335061293558739079393524404092584248380607177444609964035221891022961909032569042381374492494906892314330884224399631396391545854065286326468807581148748371408284176455226386313520264894016262494802388568231599102952620337126449279901938211134518446387544516391239377974190576649911764237637722282802318465738050121277809680315691477264910257503508758792248110223544524410872448565700755187132146592093548504552829170749596775404450779494836371756062326925757412813110241910373338080434325310884694831555729402265394972913817581338619457057799561808755951413644907613109617155928376585840036489374076822257523935988731081689667688287403837192827690431514106997678303819085690713091931340846019511147482766350724676534922040058626677632935516631939622498979912708004465982264899125226813124300528104995058595676527123591494442612554437618645029202881358582871789577224116380815161831603129728796987480139828621645629196153096358337313619724773332353025466571196902611237380629030242904275794549030022660847446513161741691916851746464945459696005330885252792083472495235473110674109099223541055506299687642153951249355986311346661725116890785633328935569150449485189113488301876365100638502565916433021928565596263914382895068324838727165616560111531517055222955765944972454788815532316417453267167978861141165355597588331979638070962998880767303616940317736448140427867784251232449974693421348217179595190698204602997172001174857303889719205597414742453011135869766256607770970225633261701108463784795555258504578058879440756064974127974530918418405207558526462208821483646754652237609210787539190454684852349759986044943322828073120679922402477507514105890774627334319091255451352225329275913842047384603056163154236552935312278389759446515787337343463172280001031380425481404022090580405056003860937403435068863081434683848900708938565050027569059678069404698435184535134141031615133683043714786642925389717165978629010728400758939700388317742648163725113277369926827709465342583596111881955092462062153978121197244762623771534452048069819082524943963962251113831177428978535825590832490480497516047104257569753442551515779815600370847230603484753977513688390404316017486248871339311818523029425425676202485688393970836748788453789172574145155917919035398535077200900594979352939459631213445503368260690059828717723533375221941915547303742062343262892968397015058892191112049249864792053410872349115430987182160055762209075732304626106597744947658346313025598636315029959672352476943975462530206788193304372284800209305354155640664838569378144603138697563459200233462606995955513484754147891180830329816421587452922952678937925647752029052675349356673744293182673374571642465407748267901046778759085408130531447176455869894169668940436489952465247443988349583871206296485413357553813419500498743813369062703973874586604296871595820715766599826607317005624465541763024501349159567288942619746144496908671655859782729228702723774835097362901019130417812735773037781804081589136005207315806941034305003184349342360269244733060013861119781774472669608928321052543116496033420102032603863672532889648333405862204843616575362001468405476649666473566979572953394809138263703324220930839366954980688240491622063147911494642042500022450413425558561937442905257252436320054487441524307305215070491020434076572476865095751174125413729531644521765577235348601821566833352520532830000108344008762266843817023235605645158256954177359197813649975559601912567744942717986360045847405209290089397315276024304951653864431388147876977541478757432610159879709758855625806766197973098472460769484821127948427976536607055051639104415022554420329721292033009353356687294595912327965886376486894188433640548494009574965791657687213927330153555097865114767947399690623184878377515462613823651665956337209345708208301840482797005728071432925727577436229587047361641609731817241594204270366066404089740245521530725227388637241859646455223673260411164598464020010216920823315155388821071527191267876531795071908204525100447821291318544054814494151867114207103693891129125012750853466337717749376016543454696390042711129829255096830420665725364279472200020835313883708781649957189717629338794854271276882652003766325924561614868744897471519366219275665852462114457407010675380427564184440834805203838265052601698584060084788422421887856927897751810442805474427229455167420335686460609977973124950433321425205053675790499520783597650415379001132579536040655172654879022173595444151139429231648950663177813039057462082449171921311864129633704661406456900178942356738775523130952785912774533241855442484484493664210731348819180640189222317302156645813473186449997905781662091469870718039388885781280740226363602294114354869871402143572055947730892808653678920201935102605361567924483276749476117858316071865710310842200560259545115191391309119544447844361032741876102338843391687589233423790859841968266525610628751237572318491474951945985728897934981791761822652480408237128109790772638864286067917082288575852703470839714561619926247844794692794996845945632382702297364173503430783194115698247820013290851202878474805860188960045901745974055630732714487679085288867978809970695240681006625611440014983413580889737246844064948857074167687916413224205373654067330186392497910915474785959163865597507090581175924899502214799250945635582514315814464060134283490422798357939659258985200763845646681640732681928346007767285876284900068874564639274964415904034033672337814491597032941787294155061054129515400159393851663929325677429557549480046658273579653990940233543644649376827272541873627547532976808190325336141086433084237771738995221536763095302045902438694632702895293994483013577589081214884558493819874505920914067209522469096263076941753340983698859363700314973728977996360018626500174929290087931189997822963712306642297996163582572600112288983647651418045975770042120833949364659647336464289044499325396227091907373705772051322815957863227591912786054297862953188615559804728160710864132803585400160055575686855791785977899197902656592621283007225351401525973569300729015392211116868504740402172174442051738000251361000494534119324331668344243125963098812396962202358858395587831685194833126653577353244379935683215269177042249034574534858913812582681366908929476809052635560638119661306063936938411817713545929884317232912236262458868394202889981693561169865429884776513118227662526739978808816010470651542335015671353744817086234314662531190291040152262927104099285072418843329007277794754111637552176563589316326636049381218401837512818884771168975479483767664084842753623074019542183217985496260666590347925816342392670947839907062923166535037285019751324813803837070894638925470887039085723581006130628646664710006104352115778926613432214655311411882596942926284522109026688414975763341554921135581254616558078273470115814006008345762133130389987843270653719956709570847385786092649188858378739239165554263577301292243641604062551736892335636568854365851646207821875741724364525814143487632761341752707376754922276287782264765154315341585713773522730335403376364204258034257264749686217823666951353410677378421131371131987373222891805275062812277716412494412401207125954319991746574745892582613712825555535080404143944557295994554635608487251339462936358940832098964801619583130429720964794128539388996265368928263807677168759588502216464582430940165009688797366157733560316836710386895228270941509545222744002735499253670214715994056544813842186380128799900820933576320736369405991424263718294000613741900579513096298545330748197802568301089672873802234820488862973130369689882640657904781562389778485365025691064231795736025330908763271784911189748432246868086340383964176127605788646574472284824932687443062551220506955168464669477183681911432873544815836350548146411099960143390595799766290646881295025039150923633011076070632863317393378149693380247580035052789782755750928604039420506342939327064636161031822879248152679306862749237275631852225654266008556849497720285909150930495425967473648331437236349555448901598668408362176913559656039519670425368863482369587129462524759031776813184977588276576740482558136502103649585505703259219957675334264223783723586058509403583977103476670644788640831109650302565215607464019652716999732373465237173456595514559493098166644006211599349133180135150528651842178828026343325934755850761168697709125580056185683710540856081249519403148064618719402577663285267019698387567561524696759028106864896869293315954352097687527137201616160931174250199709289684940034696242325688410665113304377412256176258658941236728171145526423894512631717834790276921171452887352955019336759218908006048633737786728180610254782570436788449503518925787499836694785908612975543084122677060954347612133717433156783790162012337237023338316414706428592185977610158232721997915062871868186750981665537745013020880333904353639770263363809098526494532628146558065546504823486429495390613257400496912888340518222933644476683855037967975809619983575807027759535968788226194659612223044549275600274955168583542582295336042834426318478068825395450746691877897765406038432512843812811316856204608617289408229658626174420766920297427930088129519854678713548623236610413216581279267151545961594352593456757445992307889205519540082316409719591250025455237503106735639748835542480449681383030671851931491335789202123605308199952020584503423499932150962634977812456658304680581824563524814625849331926195406884818446445248429486063016169476663242625231476322371109695369483824482316410396224507675405614287468267835723704895606990652792688455844512046654853378534026646645042339638488257719874953611300494215593735545211926186721478265416885604094928290056616883807637656690510740892510549165222968878676968631652514917701499900066637344546120262780701925698706225540928945194718778004306130021828287425867048748480826948573444778244078734102710824870269523830804910960482013901294024631244800159336670212658317677879752965963472576894326540435889267293950687860830626266263287392087327302547910099932113388977807814336728791448768373686467748528777737403547472871644217767820712964506270880978637928144071192505141148004907055608097229299792441471062852247029870699869227676341773513258602908903875707454368077876422385333700692089616351009233587303986543906071880952557553380364725895007306772122528078179471056481171378557451057691044322925429024149433588396093679321361696954251299731031032804436954501929843820842383121265825740594509426942777307124802176915781835720087170538773256017987133005505911377823841791640280841409623820847637393013930778428554545222367559824666250608754284876104145661362227642405914304455580856318180935230407793891614902116292400515074914068443203230365609954878620999194306564455332547135557365318516011700321550690787716752062881527885897149410320986984083048966524351030502444679931779147659103428949129054120361601695671222140806369405940304552186212879933092856231022418446365289097444640151986623183881962444822590783585914043686193019041458962693878907034982169868696934448086213990534591792826654304798207219634134755646525483143771156678459077797196510772468000293581546267646310224279007313631352522067062951125935874473134186492497282784796644585448962932905262058065248588707020879389134476083344653170939242408249328008915731319541348311820927752486880548733943315867562666122179355051190609992911379445634995627391898459029021713155706096267881673302940198464237390445098028030948975981259252055850973537436556825780313681902007151675693827281818824587541710721180806556448039122504537089422695358382192535075692834095639859265599740391316709290043996275976830375217503360879028295673068862263077729733533853682668734519035709709687322323738300494090123239274318759046526327095178406267264828893646896593219169521106361729757074376148061601331104911692271318609404145014842866423634716982892418180484365230538864559809839273836490685480823014267803143937440431807822678779494006206489151248952516543005634448375046751754207043313372486870633237561645232360481932024377596890914783372179553676992603235715185513391098402739063753280702313301755754269396202629423910945323537910125948964941812563672992967084250667599803456273455598559628512281414582556024841783305645240508450065988755987518601335860624932784487772006842296591945516539562982960591610046578907214842054861830418175604559815168088031783080261445994444677918012432146400983610678683412974872596729258786806223080115822026289014364459002301645823666709265571264559925790622304745235625575111770791512002789380975775468546121017307522799241407026308137792971909461413145802081087738121624539858769697371425881836152605069380926917712087321915005831977113322793572385071940612761291872572099404930250277748156614021327434743881966413330052634229082906400927944924808556131183440161804801357032507836323938921567643159620442612809700944107776130638909071294456394056601559246025454204771186140420155233371270501377121034570009578009389265329385720478576508777149663403003562380595757191609382171312222810465858388943507176431939973012661591423837170284400120399485880996231859472474858776584355077006934099220340378772192728370301380838144394114984971730766162961342059105014814283949700695951676939041557902856356911055547312684571497449635320554677940775184056667637222969090346128706829887104278761090090999160443821794511763620835379716161833124364431267855435550800507986124664397724135502128238026726719914989727248512981287283697489276420792868666970177259794407858155909332508554131299946581118527691652464790819119384233275897699573012098103009171001695718791616942270079528915191912521053891838538959315167400505723817401030621004380243011187977704252328073236575129609372456053680037516596164236147709330391224409752871732067976128120428026739256557305675931512645750047875756531854825821411574030473147492511910835615765732002546109686701890307648531373832912682481741181359032826625082549313211431478953352317043989053928534946642886074268371824902498092479487226633686823799580875637040808655649321905489637785549531167397935270799470452399153297534358690514105864096534514182896474439367182852711843560799285895978176543950113088848419163516673213692860830956744502801800373716458009168082972708715609185038654053436660045504985624687376022557041595800250174095361839287643458003670864954057941720085136357127163768323493134230703821274484501440529541695374381945459456533165140990993722722801019654652726227831512103467686166826131471843610025517863247950150022953695466317739589344131481485834694374523981159954666071205997794363440185078360899108948073419633939259318973940943110042116729120199722626609871927014024105805515315100109804996044147291039451030312664114726736839973315035036742741546992633165270432940675237449075056739508929674779115800864399992564817208847429250821546279856079127768611946086210349405535850134472190244543824521089284409498132717010673966471114931896789977661595488186193176900175027901783824624387873831483279500879026433992577026588005849778984624295660321276945810824348129690840972550671054732471317254997191901039553305847040728081693158626093886019147689944137673621432083607375131574376316754666479186753896571555100850626810005119827486807780592667765654100834778571024250133253391587384761024129794736751001163498977803745930025457609870671092153597115178252014281216647543034075128600240297038428615984289816602143429849088917359682192284469123035904329877231843309914187264674607558318725713138832356015809009594182530207799397648462597901883341793830920965841463574411985878296475850943053008148341821747826603773762252997703468752903517310792083220038080809212164346586817989810504274375385786789186350517717501606531826406928883250135919517178537687865881752366421534010961295763074762648070312757365787762352859057153932484576503944390496668087711899192498933896524852395536795827530614167131757915756386606004839994179548705868209201195154952031294562451315422506574858629161606523796643010172693950282294667489681746821163996794950294284013099235901278250437428192557634533217576162292751110598368271567229778620053722932314082887058749444060116236521627717558503013451471452765841864277071769968435499620257547431811994883385806759692359580622165832464092095350648357935817742903018315351290014321495518177456908388719320697769695657771754499149911431368950836160692539606469893374870942933219185601299108564470256257163505508620689240297589684714283678684735455533583477652536156578189996983068654671736445996343136468195427420490472433064675001442697508322369013083895492637066778406531328664886080129513771720847581157719491012345141774941482773580041432667332379617716965698582785832300505265883502247868050648201444570593197343382923860072601696510903258980909912837652275381493529845099414966933862815568031306981064525192703818515872648691762563239441425216118427769145067718411735714396681005615483952443154944864238384298900399826113322468963346522104692545137969276009719645338955332105584245640187448611050959111766828942711640054010503770420346052521318228045892998637903572350665108782350043349942391285236308896510989246641056331584171142885304143772286629832318970869030400301325951476774237516158840915838059151673504519131178193943428482922272304061422582078027829148070426761629302539228321084917759984200595105312164731818409493139800444072847325902609169730998153853939031280878823902948001579008000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
我的源程序如下:
LongCalc.h文件
//---------------------------------------------------------------------------#ifndef LongCalcH
#define LongCalcH//想减少缓冲区分配操作可适当增加此值
#define FIXBUFFERSIZE (256)
//---------------------------------------------------------------------------
class UValueCalc
{
private:
unsigned int FMaxDigit;
void __fastcall SetMaxDigit(unsigned int value);
void __fastcall SetAsString(AnsiString value);
AnsiString __fastcall GetAsString();
protected:
unsigned int *CalcBuffer;
unsigned int BufferSize;
void SetBuffer(unsigned int NewSize);
void Standardize();
unsigned int SelfDiv(unsigned int Divisor);
public:
__property unsigned int MaxDigit = { read=FMaxDigit, write=SetMaxDigit };
__property AnsiString AsString = { read=GetAsString, write=SetAsString }; UValueCalc();
UValueCalc(const UValueCalc & InitValue);
UValueCalc(unsigned int NewBufferSize);
virtual ~UValueCalc();
unsigned int GetValue(unsigned int Offset);
void SetValue(unsigned int Value);
void SetValue(const UValueCalc & Value);
void SetValue(AnsiString Value);
void Factorial(int Value);
bool IsZero();
UValueCalc& operator=(const UValueCalc & NewValue);
UValueCalc& operator=(unsigned int NewValue);
UValueCalc& operator+=(unsigned int Addend);
UValueCalc& operator-=(unsigned int Subtrahend);
UValueCalc& operator*=(unsigned int Multiplier);
UValueCalc& operator/=(unsigned int Divisor);
UValueCalc& operator%=(unsigned int Divisor);
UValueCalc operator+(unsigned int Addend);
UValueCalc operator-(unsigned int Subtrahend);
UValueCalc operator*(unsigned int Multiplier);
UValueCalc operator/(unsigned int Divisor);
unsigned int operator%(unsigned int Divisor); bool operator==(const UValueCalc & CompareTo);
bool operator>(UValueCalc CompareTo);
bool operator<(const UValueCalc & CompareTo);
bool operator!=(const UValueCalc & CompareTo);
bool operator>=(const UValueCalc & CompareTo);
bool operator<=(const UValueCalc & CompareTo);
};#endifLongCalc.cpp文件
//---------------------------------------------------------------------------#include <vcl.h>
#pragma hdrstop#include "LongCalc.h"
//---------------------------------------------------------------------------
#pragma package(smart_init)UValueCalc::UValueCalc(unsigned int NewBufferSize)
{
//计算初始化运算缓冲区的大小，设为FIXBUFFERSIZE的整倍数
NewBufferSize=((unsigned int)((NewBufferSize+FIXBUFFERSIZE-1)/FIXBUFFERSIZE))*FIXBUFFERSIZE;
//分配空间
CalcBuffer=new unsigned int[NewBufferSize];
//初始化其他变量
BufferSize=NewBufferSize;
FMaxDigit=1;
//设值为0
SetValue(0);
return;
}UValueCalc::UValueCalc()
{
//初始化缓冲区大小为FIXBUFFERSIZE
CalcBuffer=new unsigned int[FIXBUFFERSIZE];
//初始化其他变量
BufferSize=FIXBUFFERSIZE;
FMaxDigit=1;
//设值为0
SetValue(0);
return;
}UValueCalc::UValueCalc(const UValueCalc & InitValue)
{
//初始化缓冲区大小为FIXBUFFERSIZE
CalcBuffer=new unsigned int[FIXBUFFERSIZE];
//初始化其他变量
BufferSize=FIXBUFFERSIZE;
//设值为InitValue
SetValue(InitValue);
}void __fastcall UValueCalc::SetMaxDigit(unsigned int value)
{
//最大数位超出缓冲区容量，重新设置缓冲区容量
SetBuffer(value);
FMaxDigit=value;
}void UValueCalc::SetValue(unsigned int Value)
{
//设置值
CalcBuffer[0]=Value;
MaxDigit=1;
return;
}void UValueCalc::SetValue(const UValueCalc & Value)
{
//设置值
MaxDigit=Value.MaxDigit;
for(int i=0;i<MaxDigit;i++)
CalcBuffer[i]=Value.CalcBuffer[i];
return;
}unsigned int UValueCalc::GetValue(unsigned int Offset)
{
if(Offset>=MaxDigit)
return (0);
return CalcBuffer[Offset];
}void UValueCalc::SetBuffer(unsigned int NewSize)
{
unsigned int *NewBuffer;
unsigned int NewBufferSize; //计算新缓冲区的大小，变为FIXBUFFERSIZE的整倍数
NewBufferSize=BufferSize;
if(NewSize>BufferSize)
{
//扩大缓冲区
while(NewBufferSize<NewSize&&NewBufferSize<2000000000)
NewBufferSize*=2;
if(NewBufferSize<NewSize)
throw EIntOverflow("Integer Overflow");
}
NewBufferSize=((unsigned int)((NewBufferSize+FIXBUFFERSIZE-1)/FIXBUFFERSIZE))*FIXBUFFERSIZE;
if(NewBufferSize==BufferSize)
return;
//设置数位
FMaxDigit=(FMaxDigit>NewBufferSize)?NewBufferSize:FMaxDigit;
NewBuffer=new unsigned int[NewBufferSize];
//拷贝原值
for(int i=0;i<MaxDigit;i++)
NewBuffer[i]=CalcBuffer[i];
delete [] CalcBuffer;
//变换缓冲区
BufferSize=NewBufferSize;
CalcBuffer=NewBuffer;
return;
}UValueCalc::~UValueCalc()
{
delete [] CalcBuffer;
}void UValueCalc::Standardize()
{
//标准化，去掉开头无用的0
while(MaxDigit>1 && CalcBuffer[MaxDigit-1]==0)
MaxDigit--;
}//输入字符串
void UValueCalc::SetValue(AnsiString Value)
{
AsString=Value;
}void __fastcall UValueCalc::SetAsString(AnsiString value)
{
unsigned int NineDigit;
AnsiString NineDigitBuffer;
int Begin, Length; value=value.Trim();
Length=value.Length()+1;
Begin=1;
SetValue(0);
while(Length-Begin>=9)
{
NineDigitBuffer=value.SubString(Begin, 9);
Begin+=9;
NineDigit=NineDigitBuffer.ToInt();
(*this)*=(1000000000);
(*this)+=NineDigit;
}
if(Begin<Length)
{
NineDigitBuffer=value.SubString(Begin, Length-Begin);
Begin=Length-Begin;
NineDigit=NineDigitBuffer.ToInt(); unsigned Multiplier=1;
for(int i=0;i<Begin;i++)
Multiplier*=10;
(*this)*=(Multiplier);
(*this)+=NineDigit;
}
}//输出字符串
AnsiString __fastcall UValueCalc::GetAsString()
{
UValueCalc CurrentValue;
unsigned int NineDigit;
AnsiString AllDigit, NineDigitBuffer; if(IsZero())
return AnsiString("0");
CurrentValue=(*this);
while(CurrentValue.MaxDigit>1 || CurrentValue.CalcBuffer[0]>=1000000000)
{
NineDigit=CurrentValue.SelfDiv(1000000000);
NineDigitBuffer.sprintf("%09lu", NineDigit);
AllDigit=NineDigitBuffer+AllDigit;
}
NineDigit=CurrentValue.SelfDiv(1000000000);
NineDigitBuffer.sprintf("%lu", NineDigit);
AllDigit=NineDigitBuffer+AllDigit;
return (AnsiString(AllDigit));
}bool UValueCalc::IsZero()
{
Standardize();
if(MaxDigit<=1 && CalcBuffer[0]==0)
return (true);
else
return (false);
}//计算Value!
void UValueCalc::Factorial(int Value)
{
if(Value<=1)
SetValue(1); unsigned int Carry, *pAResult;
unsigned __int64 AResult; SetValue(2);
pAResult=(unsigned int *)(&AResult);
for(int i=3;i<=Value;i++)
{
Carry=0;
for(int j=0;j<MaxDigit;j++)
{
AResult=(unsigned __int64)CalcBuffer[j]*(unsigned __int64)i;
AResult+=Carry;
CalcBuffer[j]=pAResult[0];;
Carry=pAResult[1];
}
if(Carry>0)
{
MaxDigit++;
CalcBuffer[MaxDigit-1]=Carry;
}
}
return;
}//自除返回余数，划为十进制数时使用
unsigned int UValueCalc::SelfDiv(unsigned int Divisor)
{
unsigned int Carry, Quotient, *pDividend;
unsigned __int64 Dividend; if(Divisor==0)
throw EDivByZero("Division by zero.");
Dividend=CalcBuffer[MaxDigit-1];
pDividend=(unsigned int *)(&Dividend);
for(int i=MaxDigit-2;i>=0;i--)
{
asm{
mov eax,[dword ptr Dividend]
mov edx,[dword ptr Dividend+4]
div [dword ptr Divisor]
mov Quotient,eax
mov Carry,edx
}
CalcBuffer[i+1]=Quotient;
pDividend[1]=Carry;
pDividend[0]=CalcBuffer[i];
}
CalcBuffer[0]=Dividend/Divisor;
Carry=Dividend%Divisor;
Standardize();
return (Carry);
}//以下部分重载运算符
UValueCalc& UValueCalc::operator=(unsigned int NewValue)
{
SetValue(NewValue);
return (*this);
}UValueCalc& UValueCalc::operator=(const UValueCalc & NewValue)
{
SetValue(NewValue);
return (*this);
}UValueCalc UValueCalc::operator+(unsigned int Addend)
{
UValueCalc Result(MaxDigit);
unsigned int Carry, *pAResult;
unsigned __int64 AResult; Carry=Addend;
Result.MaxDigit=MaxDigit;
pAResult=(unsigned int *)(&AResult);
for(int i=0;i<MaxDigit;i++)
{
AResult=(unsigned __int64)CalcBuffer[i]+(unsigned __int64)Carry;
Result.CalcBuffer[i]=pAResult[0];
Carry=pAResult[0];
if(Carry==0)
break;
}
if(Carry>0)
{
Result.MaxDigit++;
Result.CalcBuffer[Result.MaxDigit-1]=Carry;
}
return (UValueCalc(Result));
}UValueCalc UValueCalc::operator-(unsigned int Subtrahend)
{
UValueCalc Result(MaxDigit);
unsigned int CarryFrom; if(MaxDigit<=1 && CalcBuffer[0]<Subtrahend)
{
Result.SetValue(0);
return (UValueCalc(Result));
}
Result=(*this);
CarryFrom=0;
if(CalcBuffer[0]<Subtrahend)
for(CarryFrom=1;CarryFrom<MaxDigit;CarryFrom++)
if(CalcBuffer[CarryFrom]>0)
{
Result.CalcBuffer[CarryFrom]--;
break;
}
else
Result.CalcBuffer[CarryFrom]=0xffffffff;
if(CalcBuffer[0]>=Subtrahend)
Result.CalcBuffer[0]-=Subtrahend;
else
Result.CalcBuffer[0]=(unsigned __int64)CalcBuffer[0]+(unsigned __int64)0x100000000-Subtrahend;
Result.Standardize();
return (UValueCalc(Result));
}UValueCalc UValueCalc::operator*(unsigned int Multiplier)
{
UValueCalc Result(MaxDigit);
unsigned int Carry, *pAResult;
unsigned __int64 AResult; if(Multiplier==0)
return (Result);
Carry=0;
pAResult=(unsigned int *)(&AResult);
Result.MaxDigit=MaxDigit;
for(int i=0;i<MaxDigit;i++)
{
AResult=(unsigned __int64)CalcBuffer[i]*(unsigned __int64)Multiplier;
AResult+=Carry;
Result.CalcBuffer[i]=pAResult[0];
Carry=pAResult[1];
}
if(Carry>0)
{
Result.MaxDigit++;
Result.CalcBuffer[Result.MaxDigit-1]=Carry;
}
return (UValueCalc(Result));
}UValueCalc UValueCalc::operator/(unsigned int Divisor)
{
UValueCalc Result(MaxDigit);
unsigned int Reminder, Quotient, *pDividend;
unsigned __int64 Dividend; if(Divisor==0)
throw EDivByZero("Division by zero.");
Dividend=CalcBuffer[MaxDigit-1];
Result.MaxDigit=MaxDigit;
pDividend=(unsigned int *)(&Dividend);
for(int i=MaxDigit-2;i>=0;i--)
{
asm{
mov eax,[dword ptr Dividend]
mov edx,[dword ptr Dividend+4]
div [dword ptr Divisor]
mov Quotient,eax
mov Reminder,edx
}
Result.CalcBuffer[i+1]=Quotient;
pDividend[1]=Reminder;
pDividend[0]=CalcBuffer[i];
}
Result.CalcBuffer[0]=Dividend/Divisor;
Result.Standardize();
return (UValueCalc(Result));
}unsigned int UValueCalc::operator%(unsigned int Divisor)
{
unsigned int Reminder, *pDividend;
unsigned __int64 Dividend; if(Divisor==0)
throw EDivByZero("Division by zero.");
pDividend=(unsigned int *)(&Dividend);
Dividend=CalcBuffer[MaxDigit-1];
for(int i=MaxDigit-2;i>=0;i--)
{
Reminder=Dividend%Divisor;
pDividend[0]=CalcBuffer[i];
pDividend[1]=Reminder;
}
Reminder=Dividend%Divisor;
return (Reminder);
}UValueCalc& UValueCalc::operator/=(unsigned int Divisor)
{
unsigned int Carry, Quotient, *pDividend;
unsigned __int64 Dividend; if(Divisor==0)
throw EDivByZero("Division by zero.");
Dividend=CalcBuffer[MaxDigit-1];
pDividend=(unsigned int *)(&Dividend);
for(int i=MaxDigit-2;i>=0;i--)
{
asm{
mov eax,[dword ptr Dividend]
mov edx,[dword ptr Dividend+4]
div [dword ptr Divisor]
mov Quotient,eax
mov Carry,edx
}
CalcBuffer[i+1]=Quotient;
pDividend[1]=Carry;
pDividend[0]=CalcBuffer[i];
}
CalcBuffer[0]=Dividend/Divisor;
Carry=Dividend%Divisor;
Standardize();
return (*this);
}UValueCalc& UValueCalc::operator+=(unsigned int Addend)
{
unsigned int Carry, *pAResult;
unsigned __int64 AResult; Carry=Addend;
pAResult=(unsigned int *)(&AResult);
for(int i=0;i<MaxDigit;i++)
{
AResult=(unsigned __int64)CalcBuffer[i]+(unsigned __int64)Carry;
CalcBuffer[i]=pAResult[0];
Carry=pAResult[1];
if(Carry==0)
break;
}
if(Carry>0)
{
MaxDigit++;
CalcBuffer[MaxDigit-1]=Carry;
}
return (*this);
}UValueCalc& UValueCalc::operator-=(unsigned int Subtrahend)
{
unsigned int CarryFrom; if(MaxDigit<=1 && CalcBuffer[0]<Subtrahend)
{
SetValue(0);
return (*this);
}
CarryFrom=0;
if(CalcBuffer[0]<Subtrahend)
for(CarryFrom=1;CarryFrom<MaxDigit;CarryFrom++)
if(CalcBuffer[CarryFrom]>0)
{
CalcBuffer[CarryFrom]--;
break;
}
else
CalcBuffer[CarryFrom]=0xffffffff;
if(CalcBuffer[0]>=Subtrahend)
CalcBuffer[0]-=Subtrahend;
else
CalcBuffer[0]=(unsigned __int64)CalcBuffer[0]+(unsigned __int64)0x100000000-Subtrahend;
Standardize();
return (*this);
}UValueCalc& UValueCalc::operator*=(unsigned int Multiplier)
{
unsigned int Carry, *pAResult;
unsigned __int64 AResult; if(Multiplier==0)
{
SetValue(0);
return (*this);
}
Carry=0;
pAResult=(unsigned int *)(&AResult);
for(int i=0;i<MaxDigit;i++)
{
AResult=(unsigned __int64)CalcBuffer[i]*(unsigned __int64)Multiplier;
AResult+=Carry;
CalcBuffer[i]=pAResult[0];
Carry=pAResult[1];
}
if(Carry>0)
{
MaxDigit++;
CalcBuffer[MaxDigit-1]=Carry;
}
return (*this);
}UValueCalc& UValueCalc::operator%=(unsigned int Divisor)
{
unsigned int Reminder, *pDividend;
unsigned __int64 Dividend; if(Divisor==0)
throw EDivByZero("Division by zero.");
pDividend=(unsigned int *)(&Dividend);
Dividend=CalcBuffer[MaxDigit-1];
for(int i=MaxDigit-2;i>=0;i--)
{
Reminder=Dividend%Divisor;
pDividend[0]=CalcBuffer[i];
pDividend[1]=Reminder;
}
Reminder=Dividend%Divisor;
SetValue(Reminder);
return (*this);
}bool UValueCalc::operator==(const UValueCalc & CompareTo)
{
if(MaxDigit!=CompareTo.MaxDigit)
return (false);
for(int i=0;i<MaxDigit;i++)
if(CalcBuffer[i]!=CompareTo.CalcBuffer[i])
return (false);
return (true);
}bool UValueCalc::operator>(UValueCalc CompareTo)
{
int i; if(MaxDigit<CompareTo.MaxDigit)
return (false);
if(MaxDigit>CompareTo.MaxDigit)
return (true);
for(i=MaxDigit-1;i>=0;i--)
if(CalcBuffer[i]<CompareTo.CalcBuffer[i])
return (false);
else
if(CalcBuffer[i]!=CompareTo.CalcBuffer[i])
break;
if(i>=0)
return (true);
else
return (false);
}bool UValueCalc::operator<(const UValueCalc & CompareTo)
{
int i;
if(MaxDigit<CompareTo.MaxDigit)
return (true);
if(MaxDigit>CompareTo.MaxDigit)
return (false);
for(i=MaxDigit-1;i>=0;i--)
if(CalcBuffer[i]>CompareTo.CalcBuffer[i])
return (false);
else
if(CalcBuffer[i]!=CompareTo.CalcBuffer[i])
break;
if(i>=0)
return (true);
else
return (false);
}bool UValueCalc::operator!=(const UValueCalc & CompareTo)
{
return (!((*this)==CompareTo));
}bool UValueCalc::operator>=(const UValueCalc & CompareTo)
{
return (!((*this)<CompareTo));
}bool UValueCalc::operator<=(const UValueCalc & CompareTo)
{
return (!((*this)>CompareTo));
}
环境是WinNT+BCB5，c450(c300 overclock),256m
10000!:3秒
20000!:14秒
100000!:8分多吧
里面有一个算阶乘的函数,直接调就行了,最好不要用算术符重载自己算,时间差距在十倍以上,因为算术符重载时会对内存进行大量的分配操作。
我上面贴的算法确实不是最快的！ SAsura说道“标准化后空间浪费太大”，确实是的。 可以将进位制改成10的n（n应小于所选整数类型的字长）次方来弥补，这样将对输入数的范围有更大的限制。 至于链表结构，我认为，它是不如单纯的数组快，但是它可以根据实际情况动态适应，而不会受限于静态数组定义的大小；而且，对输入数的范围的支持是很有用处的。譬如，将TLQM_Factorial_Record.Value的类型改为int64，或是gauss所提的自定义数据类型，则理论上可以使输入数的范围达到... 想了一下，我上头贴的算法应该还可以简化和加速的： 一方面 ：按照SAsura和ifairy说的，适当增加每个位的保留值的范围，输出时低位字节转换后补足位数即可（或自定义转换函数）； 另一方面 ：不知各位注意到没有，我上面的程序中，每次相乘均对链表遍历了两次，一次是简单的相乘，另一次是按位相加；当时的觉得若每位相乘后立即相加可能无法控制进位。
其实可以为链表结构添加两个值，即一个长度为2的数组。再添加一个标志量（取值0或1）用以指示当前所用的链表的一列，相乘时，将结果保存到另一列中，若有进位则扩展链表。完成后交互标志量的值，如斯循环，只需一次。但使用内存将翻倍。
取？舍？
可能汇编代码还可以用 MMX 优化一把，或者其他// j2.cpp : Defines the entry point for the console application.
//#include "stdafx.h"
#include <stdlib.h>#define XX 1000000000
#define YY ( XX-1 )typedef unsigned int UINT;UINT arraySize( UINT num )
{
return 100000;
}
UINT mult2( UINT * mul1,UINT len1,UINT mul2,UINT * result )
{
int jw = 0;
int reslen ;
_asm
{
mov ecx,0
mov esi,mul1
mov edi,result
cld
loopNext:
mov ebx,mul2
lodsd
mul ebx
add eax,jw
adc edx,0
cmp edx,0
jnz shouldDiv
cmp eax, XX
jb belowXX
shouldDiv:
mov ebx, XX
div ebx
mov [edi],edx
mov jw,eax
add edi,4
inc ecx
cmp ecx,len1
jne loopNext
jmp endLoop
belowXX:
stosd
mov jw,0
inc ecx
cmp ecx,len1
jne loopNext
endLoop:
cmp jw,0
jz ok
mov eax,jw
stosd
ok:
sub edi,result
shr edi,2
mov reslen,edi
}
// printf("len=%d\n",reslen);
return reslen;
}void showNum( UINT * num,int len )
{
for(int i=len-1;i>=0;i--)
{
printf("%09d",num[i]);
}
}void cal( UINT num )
{
UINT maxlen = arraySize(num);
UINT * num1 = new UINT[maxlen];
UINT * num2 = new UINT[maxlen];
UINT len;
UINT * beichen,* result;
UINT i; num1[0] = 120;
len = 1;
beichen = num1;
result = num2;
for(i=6;i<=num;i++)
{
len = mult2( beichen,len,i,result );
if ( beichen == num1 )
{
beichen = num2;
result = num1;
}
else
{
beichen = num1;
result = num2;
}
} showNum( beichen,len ); delete []num2;
delete []num1;
}
void main(int argc, char* argv[])
{
cal( atoi(argv[1]));
}