当前位置：文江博客话题详情

C# 3 字节整数

发布于 2024-07-12 00:59:08 字数 217 浏览 9 评论 0原文

我正在开发一个项目，需要在字节级别处理整数。由于节省空间是首要考虑因素，因此我只需要非常小的（并且可变长度的整数）。

有没有办法可以将 int '4096' 转换为 3 个字节？或者'1053'变成2个字节？

显然我可以手动执行= (byte[0] * 256) + (byte[1])，但我想知道是否有一个更简单的选项可以将 int 转换为 x 字节并再次转换回来？

原文

分享到QQ

分享到微博

如果你对这篇内容有疑问，欢迎到本站社区发帖提问参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。

发布评论

需要登录才能够评论，你可以免费注册一个本站的账号。

最冷一天 2024-07-19 00:59:09

BitConverter.GetBytes 将为您获取字节。

BitConverter.ToInt32 将从字节中获取 32 位 int。

回复收藏 0 原文

浪推晚风 2024-07-19 00:59:09

你必须做一些位移。如果你使用十六进制，那就容易多了，因为每个数字（我的意思是每个数字，但数字是以 10 为基数的，hexgit）代表四位。

回复收藏 0 原文

玩套路吗 2024-07-19 00:59:09

您可以进行可变长度整数编码。多年前的旧方法是使用每个字节的高位来表示该整数继续到另一个字节。因此，每个字节会丢失一位，但会获得小整数。这在每个最后一个字节都很重要的持久存储中最有用。

示例：假设我们正在处理无符号整数，我们会让

int  binary
0                       00000000
1                       00000001
...  
127                     01111111
128            00000001 10000000
129            00000001 10000001
...
255            00000001 11111111
256            00000010 10000000
...
16383          01111111 11111111
16384 00000001 10000000 10000000

0-127 占用 1 个字节，128-16383 占用 2 个字节，等等...

有关更复杂的方法，请查看此页面

You could do variable length integer encoding. The old method from years ago was to use the high bit of each byte to denote that the integer continues to another byte. So you lose one bit per byte, but gain small integers. This is mostly useful in persistent storage where every last byte counts.

Example: Assume we are dealing with unsigned integers, we would have

int  binary
0                       00000000
1                       00000001
...  
127                     01111111
128            00000001 10000000
129            00000001 10000001
...
255            00000001 11111111
256            00000010 10000000
...
16383          01111111 11111111
16384 00000001 10000000 10000000

so 0-127 take 1 byte and 128-16383 takes 2 bytes, etc...

For more complex ways of doing this check out this page

回复收藏 0 原文

醉态萌生 2024-07-19 00:59:09

只是为了增加疯狂性，让我们使用旧的 C 风格联合技巧在 C# 中进行操作：

[StructLayout(LayoutKind.Explicit)]
struct OddUnion
{
    /* The 32-bit integer value */
    [FieldOffset(0)]
    public int IntegerValue;

    /* The bytes that overlap with it */
    [FieldOffset(0)]
    public byte Byte1;
    [FieldOffset(1)]
    public byte Byte2;
    [FieldOffset(2)]
    public byte Byte3;
    [FieldOffset(3)]
    public byte Byte4;
 }

然后，当您想要“转换”时，执行以下操作：

OddUnion myOddUnion;
myOddUnion.IntegerValue = 4096;
Byte secondByte = myOddUnion.Byte1;

但这实际上仅在您希望“节省”成本时才有帮助从一个字中移出一个字节。我没有查看生成的 SMIL，所以我不知道这是否比任何其他解决方案更便宜。

Just for added insanity, let's do it in C# using the old C-style union trick:

[StructLayout(LayoutKind.Explicit)]
struct OddUnion
{
    /* The 32-bit integer value */
    [FieldOffset(0)]
    public int IntegerValue;

    /* The bytes that overlap with it */
    [FieldOffset(0)]
    public byte Byte1;
    [FieldOffset(1)]
    public byte Byte2;
    [FieldOffset(2)]
    public byte Byte3;
    [FieldOffset(3)]
    public byte Byte4;
 }

And then, when you want to "convert", do this:

OddUnion myOddUnion;
myOddUnion.IntegerValue = 4096;
Byte secondByte = myOddUnion.Byte1;

But that really only helps if you're looking to "save" the cost of bit-shifting out a single byte from a word. I haven't looked at the generated SMIL, so I don't know whether this is any cheaper in comparison to any other solution.

回复收藏 0 原文

故事与诗 2024-07-19 00:59:08

你可以吗？当然。会节省空间吗？也许吧，取决于你想做多少工作。您必须了解处理器是 32 位的，这意味着它有 4 字节寄存器，因此这就是它存储和访问内容的方式。要强制使用 3 字节“int”，您必须将其保存在字节数组中，并在使用前将其从数组中提取到对齐的地址。这意味着，如果您将其存储得很短，编译器要么会将其填充（并且您将失去您认为已经创建的任何效率），要么读写速度会慢。

如果这是一个桌面应用程序，那么节省空间究竟如何成为首要考虑因素，尤其是在每个元素使用 1 个字节时？元素访问的性能损失可能会改变您对一个字节的重要性的看法。

我认为，如果 1 个字节确实很重要，那么也许，只是也许，你无论如何都使用了错误的语言。如果您首先不安装和使用 CLR，那么您将节省的字节数是这些字节的很多。

旁注：您还需要进行移位，而不是乘法（尽管编译器可能会为您实现）。

回复收藏 0 原文

~没有更多了~