计算机内存对数据的存储顺序？

For program objects that span multiple bytes, we must establish two
conventions: what will be the address of the object, and how will we
order the bytes in memory. In virtually all machines, a multibyte object
is stored as a contiguous sequence of bytes, with the address of the
object given by the smallest address of the bytes used. For example,
suppose a variable x of type int has address 0x100, that is, the value
of the address expression &x is 0x100. Then the four bytes of x would
be stored in memory locations 0x100, 0x101, 0x102, and 0x103.

For ordering the bytes representing an object, there are two common
conventions. Consider a w-bit integer having a bit representation
[x_w-1,x_w-2,......,x₁,x₀], where x_w-1 is the most significant bit, and x₀ is
the least. Assuming w is a multiple of eight, these bits can be grouped
as bytes, with the most significant byte having bits [x_w-1,x_w-2,......,x_w-8],
the least significant byte having bits [x₇, x₆,......,x₀], and the other bytes
having bits from the middle. Some machines choose to store the object
in memory ordered from least significant byte to most, while other machines
store them from most to least. The former convention—where the least
significant byte comes first—is referred to as little endian. This convention
is followed by most machines from the former Digital Equipment Corporation
(now part of Compaq Corporation), as well as by Intel. The latter convention
—where the most significant byte comes first—is referred to as big endian.
This convention is followed by most machines from IBM, Motorola, and
Sun Microsystems. Note that we said “most.” The conventions do not
split precisely along corporate boundaries. For example, personal computers
manufactured by IBM use Intel-compatible processors and hence are little
endian. Many microprocessor chips, including Alpha and the PowerPC by
Motorola can be run in either mode, with the byte ordering convention
determined when the chip is powered up.

Continuing our earlier example, suppose the variable x of type int and
at address 0x100 has a hexadecimal value of 0x01234567. The ordering
of the bytes within the address range 0x100 through 0x103 depends on
the type of machine:

Big endian
0x100 0x101 0x102 0x103
01 23 45 67
Little endian
0x100 0x101 0x102 0x103
67 45 23 01

Note that in the word 0x01234567 the high-order byte has hexadecimal
value 0x01, while the low-order byte has value 0x67.

People get surprisingly emotional about which byte ordering is the proper
one. In fact, the terms “little endian” and “big endian” come from the
book Gulliver’s Travels by Jonathan Swift, where two warring factions could
not agree by which end a soft-boiled egg should be opened—the little end
or the big. Just like the egg issue, there is no technological reason to choose
one byte ordering convention over the other, and hence the arguments
degenerate into bickering about sociopolitical issues. As long as one of
the conventions is selected and adhered to consistently, the choice is arbitrary.

For most application programmers, the byte orderings used by their machines
are totally invisible. Programs compiled for either class of machine give identical
results. At times, however, byte ordering becomes an issue. The first is when
binary data is communicated over a network between different machines.
A common problem is for data produced by a little-endian machine to be sent
to a big-endian machine, or vice-versa, leading to the bytes within the words
being in reverse order for the receiving program. To avoid such problems,
code written for networking applications must follow established conventions
for byte ordering to make sure the sending machine converts its internal
representation to the network standard, while the receiving machine converts
the network standard to its internal representation.

能看懂,翻不出来.

[此贴子已经被作者于2006-3-4 16:27:11编辑过]