devbox
2023面试高手
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C#的几种位操作运算，与、或、非、异或、左移、右移_c# 与或非

作者：2023面试高手 | 2024-02-19 03:14:01

赞

踩

c# 与或非

C#的常见几种位操作运算，与($)、或(|)、非(~)、异或(^)、左移(<<)、右移(>>)

位操作一般来说比加减乘除计算要快一些

与(&)操作符

与(&)操作符的位都为1时，才为1，其他都为0，因此与(&)操作符的结果范围在[0, Math.Min(x,y)],x,y均为正整数

或(|)操作符

或(|)操作符的位都为0时，才为0，其他都为1，因此或(|)操作符的结果范围在[Math.Max(x,y), x+y],x,y均为正整数

非(~)操作符

非(~)操作符按位取反，1转化为0， 0转化为1，因此非(~)操作符满足[x+~x=-1]一个数与其取反操作之和为-1

异或(^)操作符

异或(^)操作符的位不同时为1， 位相同时为0

左移(<<)操作符

左移(<<)操作符:【最左侧位不要，在最右侧补0】,相当于乘以2个N次方,【移位是除以32后的余数，范围[0,31],即以32为一个周期】

右移(>>)操作符

右移(>>)操作符:【最右侧位不要，在最左侧补符号位。(正数补0，负数补1)】,相当于除以2个N次方,【移位是除以32后的余数，范围[0,31],即以32为一个周期】

C#新建控制台应用程序BitOperationDemo。

