值類型取值範圍、與運算（&）、或運算（|）、非運算（~）、異或運算（^）、位運算和位枚舉

時間  2020-07-21
標籤 類型 取值 範圍 運算 異或 枚舉 简体版
原文   原文鏈接

1、機器數和真值

一、機器數

一個數在計算機中的二進制表示形式，叫作這個數的機器數。機器數是帶符號的，在計算機用一個數的最高位存放符號，正數爲0，負數爲1。html

好比：十進制中的數 +3 ，計算機字長爲8位，轉換成二進制就是00000011。若是是 -3 ，就是 10000011 。編程

那麼，這裏的 00000011 和 10000011 就是機器數。函數

二、真值

由於第一位是符號位，因此機器數的形式值就不等於真正的數值。例如上面的有符號數 10000011，其最高位1表明負，其真正數值是 -3 而不是形式值131（10000011轉換成十進制等於131）。ui

因此，爲區別起見，將帶符號位的機器數對應的真正數值稱爲機器數的真值。例：0000 0001的真值 = +000 0001 = +1，1000 0001的真值 = –000 0001 = –1this

2、原碼, 反碼, 補碼

正數和負數在現代計算機裏通常用補碼錶示。編碼

一、原碼

原碼就是符號位加上真值的絕對值, 即用第一位表示符號, 其他位表示值. 好比若是是8位二進制：spa

[+1]原 = 0000 0001

[-1]原 = 1000 0001

二、反碼

反碼的表示方法是：code

　　正數的反碼是其自己htm

　　負數的反碼是在其原碼的基礎上, 符號位不變，其他各個位取反。對象

[+1] = [00000001]原 = [00000001]反

[-1] = [10000001]原 = [11111110]反

三、補碼

補碼的表示方法是：

　　正數的補碼就是其自己

　　負數的補碼是在其原碼的基礎上， 符號位不變， 其他各位取反，最後+1。 (即在反碼的基礎上+1)

[+1] = [00000001]原 = [00000001]反 = [00000001]補

[-1] = [10000001]原 = [11111110]反 = [11111111]補

補碼的出現，解決了0的符號以及兩個編碼的問題：

1-1 = 1 + (-1) = [0000 0001]原 + [1000 0001]原 = [0000 0001]補 + [1111 1111]補 = [0000 0000]補=[0000 0000]原

這樣0用[0000 0000]表示， 而之前出現問題的-0則不存在了，並且能夠用[1000 0000]表示-128。

(-1) + (-127) = [1000 0001]原 + [1111 1111]原 = [1111 1111]補 + [1000 0001]補 = [1000 0000]補

-1-127的結果應該是-128，在用補碼運算的結果中，[1000 0000]補 就是-128。可是注意由於其實是使用之前的-0的補碼來表示-128，因此-128並無原碼和反碼錶示。（對-128的補碼錶示[1000 0000]補算出來的原碼是[0000 0000]原，這是不正確的。）

使用補碼，不只僅修復了0的符號以及存在兩個編碼的問題，並且還可以多表示一個最低數。這就是爲何8位二進制，使用原碼或反碼錶示的範圍爲[-127, +127]，而使用補碼錶示的範圍爲[-128, 127]。

由於機器使用補碼，因此對於編程中經常使用到的32位int類型， 能夠表示範圍是： [-231, 231-1] 由於第一位表示的是符號位，而使用補碼錶示時又能夠多保存一個最小值。

四、負數的補碼轉化爲原碼

符號位不變， 其他各位取反，最後+1。

[-4] = [1111 1100]補 = [1000 0100]原

3、值類型取值範圍

保留字 System命名空間中的名字 字節數 取值範圍 例子
sbyte System.Sbyte 1 -128~127 sbyte val = 12;
byte System.Byte 1 0~255

byte val1 = 12;

byte val2 = 34U;
short System.Int16 2 -32768~32767 short val = 12;
ushort System.UInt16 2 0~65535

ushort val1 = 12;

ushort val2 = 34U;
int System.Int32 4 -2147483648~2147483647 int val = 12;
uint System.UInt32 4 0~4292967295

uint val1 = 12;

uint val2 = 34U;
long System.Int64 8 -9223372036854775808~9223372036854775807

