Chinaunix首页 | 论坛 | 博客

抱朴守拙ww2.blog.chinaunix.net

首页　| 　博文目录　| 　关于我

多大点儿事儿

  • 博客访问： 161895
  • 博文数量： 76
  • 博客积分： 1513
  • 博客等级： 上尉
  • 技术积分： 755
  • 用 户 组： 普通用户
  • 注册时间： 2011-11-25 15:15
文章分类

全部博文（76）

文章存档

2012年（2）

2011年（74）

我的朋友
最近访客
推荐博文
相关博文
一个完整的测试ENDIAN的代码

分类： C/C++

2011-11-25 20:10:10

  1. #ifndef ENDIAN_HPP

  3. #define ENDIAN_HPP

  5.   

  7. #include <sys/types.h>

  9. #include <stdint.h>

  11. #ifdef __linux__

  13. #include <stdint.h>

  15. #endif

  17.  

  19. class EndianIOBase

  21. {

  23.   public:
  24.   

  26. // ----(abstract virtual methods)----
  27.  
  28.     virtual uint16_t read16( uint8_t * p )= 0;

  30.     virtual uint32_t read32( uint8_t * p )= 0;

  32.     virtual uint64_t read64( uint8_t * p )= 0;

  34.     virtual void write16( uint8_t * p, uint16_t w )= 0;

  36.     virtual void write32( uint8_t * p, uint32_t w )= 0;

  38.     virtual void write64( uint8_t * p, uint64_t w )= 0;

  40.  

  42.     // declare special methods for data we know is byte-aligned

  44.     virtual uint16_t read16a( uint8_t * p )= 0;

  46.     virtual uint16_t read16a( uint16_t * p )= 0;

  48.     virtual uint32_t read32a( uint8_t * p )= 0;

  50.     virtual uint32_t read32a( uint32_t * p )= 0;

  52.     virtual uint64_t read64a( uint8_t * p )= 0;

  54.     virtual uint64_t read64a( uint64_t * p )= 0;

  56.     virtual void write16a( uint8_t * p, uint16_t w )= 0;

  58.     virtual void write16a( uint16_t * p, uint16_t w )= 0;

  60.     virtual void write32a( uint8_t * p, uint32_t w )= 0;

  62.     virtual void write32a( uint32_t * p, uint32_t w )= 0;

  64.     virtual void write64a( uint8_t * p, uint64_t w )= 0;

  66.     virtual void write64a( uint64_t * p, uint64_t w )= 0;

  68.     

  70. // ----(common 16-bit i/o operations )----
  71.   
  72.     uint16_t read16( uint16_t * p )

  74.     {

  76.       return read16( reinterpret_cast < uint8_t * >( p ) );

  78.     }

  80.     

  82.     uint16_t read16( uint16_t p )

  84.     {

  86.       return read16( &p );

  88.     }

  90.     

  92.     uint16_t read16( char *p )

  94.     {

  96.       return read16( reinterpret_cast < uint8_t * >( p ) );

  98.     }

  100.     

  102.     void write16( uint16_t * p, uint16_t w )

  104.     {

  106.       write16( reinterpret_cast < uint8_t * >( p ), w );

  108.     }

  110.     

  112.     uint16_t write16( uint16_t w )

  114.     {

  116.       uint16_t w16;

  118.       

  120.       write16( &w16, w );

  122.       return w16;

  124.     }

  126.     

  128. // ----(common 32-bit i/o operations)----
  129.   
  130.     uint32_t read32( uint32_t * p )

  132.     {

  134.       return read32( reinterpret_cast < uint8_t * >( p ) );

  136.     }

  138.     

  140.     uint32_t read32( char *p )

  142.     {

  144.       return read32( reinterpret_cast < uint8_t * >( p ) );

  146.     }

  148.     

  150.     uint32_t read32( uint32_t p )

  152.     {

  154.       return read32( &p );

  156.     }

  158.     

  160.     void write32( uint32_t * p, uint32_t w )

  162.     {

  164.       write32( reinterpret_cast < uint8_t * >( p ), w );

  166.     }

  168.     

  170.     uint32_t write32( uint32_t w )

  172.     {

  174.       uint32_t w32;

  176.       

  178.       write32( &w32, w );

  180.       return w32;

  182.     }

  184.     

  186. // ----(common 64-bit i/o operations)----

  188.     uint64_t read64( uint64_t * p )

  190.     {

  192.       return read64( reinterpret_cast < uint8_t * >( p ) );

  194.     }

  196.     

  198.     uint64_t read64( char *p )

  200.     {

  202.       return read64( reinterpret_cast < uint8_t * >( p ) );

  204.     }

  206.     

  208.     uint64_t read64( uint64_t p )

  210.     {

  212.       return read64( &p );

  214.     }

  216.     

  218.     void write64( uint64_t * p, uint64_t w )

  220.     {

  222.       write64( reinterpret_cast < uint8_t * >( p ), w );

  224.     }

  226.     

  228.     uint64_t write64( uint64_t w )

  230.     {

  232.       uint64_t w64;
  233.   
  234.       write64( &w64, w );

  236.       return w64;

  238.     }

  240. };

  242.  

  244. #ifdef __sgi

  246.   // our sgi boxes are not fast enough (and the optimizer is not smart enough)

  248.   // so we need to do the i/o the old way.

  250.   class BigEndianIO: public EndianIOBase

  252.   {

  254.     public:

  256.     virtual uint16_t read16( uint8_t * p ) { uint16_t w; memcpy( &w, p, 2); return w; };

  258.     virtual uint16_t read16a( uint8_t * p ) { return *(uint16_t*)p; };

  260.     virtual uint16_t read16a( uint16_t * p ) { return *p; };

  262.     virtual uint32_t read32( uint8_t * p ) { uint32_t w; memcpy( &w, p, 4); return w; };

  264.     virtual uint32_t read32a( uint8_t * p ) { return *(uint32_t*)p; };

  266.     virtual uint32_t read32a( uint32_t * p ) { return *p; };

  268.     virtual uint64_t read64( uint8_t * p ) { uint64_t w; memcpy( &w, p, 8); return w; };

  270.     virtual uint64_t read64a( uint8_t * p ) { return *(uint64_t*)p; };

  272.     virtual uint64_t read64a( uint64_t * p ) { return *p; };

  274.     virtual void write16( uint8_t * p, uint16_t w ) { memcpy( p, &w, 2); };

  276.     virtual void write16a( uint8_t * p, uint16_t w ) { *(uint16_t*)p = w; };

  278.     virtual void write16a( uint16_t * p, uint16_t w ) { *p = w; };

  280.     virtual void write32( uint8_t * p, uint32_t w ) { memcpy( p, &w, 4); };

  282.     virtual void write32a( uint8_t * p, uint32_t w ) { *(uint32_t*)p = w; };

  284.     virtual void write32a( uint32_t * p, uint32_t w ) { *p = w; };

  286.     virtual void write64( uint8_t * p, uint64_t w ) { memcpy( p, &w, 8); };

  288.     virtual void write64a( uint8_t * p, uint64_t w ) { *(uint64_t*)p = w; };

  290.     virtual void write64a( uint64_t * p, uint64_t w ) { *p = w; };

  292.   };

  294.  

  296. #else

  298.  

  300.   class BigEndianIO: public EndianIOBase

  302.   {

  304.     public:

  306. // ----(16-bit read operation)----

  308.       virtual uint16_t read16( uint8_t * p )

  310.     {

  312.       uint16_t w;

  314.       uint16_t hi, lo;

  316.       

  318.       // read the high byte, then the low byte

  320.       hi = *p;

  322.       lo = *( p + 1 );

  324.       w = hi << 8 | lo;

  326.       return w;

  328.     }

  330.     

  332. // ----(32-bit read operation)----

  334.     virtual uint32_t read32( uint8_t * p )

  336.     {

  338.       uint32_t w;

  340.       uint32_t hi, lo;

  342.       // read the high half, then the low half

  344.       hi = read16( p );

  346.       lo = read16( p + 2 );

  348.       w = hi << 16 | lo;

  350.       return w;

  352.     }

  354.     

  356. // ----(64-bit read operation)----

  358.     virtual uint64_t read64( uint8_t * p )

  360.     {

  362.       uint64_t w;

  364.       uint64_t hi, lo;

  366.       // read the high half, then the low half

  368.       hi = read32( p );

  370.       lo = read32( p + 4 );

  372.       w = hi << 32 | lo;

  374.       return w;

  376.     }

  378.     

  380. // ----(16-bit write operation)----

  382.     virtual void write16( uint8_t * p, uint16_t w )

  384.     {

  386.       uint8_t hi, lo;

  388.       hi =( w >> 8 )& 0xff;

  390.       lo = w & 0xff;

  392.       // write the high byte, then the low byte

  394.       *p = hi;

  396.       *( p + 1 )= lo;

  398.     }

  400.     

  402. // ----(32-bit write operation)----

  404.     virtual void write32( uint8_t * p, uint32_t w )

  406.     {

  408.       uint16_t hi, lo;

  410.       

  412.       hi =( w >> 16 )& 0xffff;

  414.       lo = w & 0xffff;

  416.       // write the high half, then the low half

  418.       write16( p, hi );

  420.       write16( ( p + 2 ), lo );

  422.     }

  424.     

  426. // ----(64-bit write operation)----

  428.  

  430.     virtual void write64( uint8_t * p, uint64_t w )

  432.     {

  434.       uint32_t hi, lo;

  436.       hi =( w >> 32 )& 0xffffffff;

  438.       lo = w & 0xffffffff;

  440.       // write the high half, then the low half

  442.       write32( p, hi );

  444.       write32( ( p + 4 ), lo );

  446.     }

  448.  

  450.     virtual uint16_t read16a( uint8_t * p ) { return read16( p ); };

  452.     virtual uint16_t read16a( uint16_t * p ) { return read16( (uint8_t*)p ); };

  454.     virtual uint32_t read32a( uint8_t * p ) { return read32( p ); };

  456.     virtual uint32_t read32a( uint32_t * p ) { return read32( (uint8_t*)p ); };

  458.     virtual uint64_t read64a( uint8_t * p ) { return read64( p ); };

  460.     virtual uint64_t read64a( uint64_t * p ) { return read64( (uint8_t*)p ); };

  462.     virtual void write16a( uint8_t * p, uint16_t w ) { write16( p, w ); };

  464.     virtual void write16a( uint16_t * p, uint16_t w ) { write16( (uint8_t*)p, w ); };

  466.     virtual void write32a( uint8_t * p, uint32_t w ) { write32( p, w ); };

  468.     virtual void write32a( uint32_t * p, uint32_t w ) { write32( (uint8_t*)p, w ); };

  470.     virtual void write64a( uint8_t * p, uint64_t w ) { write64( p, w ); };

  472.     virtual void write64a( uint64_t * p, uint64_t w ) { write64( (uint8_t*)p, w ); };

  474.   };

  476.  

  478. #endif


  481. class LittleEndianIO: public EndianIOBase

  483. {

  485.   public:

  487.     virtual uint16_t read16( uint8_t * p )

  489.     {

  491.       uint16_t w;

  493.       uint16_t hi, lo;

  495.       lo = *p;

  497.       hi = *( p + 1 );

  499.       w = hi << 8 | lo;

  501.       return w;

  503.     }

  505.     

  507.     virtual uint32_t read32( uint8_t * p )

  509.     {

  511.       uint32_t w;

  513.       uint32_t hi,

  515.       lo;

  517.       lo = read16( p );

  519.       hi = read16( p + 2 );

  521.       w = hi << 16 | lo;

  523.       return w;

  525.     }

  527.     

  529.     virtual uint64_t read64( uint8_t * p )

  531.     {

  533.       uint64_t w;

  535.       uint64_t hi,

  537.       lo;

  539.       lo = read32( p );

  541.       hi = read32( p + 4 );

  543.       w = hi << 32 | lo;

  545.       return w;

  547.     }

  549.     

  551.     virtual void write16( uint8_t * p, uint16_t w )

  553.     {

  555.       uint8_t hi,

  557.       lo;

  559.       hi =( w >> 8 )& 0xff;

  561.       lo = w & 0xff;

  563.       *p = lo;

  565.       *( p + 1 )= hi;

  567.     }

  569.     

  571.     virtual void write32( uint8_t * p, uint32_t w )

  573.     {

  575.       uint16_t hi,

  577.       lo;

  579.       hi =( w >> 16 )& 0xffff;

  581.       lo = w & 0xffff;

  583.       write16( p, lo );

  585.       write16( ( p + 2 ), hi );

  587.     }

  589.     

  591.     virtual void write64( uint8_t * p, uint64_t w )

  593.     {

  595.       uint32_t hi,

  597.       lo;

  599.       hi =( w >> 32 )& 0xffffffff;

  601.       lo = w & 0xffffffff;

  603.       write32( p, lo );

  605.       write32( ( p + 4 ), hi );

  607.     }

  609.     

  611.     // declare special methods for data we know is byte-aligned

  613.     virtual uint16_t read16a( uint8_t * p ) { return read16( p ); };

  615.     virtual uint16_t read16a( uint16_t * p ) { return read16( (uint8_t*)p ); };

  617.     virtual uint32_t read32a( uint8_t * p ) { return read32( p ); };

  619.     virtual uint32_t read32a( uint32_t * p ) { return read32( (uint8_t*)p ); };

  621.     virtual uint64_t read64a( uint8_t * p ) { return read64( p ); };

  623.     virtual uint64_t read64a( uint64_t * p ) { return read64( (uint8_t*)p ); };

  625.     virtual void write16a( uint8_t * p, uint16_t w ) { write16( p, w ); };

  627.     virtual void write16a( uint16_t * p, uint16_t w ) { write16( (uint8_t*)p, w ); };

  629.     virtual void write32a( uint8_t * p, uint32_t w ) { write32( p, w ); };

  631.     virtual void write32a( uint32_t * p, uint32_t w ) { write32( (uint8_t*)p, w ); };

  633.     virtual void write64a( uint8_t * p, uint64_t w ) { write64( p, w ); };

  635.     virtual void write64a( uint64_t * p, uint64_t w ) { write64( (uint8_t*)p, w ); };

  637. };

  639.  

  641. static EndianIOBase *BigEndian = new BigEndianIO( );

  643. static EndianIOBase *LittleEndian = new LittleEndianIO( );

  645.  

  647. #endif // ENDIAN_HPP
