深入探讨用位掩码代替分支（5）：C#2010速度测试

最新推荐文章于 2017-05-21 13:24:18 发布
最新推荐文章于 2017-05-21 13:24:18 发布
阅读量2.1k 收藏 1
点赞数
分类专栏： #All - 所有 数学&优化技巧 文章标签： c# 2010 byte 测试 语言 string
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zyl910/article/details/7408013
版权

　　前面我们测试了C语言这样纯编译型语言。那么对于像C#这样由虚拟机执行的语言，“位掩码代替分支”法是否也有效果呢？于是本文对此进行探讨。

一、移植要点

　　C#的语法与C语言很相像，多数代码可以直接用，但要注意以下几点。

1.1 unsafe——不安全上下文

　　C#虽然支持指针，但必须在unsafe——不安全上下文 中才能使用。

　　要使用unsafe，必须先配置项目属性，允许不安全代码——
1.项目->属性，打开项目的属性页。
2.点击左侧“生成”，切换到“生成”页。
3.点击上侧的“配置”组合框，选择“所有配置(C)”。
4.勾选“常规”中的“允许不安全代码(F)”。
5.点击工具栏上的“保存”按钮。

　　unsafe有两种用法——
1.unsafe方法。在函数的声明中增加“unsafe”关键字。
2.unsafe区块。在函数内，使用“unsafe{ ... }”标识不安全代码的区块。

　　当函数有指针参数时，只能使用第1种方法。
　　例如，C语言中f0_if函数的声明为——
void f0_if(BYTE* pbufD, const signed short* pbufS, int cnt)

　　而在C#中，该函数的声明应改为——
static unsafe void f0_if(byte* pbufD, short* pbufS, int cnt)

　　因为f0_if不会修改对象成员，所以应加上“static”关键字表示它是静态函数，而不是对象的成员方法。


1.2 unchecked——不检查整数溢出

　　在C语言中不会检查整数溢出，正好被我们的位运算算法所利用。而在C#中，可以配置整数溢出检查的，具体配置方法为——
1.项目->属性，打开项目的属性页。
2.点击左侧“生成”，切换到“生成”页。
3.将滚动条拉到最下面，点击“输出”中的“高级”，打开“高级生成设置”对话框。
4.在“常规”中有一个“检查运算上溢/下溢(K)”。

　　若配置了“检查运算上溢/下溢(K)”，当整数溢出时会抛出异常，打断程序流程。这对我们的位运算算法来说是不利的。怎么办呢？
　　应使用unchecked关键字来取消整数溢出检查。
　　unchecked关键字有两种用法，一种是作为区块，一种是作为函数。
　　在我们的测试函数中有大量的整数运算，使用unchecked区块更加方便。


1.3 类型检查更严格

　　C#的类型检查比C语言更加严格。所以得增加更多的强制类型转换，否则编译器会发出警告甚至报错。

　　例如这一行C语言代码——
pD[0] = (pS[0]<0) ? 0 : ( (pS[0]>255) ? 255 : (BYTE)pS[0] );

　　在C#中，得写成——
pD[0] = (pS[0] < 0) ? (byte)0 : ((pS[0] > 255) ? (byte)255 : (byte)pS[0]);

　　结合以上3点，将f0_if函数转为C#语法——

		// 用if分支做饱和处理
		static unsafe void f0_if(byte* pbufD, short* pbufS, int cnt)
		{
			short* pS = pbufS;
			byte* pD = pbufD;
			int i;
			for (i = 0; i < cnt; ++i)
			{
				// 分别对4个通道做饱和处理
				pD[0] = (pS[0] < 0) ? (byte)0 : ((pS[0] > 255) ? (byte)255 : (byte)pS[0]);
				pD[1] = (pS[1] < 0) ? (byte)0 : ((pS[1] > 255) ? (byte)255 : (byte)pS[1]);
				pD[2] = (pS[2] < 0) ? (byte)0 : ((pS[2] > 255) ? (byte)255 : (byte)pS[2]);
				pD[3] = (pS[3] < 0) ? (byte)0 : ((pS[3] > 255) ? (byte)255 : (byte)pS[3]);
				// next
				pS += 4;
				pD += 4;
			}
		}



　　其他测试函数也可以这样处理。


1.4 C#中不支持宏

　　在C#中不支持宏，所以在移植f2_neg、f3_sar函数时，得手动实现代码。