long val1 = 12;

long val2 = 34L;
ulong System.UInt64 8 0~18446744073709551615

ulong val1 = 12;

ulong val2 = 34U;

ulong val3 = 56L;

ulong val4 = 78UL;
char System.Char 2 0~65535 char val = 'h';
float System.Single 4 1.5 × 10−45 至 3.4 × 1038，7 位精度 float val = 1.23F;
double System.Double 8 5.0 × 10−324 至 1.7 × 10308，15 位精度

double val1 = 1.23;

double val2 = 4.56D;
bool System.Boolean   (true,false)

bool val1 = true;

bool val2 = false;
decimal System.Decimal 16 1.0 × 10−28 至 7.9 × 1028，28 位精度 decimal val = 1.23M;

4、與運算（&）

運算規則：

0&0=0；0&1=0；1&0=0；1&1=1

即：兩個同時爲1，結果爲1，不然爲0

例如：3 & 5

十進制3轉爲二進制的補碼爲：0000 0011

十進制5轉爲二進制的補碼爲：0000 0101

結果就是：0000 0001  轉爲十進制：+1

即：3 & 5 = 1

又例如：-2 & 2

正數和負數在現代計算機裏通常用補碼參與運算。

十進制-2的補碼爲：1111 1110

十進制 2的補碼爲：0000 0010

經過 &計算結果爲：0000 0010 轉爲十進制：+2

即：-2 & 2 = 2

又例如：-2 & -2

十進制-2的補碼爲：1111 1110

十進制-2的補碼爲：1111 1110

經過 &計算結果爲：1111 1110

首先看最高位符合位是1，說明這是一個負數的補碼錶示。

把它轉換成原碼，符合位不變，其它位取反，最後再加1，獲得原碼爲：1000 0010 轉爲十進制就是：-2

即：-2 & -2 = -2

5、或運算（|）

運算規則：

0|0=0；  0|1=1；  1|0=1；   1|1=1；

即 ：參加運算的兩個對象，一個爲1，其值爲1。

例：2 | 4

2的補碼爲：0000 0010

4的補碼爲：0000 0100

經過 | 運算結果爲：0000 0110 轉爲十進制：+6

即：2 | 4 = 6

例：6 | 8

6的補碼爲：0000 0110

8的補碼爲：0000 1000

經過 | 運算結果爲：0000 1110 轉爲十進制：+14

即：6 | 8 = 14

例：2 | -2

+2的補碼爲：0000 0010

 -2的補碼爲：1111 1110

經過 | 運算結果爲：1111 1110

首先看最高位符合位是1，說明這是一個負數的補碼錶示。

把它轉換成原碼，符合位不變，其它位取反，最後再加1，獲得原碼爲：1000 0010 轉爲十進制就是：-2

即：2 | -2 = -2

例：-2 | -4

-2的補碼爲：1111 1110

-4的補碼爲：1111 1100

經過 | 運算結果爲：1111 1110

首先看最高位符合位是1，說明這是一個負數的補碼錶示。

把它轉換成原碼，符合位不變，其它位取反，最後再加1，獲得原碼爲：1000 0010 轉爲十進制就是：-2

即：-2 | -4 = -2

6、非運算（~）

非運算即取反運算（包括符合位），在二進制中1變0，0變1。

例：~1

1的補碼爲：0000 0001

~1結果爲：1111 1110

首先看最高位符合位是1，說明這是一個負數的補碼錶示。

把它轉換成原碼，符合位不變，其它位取反，最後再加1，獲得原碼爲：1000 0010 轉爲十進制就是：-2

即：~1 = -2

例：~-1

-1的補碼爲：1111 1111

~-1結果爲：0000 0000  轉爲十進制：+0

即：~-1 = 0

7、異或運算（^）

運算規則：

0^0=0；  0^1=1；  1^0=1；   1^1=0；

即：參加運算的兩個對象，若是兩個位爲「異」（值不一樣），則該位結果爲1，不然爲0。相異爲1，相同爲0。

例：3^5

3的補碼爲：0000 0011

5的補碼爲：0000 0101

經過 ^ 運算結果爲：0000 0110 轉爲十進制：+6

