计算机二级C技巧:加密_弄乱C源代码计算机二级考试

文章作者 100test 发表时间 2009:07:25 10:38:06
来源 100Test.Com百考试题网

　　编辑特别推荐:

　　全国计算机等级考试（等考）指定教材

　　全国计算机等级考试学习视频

　　全国计算机等级考试网上辅导招生

　　全国计算机等级考试时间及科目预告

　　百考试题教育全国计算机等级考试在线测试平台

　　全国计算机等级考试资料下载

　　全国计算机等级考试论坛

　　计算机等级考试四级应用题解析汇总

　　2009年下半年全国计算机二级考试时间是2009年9月19日至23日。2009年下半年全国计算机二级考试报名时间会在考前两个月开始报名！更多优质资料尽在百考试题论坛 百考试题在线题库。

　　下面是一个Step by Step的教程，教你如何把一个清晰的代码变得复杂难懂的。当然，这只是一个“简明教程”了。还是那句话——“本文仅供朋友们“消遣作乐”，如果你要觉得有意思的话，顶个贴。如果你觉得没什么意思的话，一笑了之。仅供娱乐而已，不必太过认真。”
　　正常程序
　　下面是一个找出素数的程序：
　　void primes(int cap)
　　{
　　int i, j, composite.
　　for(i = 2. i <. cap. i) {
　　composite = 0.
　　for(j = 2. j * j <. i. j) {
　　composite = !(i % j).
　　}
　　if(!composite){
　　printf("%d\t", i).
　　}
　　}
　　}
　　int main()
　　{
　　primes(100).
　　}
　　下面我们来看看如何把上面这段代码搞得复杂难懂。
　　第一步、把for变成while
　　通常来说，for循坏要以while循坏简单一些，上面的程序有二重for循环，我们不但要把其变成while循环，而且还要把二重循环的变成一重的循环，然后使用大量的if-else语句来判断。
　　void primes(int cap)
　　{
　　int i, j, composite, t = 0.
　　while(t <. cap * cap) {
　　i = t / cap.
　　j = t % cap.
　　if(i <.= 1).
　　else if(!j)
　　composite = j.
　　else if(j == i &.&. !composite)
　　printf("%d\t",i).
　　else if(j >. 1 &.&. j <. i)
　　composite = !(i % j).
　　}
　　}
　　int main()
　　{
　　primes(100).
　　}
　　第二步，把循坏变成递归
　　递归在某些时候是可以把代码变得简单，但大多数的情况下是把代码变得复杂，而且很没有效率。下面是把上面的while循环变成了递归。变成了递归后，函数的参数都变成3个了。
　　void primes(int cap, int t, int composite)
　　{
　　int i,j.
　　i = t / cap.
　　j = t % cap.
　　if(i <.= 1)
　　primes(cap,t 1,composite).
　　else if(!j)
　　primes(cap,t 1,j).
　　else if(j == i &.&. !composite)
　　(printf("%d\t",i), primes(cap,t 1,composite)).
　　else if(j >. 1 &.&. j <. i)
　　primes(cap,t 1, composite !(i % j)).
　　else if(t <. cap * cap)
　　primes(cap,t 1,composite).
　　}
　　int main()
　　{
　　primes(100,0,0).
　　}
　　第三步，弄乱代码结构/使用没有含义的变量名
　　关于如何弄乱代码结构，其中一个小技巧是，使用“？”表达式代替if-else语句。
　　void primes(int m, int t, int c)
　　{
　　int i,j.
　　i = t / m.
　　j = t % m.
　　(i <.= 1) ? primes(m,t 1,c) : (!j) ? primes(m,t 1,j) : (j == i &.&. !c) ?
　　(printf("%d\t",i), primes(m,t 1,c)) : (j >. 1 &.&. j <. i) ?
　　primes(m,t 1,c !(i % j)) : (t <. m * m) ? primes(m,t 1,c) : 0.
　　}
　　int main()
　　{
　　primes(100,0,0).
　　}
　　第四步，取消临时变量
　　临时变量一般用来保存反复使用的一个表达式的值。使用大量重复的表达式来取消这些临时变量的也可以让代码复杂起来。
　　void primes(int m, int t, int c)
　　{
　　((t / m) <.= 1) ? primes(m,t 1,c) : !(t % m) ? primes(m,t 1, t % m) :
　　((t % m)==(t / m) &.&. !c) ? (printf("%d\t",(t / m)), primes(m,t 1,c)) :
　　((t % m)>. 1 &.&. (t % m) <. (t / m)) ? primes(m,t 1,c !((t / m) % (t % m))) :
　　(t <. m * m) ? primes(m,t 1,c) : 0.
　　}　　
　　int main()
　　{
　　primes(100,0,0).
　　}
　　第五步，继续弄乱变量名
　　我们知道，下划线是合法的变量名，所以，我们不妨用__，___，____来代替m，t，c。函数名也可以使用下划线来代替。让我们来看看求素数的函数能变成什么。
　　void _(int __, int ___, int ____)
　　{
　　((___ / __) <.= 1) ? _(__,___ 1,____) : !(___ % __) ? _(__,___ 1,___ % __) :
　　((___ % __)==(___ / __) &.&. !____) ? (printf("%d\t",(___ / __)),
　　_(__,___ 1,____)) : ((___ % __) >. 1 &.&. (___ % __) <. (___ / __)) ?
　　_(__,___ 1,____ !((___ / __) % (___ % __))) : (___ <. __ * __) ?
　　_(__,___ 1,____) : 0.
　　}
　　int main()
　　{
　　_(100,0,0).
　　}
　　第六步，移除常量
　　在上面的程序中，还有一些常量，你可以通过增加一个宏定义，或是增加一个函数的形参来取代这一常量。
　　void _(int __, int ___, int ____, int _____)
　　{
　　((___ / __) <.= _____) ? _(__,___ _____,____,_____) : !(___ % __) ? _(__,___ _____,___ % __, _____) :
　　((___ % __)==(___ / __) &.&. !____) ? (printf("%d\t",(___ / __)),
　　_(__,___ _____,____,_____)) : ((___ % __) >. _____ &.&. (___ % __) <. (___ / __)) ?
　　_(__,___ _____,____,_____ !((___ / __) % (___ % __))) : (___ <. __ * __) ?
　　_(__,___ _____,____,_____) : 0.
　　}
　　int main() {
　　_(100,0,0,1).
　　}
　　程序到这里应该差不多了。还是那句话——“每一个程序员都有把源代码弄复杂的潜质”，大家好自为之。

　　2009年9月全国计算机等级考试时间及科目预告

　　2009年NCRE考试有新变化

　　2009年全国计算机等级考试-大纲

　　全国计算机等级考试历年真题及答案

　　2009年上半年全国计算机等级考试试题及答案