大小端编译器

① c++ socket 发送字节序结构体

数据传输时，如两端无法采用统一的处理模块，比如编写语言不同(当然C++和C#其实可以使用相同的序列化/反序列化模块，比如做成DLL)。最少需考虑两点: 1.字节对齐。C++/C#编译环境通常可选，如不一致收发的数据长度将不一样。 2.字节顺序，俗称的大小端。系统内字节顺序为低位在前，高位在后，但网络发送时往往是高位在前，低位在后。 你可以发送时(C++端)按1Byte对齐，先发送结构体长度，再发送结构的整个内存数据块，接收时(C#)按ByteStream方式接收，先接收长度，再根据长度接收数据块，然后自解析数据。

② 大小端存储

在计算机系统中，存储是以字节为单位的，每个地址单元都对应着一个字节，一个字节=8bit。在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器）。对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，如何安排多个字节的存储，这就有了大端存储模式和小端存储模式。

小端：较高的有效字节存放在较高的的存储器地址，较低的有效字节存放在较低的存储器地址。

大端：较高的有效字节存放在较低的存储器地址，较低的有效字节存放在较高的存储器地址。

如果将一个16位的整数0x1234存放到一个短整型变量（short）中。这个短整型变量在内存中的存储在大小端模式由下表所示。

C语言判断大小端模式

方法一：

voidIsBigEndian()

{

    shortinta=0x1122; //十六进制，一个数值占4位charb =  *(char*)&a;//通过将short(2字节)强制类型转换成char单字节，b指向a的起始字节（低字节）

    if( b ==0x11) //低字节存的是数据的高字节数据

    {

        //是大端模式

    }

    else

    {

        //是小端模式

    }

}

方法二：

voidIsBigEndian() //原理：联合体union的存放顺序是所有成员都从低地址开始存放，而且所有成员共享存储空间

{

    uniontemp

    {

        shortint a;

        char b;

    }temp;

    temp.a=0x1234;

    if(temp.b==0x12) //低字节存的是数据的高字节数据

    {

        //是大端模式

    }

    else

    {

        //是小端模式

    }

}

参考：https://www.jianshu.com/p/152268b0ea19

③ 大端模式和小端模式

具体如下：

1、大端模式：

大端模式，是指数据的高位，保存在内存的低地址中，而数据的低位，保存在内存的高地址中，这样的存储模式类似于把数据当作字符串顺序处理。

地址由小向大增加，而数据从高位往低位放；小端模式，是指数据的高位保存在内存的高地址中，而数据的低位保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致。

在大端模式下，前16位应该这样读: e6 84 6c 4e ( 假设int占4个字节)。

记忆方法: 地址的增长顺序与值的增长顺序相反。

2、小端模式例子：

0000430: e684 6c4e 0100 1800 53ef 0100 0100 0000。

0000440: b484 6c4e 004e ed00 0000 0000 0100 0000。

在小端模式下，前16位应该这样读: 4e 6c 84 e6( 假设int占4个字节)。

记忆方法: 地址的增长顺序与值的增长顺序相同。

大小端模式：

为什么会有大小端模式之分呢？这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为 8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于 8位的处理器。

例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个如何将多个字节安排的问题。因此就导致了大端存储模式和小端存储模式。例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。

对于 大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

④ 大小端 int nTest=0x1234.若nTest在内存中起始地址为0x40000000,

对于32位int类型，int nTest=0x1234，也就是0x00001234
大端模式各个地址下的内容分别是:
0x40000000 0x00
0x40000001 0x00
0x40000002 0x12
0x40000003 0x34
小端模式各个地址下的内容分别是:
0x40000000 0x34
0x40000001 0x12
0x40000002 0x00
0x40000003 0x00

⑤ 编译器能指定大小端么

大端模式，是指数据的高字节保存在内存的低地址中，而数据的低字节保存在内存的高地址中
小端模式，是指数据的高字节保存在内存的高地址中
而数据的低字节保存在内存的低地址中
上面c是一个共用体，给共用体中的a赋值为1.然后读取b是否为1，当b为1是说明是小端模式，b为0则说明是大端模式。

⑥ 一个结构体变量在内存中是如何存储的

结构体的变量的地址存储在栈中，然后在堆中开辟控件存储真实的数据。

⑦ 为什么会有大小端模式之分呢

  这是因为在计算机系统中，我们是以字节为单位的，每个地址单元都对应着一个字节，一个字节为8bit。但是在C语言中除了8bit的char之外，还有16bit的short型，32bit的long型（要看具体的编译器），另外，对于位数大于8位的处理器，例如16位或者32位的处理器，由于寄存器宽度大于一个字节，那么必然存在着一个 如何将多个字节安排 的问题。因此就导致了 大端存储模式 和 小端存储模式 。
  例如一个16bit的short型x，在内存中的地址为0x0010，x的值为0x1122，那么0x11为高字节，0x22为低字节。对于大端模式，就将0x11放在低地址中，即0x0010中，0x22放在高地址中，即0x0011中。小端模式，刚好相反。我们常用的X86结构是小端模式，而KEIL C51则为大端模式。很多的ARM，DSP都为小端模式。有些ARM处理器还可以由硬件来选择是大端模式还是小端模式。

• Little-Endian：低位字节排放在内存的低地址端，高位字节排放在内存的高地址端。示例数字0x12 34 56 78在内存中的表示形式：
   内存 低地址 -----------------> 高地址
   0x78 | 0x56 | 0x34 | 0x12 *
   低位子节 -----------------> 高位子节*

• Big-Endian：高位字节排放在内存的低地址端，低位字节排放在内存的高地址端。示例数字0x12 34 56 78在内存中的表示形式：
   内存 低地址 -----------------> 高地址
      0x12 | 0x34 | 0x56 | 0x78
   高位子节 -----------------> 低位子节

可见，大端模式和字符串的存储模式类似。但是也有各自的特点：
• 小端模式 ：强制转换数据不需要调整字节内容，1、2、4字节的存储方式一样。
• 大端模式 ：符号位的判定固定为第一个字节，容易判断正负。

则可以通过以下方式判断机器的子节序

或者 利用联合体union成员的存放顺序都是从低地址开始的特性来做判断。

为了方便讨论，假设m_RegMW[0] = 0x3456; 在内存中为0x56、0x34。
现要将该数据发出，如果不进行数据转换直接发送，此时发送的数据为0x56,0x34。而Modbus是大端的，会将该数据解释为0x5634而非原数据0x3456，此时就会发生灾难性的错误。所以，在此之前，需要将小端数据转换成大端的，即进行高字节和低字节的交换，此时可以调用步骤五中的函数BigtoLittle16(m_RegMW[0])，之后再进行发送才可以得到正确的数据。

⑧ 大小端模式的简介

所谓的大端模式（Big-endian），是指数据的高字节，保存在内存的低地址中，而数据的低字节，保存在内存的高地址中，这样的存储模式有点儿类似于把数据当作字符串顺序处理：地址由小向大增加，而数据从高位往低位放；
例子：
0000430: e684 6c4e 0100 1800 53ef 0100 0100 0000
0000440: b484 6c4e 004e ed00 0000 0000 0100 0000
在大端模式下，前32位应该这样读: e6 84 6c 4e ( 假设int占4个字节)
记忆方法: 地址的增长顺序与值的增长顺序相同 所谓的小端模式（Little-endian），是指数据的高字节保存在内存的高地址中，而数据的低字节保存在内存的低地址中，这种存储模式将地址的高低和数据位权有效地结合起来，高地址部分权值高，低地址部分权值低，和我们的逻辑方法一致。
例子：
0000430: e684 6c4e 0100 1800 53ef 0100 0100 0000
0000440: b484 6c4e 004e ed00 0000 0000 0100 0000
在小端模式下，前32位应该这样读: 4e 6c 84 e6( 假设int占4个字节)
记忆方法: 地址的增长顺序与值的增长顺序相反 对于0x11223344 储存如下
下面这段代码可以用来测试一下你的编译器是大端模式还是小端模式：
short int x；
char x0,x1;
x=0x1122;
x0=((char*)&x)[0]; //低地址单元
x1=((char*)&x)[1]; //高地址单元
若x0=0x11,则是大端; 若x0=0x22,则是小端......
上面的程序还可以看出，数据寻址时，用的是低位字节的地址。 #definesw16(x)((short)((((short)(x)&(short)0x00ffU)<<8)|(((short)(x)&(short)0xff00U)>>8)))

⑨ C语言读写二进制文件读取 大小端，该怎么解

先看下面的代码，然后我在简短的解释一下。

#include <stdio.h>#include <stdlib.h>#include <string.h>#include <string>#define nmemb 7/****************************************************
Date types(Compiler specific) 数据类型（和编译器相关）
*****************************************************/typedef unsigned char uint8; /* Unsigned 8 bit quantity */typedef signed char int8; /* Signed 8 bit quantity */typedef unsigned short uint16; /* Unsigned 16 bit quantity */typedef signed short int16; /* Signed 16 bit quantity */typedef unsigned int uint32; /* Unsigned 32 bit quantity */typedef signed int int32; /* Signed 32 bit quantity */typedef float fp32; /* Single precision */
/* floating point */typedef double fp64; /* Double precision */
/* floating point *///int32#define BigtoLittle32(A) ((( (uint32)(A) & 0xff000000 ) >> 24) |
(( (uint32)(A) & 0x00ff0000 ) >> 8) |
(( (uint32)(A) & 0x0000ff00 ) << 8) |
(( (uint32)(A) & 0x000000ff ) << 24))//int16#define BigtoLittle16(A) (( ((uint16)(A) & 0xff00) >> 8 ) |
(( (uint16)(A) & 0x00ff ) << 8))/************************************************************
* Conversion little endian float data to big endian
* *************************************************************/float ReverseFloat(const float inFloat)
{ float retVal; char *floatToConvert = (char*) & inFloat; char *returnFloat = (char*) & retVal; // swap the bytes into a temporary buffer
returnFloat[0] = floatToConvert[3];
returnFloat[1] = floatToConvert[2];
returnFloat[2] = floatToConvert[1];
returnFloat[3] = floatToConvert[0]; return retVal;
}struct matrix
{ int row; int column;
}s[nmemb];void set_s(int j, int x, int y)
{
s[j].row = x;
s[j].column = y;
}bool is_bigendian()
{ int a = 0x1234; char b = *(char *)&a; //b == the Low address part of a
//printf("%c ", b);
if (b == 0x34) { return false;
} return true;
}int main()
{ if (is_bigendian()) { printf("BigEndian ");
} else { printf("LittleEndian ");
}

FILE *fp;
set_s(0, 1, 50);
set_s(1, 1, 80);
set_s(2, 4, 20);
set_s(3, 50, 1);
set_s(4, 80, 2);
set_s(5, 100, 3);
set_s(6, 100, 4); int ans = sizeof(struct matrix); printf("size: %d ", ans); printf("size: %d ", sizeof(s)); if ((fp = fopen("test", "wb")) == NULL) { printf("EROOR "); return 1;
} for (int j = 0; j < nmemb; ++j) { printf("row: %d column: %d ", s[j].row, s[j].column);
}
fwrite(s, sizeof(struct matrix), nmemb, fp); for (int i = 0; i < nmemb; ++i) { float *m = (float*) malloc(sizeof(float) * s[i].row * s[i].column);
bzero(m, sizeof(float) * s[i].row * s[i].column); for (int j = 0; j < s[i].row; ++j) { for (int k = 0; k < s[i].column; ++k) {
m[k + j*s[i].column] = k;
}
}
fwrite(m, sizeof(float), s[i].row * s[i].column, fp); free(m);
}

fclose(fp); printf("11 "); /*
printf("%d ", sizeof(float));
FILE *fp;
if ((fp = fopen("test", "rb")) == NULL) {
printf("EROOR ");
return 1;
}
fread(s, sizeof(struct matrix), nmemb, fp);
for (int i = 0; i < nmemb; ++i) {
printf("row: %d column: %d ", s[i].row, s[i].column);
}

for (int i = 0; i < nmemb; ++i) {
float *m = (float*) malloc(sizeof(float) * s[i].row * s[i].column);
bzero(m, sizeof(float) * s[i].row * s[i].column);
fread(m, sizeof(float), s[i].row * s[i].column, fp);
for (int j = 0; j < s[i].row; ++j) {
for (int k = 0; k < s[i].column; ++k) {
printf("%lf ", m[k + j*s[i].column]);
}
printf(" ");
}
printf(" ");
free(m);
}
fclose(fp);
*/
return 0;
}