相关测试程序如下：

  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Linq.Expressions;
  5. using System.Text;
  6. using System.Threading.Tasks;
  7.  
  8. namespace BitOperationDemo
  9. {
  10.     class Program
  11.     {
  12.         /// <summary>
  13.         /// 标识符字典
  14.         /// </summary>
  15.         static readonly Dictionary<OperationSymbol, string> dict = new Dictionary<OperationSymbol, string>()
  16.         {
  17.             { OperationSymbol.AND,"与(&)"},{ OperationSymbol.OR,"或(|)"},{ OperationSymbol.NOT,"非(~)"},{ OperationSymbol.XOR,"异或(^)"},
  18.             { OperationSymbol.SHIFT_LEFT,"左移(<<)"},{ OperationSymbol.SHIFT_RIGHT,"右移(>>)"}
  19.         };
  20.         static void Main(string[] args)
  21.         {
  22.             Console.SetWindowSize(120, 50);
  23.             Console.WriteLine($"与(&)操作符的位都为1时，才为1，其他都为0，因此与(&)操作符的结果范围在[0, Math.Min(x,y)],x,y均为正整数");
  24.             Console.WriteLine($"或(|)操作符的位都为0时，才为0，其他都为1，因此或(|)操作符的结果范围在[Math.Max(x,y), x+y],x,y均为正整数");
  25.             Console.WriteLine($"非(~)操作符按位取反，1转化为0， 0转化为1，因此非(~)操作符满足[x+~x=-1]一个数与其取反操作之和为-1");
  26.             Console.WriteLine($"异或(^)操作符的位不同时为1， 位相同时为0");
  27.             Console.WriteLine($"左移(<<)操作符:【最左侧位不要，在最右侧补0】,相当于乘以2个N次方,【移位是除以32后的余数，范围[0,31],即以32为一个周期】");
  28.             Console.WriteLine($"右移(>>)操作符:【最右侧位不要，在最左侧补符号位。(正数补0，负数补1)】,相当于除以2个N次方,【移位是除以32后的余数，范围[0,31],即以32为一个周期】");
  29.             Console.WriteLine();
  30.             int x = 12345;
  31.             int y = 34567;//34567除以32，余数为7，相当于移动7位
  32.             string binaryX = Convert.ToString(x, 2).PadLeft(32, '0');
  33.             string binaryY = Convert.ToString(y, 2).PadLeft(32, '0');
  34.             Console.WriteLine($"整数【{x}】对应的32位二进制为【{binaryX}】");
  35.             Console.WriteLine($"整数【{y}】对应的32位二进制为【{binaryY}】");
  36.             Console.WriteLine("-----------------下面分别用二进制字符串逻辑处理 以及 系统内置的操作符进行操作计算-----------------");
  37.  
  38.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.AND);
  39.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.OR);
  40.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.NOT);
  41.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.XOR);
  42.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.SHIFT_LEFT);
  43.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.SHIFT_RIGHT);
  44.  
  45.             Console.WriteLine("-----------------下面测试负数进行操作计算-----------------");
  46.             x = -12345;
  47.             binaryX = Convert.ToString(x, 2).PadLeft(32, '0');
  48.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.AND);
  49.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.OR);
  50.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.NOT);
  51.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.XOR);
  52.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.SHIFT_LEFT);
  53.             PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.SHIFT_RIGHT);
  54.             Console.ReadLine();
  55.         }
  56.  
  57.         /// <summary>
  58.         /// 打印结果比较
  59.         /// </summary>
  60.         /// <param name="x"></param>
  61.         /// <param name="y"></param>
  62.         /// <param name="binaryX"></param>
  63.         /// <param name="binaryY"></param>
  64.         /// <param name="operationSymbol"></param>
  65.         static void PrintOperatorResult(int x, int y, string binaryX, string binaryY, OperationSymbol operationSymbol)
  66.         {
  67.             string binaryResult = GetOperatorResult(binaryX, binaryY, operationSymbol);
  68.             int result = 0;
  69.             switch (operationSymbol)
  70.             {
  71.                 case OperationSymbol.AND:
  72.                     result = x & y;
  73.                     break;
  74.                 case OperationSymbol.OR:
  75.                     result = x | y;
  76.                     break;
  77.                 case OperationSymbol.NOT:
  78.                     result = ~x;
  79.                     break;
  80.                 case OperationSymbol.XOR:
  81.                     result = x ^ y;
  82.                     break;
  83.                 case OperationSymbol.SHIFT_LEFT:
  84.                     result = x << y;
  85.                     break;
  86.                 case OperationSymbol.SHIFT_RIGHT:
  87.                     result = x >> y;
  88.                     break;
  89.             }
  90.             Console.WriteLine($"{dict[operationSymbol]}操作符系统内置的操作符运算结果为【{result}】，使用二进制字符串还原后的整数结果为【{Convert.ToInt32(binaryResult, 2)}】");
  91.             Console.WriteLine();
  92.         }
  93.  
  94.         /// <summary>
  95.         /// 获取操作符的结果
  96.         /// </summary>
  97.         /// <param name="binaryX">32位二进制字符串,第一个数</param>
  98.         /// <param name="binaryY">32位二进制字符串,第二个数</param>
  99.         /// <param name="operationSymbol">指定的操作符枚举</param>
  100.         /// <returns></returns>
  101.         static string GetOperatorResult(string binaryX, string binaryY, OperationSymbol operationSymbol)
  102.         {
  103.             string result = string.Empty;
  104.             switch (operationSymbol)
  105.             {
  106.                 case OperationSymbol.AND:
  107.                     result = CalculateOperatorResult(binaryX, binaryY, (left, right) => (left == '1' && right == '1') ? "1" : "0");
  108.                     break;
  109.                 case OperationSymbol.OR:
  110.                     result = CalculateOperatorResult(binaryX, binaryY, (left, right) => (left == '0' && right == '0') ? "0" : "1");
  111.                     break;
  112.                 case OperationSymbol.NOT:
  113.                     result = CalculateOperatorResult(binaryX, binaryY, (left, right) => (left == '0') ? "1" : "0");
  114.                     break;
  115.                 case OperationSymbol.XOR:
  116.                     result = CalculateOperatorResult(binaryX, binaryY, (left, right) => (left == right) ? "0" : "1");
  117.                     break;
  118.                 case OperationSymbol.SHIFT_LEFT:
  119.                     result = CalculateShiftResult(binaryX, Convert.ToInt32(binaryY, 2), true);
  120.                     break;
  121.                 case OperationSymbol.SHIFT_RIGHT:
  122.                     result = CalculateShiftResult(binaryX, Convert.ToInt32(binaryY, 2), false);
  123.                     break;
  124.             }
  125.             Console.WriteLine($"{dict[operationSymbol]}操作符逻辑运算的32位二进制结果为【{result}】");
  126.             return result;
  127.         }
  128.  
  129.         /// <summary>
  130.         /// 计算逻辑运算的结果【与，或，非，异或】
  131.         /// </summary>
  132.         /// <param name="binaryX">32位二进制字符串,第一个数</param>
  133.         /// <param name="binaryY">32位二进制字符串,第二个数</param>
  134.         /// <param name="logicOperator">逻辑操作委托</param>
  135.         /// <returns></returns>
  136.         static string CalculateOperatorResult(string binaryX, string binaryY, Func<char, char, string> logicOperator)
  137.         {
  138.             string result = string.Empty;
  139.             for (int i = 0; i < 32; i++)
  140.             {
  141.                 result += logicOperator(binaryX[i], binaryY[i]);
  142.             }
  143.             return result;
  144.         }
  145.  
  146.         /// <summary>
  147.         /// 计算移位操作【左移，右移】
  148.         /// </summary>
  149.         /// <param name="binaryX"></param>
  150.         /// <param name="shiftCount">移动几位，该数需要转化为【除以32的余数】</param>
  151.         /// <param name="leftShift">true代表左移，false代表右移</param>
  152.         /// <returns></returns>
  153.         static string CalculateShiftResult(string binaryX, int shiftCount, bool leftShift)
  154.         {
  155.             //比如移动32位，就相当于移动0位，移动33位，就相当于移动1位【32位作为一个周期】
  156.             shiftCount = (int)((uint)shiftCount % 32U);//确保余数在0~31之间波动
  157.             if (leftShift)
  158.             {
  159.                 //左移：【最左侧位不要，在最右侧补0】
  160.                 return binaryX.Remove(0, shiftCount).PadRight(32, '0');
  161.             }
  162.             else
  163.             {
  164.                 //右移：【最右侧位不要，在最左侧补符号位。（正数补0，负数补1）】
  165.                 return binaryX.Remove(32 - shiftCount, shiftCount).PadLeft(32, binaryX[0]);
  166.             }
  167.         }
  168.     }
  169.  
  170.     /// <summary>
  171.     /// 操作符号，运算符号
  172.     /// </summary>
  173.     enum OperationSymbol
  174.     {
  175.         /// <summary>
  176.         /// 与 【位都是1时结果为1，否则为0】
  177.         /// </summary>
  178.         AND = 0,
  179.         /// <summary>
  180.         /// 或 【位都是0时结果为0，否则为1】
  181.         /// </summary>
  182.         OR = 1,
  183.         /// <summary>
  184.         /// 非 【位取反】,非操作只考虑第一个数
  185.         /// </summary>
  186.         NOT = 2,
  187.         /// <summary>
  188.         /// 异或 【位不同是为1，相同为0】
  189.         /// </summary>
  190.         XOR = 3,
  191.         /// <summary>
  192.         /// 左移，相当于乘以2个N次方【最左侧位不要，在最右侧补0】
  193.         /// </summary>
  194.         SHIFT_LEFT = 4,
  195.         /// <summary>
  196.         /// 右移，相当于除以2个N次方【最右侧位不要，在最左侧补符号位。（正数补0，负数补1）】
  197.         /// </summary>
  198.         SHIFT_RIGHT = 5
  199.     }
  200. }

程序运行如图：

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/2023面试高手/article/detail/112290
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号