C# 位操作类

最新推荐文章于 2023-08-09 20:45:11 发布
最新推荐文章于 2023-08-09 20:45:11 发布
阅读量1.9k 收藏 8
点赞数
分类专栏： C# 文章标签： C# 位操作
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hkxia128/article/details/79007408
版权


转载请注明出处.

Public Class BitHelper

{

 /// <summary>
        /// 按位取反操作
        /// </summary>
        /// <param name="v"></param>
        /// <returns></returns>
        public static byte Reverse(byte v)
        {
            byte c = v;
            for (int i = 0; i < sizeof(byte); i++)
            {
                c = (byte)(c ^ (byte)(1 << i));
            }


            return c;
        }
        public static UInt16 Reverse(UInt16 v)
        {
            UInt16 c = v;
            for (int i = 0; i < sizeof(UInt16) * 8; i++)
            {
                c = (UInt16)(c ^ (UInt16)(1 << i));
            }
            return c;
        }
        public static UInt32 Reverse(UInt32 v)
        {
            UInt32 c = v;
            for (int i = 0; i < sizeof(UInt32) * 8; i++)
            {
                c = (UInt32)(c ^ (UInt32)(1 << i));
            }
            return c;
        }
        public static UInt64 Reverse(UInt64 v)
        {
            UInt64 c = v;
            for (int i = 0; i < sizeof(UInt64) * 8; i++)
            {
                c = (UInt64)(c ^ (UInt64)(1 << i));
            }
            return c;
        }
        public static byte Reverse(byte v, int index)
        {
            return (byte)(v ^ (byte)(1 << index));
        }
        public static UInt16 Reverse(UInt16 v, int index)
        {
            return (UInt16)(v ^ (UInt16)(1 << index));
        }
        public static UInt32 Reverse(UInt32 v, int index)
        {
            return (UInt32)(v ^ (UInt32)(1 << index));
        }
        public static UInt64 Reverse(UInt64 v, int index)
        {
            return (UInt64)(v ^ (UInt64)(1 << index));
        }
        public static byte Reverse(byte v, int startIndex, int endIndex)
        {
            byte c = v;
            for (int i = startIndex; i <= endIndex; i++)
            {
                c = Reverse(c, i);
            }
            return c;
        }
        public static UInt16 Reverse(UInt16 v, int startIndex, int endIndex)
        {
            UInt16 c = v;
            for (int i = startIndex; i <= endIndex; i++)
            {
                c = Reverse(c, i);
            }
            return c;
        }
        public static UInt32 Reverse(UInt32 v, int startIndex, int endIndex)
        {
            UInt32 c = v;
            for (int i = startIndex; i <= endIndex; i++)
            {
                c = Reverse(c, i);
            }
            return c;
        }
        public static UInt64 Reverse(UInt64 v, int startIndex, int endIndex)
        {
            UInt64 c = v;
            for (int i = startIndex; i <= endIndex; i++)
            {
                c = Reverse(c, i);
            }
            return c;
        }


        /// <summary>
        /// 反码位操作,正数相同，负数为符号位不变，其余取反
        /// </summary>
        /// <param name="b1"></param>
        /// <param name="b2"></param>
        /// <returns></returns>
        public static byte RadixMinusOneComplement(byte v)
        {
            byte s = sizeof(byte) * 8 - 1;
            if ((v & (1 << s)) == 0) return v; //正数反码相同


            return Reverse(v, 0, s - 1);
        }
        public static UInt16 RadixMinusOneComplement(UInt16 v)
        {
            byte s = sizeof(UInt16) * 8 - 1;
            if ((v & (1 << s)) == 0) return v; //正数反码相同


            return Reverse(v, 0, s - 1);
        }
        public static UInt32 RadixMinusOneComplement(UInt32 v)
        {
            byte s = sizeof(UInt32) * 8 - 1;
            if ((v & (1 << s)) == 0) return v; //正数反码相同


            return Reverse(v, 0, s - 1);
        }
        public static UInt64 RadixMinusOneComplement(UInt64 v)
        {
            byte s = sizeof(UInt64) * 8 - 1;
            if ((v & (UInt64)(1 << s)) == 0) return v; //正数反码相同


            return Reverse(v, 0, s - 1);
        }


        /// <summary>
        /// 补码
        /// </summary>
        /// <returns></returns>
        public static byte Complement(byte v)
        {
            byte s = sizeof(byte) * 8 - 1;
            if ((v & (1 << s)) == 0) return v; //正数反码相同


            byte b = RadixMinusOneComplement(v);
            return (byte)(b + 1);
        }
        public static UInt16 Complement(UInt16 v)
        {
            byte s = sizeof(UInt16) * 8 - 1;
            if ((v & (1 << s)) == 0) return v; //正数反码相同


            UInt16 b = RadixMinusOneComplement(v);
            return (UInt16)(b + 1);
        }
        public static UInt32 Complement(UInt32 v)
        {
            byte s = sizeof(UInt32) * 8 - 1;
            if ((v & (1 << s)) == 0) return v; //正数反码相同


            UInt32 b = RadixMinusOneComplement(v);
            return (UInt32)(b + 1);
        }
        public static UInt64 Complement(UInt64 v)
        {
            byte s = sizeof(UInt64) * 8 - 1;
            if ((v & (UInt64)(1 << s)) == 0) return v; //正数反码相同


            UInt64 b = RadixMinusOneComplement(v);
            return (UInt64)(b + 1);
        }


        /// <summary>
        /// 原码，正数相同，最高位为1表示负数，其余位就是原码真值
        /// </summary>
        /// <param name="v"></param>
        /// <returns></returns>
        public static sbyte TrueForm(byte v)
        {
            byte s = sizeof(byte) * 8 - 1;
            if ((v & (1 << s)) == 0) return (sbyte)v; //正数反码相同


            byte c = Reverse(v, s);


            return (sbyte)(c * (-1));
        }
        public static Int16 TrueForm(UInt16 v)
        {
            byte s = sizeof(UInt16) * 8 - 1;
            if ((v & (1 << s)) == 0) return (Int16)v; //正数反码相同


            UInt16 c = Reverse(v, s);


            return (Int16)(c * (-1));
        }
        public static Int32 TrueForm(UInt32 v)
        {
            byte s = sizeof(UInt32) * 8 - 1;
            if ((v & (1 << s)) == 0) return (int)v; //正数反码相同


            UInt32 c = Reverse(v, s);


            return (Int32)(c * (-1));
        }
        public static Int64 TrueForm(UInt64 v)
        {
            byte s = sizeof(UInt64) * 8 - 1;
            if ((v & (UInt64)(1 << s)) == 0) return (int)v; //正数反码相同


            UInt64 c = Reverse(v, s);


            Int64 cc = Convert.ToInt64(c);
            return cc * (-1);
        }


        /// <summary>
        /// 根据补码，计算原码
        /// </summary>
        /// <param name="v"></param>
        /// <returns></returns>
        public static byte ComplementToTrueForm(byte v)
        {
            byte s = sizeof(byte) * 8 - 1;
            if ((v & (1 << s)) == 0) return v; //正数补码相同


            byte b = (byte)(v - (byte)1); //逆操作，先减1
            byte c = RadixMinusOneComplement(b); //再取反


            return c;
        }
        public static UInt16 ComplementToTrueForm(UInt16 v)
        {
            byte s = sizeof(UInt16) * 8 - 1;
            if ((v & (1 << s)) == 0) return v; //正数补码相同


            UInt16 b = (UInt16)(v - (UInt16)1); //逆操作，先减1
            UInt16 c = RadixMinusOneComplement(b); //再取反


            return c;
        }
        public static UInt32 ComplementToTrueForm(UInt32 v)
        {
            byte s = sizeof(UInt32) * 8 - 1;
            if ((v & (1 << s)) == 0) return v; //正数补码相同


            UInt32 b = (UInt32)(v - (UInt32)1); //逆操作，先减1
            UInt32 c = RadixMinusOneComplement(b); //再取反


            return c;
        }
        public static UInt64 ComplementToTrueForm(UInt64 v)
        {
            byte s = sizeof(UInt64) * 8 - 1;
            if ((v & (ulong)(1 << s)) == 0) return v; //正数补码相同


            UInt64 b = (UInt64)(v - (UInt64)1); //逆操作，先减1
            UInt64 c = RadixMinusOneComplement(b); //再取反


            return c;
        }


        /// <summary>
        /// 保留某些位，其余位设置为0
        /// 如： ReserveBit(0xDE, 0, 3) = 0x0E
        /// </summary>
        /// <param name="b"></param>
        /// <param name="startBit"></param>
        /// <param name="endBit"></param>
        /// <returns></returns>
        public static byte Reserve(byte b, int startBit, int endBit)
        {
            byte s = sizeof(byte) * 8 - 1;


            if (endBit > s) return b;


            byte c = b;
            if (startBit > 0)
            {
                for (int i = 0; i < startBit; i++)
                {
                    c = (byte)(c & (byte)(byte.MaxValue - (1 << i)));
                }
            }


            for (int i = endBit + 1; i < s + 1; i++)
            {
                c = (byte)(c & (byte)(byte.MaxValue - (1 << i)));
            }


            return c;
        }
        public static UInt16 Reserve(UInt16 b, int startBit, int endBit)
        {
            byte s = sizeof(UInt16) * 8 - 1;


            if (endBit > s) return b;


            UInt16 c = b;
            if (startBit > 0)
            {
                for (int i = 0; i < startBit; i++)
                {
                    c = (UInt16)(c & (UInt16)(UInt16.MaxValue - (1 << i)));
                }
            }


            for (int i = endBit + 1; i < s + 1; i++)
            {
                c = (UInt16)(c & (UInt16)(UInt16.MaxValue - (1 << i)));
            }


            return c;
        }
        public static UInt32 Reserve(UInt32 b, int startBit, int endBit)
        {
            byte s = sizeof(UInt32) * 8 - 1;


            if (endBit > s) return b;


            UInt32 c = b;
            if (startBit > 0)
            {
                for (int i = 0; i < startBit; i++)
                {
                    c = (UInt32)(c & (UInt32)(UInt32.MaxValue - (1 << i)));
                }
            }


            for (int i = endBit + 1; i < s + 1; i++)
            {
                c = (UInt32)(c & (UInt32)(UInt32.MaxValue - (1 << i)));
            }


            return c;
        }
        public static UInt64 Reserve(UInt64 b, int startBit, int endBit)
        {
            byte s = sizeof(UInt64) * 8 - 1;


            if (endBit > s) return b;


            UInt64 c = b;
            if (startBit > 0)
            {
                for (int i = 0; i < startBit; i++)
                {
                    c = (UInt64)(c & (UInt64)(UInt64.MaxValue - (ulong)(1 << i)));
                }
            }


            for (int i = endBit + 1; i < s + 1; i++)
            {
                c = (UInt64)(c & (UInt64)(UInt64.MaxValue - (ulong)(1 << i)));
            }


            return c;
        }


        /// <summary>
        /// 合并多个字节，第一个参数是最高字节，其余类推
        /// 如：Combine2Byte(0x0f, 0x13) = 0x0F13
        /// </summary>
        /// <param name="b1"></param>
        /// <param name="b2"></param>
        /// <returns></returns>
        public static UInt16 Combine(byte b1, byte b2)
        {
            byte[] a = { b2, b1 };
            UInt16 b = BitConverter.ToUInt16(a, 0);
            return b;
        }
        public static UInt32 Combine(byte b1, byte b2, byte b3)
        {
            byte[] a = { b3, b2, b1 };
            UInt32 b = BitConverter.ToUInt32(a, 0);
            return b;
        }
        public static UInt64 Combine(byte b1, byte b2, byte b3, byte b4)
        {
            byte[] a = { b4, b3, b2, b1 };
            UInt64 b = BitConverter.ToUInt64(a, 0);
            return b;
        }


        /// <summary>
        /// 获取某位的值，1=true；0=false；
        /// </summary>
        /// <param name="v"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public static bool GetBit(byte v, byte index)
        {
            Contract.Requires(index + 1 <= 8);
            byte c = Convert.ToByte(((v & (1 << index)) > 0) ? 1 : 0);
            bool b = c == 0x01 ? true : false;


            return b;
        }
        public static bool GetBit(UInt16 v, byte index)
        {
            Contract.Requires(index + 1 <= 16);
            byte c = Convert.ToByte(((v & (1 << index)) > 0) ? 1 : 0);
            bool b = c == 0x01 ? true : false;


            return b;
        }
        public static bool GetBit(UInt32 v, byte index)
        {
            Contract.Requires(index + 1 <= 32);
            byte c = Convert.ToByte(((v & (1 << index)) > 0) ? 1 : 0);
            bool b = c == 0x01 ? true : false;


            return b;
        }
        public static bool GetBit(UInt64 v, byte index)
        {
            Contract.Requires(index + 1 <= 64);
            byte c = Convert.ToByte(((v & (ulong)(1 << index)) > 0) ? 1 : 0);
            bool b = c == 0x01 ? true : false;


            return b;
        }


        /// <summary>
        /// 设置某一位的值
        /// </summary>
        /// <param name="data"></param>
        /// <param name="v"></param>
        /// <param name="index"></param>
        /// <returns></returns>
        public static byte SetBit(byte data, bool v, byte index)
        {
            byte a = v == true ? (byte)1 : (byte)0;


            Contract.Requires(index + 1 <= 8);
            Contract.Requires(a < (1 << (byte)1));


            if (v) return (byte)(data | (1 << index));


            return (byte)(data & (byte.MaxValue - (1 << index)));
        }
        public static UInt16 SetBit(UInt16 data, bool v, byte index)
        {
            byte a = v == true ? (byte)1 : (byte)0;
            Contract.Requires(index + 1 <= 16);
            Contract.Requires(a < (1 << (byte)1));


            if (v) return (UInt16)(data | (1 << index));


            return (UInt16)(data & (UInt16.MaxValue - (1 << index)));
        }
        public static UInt32 SetBit(UInt32 data, bool v, byte index)
        {
            byte a = v == true ? (byte)1 : (byte)0;
            Contract.Requires(index + 1 <= 16);
            Contract.Requires(a < (1 << (byte)1));


            if (v) return (UInt32)(data | (1 << index));


            return (UInt32)(data & (UInt32.MaxValue - (1 << index)));
        }
        public static UInt64 SetBit(UInt64 data, bool v, byte index)
        {
            byte a = v == true ? (byte)1 : (byte)0;
            Contract.Requires(index + 1 <= 16);
            Contract.Requires(a < (1 << (byte)1));


            if (v) return (UInt64)(data | (ulong)(1 << index));


            return (UInt64)(data & (UInt64.MaxValue - (ulong)(1 << index)));
        }


        /// <summary>
        /// 取原码二进制格式，如：输入63，输出00111111
        /// </summary>
        /// <param name="originalValue">63</param>
        /// <returns>00111111</returns>
        public static string MachineCodeFormat(int originalValue)
        {
            StringBuilder buffer = new StringBuilder();


            int quotient = 0;
            int remainder = 0;


            int tmp = Math.Abs(originalValue);


            do
            {
                quotient = tmp / 2;
                remainder = tmp % 2;


                buffer.Insert(0, Convert.ToString(remainder));


                tmp = quotient;
            } while (tmp != 0);


            string result = buffer.ToString().TrimStart('0').PadLeft(7, '0');
            return result;


            //return (Convert.ToString(originalValue < 0 ? SECONT_CHAR_B : FIRST_CHAR_B)) + result;
        }


        /// <summary>
        /// 将二进制转为十六进制
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string C2To16(string data)
        {
            return string.Format("{0:X}", System.Convert.ToInt32(data, 2));
        }
        public static Int16 C2To10(string data)
        {
            if (data.Length > 16) return 0;


            string i = string.Format("{0:D}", System.Convert.ToInt16(data, 2));
            Int16 r = Convert.ToInt16(i);
            return r;
        }


        /// <summary>
        /// 将十六进制转为二进制
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string C16To2(string data)
        {
            int d = Convert.ToInt16(data, 16);
            string a = MachineCodeFormat(d);
            return a;
        }
        public static string C16To2(UInt16 data)
        {
            string a = MachineCodeFormat(data);
            return a;
        }
        public static string C16To2(UInt32 data)
        {
            string a = MachineCodeFormat((int)data);
            return a;
        }


        /// <summary>
        /// 十六进制转二进制
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static Int16 C16To10(string data)
        {
            return Convert.ToInt16(data, 16);
        }


        /// <summary>
        /// 十进制转十六进制
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static byte C10To16(Int16 data)
        {
            string c = string.Format("{0:X}", data);
            byte d = Convert.ToByte(c, 16);
            return d;
        }


        /// <summary>
        /// 十进制转二进制
        /// </summary>
        /// <param name="data"></param>
        /// <returns></returns>
        public static string C10To2(Int16 data)
        {
            string a = Convert.ToString(data, 2);
            string r = a.ToString().TrimStart('0').PadLeft(7, '0');
            return r;
        }

}