　　虽然可以将LIMITSU_BYTE这些宏改写为函数，但函数调用开销会影响性能。于是增加了f2_negB、f3_sarB这两个测试函数来验证这一论断。


1.5 bool转整数

　　在C语言中，逻辑比较的结果是整型，这样有助于位运算算法。
　　但在C#，单独设计了bool类型，与整型隔离。甚至不允许强制转换，只能用Convert.ToInt16方法将bool转整数。

　　例如将f2_neg函数转为C#语法——

		// 用位掩码做饱和处理.用带符号右移生成掩码
		static unsafe void f2_neg(byte* pbufD, short* pbufS, int cnt)
		{
			unchecked
			{
				short* pS = pbufS;
				byte* pD = pbufD;
				int i;
				for (i = 0; i < cnt; ++i)
				{
					// 分别对4个通道做饱和处理
					pD[0] = (byte)(pS[0] & -Convert.ToInt16(pS[0] >= 0) | -Convert.ToInt16(pS[0] >= 256));
					pD[1] = (byte)(pS[1] & -Convert.ToInt16(pS[1] >= 0) | -Convert.ToInt16(pS[1] >= 256));
					pD[2] = (byte)(pS[2] & -Convert.ToInt16(pS[2] >= 0) | -Convert.ToInt16(pS[2] >= 256));
					pD[3] = (byte)(pS[3] & -Convert.ToInt16(pS[3] >= 0) | -Convert.ToInt16(pS[3] >= 256));
					// next
					pS += 4;
					pD += 4;
				}
			}
		}



　　Convert.ToInt16会带来函数调用开销，影响性能。而且，貌似它内部是采用分支实现bool到整数的转换的，又带了跳转堵塞流水线的问题。


1.6 delegate——委托

　　虽然C#不支持函数指针，但可以使用委托。
　　C语言中，我们是这样定义测试函数的类型的——
typedef void (*TESTPROC)(BYTE* pbufD, const signed short* pbufS, int cnt);

　　在C#中改为委托——
unsafe delegate void TESTPROC(byte* pbufD, short* pbufS, int cnt);

　　因含有指针参数，所以得加上unsafe关键字。而且必须处于unsafe区块才能使用该委托，例如——

			// 进行测试
			unsafe
			{
				runTest("f0_if", f0_if);
				runTest("f1_min", f1_min);
				runTest("f2_neg", f2_neg);
				runTest("f2_negB", f2_negB);
				runTest("f3_sar", f3_sar);
				runTest("f3_sarB", f3_sarB);
			}




1.7 fixed——绑定指针

　　在C#中，不能像C语言那样随时可以用&运算符获取地址。得使用fixed语句来绑定变量、获取指针。MSDN对它的说明——
http://msdn.microsoft.com/zh-cn/library/f58wzh21.aspx
fixed 语句禁止垃圾回收器重定位可移动的变量。 fixed 语句只在不安全的上下文中是允许的。 Fixed 还可用于创建固定大小缓冲区。
fixed 语句设置指向托管变量的指针，并在执行该语句期间“固定”此变量。 如果没有 fixed 语句，则指向可移动托管变量的指针的作用很小，因为垃圾回收可能不可预知地重定位变量。 C# 编译器只允许在 fixed 语句中分配指向托管变量的指针。

　　在这里，我们利用fixed语句来获得bufS、bufD这两个缓冲区的指针。注意它们类型不同，所以得嵌套使用fixed语句。
　　将runTest函数转为C#语法——

		// 进行测试
		static unsafe void runTest(string szname, TESTPROC proc)
		{
			int i, j;
			Stopwatch stw = new Stopwatch();	// 执行时间
			// 绑定指针
			fixed (short* pbufS = &bufS[0])
			{
				fixed (byte* pbufD = &bufD[0])
				{
					// 开始测试
					for (i = 1; i <= 3; ++i)	// 多次测试
					{
						stw.Reset();
						stw.Start();
						// main
						for (j = 1; j <= 4000; ++j)	// 重复运算几次延长时间，避免计时精度问题
						{
							proc(pbufD, pbufS, DATASIZE);
						}
						// show
						stw.Stop();
						//_tprintf(_T("%s[%d]:\t%u\n"), szname, i, tm1);
						Console.WriteLine("{0}[{1}]:\t{2}", szname, i, stw.ElapsedMilliseconds);

					}
				}
			}

		}




1.8 平台配置

　　在VS2010中，C#支持多种平台。本文将测试其中三种——Any、x86、x64。
　　点击菜单栏的 生成->配置管理器，打开“配置管理器”对话框。C#的默认平台是“x86”，新建平台“Any”、“x64”。

　　还要注意配置好输出路径，别发生冲突。
1.项目->属性，打开项目的属性页。
2.点击左侧“生成”，切换到“生成”页。
3.点击上侧的“配置”组合框，切换配置。
4.点击上侧的“平台”组合框，切换平台。
5.修改“输出”中的“输出路径”。
6.重复第3步至第5步，直到配置好所有平台和配置。
7.点击工具栏上的“保存”按钮。

　　建议将输出路径配置为——
Any：bin\Debug\，bin\Release\
x86：bin\x86\Debug\，bin\x86\Release\
x64：bin\x64\Debug\，bin\x64\Release\

　　请参考——
http://msdn.microsoft.com/zh-cn/library/ms185328.aspx
如何：配置项目以面向目标平台

 


1.9 平台判断

　　虽然C#中提供了Environment.Is64BitProcess来判断WOW64。但是现在有3种平台，该方法不适合。 这时最好使用条件编译来做平台判断。
　　先在项目属性页中配置条件编译符号——
Any：（无）
x86：ISX86
x64：ISX64


　　然后在代码中使用条件编译语句——

#if (ISX86)
			string sBitCode = "x86";
#elif (ISX64)
			string sBitCode = "x64";
#else
			string sBitCode = "any";
#endif
			Console.Write("== noif:C#2010({0}) on {1}bit ==", sBitCode, nBitSys);




二、全部代码

　　全部代码——

using System;
//using System.Collections.Generic;
//using System.Linq;
//using System.Text;
using System.Diagnostics;

namespace noifCS2010
{
	/// <summary>
	/// 用位掩码代替分支：C#2010性能测试
	/// </summary>
	/// <remarks>Author: zyl910</remarks>
	class CnoifCS2010
	{
		const int DATASIZE = 16384;	// 128KB / (sizeof(signed short) * 4)

		static short[] bufS = new short[DATASIZE * 4];	// 源缓冲区。64位的颜色（4通道，每通道16位）
		static byte[] bufD = new byte[DATASIZE * 4];	// 目标缓冲区。32位的颜色（4通道，每通道8位）

		unsafe delegate void TESTPROC(byte* pbufD, short* pbufS, int cnt);

		// 用if分支做饱和处理
		static unsafe void f0_if(byte* pbufD, short* pbufS, int cnt)
		{
			short* pS = pbufS;
			byte* pD = pbufD;
			int i;
			for (i = 0; i < cnt; ++i)
			{
				// 分别对4个通道做饱和处理
				pD[0] = (pS[0] < 0) ? (byte)0 : ((pS[0] > 255) ? (byte)255 : (byte)pS[0]);
				pD[1] = (pS[1] < 0) ? (byte)0 : ((pS[1] > 255) ? (byte)255 : (byte)pS[1]);
				pD[2] = (pS[2] < 0) ? (byte)0 : ((pS[2] > 255) ? (byte)255 : (byte)pS[2]);
				pD[3] = (pS[3] < 0) ? (byte)0 : ((pS[3] > 255) ? (byte)255 : (byte)pS[3]);
				// next
				pS += 4;
				pD += 4;
			}
		}

		// 用min、max饱和处理
		static unsafe void f1_min(byte* pbufD, short* pbufS, int cnt)
		{
			short* pS = pbufS;
			byte* pD = pbufD;
			int i;
			for (i = 0; i < cnt; ++i)
			{
				// 分别对4个通道做饱和处理
				pD[0] = (byte)Math.Min(Math.Max((byte)0, pS[0]), (byte)255);
				pD[1] = (byte)Math.Min(Math.Max((byte)0, pS[1]), (byte)255);
				pD[2] = (byte)Math.Min(Math.Max((byte)0, pS[2]), (byte)255);
				pD[3] = (byte)Math.Min(Math.Max((byte)0, pS[3]), (byte)255);
				// next
				pS += 4;
				pD += 4;
			}
		}

