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

这篇具有很好参考价值的文章主要介绍了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。

相关测试程序如下:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Linq.Expressions;
using System.Text;
using System.Threading.Tasks;

namespace BitOperationDemo
{
    class Program
    {
        /// <summary>
        /// 标识符字典
        /// </summary>
        static readonly Dictionary<OperationSymbol, string> dict = new Dictionary<OperationSymbol, string>()
        {
            { OperationSymbol.AND,"与(&)"},{ OperationSymbol.OR,"或(|)"},{ OperationSymbol.NOT,"非(~)"},{ OperationSymbol.XOR,"异或(^)"},
            { OperationSymbol.SHIFT_LEFT,"左移(<<)"},{ OperationSymbol.SHIFT_RIGHT,"右移(>>)"}
        };
        static void Main(string[] args)
        {
            Console.SetWindowSize(120, 50);
            Console.WriteLine($"与(&)操作符的位都为1时,才为1,其他都为0,因此与(&)操作符的结果范围在[0, Math.Min(x,y)],x,y均为正整数");
            Console.WriteLine($"或(|)操作符的位都为0时,才为0,其他都为1,因此或(|)操作符的结果范围在[Math.Max(x,y), x+y],x,y均为正整数");
            Console.WriteLine($"非(~)操作符按位取反,1转化为0, 0转化为1,因此非(~)操作符满足[x+~x=-1]一个数与其取反操作之和为-1");
            Console.WriteLine($"异或(^)操作符的位不同时为1, 位相同时为0");
            Console.WriteLine($"左移(<<)操作符:【最左侧位不要,在最右侧补0】,相当于乘以2个N次方,【移位是除以32后的余数,范围[0,31],即以32为一个周期】");
            Console.WriteLine($"右移(>>)操作符:【最右侧位不要,在最左侧补符号位。(正数补0,负数补1)】,相当于除以2个N次方,【移位是除以32后的余数,范围[0,31],即以32为一个周期】");
            Console.WriteLine();
            int x = 12345;
            int y = 34567;//34567除以32,余数为7,相当于移动7位
            string binaryX = Convert.ToString(x, 2).PadLeft(32, '0');
            string binaryY = Convert.ToString(y, 2).PadLeft(32, '0');
            Console.WriteLine($"整数【{x}】对应的32位二进制为【{binaryX}】");
            Console.WriteLine($"整数【{y}】对应的32位二进制为【{binaryY}】");
            Console.WriteLine("-----------------下面分别用二进制字符串逻辑处理 以及 系统内置的操作符进行操作计算-----------------");

            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.AND);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.OR);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.NOT);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.XOR);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.SHIFT_LEFT);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.SHIFT_RIGHT);

            Console.WriteLine("-----------------下面测试负数进行操作计算-----------------");
            x = -12345;
            binaryX = Convert.ToString(x, 2).PadLeft(32, '0');
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.AND);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.OR);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.NOT);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.XOR);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.SHIFT_LEFT);
            PrintOperatorResult(x, y, binaryX, binaryY, OperationSymbol.SHIFT_RIGHT);
            Console.ReadLine();
        }

        /// <summary>
        /// 打印结果比较
        /// </summary>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <param name="binaryX"></param>
        /// <param name="binaryY"></param>
        /// <param name="operationSymbol"></param>
        static void PrintOperatorResult(int x, int y, string binaryX, string binaryY, OperationSymbol operationSymbol)
        {
            string binaryResult = GetOperatorResult(binaryX, binaryY, operationSymbol);
            int result = 0;
            switch (operationSymbol)
            {
                case OperationSymbol.AND:
                    result = x & y;
                    break;
                case OperationSymbol.OR:
                    result = x | y;
                    break;
                case OperationSymbol.NOT:
                    result = ~x;
                    break;
                case OperationSymbol.XOR:
                    result = x ^ y;
                    break;
                case OperationSymbol.SHIFT_LEFT:
                    result = x << y;
                    break;
                case OperationSymbol.SHIFT_RIGHT:
                    result = x >> y;
                    break;
            }
            Console.WriteLine($"{dict[operationSymbol]}操作符系统内置的操作符运算结果为【{result}】,使用二进制字符串还原后的整数结果为【{Convert.ToInt32(binaryResult, 2)}】");
            Console.WriteLine();
        }

        /// <summary>
        /// 获取操作符的结果
        /// </summary>
        /// <param name="binaryX">32位二进制字符串,第一个数</param>
        /// <param name="binaryY">32位二进制字符串,第二个数</param>
        /// <param name="operationSymbol">指定的操作符枚举</param>
        /// <returns></returns>
        static string GetOperatorResult(string binaryX, string binaryY, OperationSymbol operationSymbol)
        {
            string result = string.Empty;
            switch (operationSymbol)
            {
                case OperationSymbol.AND:
                    result = CalculateOperatorResult(binaryX, binaryY, (left, right) => (left == '1' && right == '1') ? "1" : "0");
                    break;
                case OperationSymbol.OR:
                    result = CalculateOperatorResult(binaryX, binaryY, (left, right) => (left == '0' && right == '0') ? "0" : "1");
                    break;
                case OperationSymbol.NOT:
                    result = CalculateOperatorResult(binaryX, binaryY, (left, right) => (left == '0') ? "1" : "0");
                    break;
                case OperationSymbol.XOR:
                    result = CalculateOperatorResult(binaryX, binaryY, (left, right) => (left == right) ? "0" : "1");
                    break;
                case OperationSymbol.SHIFT_LEFT:
                    result = CalculateShiftResult(binaryX, Convert.ToInt32(binaryY, 2), true);
                    break;
                case OperationSymbol.SHIFT_RIGHT:
                    result = CalculateShiftResult(binaryX, Convert.ToInt32(binaryY, 2), false);
                    break;
            }
            Console.WriteLine($"{dict[operationSymbol]}操作符逻辑运算的32位二进制结果为【{result}】");
            return result;
        }

        /// <summary>
        /// 计算逻辑运算的结果【与,或,非,异或】
        /// </summary>
        /// <param name="binaryX">32位二进制字符串,第一个数</param>
        /// <param name="binaryY">32位二进制字符串,第二个数</param>
        /// <param name="logicOperator">逻辑操作委托</param>
        /// <returns></returns>
        static string CalculateOperatorResult(string binaryX, string binaryY, Func<char, char, string> logicOperator)
        {
            string result = string.Empty;
            for (int i = 0; i < 32; i++)
            {
                result += logicOperator(binaryX[i], binaryY[i]);
            }
            return result;
        }

        /// <summary>
        /// 计算移位操作【左移,右移】
        /// </summary>
        /// <param name="binaryX"></param>
        /// <param name="shiftCount">移动几位,该数需要转化为【除以32的余数】</param>
        /// <param name="leftShift">true代表左移,false代表右移</param>
        /// <returns></returns>
        static string CalculateShiftResult(string binaryX, int shiftCount, bool leftShift)
        {
            //比如移动32位,就相当于移动0位,移动33位,就相当于移动1位【32位作为一个周期】
            shiftCount = (int)((uint)shiftCount % 32U);//确保余数在0~31之间波动
            if (leftShift)
            {
                //左移:【最左侧位不要,在最右侧补0】
                return binaryX.Remove(0, shiftCount).PadRight(32, '0');
            }
            else
            {
                //右移:【最右侧位不要,在最左侧补符号位。(正数补0,负数补1)】
                return binaryX.Remove(32 - shiftCount, shiftCount).PadLeft(32, binaryX[0]);
            }
        }
    }

    /// <summary>
    /// 操作符号,运算符号
    /// </summary>
    enum OperationSymbol
    {
        /// <summary>
        /// 与 【位都是1时结果为1,否则为0】
        /// </summary>
        AND = 0,
        /// <summary>
        /// 或 【位都是0时结果为0,否则为1】
        /// </summary>
        OR = 1,
        /// <summary>
        /// 非 【位取反】,非操作只考虑第一个数
        /// </summary>
        NOT = 2,
        /// <summary>
        /// 异或 【位不同是为1,相同为0】
        /// </summary>
        XOR = 3,
        /// <summary>
        /// 左移,相当于乘以2个N次方【最左侧位不要,在最右侧补0】
        /// </summary>
        SHIFT_LEFT = 4,
        /// <summary>
        /// 右移,相当于除以2个N次方【最右侧位不要,在最左侧补符号位。(正数补0,负数补1)】
        /// </summary>
        SHIFT_RIGHT = 5
    }
}

