位操作类

在标准C++中，C++中的位操作类(Bitset)提供一个位集合的数据结构。利用这个结构，可以实现某些很复杂的功能，比如权限设计、游戏中的存档，成绩是否及格等。这个结构的一个优点是能够节省空间（尤其在网络传输的时候，优点就体现出来了），这里模仿<Data Structure for game programers>写了一个类似的位操作类，主要采用长整型数来保存位，两个长整型就能保存64个位，主要的操作还是位操作（以为、与、并、异或等等）。

 类的设计与定义如下：

//  文件摘要：通用位数组类
//  文件标识：BitVector.h
//  创建日期：2010-10-29
//  ============================================================================
#ifndef BITVECTOR_H
#define  BITVECTOR_H

#include  < iostream >
#include  < cstdio >

class  BitVector
{
public :
     // 摘要：构造函数
     // 参数：pSize-位数
    BitVector(size_t pSize  =  INIT_SIZE):elems( 0 ),size(pSize)
    {
        size_t nums  =   0 ;
         if (size  %   32   ==   0 )
        {
            size  =  size  /   32 ; 
        }
         else
        {
            size  =  size  /   32   +   1 ;
        }
        elems  =   new  unsigned  long   int [size];
    }

     // 析构函数
     ~ BitVector()
    {
         if (elems  !=   0 )
            delete[] elems;
        elems  =   0 ;
    }

     // 摘要：改变大小成员函数
     // 参数：pSize-位数
     void  Resize(size_t pSize);

     // 摘要：下标操作符，取得所在位的值
     // 参数：位所在位置
     // 返回：true 或者 false
     bool   operator [](size_t pIndex);

     // 摘要：设置某位为特定值(0或者1)
     // 参数：pIndex - 索引位位置 ， pValue - 待设置的值
     void  Set(size_t pIndex ,  bool  pValue);

     // 摘要：全部清零操作
     void  ClearAll();

     // 摘要：全部置位操作(其实可以采用默认参数，如果不传特定值，默认全部置位)
     void  SetAll();

     // 摘要：写二进制文件
     // 参数：path-文件保存路径
     // 返回：成功返回true否则返回false
     bool  WriteToFile( const   char   * path);

     // 摘要：读二进制文件
     // 参数：path-文件路径
     // 返回：成功返回true否则返回false
     bool  ReadFromFile( const   char   * path);

     // 摘要：输出所有的长整型表示的数，以及二进制表示形式
     void  ToString() 
    {
         for (size_t index  =   0 ; index  <  size ;  ++ index)
        {
            std::cout  <<   " 长整型数值为： "   <<  std::dec  <<  elems[index]  <<   "  二进制表示为： "   <<  std::hex  <<  elems[index]  <<  std::endl;
        }
    }
private :
     static   const   int  INIT_SIZE  =   32 ;
    unsigned  long   int   * elems;   // 长整型数组
    size_t size;                // 长整型数目，据此可求出可表达的位数为：size*32;
};

inline  void  BitVector::Resize(size_t pSize)
{
     // 定义新空间
    unsigned  long   int   * newVector  =   0 ;

     // 求出整形数目
     if (pSize  %   32   ==   0 )
    {
        size  =  size  /   32 ;
    }
     else
    {
        size  =  (size  /   32 )  +   1 ;
    }

     // 分配新空间
    newVector  =   new  unsigned  long   int [size];

     // 分配失败，退出
     if (newVector  ==   0 )
         return ;

     // 取小值
    size_t min  =  size  <  pSize  ?  size : pSize;

     // 复制
     for (size_t index  =   0  ; index  <  min;  ++ index)
    {
        newVector[index]  =  elems[index];
    }

     // 保存新值
    size  =  pSize;

     // 删除旧空间
     if (elems  !=   0 )
        delete[] elems;

     // 保存新地址
    elems  =  newVector;
}

inline  bool  BitVector:: operator [](size_t pIndex)
{
    size_t cell  =  pIndex  /   32 ;
    size_t bit  =  pIndex  %   32 ;
     return  (elems[cell]  &  ( 1   <<  bit))  >>  bit;
}

inline  void  BitVector::Set(size_t pIndex ,  bool  pValue)
{
     // 找出所在单元和具体位置
    size_t cell  =  pIndex  /   32 ;
    size_t bit  =  pIndex  %   32 ;

     // 如果设置true
     if (pValue)
    {
        elems[cell]  =  (elems[cell]  |  ( 1 << bit));
    }
     // 如果设置为false
     else
    {
        elems[cell]  =  (elems[cell]  &  ( ~ ( 1 << bit)));
    }
}

inline  void  BitVector::ClearAll()
{
     for (size_t index  =   0  ; index  <  size;  ++ index)
    {
        elems[index]  =   0 ;
    }
}

inline  void  BitVector::SetAll()
{
     for (size_t index  =   0 ; index  <  size;  ++ index)
    {
        elems[index]  =   0xFFFFFFFF ;
    }
}

inline  bool  BitVector::WriteToFile( const   char   * path)
{
    std::FILE  * outFile  =   0 ;
     int  written  =   0 ;
    outFile  =  std::fopen(path, " wb " );
    
     // 打开文件失败
     if (outFile  ==   0 )
    {
         return   false ;
    }

     // 写文件，同时返回写入的对象个数
    written  =  std::fwrite(elems, sizeof ( * elems),size,outFile);

     // 关闭文件流
    std::fclose(outFile);
    
     // 检测写入的个数
     if (written  !=  size)
    {
         return   false ;
    }

     return   true ;
}

inline  bool  BitVector::ReadFromFile( const   char   * path)
{
    std::FILE  * inFile  =   0 ;
     int  read  =   0 ;
    inFile  =  std::fopen(path, " rb " );
     if (inFile  ==   0 )
         return   false ;

     // 读文件，返回读入的对象个数
    read  =  std::fread(elems, sizeof (unsigned  long   int ),size,inFile);

     // 关闭文件
    std::fclose(inFile);

     if (read  !=  size)
         return   false ;

     return   true ;
}
#endif 

 

//测试代码如下： 

#include  < iostream >
#include  < tchar.h >
#include  < string >
#include  < cstdlib >
#include  < cstring >
#include  < ctime >
#include  < sys / timeb.h >

#include  " BitVector.h "
using   namespace  std;

int  _tmain( int  argc, _TCHAR *  argv[])
{
  
     // 一个长整形表示32个位值（随机数）
    BitVector bitv( 32 );
    bitv.ToString();

     // 设置所有位为1，同 bitv.SetAll()
     for ( int  i = 0 ;i < 32 ;i ++ )
    {
        bitv.Set(i, true );
    }
    bitv.ToString();

     // 设置第三位为0，于是最后变为1011（十六进制的b）
    bitv.Set( 2 , 0 );
    bitv.ToString();

     // 写文件
    bitv.WriteToFile( " bitv.py " );

     // 读文件
    bitv.ReadFromFile( " bitv.py " );

     // 位全部设置为0
    bitv.ClearAll();
    bitv.ToString();

    system( " pause " );
     return   0 ;
}