用C语言和汇编语言实现将1个整数分解成几个素数的乘积
任何1个大于2的整数都可以分解成几个素数的乘积。将1个整数分解成几个素数的乘积是个热门话题。
经常有人问到。本文试图用C语言和32位X86汇编语言给出一个比较好的实现。希望对c语言学习者和
汇编语言学习者带来帮助。
问题的提出：将一个整数分解素因数
根据算术基本定理，任何大于2的正整数都可以表示为素数的乘积，如果不考虑这些素数出现的次序，其
表示方式为唯一的。本题目的要求是输入一个正整数，将这个正整数显示为几个素数乘积的形式，如
如
1=1
2=2
3=3
4=2*2
5=5
6=2*3
7=7
...
60=2*2*3*5
算法：
对于合数n，它总可表示为两个数的乘积，如n=a*b,令a<=b,容易证明a <= sqrt(n),这里sqrt(n)表示n的
平方根，下同。这说明了，用i =2 到 sqrt(n)之间的数逐一试除，如果所有的i都不是n的因数，则n一定
是一个素数。如果在试除过程中,某个i能够整数n，则将i存入因子表，n/i => n,直到 i*i大于n为止。
在试除过程中，若p和q都是n的因子，p是素数，q大于p，q是p的倍数，如果p能够整除n，则n = n / p,
这样，最终n就不再是p的倍数，故n也不会是q的倍数，故在计算n = n / p这一过程，p一定是一个素数，
这种方法得到的所有因子都是素因子。
在所有的试除方法中，最少的试除步骤是用2到sqrt(n)之间的所有素数去试除。但这个算法需要预先算出
sqrt(n)之间的所有素数。这是最快的算法，但我们这里不打算搞得这么复杂，我们这里的算法是用2和所有2
以上的奇数去试出。因为如果一个数是4，6，8的倍数，那么他一定是2的倍数，当被2除后，就不需要试再试
除4,6,8了。
下面给出一个C语言的实现
#include
#include
typedef unsigned long DWORD;
//函数decomp_integer对n分解素因数，分解后的素数存入facArr数组，并返回因子的个数
int decomp_integer( DWORD n, DWORD facArr[])
{
DWORD fac; //n的可能的一个因子
int count;
if (n<4) //4以内的数，不需要分解
{
facArr[0]=n; return 1;
}
count=0;
//下面的while循环为2试出n，直到2不是n的因子为止
while ( (n & 1)==0) // 这里判断偶数用 （n &1）==0，这比(n % 2)==0更快
{
facArr[count++]=2; n/=2;
}
fac=3; //用3到sqrt(n)之间的奇数试除
while (fac*fac<=n) // fac*fac <= n
{
while (n % fac==0)
{
facArr[count++]=fac;
n /= fac;
}
fac+=2;
}
if (n==1)
return count;
facArr[count++]=n;
return count;
}
int main(int argc, char* argv[])
{
DWORD n,facArray[32];
int i,count;
printf("Please input unsigned integer:");
scanf("%u",&n);
count=decomp_integer(n,facArray);
printf("%u=%u",n,facArray[0]);
for (i=1;i 汇编语言可能是最麻烦的语言，在实践中，除非必要，好少有人用汇编语言写程序。这主要是因为
1.同样的题目，用汇编语言编程需要的代码量较大，费时费力
2.汇编语言的可读性很差，日后维护的成本也大。
许多有经验的工程师对汇编语言写程序都很头疼，对许多初学这说，更是一件难以完成的任务。
初学者常犯的错误是，一上来就有汇编写程序，不管有没有理清头绪，这样造成的结果就是，程序改
了又改，但总是不对，好容易改对了，但程序的风格很差，代码冗长，逻辑混乱，可读性很差。其实，
用任何语言写成都需要设计，程序应该具有模块化，条理清晰，风格一致。汇编语言是最接近机器的
语言，编写汇编程序，非常有利用理解计算机的工作原理。
个人觉得，对于一个逻辑比较复杂的汇编程序的设计，不妨采用高级语言为原型，用高级语言编译运
行通过了，说明你也就对这个题目理解了，然后，看看你的程序，哪里可以简化，哪里可以重构使其
更优雅。最后可将你用高级语言写的程序翻译成汇编语言，这里的翻译不是简单的翻译，汇编语言有
汇编语言的特点，他具有更大的灵活性，开发者应该总是用最适当的方式来实现它。
下面是这个题目的汇编版本，使用masm32编写。关于输入输出部分，使用的几个Windows API函数，
这里说明如下：
程序使用ReadFile从控制台输入数据，使用WriteConsole输出运算结果到控制台。字符串到数的转化
子程序是自己写的。见myAtoi。而数到字符串的转化调用的则是Windows API函数wsprintf。此外，程
序还用到GetStdHandle和ExitProcess，感兴趣的同学，可以查MSDN来得到更多的信息。
在C语言版，外循环的判断语句"while (fac*fac<=n)"使用了乘法，而汇编语言班则使用了性能更好的lea
指令，见下
mov edx,s_fac
mov eax,fac
lea edx,[edx+eax*4+4] ; (fac+2)*(fac+2)=s_fac * 4*fac+4
mov s_fac,edx
add fac,2 ; fac +=2
其基本原理为，若s_fac是fac的平方，则在求(fac+2)^2时，使用了数学公式(fac+2)^2= fac^2 + 4*fac +4,
这里的^表示乘方，程序中，fac和s_fac分别表示当前因子和当前因子的平方，然后当前因子加2，同时需要
更新s_fac,在上面的代码中，先计算(fac+2)^2,(fac+2)=fac^2 + 4*fac +4=s_fac+ 4*fac +4,然后计算fac+2.
lea指令支持*4,*8这样的形式，故这里使用lea指令而没有时候性能很慢的乘法指令。
下面给出汇编语言版的代码，可借助c版的程序来理解汇编版，同时请体会汇编语言和c语言在处理逻辑方面的
的不同，特别是分支和循环语句。
; 如何编译链接该程序
; 本程序需使用masm32来编译，若你的masm32安装在c盘，请设置如下环境变量
; set include=c:\masm32\include
; set lib=c:\masm32\lib
; set PATH=c:\masm32\bin;%PATH%
; 若本程序名为decomp.asm,则运行如下命令编译和链接和运行
; ml /c /coff decomp.asm
; link /subsystem:console decomp.obj
; decomp.exe
.386
.model flat,stdcall ; 32 bit memory model
option casemap :none ; case sensitive
include windows.inc
include user32.inc
includelib user32.lib
include kernel32.inc
includelib kernel32.lib
.data
facTab dd 32 dup(?) ;number的所有素因子
facCount dd ? ;number的所有素因子的个数
number dd ? ;被分解的数
fac dd ? ;number的当前因子
s_fac dd ? ;number的平方
tLen dd ? ;临时变量，仅在调用Windows API函数是用
hInput dd ? ;标准输入设备句柄
hOutput dd ? ;标准输出设备句柄
inBuffer db 32 dup(?) ;输入缓冲区
outBuffer db 128 dup(?) ;输出缓冲区
.const
szFmtIn db '%u',0
szFmtOut1 db 'Please input an unsigned integer:'
szFmtOut2 db '%u=%u',0
szFmtOut4 db '*%u',0
.code
;use global varible, don't pass any in parameter in stack
dcomp proc far uses esi
mov esi,number ;esi is copy of n
cmp esi,4
jae case_02
case_01:
mov facTab[0],eax
mov ecx,1
jmp this_exit
case_02:
xor ecx,ecx ;ecx: copy of count
jmp loop_02_cmp
loop_02:
mov facTab[ecx*4], 2
inc ecx ;count++
shr esi,1 ;esi is copy of n,n /=2
loop_02_cmp:
mov edx,esi
and edx, 1
jz loop_02 ; n % 2==0
mov fac,3
mov s_fac, 9
jmp loop03_outer_cmp
loop03_outer:
jmp loop03_inner_cmp
loop03_inner:
mov edx, fac
mov facTab[ecx*4],edx ;fac[count++]=fac
inc ecx ;count++
xor edx,edx
mov eax,esi
div fac
mov esi,eax
loop03_inner_cmp:
xor edx,edx
mov eax,esi
div fac
or edx,edx
jz loop03_inner
mov edx,s_fac
mov eax,fac
lea edx,[edx+eax*4+4] ; (fac+2)*(fac+2)=s_fac * 4*fac+4
mov s_fac,edx
add fac,2 ; fac +=2
loop03_outer_cmp:
mov eax,s_fac
cmp eax,esi
jbe loop03_outer
cmp esi,1 ;
jz this_exit ; n ==1
mov facTab[ecx*4],esi
inc ecx
mov eax,ecx
this_exit:
mov eax,ecx ;返回素因子数
ret
dcomp endp
; convert from a string to a integer
myAtoi proc far C uses ebx esi, var_String
mov esi,var_String ;in parameter => esi
mov ebx,10
xor eax,eax
xor ecx,ecx
loop_read_char:
mov cl,byte ptr [esi] ; get a char from in_buff
inc esi
sub cl,'0'
cmp cl,9
ja input_exit ;if the char <'0' or >'9', then jump out loop
mul ebx
add eax,ecx
jmp loop_read_char
input_exit:
ret
myAtoi endp
; use global varible, don't pass parameter in stack
; number: in parameter
; facTab: in paramter
; facCount: factor count
; hInstance: input device handle
output_fac proc far C uses ebx edi
lea edi, outBuffer
mov eax,facTab[0]
invoke wsprintf, edi, addr szFmtOut2,number,eax
add edi, eax
mov ebx,1
jmp next_cmp
convert_loop:
mov eax,facTab[ebx*4]
invoke wsprintf,edi,addr szFmtOut4,eax
add edi, eax ;edi the write pointer in next ; 下次输出时的地址送edi
inc ebx
next_cmp:
cmp ebx,facCount
jb convert_loop
print:
lea eax, outBuffer
sub edi, eax ;计算输出的字符串的长度，存入edi
invoke WriteConsole,hOutput,addr outBuffer,edi,addr tLen,0 ;在控制台输出
ret
output_fac endp
main proc far
invoke GetStdHandle,STD_OUTPUT_HANDLE ; 获取控制台输出设备的句柄
mov hOutput,eax
invoke WriteConsole,hOutput,addr szFmtOut1,sizeof szFmtOut1,addr tLen,0
invoke GetStdHandle,STD_INPUT_HANDLE ; 获取控制台输入设备的句柄
mov hInput, eax
invoke ReadFile,hInput,addr inBuffer,sizeof inBuffer,ADDR tLen,NULL
lea eax, inBuffer
invoke myAtoi,eax ;转化字符串为一个数
mov number, eax ;将这个数存入number
invoke dcomp ;调用因子分解子程序，,各个因子存入facTab
mov facCount,eax ;分解后的因子个数存入facCount
invoke output_fac ;调用output_fac打印number的分解式
xor eax, eax
invoke ExitProcess,eax ;退出进程
ret
main endp
end main
[email protected], 转载请注明出处。