即：3^5 = 6

例：-2^4

-2的補碼爲：1111 1110

 4的補碼爲：0000 0100

經過 ^ 運算結果爲：1111 1010

首先看最高位符合位是1，說明這是一個負數的補碼錶示。

把它轉換成原碼，符合位不變，其它位取反，最後再加1，獲得原碼爲：1000 0110 轉爲十進制就是：-6

即：-2^4 = -6

8、位運算

一、<<左移運算符（此處以1個字節爲例）

將一個運算對象的各二進制位所有左移若干位（左邊的二進制丟棄，右邊補0）

例：1 << 1

1的補碼爲：0000 0001

左移1位後：0000 0010 轉爲十進制：+2

即：1<<1 = 2

例：1 << 2

1的補碼爲：0000 0001

左移1位後：0000 0100 轉爲十進制：+4

即：1<<2 = 4

例：-1<<1

-1的補碼爲：1111 1111

左移1位後：1111 1110

首先看最高位符合位是1，說明這是一個負數的補碼錶示。

把它轉換成原碼，符合位不變，其它位取反，最後再加1，獲得原碼爲：1000 0010 轉爲十進制就是：-2

即：-1<<1 = -2

例：-5<<2

-5的補碼爲：1111 1011

左移2位後：1110 1100

首先看最高位符合位是1，說明這是一個負數的補碼錶示。

把它轉換成原碼，符合位不變，其它位取反，最後再加1，獲得原碼爲：1001 0100 轉爲十進制就是：-20

即：-5<<2 = -20

注意：以1個字節爲例，-5左移5位後最高位就變成了0，結果就會是正數了。

PS：對於左移，直觀的理解爲，對於正數來講，左移至關於乘以2（但效率比乘法高）；對於負數來講，沒有直觀的理解，由於它是用補碼參與運算。

二、>>右移運算符（此處以1個字節爲例）

將一個運算對象的各二進制位所有右移若干位，正數左補0，負數左補1。

例：4>>2

4的補碼爲：0000 0100

右移2位後：0000 0001 轉爲十進制就是：+1

即：4>>2 = 1

例：-14>>2

-14的補碼爲：1111 0010

右移2位後：1111 1100

首先看最高位符合位是1，說明這是一個負數的補碼錶示。

把它轉換成原碼，符合位不變，其它位取反，最後再加1，獲得原碼爲：1000 0100 轉爲十進制就是：-4

即：-14>>2 = -4

PS：對於右移，直觀的理解爲，對於正數來講，右移1位至關於除以2（但效率比除法高）；對於負數來講，沒有直觀的理解。

9、位枚舉

位枚舉能夠爲枚舉變量保存多個枚舉值。

枚舉中每一個元素的基礎類型都是int，可使用冒號指明另外一種整數類型。已批准的枚舉類型有：byte、sbyte、short、ushort、int、uint、long、ulong。

從 C# 7.3 開始，你能夠在基類約束中使用 System.Enum（稱爲枚舉約束），以指定類型參數爲枚舉類型。

位枚舉示例以下：

/// <summary>
/// 權限位枚舉
/// 位枚舉的枚舉值是互斥得，一般是用2的n次方來依次爲每一項賦值，爲了運算此處不能是負數。
/// 枚舉成員：1L << 0 到 1L << 62 共63個
/// </summary>
[Flags]
public enum Permission : long
{
    /// <summary>
    /// 建立
    /// </summary>
    [EnumDescription("Create")]
    Create = 1L << 0, //1

    /// <summary>
    /// 讀取
    /// </summary>
    [EnumDescription("Read")]
    Read = 1L << 1,  //2

    /// <summary>
    /// 修改
    /// </summary>
    [EnumDescription("Update")]
    Update = 1L << 2, //4

    /// <summary>
    /// 刪除
    /// </summary>
    [EnumDescription("Delete")]
    Delete = 1L << 3,  //8

    /// <summary>
    /// 管理員
    /// </summary>
    [EnumDescription("Admin")]
    Admin = 1L << 62 //注意：此處必須是1L，表示長整型的1，而不能是1。若是是1默認會是Int32位整型的1，Int32位整型的1左移62位後結果會是不對的。
}