fopen和fclose是很常见的，在这里就不做解释了。我们来看看fwrite和fread，本来以为这个很麻烦，但是用过之后发现这个二进制文件读写才是最简单的。

size_t fwrite(const void * ptr,size_t size,size_t nmemb,FILE * stream);
fwrite()用来将数据写入文件流中。
stream为已打开的文件指针
ptr 指向欲写入的数据地址
写入的字符数以参数size*nmemb来决定。
size表示写入一个nmemb的内存大小。
fwrite()会返回实际写入的nmemb数目。

size_t fread(void * ptr,size_t size,size_t nmemb,FILE * stream);
fread()用来从文件流中读取数据。
stream为已打开的文件指针
ptr 指向欲存放读取进来的数据空间
读取的字符数以参数size*nmemb来决定
size表示读取一个nmemb的内存大小。
fread()会返回实际读取到的nmemb数目，如果此值比参数nmemb 小，则代表可能读到了文件尾或有错误发生，这时必须用feof()或ferror()来决定发生什么情况。
返回实际读取到的nmemb数目。

详情参见上面的代码。

另外就是大小端的问题了。关于大小端的具体解释网上有很多，在此不作解释。参考上面写的代码，我判断了自己机器是大端还是小端，并且实现了int16，int32已经float数据类型的大小端转换，大端转小端，在使用相同的代码一次小端又变成了大端。

