15

以下类型的字节序有什么区别？

  • 字节（8b）不变的大端和小端
  • 半字 (16b) 不变的大端和小端
  • word (32b) 不变的大端和小端
  • 双字 (64b) 不变的大端和小端

还有其他类型/变体吗？

4

8 回答 8

28

字节序映射有两种方法：地址不变性和数据不变性。

地址不变性

在这种类型的映射中，字节的地址总是保持在大小之间。这具有颠倒特定数据（例如 2 或 4 字节字）的重要性顺序（从最重要到最不重要）的副作用，并因此对数据的解释。具体来说，在 little-endian 中，数据的解释对最重要的字节来说是最不重要的，而在 big-endian 中，解释是最重要的到最不重要的。在这两种情况下，访问的字节集保持不变。

例子

地址不变性（也称为字节不变性）：字节地址是恒定的，但字节意义是相反的。

Addr   Memory
       7    0
       |    |    (LE)   (BE)
       |----|
 +0    | aa |    lsb    msb
       |----|
 +1    | bb |     :      :
       |----|
 +2    | cc |     :      :
       |----|
 +3    | dd |    msb    lsb
       |----|
       |    |

At Addr=0:          Little-endian          Big-endian
Read 1 byte:              0xaa                0xaa   (preserved)
Read 2 bytes:           0xbbaa              0xaabb
Read 4 bytes:       0xddccbbaa          0xaabbccdd

数据不变性

在这种类型的映射中，为特定大小的数据保留了相对字节的重要性。因此，对于不同的数据大小，存在不同类型的数据不变字节序映射。例如，32 位字不变端映射将用于 32 的数据大小。保留特定大小数据的值的效果是，数据内字节的字节地址在大端映射和小端映射之间颠倒.

例子

32 位数据不变性（也称为字不变性）：数据是始终具有值的 32 位字，0xddccbbaa与字节顺序无关。但是，对于小于一个字的访问，字节的地址在大端和小端映射之间颠倒。

Addr                Memory

            | +3   +2   +1   +0 |  <- LE
            |-------------------|
+0      msb | dd | cc | bb | aa |  lsb
            |-------------------|
+4      msb | 99 | 88 | 77 | 66 |  lsb
            |-------------------|
     BE ->  | +0   +1   +2   +3 |


At Addr=0:             Little-endian              Big-endian
Read 1 byte:                 0xaa                    0xdd
Read 2 bytes:              0xbbaa                  0xddcc
Read 4 bytes:          0xddccbbaa              0xddccbbaa   (preserved)
Read 8 bytes:  0x99887766ddccbbaa      0x99887766ddccbbaa   (preserved)

例子

16 位数据不变性（也称为半字不变性）：数据是一个 16 位，始终具有值0xbbaa，与字节顺序无关。但是，对于小于半字的访问，字节的地址在大端和小端映射之间颠倒。

Addr           Memory

            | +1   +0 |  <- LE
            |---------|
+0      msb | bb | aa |  lsb
            |---------|
+2      msb | dd | cc |  lsb
            |---------|
+4      msb | 77 | 66 |  lsb
            |---------|
+6      msb | 99 | 88 |  lsb
            |---------|
     BE ->  | +0   +1 |


At Addr=0:             Little-endian              Big-endian
Read 1 byte:                 0xaa                    0xbb
Read 2 bytes:              0xbbaa                  0xbbaa   (preserved)
Read 4 bytes:          0xddccbbaa              0xddccbbaa   (preserved)
Read 8 bytes:  0x99887766ddccbbaa      0x99887766ddccbbaa   (preserved)

例子

64 位数据不变性（也称为双字不变性）：数据是始终具有值的 64 位字，0x99887766ddccbbaa与字节顺序无关。但是，对于小于双字的访问，字节的地址在大端和小端映射之间颠倒。

Addr                         Memory

            | +7   +6   +5   +4   +3   +2   +1   +0 |  <- LE
            |---------------------------------------|
+0      msb | 99 | 88 | 77 | 66 | dd | cc | bb | aa |  lsb
            |---------------------------------------|
     BE ->  | +0   +1   +2   +3   +4   +5   +6   +7 |


At Addr=0:             Little-endian              Big-endian
Read 1 byte:                 0xaa                    0x99
Read 2 bytes:              0xbbaa                  0x9988
Read 4 bytes:          0xddccbbaa              0x99887766
Read 8 bytes:  0x99887766ddccbbaa      0x99887766ddccbbaa   (preserved)
于 2008-09-14T23:46:37.037 回答
4

菲利贝尔说，

位实际上是倒置的

我怀疑任何架构都会破坏字节值不变性。在将包含它们的结构映射到数据时，可能需要反转位域的顺序。这种直接映射依赖于 C99 标准之外但可能仍然很常见的编译器细节。直接映射速度更快，但不符合没有规定打包、对齐和字节顺序的 C99 标准。符合 C99 的代码应该使用基于值而不是地址的慢速映射。也就是说，而不是这样做，

#if LITTLE_ENDIAN
  struct breakdown_t {
    int least_significant_bit: 1;
    int middle_bits: 10;
    int most_significant_bits: 21;
  };
#elif BIG_ENDIAN
  struct breakdown_t {
    int most_significant_bits: 21;
    int middle_bits: 10;
    int least_significant_bit: 1;
  };
#else
  #error Huh
#endif

uint32_t data = ...;
struct breakdown_t *b = (struct breakdown_t *)&data;

应该写这个（这就是编译器无论如何都会生成代码的方式，即使是上面的“直接映射”），

uint32_t data = ...;
uint32_t least_significant_bit = data & 0x00000001;
uint32_t middle_bits = (data >> 1) & 0x000003FF;
uint32_t most_significant_bits = (data >> 11) & 0x001fffff;

需要在每个字节序中性、特定于应用程序的数据存储单元中反转位字段顺序的原因是编译器将位字段打包成增长地址的字节。

每个字节中的“位顺序”并不重要，因为提取它们的唯一方法是应用值掩码并转移到最低有效位或最高有效位方向。“位顺序”问题只会在具有位地址概念的虚构架构中变得重要。我相信所有现有的架构都在硬件中隐藏了这个概念，并且只提供了最低与最高有效位提取，这是基于字节序中性字节值的概念。

于 2010-08-27T04:29:59.587 回答
3

还有中端或混合端。有关详细信息，请参阅维基百科。

我唯一需要担心的是在用 C 编写一些网络代码时。网络通常使用大端 IIRC。大多数语言要么抽象整个事物，要么提供库来保证您使用正确的字节序。

于 2008-08-21T23:57:39.673 回答
1

我读到的关于字节序的最佳文章“理解大字节序和小字节序”。

于 2008-08-22T01:57:42.600 回答
1

实际上，我将机器的字节顺序描述为单词中字节的顺序，而不是位的顺序。

上面的“字节”是指“体系结构可以单独管理的最小内存单元”。因此，如果最小单元是 16 位长（在 x86 中称为word），那么表示值 0xFFFF0000 的 32 位“word”可以这样存储：

FFFF 0000

或这个：

0000 FFFF

在内存中，取决于字节顺序。

因此，如果您有 8 位字节序，则意味着每个由 16 位组成的单词将存储为：

FF 00

或者：

00 FF

等等。

于 2008-08-22T00:39:51.520 回答
0

13 年前，我开发了一种可移植到 DEC ALPHA 系统和 PC 的工具。在这个 DEC ALPHA 上，位实际上是反转的。那是：

1010 0011

实际上翻译成

1100 0101

它在 C 代码中几乎是透明和无缝的，除了我声明了一个位域

typedef struct {
   int firstbit:1;
   int middlebits:10;
   int lastbits:21;
};

需要翻译的内容（使用#ifdef 条件编译）

typedef struct {
   int lastbits:21;
   int middlebits:10;
   int firstbit:1;
};
于 2008-09-16T03:27:04.627 回答
0

实际上，字节序是指处理器解释给定内存位置内容的方式。例如，如果我们的内存位置 0x100 具有以下内容（十六进制字节）


  0x100:  12 34 56 78 90 ab cd ef

Reads    Little Endian            Big Endian
 8-bit:  12                        12
16-bit:  34 12                     12 34
32-bit:  78 56 34 12               12 34 56 78
64-bit:  ef cd ab 90 78 56 34 12   12 34 56 78 90 ab cd ef

您需要注意字节顺序的两种情况是使用网络代码以及使用指针进行向下转换。

TCP/IP 指定线路上的数据应该是大端。如果您传输字节数组以外的类型（如指向结构的指针），您应该确保使用 ntoh/hton 宏来确保数据以大端方式发送。如果从 little-endian 处理器发送到 big-endian 处理器（反之亦然），数据会出现乱码...

选角问题：


 uint32_t* lptr = 0x100;
 uint16_t  data;
 *lptr = 0x0000FFFF

 data = *((uint16_t*)lptr);

数据的价值是什么？在大端系统上，它将是 0 在小端系统上，它将是 FFFF

于 2008-09-16T01:53:37.173 回答
-1

基本概念是位的顺序：

1010 0011

在 little-endian 中是一样的

0011 1010

在大端（反之亦然）。

您会注意到按分组而不是按单个位更改的顺序。我不知道一个系统，例如，在哪里

1100 0101

将是第一个版本的“other-endian”版本。

于 2008-08-21T23:49:01.923 回答