有没有一种很好的方法可以将一个 int 分成两个短裤（.NET）？

Question

我认为这是不可能的，因为Int32 有 1 位符号和 31 位数字信息，而 Int16 有 1 位符号和 15 位数字信息，这导致有 2 位符号和 30 位信息.

如果这是真的，那么我不能将一个Int32 分成两个Int16。这是真的吗？

提前致谢。

额外信息：使用 Vb.Net，但我认为我可以毫无问题地翻译 C# 答案。

最初我想做的是将一个UInt32 转换为两个UInt16，因为这是用于与基于WORD 的机器交互的库。然后我意识到 Uint 不符合 CLS 并尝试对 Int32 和 Int16 做同样的事情。

更糟糕的是：执行a = CType(c And &HFFFF, Int16); 会引发OverflowException。我希望该语句与a = (Int16)(c & 0xffff); 相同（不会引发异常）。

Answer 1

这当然可以在不丢失信息的情况下完成。在这两种情况下，您最终都会得到 32 位信息。它们是否用于符号位无关紧要：

int original = ...;

short firstHalf = (short) (original >> 16);
short secondHalf = (short) (original & 0xffff);

int reconstituted = (firstHalf << 16) | (secondHalf & 0xffff);

这里，reconstituted 将始终等于 original，因此不会丢失任何信息。

现在两条短裤符号的含义是另一回事 - 如果original 为负，firstHalf 将为负，但如果第 15 位（计数），secondHalf 将为负original 的 0-31) 被设置，这在原始形式中并没有特别的意义。

Answer 2

这应该可行：

int original = ...;
byte[] bytes = BitConverter.GetBytes(original);
short firstHalf = BitConverter.ToInt16(bytes, 0);
short secondHalf = BitConverter.ToInt16(bytes, 2);

编辑：

用 0x7FFFFFFF 测试，它可以工作

byte[] recbytes = new byte[4];
recbytes[0] = BitConverter.GetBytes(firstHalf)[0];
recbytes[1] = BitConverter.GetBytes(firstHalf)[1];
recbytes[2] = BitConverter.GetBytes(secondHalf)[0];
recbytes[3] = BitConverter.GetBytes(secondHalf)[1];
int reconstituted = BitConverter.ToInt32(recbytes, 0);

Answer 3

Jon's answer，翻译成Visual Basic，没有溢出：

Module Module1
    Function MakeSigned(ByVal x As UInt16) As Int16
        Dim juniorBits As Int16 = CType(x And &H7FFF, Int16)
        If x > Int16.MaxValue Then
            Return juniorBits + Int16.MinValue
        End If
        Return juniorBits
    End Function

    Sub Main()
        Dim original As Int32 = &H7FFFFFFF    
        Dim firstHalfUnsigned As UInt16 = CType(original >> 16, UInt16)
        Dim secondHalfUnsigned As UInt16 = CType(original And &HFFFF, UInt16)
        Dim firstHalfSigned As Int16 = MakeSigned(firstHalfUnsigned)
        Dim secondHalfSigned As Int16 = MakeSigned(secondHalfUnsigned)

        Console.WriteLine(firstHalfUnsigned)
        Console.WriteLine(secondHalfUnsigned)
        Console.WriteLine(firstHalfSigned)
        Console.WriteLine(secondHalfSigned)
    End Sub
End Module

结果：

32767
65535
32767
-1

在 .NET 中，CType(&Hffff, Int16) 导致溢出，(short)0xffff 给出 -1（没有溢出）。这是因为默认情况下 C# 编译器使用未经检查的操作和 VB.NET 检查。

我个人喜欢Agg's answer，因为我的代码比较复杂，而Jon的在checked环境下会导致溢出异常。

我也是created another answer，基于BitConverter 类的代码，针对这个特定任务进行了优化。但是，它使用了不安全的代码。

Answer 4

是的，它可以使用掩码和位移来完成

 Int16 a,b;
 Int32 c;

 a = (Int16) (c&0xffff);
 b = (Int16) ((c>>16)&0xffff);

编辑

回答评论。重建工作正常：

 Int16 a, b;
 Int32 c = -1;

 a = (Int16)(c & 0xffff);
 b = (Int16)((c >> 16) & 0xffff);

 Int32 reconst = (((Int32)a)&0xffff) | ((Int32)b << 16);

 Console.WriteLine("reconst = " + reconst);

测试它并按预期打印-1。

EDIT2：改变了重建。 Int16 到 Int32 的提升导致所有符号位扩展。忘记了，它必须是 AND'ed。

Answer 5

为什么不呢？为简单起见，让我们减少位数：假设我们有 8 位，其中左位是负位。

[1001 0110] // representing -22

你可以将它存储在 2 次 4 位中

[1001] [0110] // representing   -1 and 6

我不明白为什么不可能，你两次有 8 位信息

编辑：为了简单起见，我不仅减少了位数，而且也不使用 2-complement 方法。在我的例子中，左边的位表示减号，其余的将被解释为正常的正二进制数

Answer 6

C#中的不安全代码，不会发生溢出，自动检测字节序：

using System;
class Program
{
    static void Main(String[] args)
    {
        checked // Yes, it works without overflow!
        {
            Int32 original = Int32.MaxValue;
            Int16[] result = GetShorts(original);
            Console.WriteLine("Original int: {0:x}", original);
            Console.WriteLine("Senior Int16: {0:x}", result[1]);
            Console.WriteLine("Junior Int16: {0:x}", result[0]);
            Console.ReadKey();
        }
    }
    static unsafe Int16[] GetShorts(Int32 value)
    {
        byte[] buffer = new byte[4];
        fixed (byte* numRef = buffer)
        {
            *((Int32*)numRef) = value;
            if (BitConverter.IsLittleEndian)
                return new Int16[] { *((Int16*)numRef), *((Int16*)numRef + 1) };
            return new Int16[] { 
                (Int16)((numRef[0] << 8) | numRef[1]),  
                (Int16)((numRef[2] << 8) | numRef[3])
            };
        }
    }
}