具體使用以下：

class Program
{
    static void Main(string[] args)
    {
        //一、給用戶建立、讀取、修改和刪除的權限
        var permission = Permission.Create | Permission.Read | Permission.Update | Permission.Delete;

        //二、去掉用戶的修改和刪除權限
        permission = permission & ~Permission.Update;
        permission = permission & ~Permission.Delete;

        //三、給用戶加上管理員的權限
        permission = permission | Permission.Admin;

        //四、判斷用戶是否有建立的權限
        var isCreate = (permission & Permission.Create) != 0;

        //五、獲取用戶剩餘的權限
        var listPermission = permission.GetDescriptionFlagsEnum();

        //打印結果
        Console.WriteLine("用戶是否有建立的權限：" + isCreate);
        Console.WriteLine("下面是用戶剩餘的權限：");
        foreach (var item in listPermission)
        {
            Console.WriteLine(item);
        }

        Console.ReadKey();
    }
}

運行結果以下：

上面代碼中涉及到2個類，自定義枚舉描述特性類和枚舉幫助類：

using System;

namespace TianYaSharpCore.Utility
{
    /// <summary>
    /// 自定義枚舉描述特性
    /// </summary>
    [AttributeUsage(AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
    public class EnumDescriptionAttribute : Attribute
    {
        /// <summary>
        /// 描述
        /// </summary>
        public string Desc { get; set; }

        /// <summary>
        /// 構造函數
        /// </summary>
        /// <param name="desc">描述</param>
        public EnumDescriptionAttribute(string desc)
        {
            this.Desc = desc;
        }
    }
}
using System;
using System.Collections.Generic;
using System.Reflection;

namespace TianYaSharpCore.Utility
{
    /// <summary>
    /// 枚舉幫助類
    /// 從 C# 7.3 開始，你能夠在基類約束中使用 System.Enum（稱爲枚舉約束），以指定類型參數爲枚舉類型。
    /// </summary>
    public static class EnumHelper
    {
        #region 獲取指定字段上的自定義特性標籤的描述（基礎方法）

        /// <summary>
        /// 獲取指定字段上的自定義特性標籤的描述（基礎方法）
        /// </summary>
        /// <param name="fi">字段</param>
        /// <param name="splitChar">分隔符</param>
        /// <returns>返回指定字段上的自定義特性標籤的描述</returns>
        public static string GetDescription(this FieldInfo fi, char splitChar = ',')
        {
            var desc = string.Empty; //字段上特性標籤的描述
            Type typeEnumDescription = typeof(EnumDescriptionAttribute); //自定義枚舉描述特性
            if (fi == null || !fi.IsDefined(typeEnumDescription, false)) //是否認義了特性
            {
                return desc;
            }

            object[] objs = fi.GetCustomAttributes(typeEnumDescription, false);//獲取指定特性
            if (objs == null || objs.Length <= 0)
            {
                return desc;
            }

            //獲取私有或者公開的實例屬性
            PropertyInfo pi = typeEnumDescription.GetProperty("Desc", BindingFlags.Public | BindingFlags.Instance | BindingFlags.NonPublic);
            if (pi == null)
            {
                return desc;
            }

            EnumDescriptionAttribute[] arr = objs as EnumDescriptionAttribute[];
            foreach (EnumDescriptionAttribute item in arr) //遍歷獲取標籤描述
            {
                desc += pi.GetValue(item, null) + splitChar.ToString();
            }
            desc = desc.TrimEnd(splitChar);

            return desc;
        }

        #endregion 獲取指定字段上的自定義特性標籤的描述（基礎方法）

        #region 獲取枚舉描述（基礎方法TEnum）

        /// <summary>
        /// 獲取枚舉描述（基礎方法TEnum）
        /// </summary>
        /// <typeparam name="TEnum">枚舉類型</typeparam>
        /// <param name="enumValue">枚舉值，例如Gender.Male</param>
        /// <param name="splitChar">分隔符</param>
        /// <returns>返回枚舉描述</returns>
        public static string GetDescription<TEnum>(this TEnum enumValue, char splitChar = ',')
            where TEnum : Enum
        {
            Type t = enumValue.GetType();
            FieldInfo fi = t.GetField(enumValue.ToString());

            return fi.GetDescription(splitChar);
        }

        #endregion 獲取枚舉描述（基礎方法TEnum）

        #region 獲取枚舉描述(long)

        /// <summary>
        /// 獲取枚舉描述
        /// </summary>
        /// <typeparam name="TEnum">枚舉類型</typeparam>
        /// <param name="enumValue">枚舉值</param>
        /// <param name="splitChar">分隔符</param>
        /// <returns>返回枚舉描述</returns>
        public static string GetDescription<TEnum>(this long enumValue, char splitChar = ',')
            where TEnum : Enum
        {
            TEnum e = (TEnum)Enum.Parse(typeof(TEnum), enumValue.ToString());
            return GetDescription(e, splitChar);
        }

        #endregion 獲取枚舉描述(long)

        #region 獲取枚舉描述(int)

        /// <summary>
        /// 獲取枚舉描述
        /// </summary>
        /// <typeparam name="TEnum">枚舉類型</typeparam>
        /// <param name="enumValue">枚舉值</param>
        /// <param name="splitChar">分隔符</param>
        /// <returns>返回枚舉描述</returns>
        public static string GetDescription<TEnum>(this int enumValue, char splitChar = ',')
            where TEnum : Enum
        {
            TEnum e = (TEnum)Enum.Parse(typeof(TEnum), enumValue.ToString());
            return GetDescription(e, splitChar);
        }

        #endregion 獲取枚舉描述(int)

        #region 獲取枚舉描述(Enum)

        /// <summary>
        /// 獲取枚舉描述
        /// </summary>
        /// <param name="enumValue">枚舉值，例如Gender.Male</param>
        /// <param name="splitChar">分隔符</param>
        /// <returns>返回枚舉描述</returns>
        public static string GetDescription(this Enum enumValue, char splitChar = ',')
        {
            return GetDescription<Enum>(enumValue, splitChar);
        }

        #endregion 獲取枚舉描述(Enum)

        #region 獲取枚舉值+枚舉項字典

        /// <summary>
        /// 獲取枚舉值+枚舉項字典
        /// </summary>
        /// <typeparam name="TEnum">枚舉類型</typeparam>
        /// <returns>返回枚舉值+枚舉項字典</returns>
        public static Dictionary<int, string> GetEnumValueItemDictionary<TEnum>()
            where TEnum : Enum
        {
            var dicEnum = new Dictionary<int, string>(); //key：枚舉值，value：枚舉項
            Type t = typeof(TEnum);
            FieldInfo[] fis = t.GetFields(BindingFlags.Static | BindingFlags.Public); //全部枚舉成員
            if (fis == null || fis.Length <= 0)
            {
                return dicEnum;
            }

            //遍歷枚舉全部成員獲取枚舉值及枚舉項
            foreach (var fi in fis)
            {
                if (!fi.FieldType.IsEnum) //是不是枚舉字段
                {
                    continue;
                }

                var key = (int)fi.GetValue(null); //枚舉值
                if (!dicEnum.ContainsKey(key))
                {
                    dicEnum.Add(key, fi.Name);
                }
            }

            return dicEnum;
        }

        #endregion 獲取枚舉值+枚舉項字典

        #region 獲取枚舉值+描述字典

        /// <summary>
        /// 獲取枚舉值+描述字典
        /// </summary>
        /// <typeparam name="TEnum">枚舉類型</typeparam>
        /// <param name="splitChar">分隔符</param>
        /// <returns>返回枚舉值+描述字典</returns>
        public static Dictionary<int, string> GetEnumValueDescDictionary<TEnum>(char splitChar = ',')
            where TEnum : Enum
        {
            var dicEnum = new Dictionary<int, string>(); //key：枚舉值，value：枚舉描述
            Type t = typeof(TEnum);
            FieldInfo[] fis = t.GetFields(BindingFlags.Static | BindingFlags.Public); //全部枚舉成員
            if (fis == null || fis.Length <= 0)
            {
                return dicEnum;
            }

            //遍歷枚舉全部成員獲取枚舉值及描述
            foreach (var fi in fis)
            {
                if (!fi.FieldType.IsEnum) //是不是枚舉字段
                {
                    continue;
                }

                var key = (int)fi.GetValue(null); //枚舉值
                if (!dicEnum.ContainsKey(key))
                {
                    //fi.GetDescription(splitChar)：枚舉描述
                    dicEnum.Add(key, fi.GetDescription(splitChar));
                }
            }

            return dicEnum;
        }

        #endregion 獲取枚舉值+描述字典

        #region 獲取枚舉項+描述字典

        /// <summary>
        /// 獲取枚舉項+描述字典
        /// </summary>
        /// <typeparam name="TEnum">枚舉類型</typeparam>
        /// <param name="splitChar">分隔符</param>
        /// <returns>返回枚舉項+描述字典</returns>
        public static Dictionary<string, string> GetEnumItemDescDictionary<TEnum>(char splitChar = ',')
            where TEnum : Enum
        {
            var dicEnum = new Dictionary<string, string>(); //key：枚舉項，value：枚舉描述
            Type t = typeof(TEnum);
            FieldInfo[] fis = t.GetFields(BindingFlags.Static | BindingFlags.Public); //全部枚舉成員
            if (fis == null || fis.Length <= 0)
            {
                return dicEnum;
            }

            //遍歷枚舉全部成員獲取枚舉項及描述
            foreach (var fi in fis)
            {
                if (!fi.FieldType.IsEnum) //是不是枚舉字段
                {
                    continue;
                }

                if (!dicEnum.ContainsKey(fi.Name))
                {
                    //fi.GetDescription(splitChar)：枚舉描述
                    dicEnum.Add(fi.Name, fi.GetDescription(splitChar));
                }
            }

            return dicEnum;
        }

        #endregion 獲取枚舉項+描述字典

        #region 獲取位枚舉描述

        /// <summary>
        /// 獲取位枚舉描述
        /// </summary>
        /// <typeparam name="TEnum">
        /// 枚舉類型
        /// </typeparam>
        /// <param name="enumValue">
        /// 枚舉值
        /// </param>
        /// <param name="splitChar">
        /// 分隔符（枚舉上打多個一樣的特性標籤時纔會用到）
        /// </param>
        /// <returns>
        /// 位枚舉描述
        /// </returns>
        public static List<string> GetDescriptionFlagsEnum<TEnum>(this TEnum enumValue, char splitChar = ',')
            where TEnum : Enum
        {
            var listDesc = new List<string>();
            Type t = typeof(TEnum);
            if (!t.IsEnum || !t.IsDefined(typeof(FlagsAttribute), false)) //必須是位枚舉
            {
                return listDesc;
            }

            FieldInfo[] fis = t.GetFields(BindingFlags.Static | BindingFlags.Public); //全部枚舉成員
            if (fis == null || fis.Length <= 0)
            {
                return listDesc;
            }

            //遍歷枚舉全部成員獲取描述
            foreach (var fi in fis)
            {
                if (!fi.FieldType.IsEnum) //是不是枚舉字段
                {
                    continue;
                }

                var value = (long)fi.GetValue(null); //枚舉值
                if ((Convert.ToInt64(enumValue) & value) != 0) //&與運算 包含該枚舉成員
                {
                    var enumDesc = fi.GetDescription(splitChar);
                    if (!string.IsNullOrEmpty(enumDesc))
                    {
                        listDesc.Add(enumDesc);
                    }
                }
            }

            return listDesc;
        }

        #endregion 獲取位枚舉描述
    }
}

PS：從 C# 7.3 開始，你能夠在基類約束中使用 System.Enum（稱爲枚舉約束），以指定類型參數爲枚舉類型。

具體可參考官網：https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/builtin-types/enum

C# 7.3 以前：

從 C# 7.3 開始：

參考相關文章：

https://docs.microsoft.com/zh-cn/dotnet/csharp/language-reference/builtin-types/enum

https://www.cnblogs.com/wqbin/p/11142873.html

https://www.runoob.com/w3cnote/csharp-enum.html

https://www.cnblogs.com/qqxz/p/5198474.html

 

此文由博主精心撰寫轉載請保留此原文連接：http://www.javashuo.com/article/p-mxxrbkum-mh.html

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程