大端小端

基于skynet 手动写个读流写流的模块.

顺便阅读了这里面大端小端的部分的写法. 感觉比普通博文看的更清晰明了

这里直接贴个代码.

 1 // 小端 高字节 高地址 高高                                                          
 2 // 大端 高字节 低地址 高低                                                          
 3 /* 0x11223344                                                                       
 4  * 小端  大端                                                                       
 5  * 3 11  44                                                                         
 6  * 2 22  33                                                                         
 7  * 1 33  22                                                                         
 8  * 0 44  11                                                                         
 9  */ 
10 #include                                                               
11 #include <string.h>                                                              
12 #include                                                               
13 using namespace std;                                                             
14                                                                                  
15 static inline                                                                    
16 int32_t loadInt32(int8_t *b) {                                                   
17   const int8_t *p = b;                                                           
18   int32_t v = p[0] | p[1]<<8 | p[2]<<16 | p[3]<<24;                                 
19   return v;                                                                         
20 }                                                                                   
21                                                                                     
22 static void                                                                         
23 big_uint32(uint8_t * buf, uint32_t n) {                                             
24   buf[3] = n & 0xff;                                                                
25   buf[2] = (n >> 8) & 0xff;                                                         
26   buf[1] = (n >> 16) & 0xff;                                                        
27   buf[0] = (n >> 24) & 0xff;                                                        
28 }                                                                                   
29                                                                                     
30 int checkEndian()                                                                   
31 {                                                                                   
32   uint32_t a = 0x11223344;                                                          
33   union {                                                                           
34     uint32_t v;                                                                     
35     uint8_t b[4];                                                                   
36   }u;                                                                               
37   u.v = a;                                                                          
38                                                                                     
39   printf("init val: 0x%x load32:0x%x\n", a, loadInt32((int8_t*)u.b));               
40   int i;                                                                            
41   for (i=3; i >=0; --i) {                                                           
42     printf("u.b[%d] 0x%x\n", i, u.b[i]);                                            
43   }                                                                                 
44                                                                                     
45   uint8_t big[4] = {0};                                                             
46   big_uint32(big, a);                                                               
47   uint32_t *pBig = (uint32_t*)big;                                                  
48   uint32_t uv = *pBig;                                                              
49   printf("big 0x%x loadInt32:0x%x\n", uv, loadInt32((int8_t*)big));                 
50   for (i=3; i >=0; --i) {                                                           
51     printf("big[%d] 0x%x\n", i, big[i]);                                            
52   }        
53                                                                                  
54                                                                                  
55   int t = 1;                                                                     
56   char *p = (char *)&t;                                                          
57   puts(*p == 1? "little-endian" : "big-endian");;                                
58   return (*p == 1);                                                              
59                                                                                  
60 }                                                                                
61 int main() {                                                                     
62   checkEndian();                                                                 
63   return 0;                                                                      
64 }  

 

转载于:https://www.cnblogs.com/sftxlin/p/9416441.html