		// 用位掩码做饱和处理.用带符号右移生成掩码
		static unsafe void f2_neg(byte* pbufD, short* pbufS, int cnt)
		{
			unchecked
			{
				short* pS = pbufS;
				byte* pD = pbufD;
				int i;
				for (i = 0; i < cnt; ++i)
				{
					// 分别对4个通道做饱和处理
					pD[0] = (byte)(pS[0] & -Convert.ToInt16(pS[0] >= 0) | -Convert.ToInt16(pS[0] >= 256));
					pD[1] = (byte)(pS[1] & -Convert.ToInt16(pS[1] >= 0) | -Convert.ToInt16(pS[1] >= 256));
					pD[2] = (byte)(pS[2] & -Convert.ToInt16(pS[2] >= 0) | -Convert.ToInt16(pS[2] >= 256));
					pD[3] = (byte)(pS[3] & -Convert.ToInt16(pS[3] >= 0) | -Convert.ToInt16(pS[3] >= 256));
					// next
					pS += 4;
					pD += 4;
				}
			}
		}

		static byte LIMITSU_BYTE(short n)
		{
			unchecked
			{
				return (byte)(n & -Convert.ToInt16(n >= 0) | -Convert.ToInt16(n >= 256));
			}
		}

		// 调用LIMITSU_BYTE函数
		static unsafe void f2_negB(byte* pbufD, short* pbufS, int cnt)
		{
			unchecked
			{
				short* pS = pbufS;
				byte* pD = pbufD;
				int i;
				for (i = 0; i < cnt; ++i)
				{
					// 分别对4个通道做饱和处理
					pD[0] = LIMITSU_BYTE(pS[0]);
					pD[1] = LIMITSU_BYTE(pS[1]);
					pD[2] = LIMITSU_BYTE(pS[2]);
					pD[3] = LIMITSU_BYTE(pS[3]);
					// next
					pS += 4;
					pD += 4;
				}
			}
		}

		// 用位掩码做饱和处理.用求负生成掩码
		static unsafe void f3_sar(byte* pbufD, short* pbufS, int cnt)
		{
			unchecked
			{
				short* pS = pbufS;
				byte* pD = pbufD;
				int i;
				for (i = 0; i < cnt; ++i)
				{
					// 分别对4个通道做饱和处理
					pD[0] = (byte)(((ushort)pS[0] | ((short)(255 - pS[0]) >> 15)) & ~(pS[0] >> 15));
					pD[1] = (byte)(((ushort)pS[1] | ((short)(255 - pS[1]) >> 15)) & ~(pS[1] >> 15));
					pD[2] = (byte)(((ushort)pS[2] | ((short)(255 - pS[2]) >> 15)) & ~(pS[2] >> 15));
					pD[3] = (byte)(((ushort)pS[3] | ((short)(255 - pS[3]) >> 15)) & ~(pS[3] >> 15));
					// next
					pS += 4;
					pD += 4;
				}
			}
		}

		static byte LIMITSW_BYTE(short n)
		{
			unchecked
			{
				return (byte)(((ushort)n | ((short)(255 - n) >> 15)) & ~(n >> 15));
			}
		}

		// 调用LIMITSW_BYTE函数
		static unsafe void f3_sarB(byte* pbufD, short* pbufS, int cnt)
		{
			unchecked
			{
				short* pS = pbufS;
				byte* pD = pbufD;
				int i;
				for (i = 0; i < cnt; ++i)
				{
					// 分别对4个通道做饱和处理
					pD[0] = LIMITSW_BYTE(pS[0]);
					pD[1] = LIMITSW_BYTE(pS[1]);
					pD[2] = LIMITSW_BYTE(pS[2]);
					pD[3] = LIMITSW_BYTE(pS[3]);
					// next
					pS += 4;
					pD += 4;
				}
			}
		}

		// 进行测试
		static unsafe void runTest(string szname, TESTPROC proc)
		{
			int i, j;
			Stopwatch stw = new Stopwatch();	// 执行时间
			// 绑定指针
			fixed (short* pbufS = &bufS[0])
			{
				fixed (byte* pbufD = &bufD[0])
				{
					// 开始测试
					for (i = 1; i <= 3; ++i)	// 多次测试
					{
						stw.Reset();
						stw.Start();
						// main
						for (j = 1; j <= 4000; ++j)	// 重复运算几次延长时间，避免计时精度问题
						{
							proc(pbufD, pbufS, DATASIZE);
						}
						// show
						stw.Stop();
						//_tprintf(_T("%s[%d]:\t%u\n"), szname, i, tm1);
						Console.WriteLine("{0}[{1}]:\t{2}", szname, i, stw.ElapsedMilliseconds);

					}
				}
			}

		}

