long和DWORD的一个压缩算法

 

 #ifndef __JONES__COMPRESS__
#define  __JONES__COMPRESS__

/**/ //
//  Compress and decompress (long/DWORD)
//  by jones 06.8.17
/**/ /

namespace  COMPRESS
... {
 template<typename Type> DWORD MapDataToBuf(const Type& ,LPSTR lpBuf); //compress data template
 template<typename Type> DWORD MapBufToData(Type&,LPCSTR lpBuf); //decompress data template

 /**//*******************************************************************/
 typedef struct tagMapData //带符号数
 ...{
  BYTE bFlag:1; //0:正数;1:负数
  BYTE bNext:1; //0:本字节结束;1:需要继续拼装下一字节
  BYTE bData:6; //数值存放(2^6 [0-63])
 }MAP_DATA,*PMAP_DATA;

 typedef struct tagMapUnsignedData //不带符号数
 ...{
  BYTE bNext:1; //0:本字节结束;1:需要继续拼装下一字节
  BYTE bData:7; //数值存放 (2^7 [0-127])
 }MAP_UN_DATA,*PMAP_UN_DATA;

 /**//****************************************************************
 /    long data compress and decompress
 ****************************************************************/
 //X+X1*64+X2*64*128+X3*64*128*128.........
 template<> DWORD MapDataToBuf<long> (const long& lData,LPSTR lpBuf)
 ...{
  long lValue=lData;
  PMAP_DATA pData=(PMAP_DATA)(lpBuf);
  if (lValue<0) //判断正负
  ...{
   pData->bFlag=1;
   lValue=-lValue;
  }

  if (lValue<64)
  ...{
   pData->bData=lValue;
   return (1);
  }

  pData->bNext=1;
  pData->bData=lValue%64;
  lValue /= 64;
  PMAP_UN_DATA pUnData=(PMAP_UN_DATA)(lpBuf+1);
  DWORD i=0;
  for(;i<4;++i)
  ...{
   if (lValue<128)
   ...{
    pUnData[i].bData=lValue;
    break;
   }
   pUnData[i].bNext=1;
   pUnData[i].bData=lValue%128;
   lValue/=128;
  }
  return (i+2);
 }

 template<> DWORD MapBufToData<long> (long& lData,LPCSTR lpBuf)
 ...{
  PMAP_DATA pData=(PMAP_DATA)lpBuf;
  lData=pData->bData;
  DWORD dwByte=1;
  if (pData->bNext)
  ...{
   PMAP_UN_DATA pUnData=(PMAP_UN_DATA)(lpBuf+1);
   for(DWORD i=0,dwSeed=64;i<4;++i,++dwByte, dwSeed*=128L)
   ...{
    lData += pUnData[i].bData*dwSeed;
    if (!pUnData[i].bNext) break;
   }
  }
  if (pData->bFlag) lData=-lData;
  return (dwByte+1);
 }

 /**//*****************************************************************
 /    DWORD data compress and decompress
 *****************************************************************/
 //X+X1*128+X2*128*128+X3*128*128*128.........
 template<> DWORD MapDataToBuf<DWORD> (const DWORD& dwData,LPSTR lpBuf)
 ...{
  DWORD dwValue=dwData;
  PMAP_UN_DATA pUnData=(PMAP_UN_DATA)lpBuf;
  DWORD i=0;
  for(;i<5;++i)
  ...{
   if (dwValue<128)
   ...{
    pUnData[i].bData=dwValue;
    break;
   }
   pUnData[i].bNext=1;
   pUnData[i].bData=dwValue%128;
   dwValue/=128;
  }
  return (i+1);
 }

 template<> DWORD MapBufToData<DWORD> (DWORD& dwData,LPCSTR lpBuf)
 ...{
  PMAP_UN_DATA pUnData=(PMAP_UN_DATA)lpBuf;
  DWORD i=0;
  for(DWORD dwSeed=1L;i<5;++i, dwSeed*=128L)
  ...{
   dwData += pUnData[i].bData*dwSeed;
   if (!pUnData[i].bNext) break;
  }
  return (i+1);
 }

} ;

#endif

 

调用:

 

using   namespace  COMPRESS;


int  _tmain( int  argc, _TCHAR *  argv[])
... {
    long lData=10000;
    long lValue=0;
    DWORD dwValue=0;
    DWORD dwData=128900;
    char Buf[100]=...{0};
    DWORD dwByte=0;
    dwByte+=MapDataToBuf(lData,Buf);
    dwByte+=MapDataToBuf(dwData,Buf+dwByte);

    DWORD dwByte2=0;
    dwByte2+=MapBufToData(lValue,Buf);
    dwByte2+=MapBufToData(dwValue,Buf+dwByte2);
    return 0;
}