下面是main.cpp函数：
  1. #include "Endian.hpp"

  3. #include <stdint.h>

  5.  

  7. #include <stdio.h>

  9. #include <string.h>

  11.  

  13. int main( int argc, char *argv[] )

  15. {

  17.   uint8_t x[] = { 0x01, 0x23, 0x45, 0x67, 0x89, 0xab, 0xcd, 0xef };

  19.   uint8_t z[sizeof( x )];

  21.   uint16_t w16;

  23.   uint32_t w32;

  25.   uint64_t w64;

  27.   

  29.   uint16_t be16 = BigEndian->read16( x );

  31.   uint32_t be32 = BigEndian->read32( x );

  33.   uint64_t be64 = BigEndian->read64( x );

  35.   

  37.   printf( "be16 =%04x\n", be16 );

  39.   printf( "be32 =%08x\n", be32 );

  41.   printf( "be64 =%016llx\n", be64 );

  43.   

  45.   memset( z, 0, sizeof( z ) );

  47.   BigEndian->write16( z, be16 );

  49.   w16 = BigEndian->write16( be16 );

  51.   printf( "z = %02x %02x w16=%04x\n", z[0], z[1], w16 );

  53.   

  55.   memset( z, 0, sizeof( z ) );

  57.   BigEndian->write32( z, be32 );

  59.   w32 = BigEndian->write32( be32 );

  61.   printf( "z = %02x %02x %02x %02x w32=%08x\n", z[0], z[1], z[2], z[3], w32 );

  63.   

  65.   memset( z, 0, sizeof( z ) );

  67.   BigEndian->write64( z, be64 );

  69.   w64 = BigEndian->write64( be64 );

  71.   printf( "z = %02x %02x %02x %02x %02x %02x %02x %02x w64=%016llx\n", z[0],

  73.           z[1], z[2], z[3], z[4], z[5], z[6], z[7], w64 );

  75.           

  77.   uint16_t le16 = LittleEndian->read16( x );

  79.   uint32_t le32 = LittleEndian->read32( x );

  81.   uint64_t le64 = LittleEndian->read64( x );

  83.   

  85.   printf( "le16 =%04x\n", le16 );

  87.   printf( "le32 =%08x\n", le32 );

  89.   printf( "le64 =%016llx\n", le64 );

  91.   

  93.   memset( z, 0, sizeof( z ) );

  95.   LittleEndian->write16( z, le16 );

  97.   w16 = BigEndian->write16( be16 );

  99.   printf( "z = %02x %02x w16=%04x\n", z[0], z[1], w16 );

  101.   

  103.   memset( z, 0, sizeof( z ) );

  105.   LittleEndian->write32( z, le32 );

  107.   w32 = BigEndian->write32( be32 );

  109.   printf( "z = %02x %02x %02x %02x w32=%08x\n", z[0], z[1], z[2], z[3], w32 );

  111.   

  113.   memset( z, 0, sizeof( z ) );

  115.   LittleEndian->write64( z, le64 );

  117.   w64 = BigEndian->write64( be64 );

  119.   printf( "z = %02x %02x %02x %02x %02x %02x %02x %02x w64=%016llx\n", z[0],

  121.           z[1], z[2], z[3], z[4], z[5], z[6], z[7], w64 );

  123.           

  125.   return 0;

  127. }


Output：

be16 =0123

be32 =01234567

be64 =0123456789abcdef

z = 01 23 w16=2301

z = 01 23 45 67 w32=67452301

z = 01 23 45 67 89 ab cd ef w64=efcdab8967452301

le16 =2301

le32 =67452301

le64 =efcdab8967452301

z = 01 23 w16=2301

z = 01 23 45 67 w32=67452301

z = 01 23 45 67 89 ab cd ef w64=efcdab8967452301

阅读(588) | 评论(0) | 转发(0) |
0

上一篇：warning: deprecated conversion from string constant to "char *"

下一篇：double类型数据的文件读写

给主人留下些什么吧！~~
关于我们 | 关于IT168 | 联系方式 | 广告合作 | 法律声明 | 免费注册

Copyright 2001-2010 ChinaUnix.net All Rights Reserved 北京皓辰网域网络信息技术有限公司. 版权所有

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6