test

在C中，编写跑在普通的X86处理器(连MMX指令都不支持的)上的程序，这种写法的确还不错；但在C#中，这种写法没什么太大意义吧...

即使我们按照普通的乘除法写法，JIT在编译生成本机机器指令时，会针对具体处理器的寄存器、支持的指令集进行优化(据称是这样)，可能只需在几个CPU时钟周期内即可完成计算，但按照这种乘法拆成移位+加法的方式，要生成多少指令，花费多少CPU时钟周期呢?

楼主可以搜下《不同CPU架构如何影响浮点运算性能》，了解下更“复杂”的浮点数运算...

可以用以下代码对效率进行测试：
using System;
using System.Collections.Generic;
using System.Text;

namespace ConsoleApplication44
{
class Program
{
static void Main(string[] args)
{
int a = -25547788;
int len = 500000;
int c1 = 543;
int c2 = 188;
int c;
ESCF e = new ESCF();

DateTime start1 = DateTime.Now;

for (int i = 0; i < len; i++)
{
c = e.GetResult(c1, c2);
}

TimeSpan ts1 = DateTime.Now - start1;

Console.WriteLine("使用位操作的时间:" + ts1.TotalMilliseconds);

DateTime start2 = DateTime.Now;

for (int i = 0; i < len; i++)
{
c = c1 * c2;
}

TimeSpan ts2 = DateTime.Now - start2;

Console.WriteLine("使用求模操作的时间:" + ts2.TotalMilliseconds);
}
}

/// <summary>
/// 判断一个整数是奇数还是偶数。使用位操作
/// </summary>
static class OddEven
{
static public bool IsEven(int a)
{
return ((a & 1) == 0);
}

static public bool IsOdd(int a)
{
return !IsEven(a);
}
}

/// <summary>
/// 判断一个整数是奇数还是偶数。使用求模操作
/// </summary>
static class Mod2
{
static public bool IsEven(int a)
{
return ((a % 2) == 0);
}

static public bool IsOdd(int a)
{
return !IsEven(a);
}
}

class ESCF
{
private int _small;
private int _big;

//private bool _minus;

private void init(int a, int b)
{
//int f = 0;

//if (a < 0) f++;
//if (b < 0) f++;

//if (f == 0 || f == 2) _minus = false;
//else _minus = true;

//a = Math.Abs(a);
// b = Math.Abs(b);

_small = a <= b ? a : b;
_big = a > b ? a : b;
}

public int GetResult(int a, int b)
{
init(a, b);

int reslut = 0;

while (_small != 1)
{
if (OddEven.IsOdd(_small))
{
_small--;
reslut += _big;
}

_small >>= 1;
_big <<= 1;
}

reslut += _big;

//if (_minus)
// reslut = -reslut;

return reslut;
}
}
}

@Silent Void
谢谢你的指教，这种写法的效率我刚刚测试过了，比自带的慢了上百倍，唉～～