程序运行如图:

c# 或,.Net Core,C#,算法与数据结构,c#,蓝桥杯,fpga开发

 文章来源地址https://www.toymoban.com/news/detail-602817.html

到了这里,关于C#的几种位操作运算,与、或、非、异或、左移、右移的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • DevOps中的左移和右移

        一段时间以来,随着DevSecOps、DevTestOps的出现,表明DevOps软件开发方法已完全成熟并进化到了新的阶段,但究其根本,仍是通过频繁发布小型构建来加快产品的生产速度和上线速度。作为渐进交付的连续周期的一部分,DevOps开发团队采用了左移和右移的原则,以确保在这

    2024年02月11日
    浏览(40)
  • 蓝桥杯第十三届决赛真题-左移右移

    题目链接 问题描述 小蓝有一个长度为 N 的数组, 初始时从左到右依次是 1,2,3, …N 。 之后小蓝对这个数组进行了 M 次操作, 每次操作可能是以下 2 种之一: 左移 x, 即把 x 移动到最左边。 右移 x, 即把 x 移动到最右边。 请你回答经过 M 次操作之后, 数组从左到右每个数是多少? 输

    2023年04月09日
    浏览(46)
  • 有符号数和无符号数左移和右移

    主要是有符号数的左移。 有的说不管符号位,直接左移,所以可以一会正数一会复数 https://bbs.csdn.net/topics/391075092 有的说符号位不动,其他来左移 不明白了。。。。 https://blog.csdn.net/hnjzsyjyj/article/details/119721014 https://wenku.baidu.com/view/6e31935402f69e3143323968011ca300a6c3f60d.html? wkts =1

    2024年02月01日
    浏览(41)
  • C#针对VS线程间操作提示:程间操作无效: 从不是创建控件“”的线程访问它的几种解决方法

    转载请标明出处:Python Excellent的博客 此为最基础方法 (入门级) 运行效果如图所示 * 先在按钮事件中创建一个Test1()线程 * 在测试1中有两种方法可以访问窗体线程(首推荐) public SynchronizationContext UiContext //第一步全局声明 UiContext = SynchronizationContext.Current; //第二部在public For

    2024年02月08日
    浏览(43)
  • 软件测试流程扫盲:V/W/H模型,测试左移测试右移

    想了想,如何运用在工作环境进阶一个小level:公司当前的软件测试模型更类似于H模型,然后测试流程也倾向于传统测试流程,单元集成冒烟系统回归验收测试,单元一般是开发自己去写去做。【左移右移做的还不好,需要后面学习相关技术运用在工作中】 V模型是瀑布模型

    2024年02月12日
    浏览(34)
  • 第十三届蓝桥杯Java B 组国赛 C 题——左移右移(AC)

    小蓝有一个长度为 N N N 的数组, 初始时从左到右依次是 1 , 2 , 3 , … N 1,2,3, ldots N 1 , 2 , 3 , … N 。 之后小蓝对这个数组进行了 M M M 次操作, 每次操作可能是以下 2 种之一: 左移 x x x , 即把 x x x 移动到最左边。 右移 x x x , 即把 x x x 移动到最右边。 请你回答经过 M M M 次操作之后

    2024年02月02日
    浏览(53)
  • Python 四则运算的几种方法?

    Python的四则运算主要有以下几种方法: 1、使用基本算术运算符: Python支持基本的算术运算符,包括加(+), 减(-), 乘(*), 除(/) 和求模运算符(%), 可以用于数值类型的数据,例如整数(int)、浮点数(float)等。例如: 2、使用math模块中的函数: Python的标准库中提供了一个math模块,其

    2024年03月21日
    浏览(40)
  • 【基础算法】矩阵的几种基本运算 & C++实现

            从线性代数中我们已知,两个矩阵可以进行加减乘运算,但矩阵之间没有除法运算。(下面以3×3矩阵为例):          矩阵的数乘运算类属与两矩阵相乘的一种特殊形式(数乘矩阵的这个数,我们可以将其化为对角线为该数,其余位置都为0的矩阵,再用该对

    2024年02月11日
    浏览(48)
  • java的7种位运算符

    1 概述 ​ 在Java语言中,提供了7种位运算符,分别是按位与()、按位或(|)、按位异或(^)、取反(~)、左移()、带符号右移()和无符号右移()。 ​ 这些运算符当中,仅有~是单目运算符,其他运算符均为双目运算符。 ​ 对数值类型数据进行按位操作;1表示true、0表示false。

    2024年02月09日
    浏览(36)
  • 记录一下C#深拷贝的几种方式

    一、C#中预定义数据类型         1》值类型          2》引用类型 两种类型的不同点:        概念: 值类型直接存储其值,而引用类型存储对值的引用        存储: 值类型存储在堆栈 (stack) 上,而引用类型存储在托管堆上(managed heap)。 当使用值类型,进行赋值的

    2023年04月08日
    浏览(49)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包