		static void Main(string[] args)
		{
			int i;	// 循环变量

			//Console.WriteLine("Hello the world!");
			int nBitSys = (Environment.Is64BitOperatingSystem) ? 64 : 32;
			//int nBitCode = (Environment.Is64BitProcess) ? 64 : 32;
			//Console.Write("== noif:C#2010({0}) on {1}bit ==", nBitCode, nBitSys);
#if (ISX86)
			string sBitCode = "x86";
#elif (ISX64)
			string sBitCode = "x64";
#else
			string sBitCode = "any";
#endif
			Console.Write("== noif:C#2010({0}) on {1}bit ==", sBitCode, nBitSys);

			// 初始化
			Random rnd = new Random();
			for (i = 0; i < DATASIZE*4; ++i)
			{
				bufS[i] = (short)((rnd.Next() & 0x1FF) - 128);	// 使数值在 [-128, 383] 区间
			}

			// 准备开始。可以将将进程优先级设为实时
			if (args.Length <= 0)
			{
				Console.Write("<Press any key to continue>");
				Console.ReadKey(true);
			}
			Console.WriteLine();

			// 进行测试
			unsafe
			{
				runTest("f0_if", f0_if);
				runTest("f1_min", f1_min);
				runTest("f2_neg", f2_neg);
				runTest("f2_negB", f2_negB);
				runTest("f3_sar", f3_sar);
				runTest("f3_sarB", f3_sarB);
			}

			// 结束前提示
			if (args.Length <= 0)
			{
				Console.Write("<Press any key to exit>");
				Console.ReadKey(true);
			}
			Console.WriteLine();

		}
	}
}



三、编译与测试

　　点击菜单栏的 生成->批生成。生成Release版。

　　生成完毕后，将会有以下三个可执行文件——
bin\Release\noifCS2010.exe
bin\x86\Release\noifCS2010.exe
bin\x64\Release\noifCS2010.exe

　　在32位winXP上的测试结果——

== noif:C#2010(any) on 32bit ==<Press any key to continue>
f0_if[1]:       1935
f0_if[2]:       1922
f0_if[3]:       1921
f1_min[1]:      2139
f1_min[2]:      2144
f1_min[3]:      2147
f2_neg[1]:      2472
f2_neg[2]:      2471
f2_neg[3]:      2458
f2_negB[1]:     2641
f2_negB[2]:     2660
f2_negB[3]:     2640
f3_sar[1]:      562
f3_sar[2]:      559
f3_sar[3]:      557
f3_sarB[1]:     813
f3_sarB[2]:     823
f3_sarB[3]:     822


== noif:C#2010(x86) on 32bit ==<Press any key to continue>
f0_if[1]:       1930
f0_if[2]:       1931
f0_if[3]:       1904
f1_min[1]:      2153
f1_min[2]:      2142
f1_min[3]:      2142
f2_neg[1]:      2437
f2_neg[2]:      2464
f2_neg[3]:      2462
f2_negB[1]:     2641
f2_negB[2]:     2637
f2_negB[3]:     2642
f3_sar[1]:      556
f3_sar[2]:      545
f3_sar[3]:      545
f3_sarB[1]:     822
f3_sarB[2]:     812
f3_sarB[3]:     823


　　在64位win7上的测试结果——

== noif:C#2010(any) on 64bit ==<Press any key to continue>
f0_if[1]:       1902
f0_if[2]:       1871
f0_if[3]:       1871
f1_min[1]:      1919
f1_min[2]:      1918
f1_min[3]:      1916
f2_neg[1]:      2409
f2_neg[2]:      2406
f2_neg[3]:      2405
f2_negB[1]:     2956
f2_negB[2]:     2954
f2_negB[3]:     2954
f3_sar[1]:      652
f3_sar[2]:      651
f3_sar[3]:      650
f3_sarB[1]:     1032
f3_sarB[2]:     1031
f3_sarB[3]:     1031


== noif:C#2010(x86) on 64bit ==<Press any key to continue>
f0_if[1]:       1857
f0_if[2]:       1829
f0_if[3]:       1829
f1_min[1]:      2073
f1_min[2]:      2071
f1_min[3]:      2076
f2_neg[1]:      2340
f2_neg[2]:      2342
f2_neg[3]:      2340
f2_negB[1]:     2540
f2_negB[2]:     2541
f2_negB[3]:     2540
f3_sar[1]:      516
f3_sar[2]:      516
f3_sar[3]:      515
f3_sarB[1]:     766
f3_sarB[2]:     765
f3_sarB[3]:     766