Answer 7

您可以在 VB.NET 中使用 StructLayout：

更正：word 是 16bit，dword 是 32bit

<StructLayout(LayoutKind.Explicit, Size:=4)> _
   Public Structure UDWord
      <FieldOffset(0)> Public Value As UInt32
      <FieldOffset(0)> Public High As UInt16
      <FieldOffset(2)> Public Low As UInt16

      Public Sub New(ByVal value As UInt32)
         Me.Value = value
      End Sub

      Public Sub New(ByVal high as UInt16, ByVal low as UInt16)
         Me.High = high
         Me.Low = low
      End Sub
   End Structure

仅使用这些类型，签名将是相同的

<StructLayout(LayoutKind.Explicit, Size:=4)> _
   Public Structure DWord
      <FieldOffset(0)> Public Value As Int32
      <FieldOffset(0)> Public High As Int16
      <FieldOffset(2)> Public Low As Int16

      Public Sub New(ByVal value As Int32)
         Me.Value = value
      End Sub

      Public Sub New(ByVal high as Int16, ByVal low as Int16)
         Me.High = high
         Me.Low = low
      End Sub
   End Structure

编辑：

我已经发布/编辑了我的 anwser 几次，但还没有解释这个解决方案，所以我觉得我还没有完成我的答案。所以我现在就这样做：

在结构上显式使用 StructLayout 需要您通过 FieldOffset 属性 [FieldOffsetAttribute] 提供每个字段的定位（按字节偏移量）[StructLayoutAttribute]

使用这两个属性，您可以创建重叠字段，即unions。

第一个字段 (DWord.Value) 将是 32 位整数，偏移量为 0（零）。要拆分这个 32 位整数，您将有两个额外的字段再次从偏移量 0（零）开始，然后第二个字段再多 2 个字节，因为 16 位（短）整数是 2 个字节。

据我回忆，通常当你拆分一个整数时，他们通常称前半部分为“高”，后半部分为“低”；从而命名我的另外两个字段。

通过使用这样的结构，您可以为运算符和类型加宽/收窄创建重载，以便轻松地从 Int32 类型交换到此 DWord 结构，以及比较 Operator Overloading in VB.NET

Answer 8

您可以使用 StructLayout 来执行此操作：

[StructLayout(LayoutKind.Explicit)]
        struct Helper
        {
            [FieldOffset(0)]
            public int Value;
            [FieldOffset(0)]
            public short Low;
            [FieldOffset(2)]
            public short High;
        }

使用它，您可以将完整的 Value 设为 int ，将低部分、高部分设为 short 。

类似：

var helper = new Helper {value = 12345};

Answer 9

由于存储宽度（32 位和 16 位），如果您的 Int32 大于 32767，将 Int32 转换为 Int16 可能意味着信息丢失。

Answer 10

如果你看一下位表示，那么你是对的。

您可以使用无符号整数来执行此操作，因为它们没有符号位。

Answer 11

Int32 数字 = 70000;

        string str = Convert.ToString(num, 2);
    //convert INT32 to Binary string   
        Int32 strl = str.Length;
    //detect string length


        string strhi, strlo;
    //ifvalue is greater than 16 bit 
        if (strl > 16)
        {
           int lg = strl - 16;
          //dtect bits in higher word 
           strlo = str.Substring(lg, 16);
     ///move lower word string to strlo 

            strhi = str.Substring(0, lg);
   //mov higher word string to strhi

        }
        else
//if value is less than 16 bit
        {
           strhi = "0";
//set higher word zero
           strlo = str;
///move lower word string to strlo 

        }

        Int16 lowword, hiword;
        lowword = Convert.ToInt16(strlo, 2);
        hiword = Convert.ToInt16(strhi, 2);
        ////convert binary string to int16
        }

Answer 12

我没有使用位运算符，但对于无符号值，这可能有效：

public (ushort, ushort) SplitToUnsignedShorts(uint value)
{
    ushort v1 = (ushort) (value / 0x10000);
    ushort v2 = (ushort) (value % 0x10000);

    return (v1, v2);
}

或者它的表达式主体版本：

public (ushort, ushort) SplitToUShorts(uint value)
    => ((ushort)(value / 0x10000), (ushort)(value % 0x10000));

至于标志，您必须决定如何拆分数据。两个中只能有一个负输出。请记住，有符号值总是牺牲一位来存储数字的负状态。这基本上将您在该变量中可以拥有的最大值“减半”。这也是 uint 可以存储两倍于有符号 int 的原因。

至于将其编码为您的目标格式，您可以选择将第二个数字设为无符号短整数，以保留数值，或者您可以手动对其进行编码，这样一位现在代表该值的符号。这样，虽然您会丢失最初预期的符号位数值，但您不会丢失原始二进制数据，并且始终可以将其重建为原始值。

最终归结为您希望如何存储和处理这些数据。只要您知道如何从您的编码值中提取（或合并到）数据，就不会丢失位，进而不会丢失数据。

Answer 13

你可以使用这个 Nuget 包 LSharpCode.XExtensions 安装好之后就可以这样使用了：

using LSharpCode.XExtensions.MathExtensions;
Int32 varInt32name;
Int16 varint16nameLow;
Int16 varint16nameHigh;
varInt32name.ToTwoInt16(out varint16nameLow,out varint16nameHigh);