PS：float的大小端转化我之前一直以为写的是错的，因为好多数据转化之后输出都是0。后来发现可能是与float类型在内存中的存放有关，我们的程序是对的。

⑩ Big Endian 和 Little Endian的区别

区别是：
Big Endian可以在最小的地址里存储一系列符号中最重要符号记忆的计算机，根据递减的重要性存储的方法。
Little Endian用最小的地址储存最少的重要字节 (而用最大的地址储存最多的重要字节)
的计算机记忆力。

在ARM体系中，每个字单元包含4个字节单元或者两个半字单元。在字单元中，4个字节哪一个是高位字节，哪一个是低位字节则有两种不同的格式：big-endian和little-endian格式。在小端模式中，低位字节放在低地址，高位字节放在高地址；在大端模式中，低位字节放在高地址，高位字节放在低地址。
如果将一个32位的整数0x12345678（如用UltraEdit打开某个文件看到的第一行头四个字节是："00000000h:12 34 56 78"）存放到一个整型变量（int）中，这个整型变量(文件内容)采用大端或者小端模式在内存中的存储。
对于文件内容 0x12345678，把前面("12")的看为高端字节，后面("78")的看为低端字节，那么可以使用"高高低低"（Little Endian），"高低高低"(Big Endian)的口诀。直观的区分，如果发现内存的内容和文件的内容在顺序上以4个字节颠倒，那么他就是Little Edian。实现Big Endian和Little Endian主要是由编译器指定的，通常是在CCFLAG 加参数，如： -DENDIAN_LITTLE，设定编译为小端字节。实际中用Trace 32可以用Memory Dump查看内存内容，和写入文件比较后判断为大端还是小端。
如果将一个16位的整数0x1234存放到一个短整型变量（short）中。这个短整型变量在内存中的存储在大小端模式。

采用大小模式对数据进行存放的主要区别在于在存放的字节顺序，大端方式将高位存放在低地址，小端方式将低位存放在低地址。

那么该如何判断CPU是大端模式还是小端模式呢？
在C语言中，联合体union的存放顺序是所有成员都从低地址开始存放的。利用这一特点，可以用联合体变量判断ARM或x86环境下，存储系统是是大端还是小端模式。

具体的代码如下：
#include "stdio.h"
int main()
{
union w
{
int a; //4 bytes
char b; //1 byte
} c;
c.a=1;
if (c.b==1)
printf("It is Little_endian!/n");
else
printf("It is Big_endian!/n");
return 1;
}