== noif:C#2010(x64) on 64bit ==<Press any key to continue>
f0_if[1]:       1883
f0_if[2]:       1865
f0_if[3]:       1864
f1_min[1]:      1913
f1_min[2]:      1911
f1_min[3]:      1911
f2_neg[1]:      2399
f2_neg[2]:      2396
f2_neg[3]:      2400
f2_negB[1]:     2949
f2_negB[2]:     2949
f2_negB[3]:     2949
f3_sar[1]:      652
f3_sar[2]:      651
f3_sar[3]:      651
f3_sarB[1]:     1031
f3_sarB[2]:     1030
f3_sarB[3]:     1030


　　硬件环境——
CPU：Intel Core i3-2310M, 2100 MHz
内存：DDR3-1066


源码下载——
http://files.cnblogs.com/zyl910/noifCS2010.rar
（建议阅读编译器生成的汇编代码。提示：使用ILSPY）

zyl910
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unity-bitmasktypes:Unity生成的位掩码类型使用ScriptableObjects进行快速比较
04-11
单位位掩码类型介绍这个项目的想法是要有一种方法，例如在Game Designers的编辑器中创建自定义枚举，并在内部使用它们作为位掩码进行快速比较。 现在，每次创建新类型时，资产导入器都会自动为该资产分配一个位掩码...
C#设置本地网络如DNS、网关、子网掩码、IP等等
01-20
如今网络在我们的生活工作中所起的作用越来越大，可以说离开了网络我们就无法正常的工作和生活。作为程序员我们写的程序... 在C#中使用WMI还是比较简单的: 代码如下: using System; using System.Collections.Generic
深入探讨用位掩码代替分支（9）：测试成绩总结
weixin_33691700的博客
04-13 108
一、测试结果汇总 　　将前面的测试结果进行汇总，整理为表格（单位是毫秒，数值越小越好）—— 测试 f0_if f1_min f2_neg f3_sar f4_mmx f5_sse VC6 on 32bit 2016 2063 719 672 37.5 25.7 VC6 on 64bit 2028 2075 718 687 ...
WPF Extend toolkit 中的MashedTextBox
weixin_30915275的博客
07-10 129
掩码控件还是比较常用的，一下是摘自msdn的掩码元素表： 掩码元素 说明 0 数字，必选。此元素将接受 0 到 9 之间的任何一个数字。 9 数字或空间，可选。 # 数字或空间，可选。如果掩码中该位置为空白，在Text属性中将把它呈现为一个空格。允许使用加号 (+) 和减号 (-)。 ...
位掩码的介绍与使用
热门推荐
Ray的专栏
05-21 2万+
位掩码的介绍与使用一、小白鼠试毒有1000瓶水，其中有一瓶有毒，小白鼠只要尝一点带毒的水24小时后就会死亡，问至少要多少只小白鼠才能在24小时鉴别出哪瓶水有毒，刚看类似的问题，一般人一定是一脸懵逼的状态的，分析一下，喝了带毒的水24小时才会毒发，目前需求是要24小时就要鉴别出来哪瓶有毒，所以小白鼠只够喝一次水的时间，完全摸不到头脑……解决办法先直接来说解决问题的办法：将1000个瓶子使用二进制来标识
C# 二进制掩码
weixin_34034670的博客
09-07 603
之所以写这边文章,是因为在某些情况下,运用掩码来传递信息,显得非常简洁和方便.比如有2个参数共同确定1个实物.如牌,有花色和值.那么,传2个参数,显得非常繁琐,而且容易出错.那么定义 黑 , 红 , 梅 , 品 花色为 3,2,1, 0, 大小王为4 .1~k :分别为1~13.小王14 , 大王15 .大王最大,值的二进制正好为 : 1111(注意必须全为1 , 十进制为1...
TicTacToe：使用Javascript，HTML5，Canvas和位掩码的Tic Tac Toe游戏！
02-17
井字游戏 使用Javascript，HTML5，画布和位掩码的井字游戏！
C#实现一键换IP、重置DNS、网关及掩码的方法
09-04
主要介绍了C#实现一键换IP、重置DNS、网关及掩码的方法,很实用的功能,需要的朋友可以参考下
子网掩码计算工具：IPSubnetter
09-22
该软件根据子网内某一个IP地址和子网掩码，不仅可以计算出该子网内的可用IP地址，还可以计算出IP地址的二进制数值，并判断该IP地址所属的地址类别等各种信息。
位掩码（BitMask）
Pizza_Lawson的专栏
10-14 9283
位运算在实际开发中用得很少，主要原因还是它对于不熟悉的人不好读不好懂不好计算，如果不经常实践会生疏。但它的优点自然是计算快，代码更少。在某些地方它的优势会更加明显比如如下代码（http://xxgblog.com/2013/09/15/java-bitmask/）： public class NewPermission { // 是否允许查询，二进制第1位，0表示否，1表示是 public
C#中Delegate的效率问题
人生如旅
12-05 3983
<br /><br />昨天在研究C＃的定时器的过程中，发现　Delegate的效率比直接调用一个函数的效率要低不少，今天研究了一下，的确如此。在网上查了一下<br />http://www.cnblogs.com/sumtec/archive/2004/05/23/11025.aspx<br />也写了一个程序进行测试，但给出的程序不是太合理，因为在调用接口注册的函数时使用了for循环，操作明显多于delegate测试函数，所以执行结果反而是delegate比接口调用要快很多，于是我又写了如下程序进行测试
深入探讨用位掩码代替分支（2）：汇编代码分析
zyl910的专栏
03-21 1482
查看编译器生成的汇编代码，有助于我们分析程序的性能。 1 让VC6输出编译的汇编代码 　　用VC6打开前一篇文章（http://blog.csdn.net/zyl910/article/details/7345655）的工程“noifCheck.dsw”。 　　首先需要配置项目设置—— 1.点击菜单栏 “工程”->“Project Settings”打开“Project Settings”
如何在DOS中枚举PCI设备
zyl910的专栏
07-01 2万+
File:      zEnumPCIName:      如何在DOS中枚举PCI设备Author:    zyl910Blog:      http://blog.csdn.net/zyl910/Version:   V1.0Updata:    2006-6-30下载（注意修改下载后的扩展名）前言~~~~　　学计算机这么多年了，PCI这个名词不知道叫了几百遍了。可是，我一直不知道
用VB写高效的图像处理程序 V2.0（2006-5-24）
zyl910的专栏
05-24 1万+
用VB写高效的图像处理程序 V2.0（2006-5-24）作者：zyl910 一、为什么这么慢？ 二、DIB的结构 三、DIB访问函数
用VB6写的一个简单俄罗斯方块代码
zyl910的专栏
05-30 1万+
网络上有很多俄罗斯方块代码。它们大都为了视觉效果，程序比较复杂，不利于学习游戏编程。所以我写了个简单俄罗斯方块代码，尽量用VB本身的功能，没有复杂的DirectX。下载（注意修改下载后的扩展名） mBlock.bas Attribute VB_Name = "mBlock"Option
终于真正明白了超光速旅行中的时间倒流现象
zyl910的专栏
12-15 1万+
我最开始看见相对论中的一些概念时，总觉得违背直观、难以理解。可是过了一段时间，会突然发现，一切原来是这样一回事。因为光速是300000km/s，所以距地球为d光年的恒星，它的发出来的光要过d年才能到达地球。换句话说，我们现在看见的是该恒星d年前的景象。假设在今年一月份的时候，有一艘飞船位于离地球一光年的位置，它以两倍光速匀速直线地飞回地球。所以该飞船花半年时间就能到达地球，即今年七月份时我
[C] 跨平台使用TCHAR——让Linux等平台也支持tchar.h，解决跨平台时的格式控制字符问题，多国语言的同时显示（兼容vc/gcc/bcb，支持Windows/Linux/Mac）
zyl910的专栏
01-17 1万+
作者：zyl910 　　将Windows程序移植到Linux等平台时，经常会遇到tchar.h问题与字符串的格式控制字符问题（char串、wchar_t串、TCHAR串混合输出）。本文探讨如何解决这些问题。 一、背景 1.1 历史 　　传统的C程序使用char字符串，采用ANSI+DBCS方案来支持当地语言，不能实现多国语言同时显示。 　　当年微软在设计Windows NT时考虑到国
子网掩码计算器源码c#
最新发布
10-02
在`calculateSubnet`函数中，我们使用位运算将前缀部分设置为1，后面部分设置为0，并将计算得到的子网掩码转换为字符串形式。最后，我们在`main`函数中输出结果并释放内存。 注意，这段代码中对输入的合法性没有...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值