_HKXia
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C# 位操作
leedoom的专栏
11-24 985
其实就是将各种数据二进制化，不够8位的高位补0。不管取值还是赋值都没有想象那么复杂。          11111111  = 255          01111111  = 127          00111111  = 63           00011111  = 31          00001111  = 15          00000111  = 7    
C#实现的Excel文件操作类实例
08-30
"C#实现的Excel文件操作类实例" 本文主要介绍了C#实现的Excel文件操作类实例，结合具体实例形式分析了C#数据库及Excel文件相关操作技巧。 首先，我们需要了解什么是Excel文件操作类。在C#中，我们可以使用...
C#操作类全-- 几乎涵盖所有常用的C#类库
03-06
C#操作类全-- 几乎涵盖所有常用的C#类库 ，C#操作类全-- 几乎涵盖所有常用的C#类库
C#中的文件操作类
weixin_30763455的博客
07-23 415
一.File类常见的操作方法 (1).public static FileStream Create(string path)：在指定路径中创建或覆盖文件，path：要创建的文件的路径及名称。 (2).public static StreamWriter AppendText(string path)：创建一个 System.IO.StreamWriter，它将 UTF-8 编码文本...
C#中的位操作
jelink的专栏
08-30 6776
位操作符是对数据按二进制位进行运算的操作符。c#位操作符包括： 按位与 & 按位或 | 按位取反 ~ 左移 右移 >>举例说明using System; class MikeCat { 　　public static void Main() 　　{ 　　　　int a=6&3; 　　　　Console.WriteLine("a=
C#常见操作类（四）
零一
01-15 326
1、Javascript类： using System.Web; namespace Common.Utility { /// <summary> /// 客户端脚本输出 /// </summary> public class JsHelper { /// <summary> //...
TDengine数据库操作类C#
09-15
C#引用IoTSharp.Data.Taos组件，操作TDengine，基于TDengine3.0版本
C#操作Excel类示例
09-23
本示例将详细介绍如何使用C#来操作Excel文件，特别是对于那些没有安装完整Office环境，而是使用绿色版Excel的情况。 首先，我们要明白，C#本身并不直接支持操作Excel，但可以通过Microsoft提供的COM Interop或第三...
C#注册表操作类(完整版))
05-09
在本段内容中，主要介绍了C#中注册表操作类的基础知识，包括注册表基项的定义和注册表数据类型的分类。这些知识点是进行C#编程时，尤其是进行系统配置和管理时的重要组成部分。 注册表是Windows操作系统中的一个...
C#下利用类的方式封装了位操作类，仿照C语言的联合体配合结构体的方式
11-23
C#下利用类的方式封装了位操作类，仿照C语言的联合体配合结构体的方式。里面包含了无符号8位的字节操作类和无符号16位的字节操作。使用方式为直接创建实例类就行了，位操作为逻辑型变量的方式。
C#中的位操作小结
01-20
位操作符是对数据按二进制位进行运算的操作符。位操作是其他很多语言都支持的操作,如C、C++和Java等，C#也不例外支持位操作。注意位操作支持的数据类型是基本数据类型，如byte、short、char、int、long等，C#支持的位操作有如下几种： •按位与 &•按位或 |•按位取反 ~•左移 <<•右移 >>•异或^ 在C#中位操作同C的位操作没有什么区别，位操作的速度相对较快，而且如果熟练的话，处理起来也相对方便，特别是在一些权限等相关的设置中，比如：用1、2、4、8、16、32、64分别代表查看、添加、编辑、修改、删除、审批等权限值的时候，如果某个用户的最终权限是多种权限值的叠加，用位
比特流操作
01-18
比特流操作的相关函数，包括从源地址复制n个比特数据到目的地址函数，取数据中某起始位置n个比特模板函数等等。
C# 位运算
胡老汉的博客
08-15 1133
程序中的所有数在计算机内存中都是以二进制的形式储存的。位运算就是直接对整数在内存中的二进制位进行操作。比如，and运算本来是一个逻辑运算符，但整数与整数之间也可以进行and运算。举个例子，6的二进制是110，11的二进制是1011，那么6 and 11的结果就是2，它是二进制对应位进行逻辑运算的结果（0表示False，1表示True，空位都当0处理）。 6 and 11 转成二进制 01...
C# .Net 位运算,字节操作,工具类
06-30 310
c# 位运算 操作类(提供对字节的位获取，和替换) 闲来没事写了一个位运算操作的简单类 1 using System;2 using System.Collections.Generic;3 using System.Text;4 5 namespace NatureSex.CommonTool.Basic6 {7 ///<summary>8 /// 位 操作工具...
C#常用42个操作类
luoyanqing119的专栏
01-09 901
C#常用42个操作类
C#位操作
weixin_30367873的博客
12-17 72
一.原码与补码 　　在计算机系统中，数值一律用补码来存储（表示）。主要原因：使用补码，可以将符号位和其他位统一处理；同时减法也可按加法来处理。另外，两个补码表示的数相加时，如果最高位（符号位）有进位，则进位被舍弃。 1.原码转补码分两种情况（1）正数的补码：与原码相同（已知原码求补码）　　例如：+9的原码是0000 1001。补码也是0000 1001。 （2）负数的补码：符...
C#之位运算符
最新发布
qq_61845982的博客
08-09 355
目录一、位运算符是什么？二、语法1.位与 &2.位或 |3.异或 ^ 4.位取反 ~5. 左移>总结 //位运算符 主要用数值类型进行计算的 //将数值转换为2进制 再进行位运算 // 规则 连接两个数值进行位计算 将数值转为2进制 // 对位运算 有0则0代码如下（示例）： 代码如下（示例）： 4.位取反 ~ // 规则 写在数值前面 将数值转为2进制 //
C#位运算讲解与示例
Root915的博客
06-08 2849
二进制补码运算公式：  -x = ~x + 1 = ~(x-1) ~x = -x-1 (逻辑非)  -(~x) = x+1  ~(-x) = x-1  x+y = x - ~y - 1 = (x|y)+(x&y)  x-y = x + ~y + 1 = (x|~y)-(~x&y)  x^y = (x|y)-(x&y)  x|y = (x&~y)+y  x&y = (~x|y)
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值