In the operating system.

Different CPUs have different sort of bytes. These sort of bytes refer to the order in which integers are stored in the memory. This is called the host order.

There are two most common

1. little endian: stores low-order bytes at the starting address

2. Big endian: stores High-Order bytes at the starting address.

 

Le little-Endian

The byte sequence that best fits people's thinking

Low-level address storage value

High address storage value

This is the byte sequence that best fits people's thinking, because it is from the perspective of human first.

If the low value is small, it should be placed where the memory address is small, that is, the low value of the memory address.

Otherwise, the high value should be placed in the place where the memory address is large, that is, the memory address is high.

 

Be big-Endian

The most intuitive byte order

High level of the low-level address storage value

The low storage value of the high address

Why is it intuitive? Do not consider mappings.

Write the memory address from left to right in ascending order.

Write the value in the order of high to low.

By contrast, one byte and one byte are filled in.

 

Example: Memory dual-word 0x01020304 (DWORD) Storage Method

 

Memory Address

4000 4001 4002 4003

Le 04 03 02 01

Be 01 02 03 04

 

Example: If we write 0x1234abcd to the memory starting with 0x0000, the result is

Big-Endian little-Endian

0x0000 0x12 0xcd

0x0001 0x23 0xab

0x0002 0xab 0x34

0x0003 0xcd 0x12

X86 series CPUs are in the byte order of little-Endian.

 

The Network byte sequence is a data representation format specified in TCP/IP. It has nothing to do with the specific CPU type and operating system, this ensures that data can be correctly interpreted during transmission between different hosts. The Network byte sequence adopts the big endian sorting method.

 

The following four conversion functions are provided for BSD socket conversion:

Htons converts the unsigned short type from host to Network

Htonl converts the unsigned long type from the host sequence to the network Sequence

Ntohs converts the unsigned short type from the network sequence to the host Sequence

Ntohl converts the unsigned long type from the network sequence to the host Sequence

 

In systems using little endian, these functions convert the byte order.

In systems using the big endian type, these functions are defined as empty macros.

 

During network program development or cross-platform development, you should also ensure that only one byte sequence is used. Otherwise, different interpretations of the two parties may cause bugs.

 

Note:

1. Network and host byte Conversion Function: htons ntohs htonl ntohl (s means that short L is long H is host N is network)

2. different operating systems run on different CPUs in different bytes. See the following table.

Processor operating system byte sorting

Alpha all little endian

HP-PA nt little endian

UNIX big endian HP-PA

Intelx86 all little endian <----- x86 systems are small-end bytecode Systems

Motorola680x () All big endian

MIPs nt little endian

MIPs UNIX big endian

PowerPC nt little endian

PowerPC non-nt big endian <----- PPC system is a large-end bytecode System

RS/6000 UNIX big endian

Linux UNIX big endian

IXP1200 ARM core all little endian

 

Generally, x86 series CPUs are in the byte order of little-Endian, PowerPC is usually big endian, and some CPUs can use jumpers to set whether the CPU works in the little endian or big endian mode.
Answer:
Obviously, the solution to this problem can only store data of one byte (Char/byte type) and one integer in the same memory.
Start address: reads integer data and analyzes whether the char/byte data is at the high or low level of integer data to determine whether the CPU is working at Little
Endian or big endian mode. Get the following answer:
Typedef unsigned char byte;
Int main (INT argc, char * argv [])
{
Unsigned int num, * P;
P = & num;
Num = 0;
* (Byte *) P = 0xff;
If (num = 0xff)
{
Printf ("The endian of CPU is little \ n ");
}
Else // num = 0xff000000
{
Printf ("The endian of CPU is big \ n ");
}
Return 0;
}

To implement the same function, let's take a look at how the source code in the Linux operating system is implemented:
Static Union {char C [4]; unsigned long mylong;} endian_test = {'l ','? ','? ',' B '}};

# Define endianness (char) endian_test.mylong)
Linux Kernel authors only use a union variable and a simple macro definition to implement the same function of a large segment of code! From the above code, we can deeply understand the subtlety of Linux source code! (If endianness = 'l', the system is little endian, and 'B' indicates big endian)