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

  • byte(8b)不变的大和小的字节序
  • 半字(16b)不变的大和小的字节序
  • 字(32b)不变的大和小的字节序
  • 双字(64b)不变的大和小的字节序

还有其他类型/变化吗?

===============>>#1 票数:25

端点映射有两种方法: 地址不变性数据不变性

地址不变性

在这种类型的映射中,字节地址总是保持在大和小之间。 这具有反转特定数据(例如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)

===============>>#2 票数:3

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

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

===============>>#3 票数:3

菲利贝尔说,

比特实际上是倒置的

我怀疑任何架构都会破坏字节值的不变性。 当根据数据映射包含它们的结构时,位字段的顺序可能需要反转。 这种直接映射依赖于编译器细节,这些编译器细节不在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;

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

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

===============>>#4 票数:1

实际上,我将机器的字节序描述为内的字节顺序,而不是的顺序。

在那里,“字节”是指“架构可以单独管理的最小内存单元”。 因此,如果最小单位是16位长(在x86中称为 ),那么表示值0xFFFF0000的32位“字”可以像这样存储:

FFFF 0000

或这个:

0000 FFFF

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

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

FF 00

要么:

00 FF

等等。

===============>>#5 票数:1

我读到的关于字节序“ 理解Big和Little Endian字节顺序 ”的最佳文章。

===============>>#6 票数:0

实际上,endianess指的是处理器解释给定内存位置内容的方式。 例如,如果我们的内存位置为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宏来确保数据以big endian形式发送。 如果您从小端处理器发送到大端处理器(反之亦然),数据将出现乱码...

铸造问题:


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

 data = *((uint16_t*)lptr);

数据的价值是什么? 在大端系统上,它将为0在小端系统上,它将是FFFF

===============>>#7 票数: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;
};

===============>>#8 票数:-1

比特的基本概念是:

1010 0011

在little-endian中是一样的

0011 1010

在big-endian(反之亦然)。

您会注意到订单的分组更改,而不是单个位。 我不知道系统,例如,在哪里

1100 0101

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

  ask by Ben Lever translate from so

未解决问题?本站智能推荐: