编程练习——可变长bit数组(bitArray)

 其实c++里有bitset这个类，但是bitset使用时必须给定大小。例如

bitset<8> c;//这里必须在编码里写死，不能使用变量替代

c = 234;

我主要是用这个东西来存储可变长的huffman编码。所以这个类对我根本不能用。除非开始就给一个足够大的bitset。

所以我创建里一个可变长的bit vector用于存放Huffman编码。

在这里内部使用的是__int64,64位。当然根据实际需要可以将这个做为模板传入，不过现在还没有这样编码。

 

 

1. /* created by chico chen
2. *  date 2008/10/25
3. */
4. #ifndef _BIT_VECTOR_
5. #define _BIT_VECTOR_
6. #include <iostream>
7. using namespace std;
10. class BITVector
11. {
12. private:
13.     __int64 * bitarray;
14.     const int bits;
15.     const unsigned __int64 mask ;
16.     int size;
17.     void SetOne(int index);// x is 0 
18.     void SetZero(int index);// x is 1
19.     void Larger();
20.     
21. public:
22.     BITVector(void);
23.     void Set(int index, int x); // x is 0 or 1
24.     int Get(int index);
25.     int Size();
26.     void SetInt(unsigned int integer,int start,int len);
27.     void PrintfZeroOne(int start , int len);// print the unsigned it as 0 or 1
28.     void SetBitVector(BITVector & c, int start, int len);
29.     const BITVector& operator=(const BITVector& bitVector);
30.     explicit BITVector(const BITVector & bitVector);
32. public:
33.     ~BITVector(void);
34. };
35. #endif

然后是bitVector.cpp文件

 

 

1. /* created by chico chen
2. *  date 2008/10/25
3. */
4. #include "StdAfx.h"
5. #include "BITVector.h"
7. BITVector::BITVector(void):mask(0x8000000000000000),bits(sizeof(__int64)*8)
8. {
9.     bitarray = new __int64[1];
10.     memset(bitarray,0,sizeof(__int64));
11.     size = 1;
12. }
14. BITVector::~BITVector(void)
15. {
16.     size = 0;
17.     delete[] bitarray;
18. }
20. void BITVector::Set(int index, int x)
21. {
22.     if(x == 0)
23.     {
24.         return SetZero(index);
25.     }
26.     else
27.     {
28.         return SetOne(index);
29.     }
30. }
32. void BITVector::SetZero(int index)
33. {
34.     int innIndex = index/bits;
35.     int bitPos = index & (bits-1); // innIndex % 8
36.     if( innIndex < size)
37.     {
38.         // vector maybe has enough space to store this .
39.         this->bitarray[innIndex] = this->bitarray[innIndex] & ~(mask >> bitPos);
40.     }
41.     else if(innIndex == size)
42.     {
43.         // should larger the size of bitarray
44.         // and innIndex must be the first bit of last char 
45.         
46.         if(bitPos == 0)
47.         {
48.             // correct
49.             this->Larger();
50.             this->bitarray[innIndex] = this->bitarray[innIndex] & ~(mask >> bitPos);
51.         
52.         }
53.         else
54.         {
55.             // error
56.             
57.         }
58.     }
59.     else
60.     {
61.         // there may be something error, or some code missing
62.         
63.     }
64. }
67. void BITVector::Larger()
68. {
69.     __int64 * tempArray = new __int64[size];
70.     memcpy(tempArray,this->bitarray,sizeof(__int64)*size);
71.     delete[] this->bitarray;
72.     
73.     this->bitarray = new __int64[size*2]; // may be error
74.     memset(bitarray,0,sizeof(__int64)*size*2);
75.     memcpy(this->bitarray,tempArray,sizeof(__int64)*size);
76.     size = size*2;
77.     delete[] tempArray;
78.     
80. }
82. void BITVector::SetOne(int index)
83. {
84.     int innIndex = index/bits; // you can use >>(bits-1)
85.     int bitPos = index % bits; // innIndex & (bits-1)
86.     if( innIndex < size)
87.     {
88.         // vector maybe has enough space to store this .
89.         this->bitarray[innIndex] = this->bitarray[innIndex] | (mask >> bitPos);
90.     }
91.     else if(innIndex == size)
92.     {
93.         // should larger the size of bitarray
94.         // and innIndex must be the first bit of last char 
95.         
96.         if(bitPos == 0)
97.         {
98.             // correct
99.             this->Larger();
100.             this->bitarray[innIndex] = this->bitarray[innIndex] | (mask >> bitPos);
101.             
102.         }
103.         else
104.         {
105.             // error
106.             
107.         }
108.     }
109.     else
110.     {
111.         // there may be something error, or some code missing
113.     }
115. }
117. int BITVector::Get(int index)
118. {
119.     if(index < size*bits)
120.     {
121.         int position = index & (bits-1); // % bits
122.         int innIndex = index/bits;
123.         __int64 i = this->bitarray[innIndex] & (mask >> position);
124.         if(i == 0)
125.         {
126.             return 0;
127.         }
128.         else
129.         {
130.             return 1;
131.         }
132.     }
133.     throw "access out of the array";
134. }
136. int BITVector::Size()
137. {
138.     return size*bits;
139. }
141. // int integer is 0x01010111
142. // start is the start position of bitvector, and start starts zero
143. // len is length of the number of bits you want set into bit array
144. void BITVector::SetInt(unsigned int integer,int start, int len)
145. {
146.     int finalPos = start + len; 
147.     int i=start;
148.     int j = 0;
149.     int temp = 0;
150.     for(;i < finalPos; i++,j++)
151.     {
152.         temp = integer & (0x80000000 >> j);
153.         this->Set(i,temp);
154.     }
155. }
158. void BITVector::PrintfZeroOne(int start,int len)
159. {
160.     int finalPos = start+len;
161.     int temp = 0;
162.     for(int i = start; i < finalPos; i++)
163.     {
164.         printf("%d",this->Get(i));
165.     }
166. }
168. // start is where to insert bit vector c
169. // len is the length of bits inserted
170. // "start" is of this, and "len" is of c; 
171. void BITVector::SetBitVector(BITVector & c, int start, int len)
172. {
174.     for(int i = 0; i < len; i++)
175.     {
176.         this->Set(start+i,c.Get(i));
177.     }
178.             
179. }
181. // copy construct
182. BITVector::BITVector(const BITVector & bitVector):mask(0x8000000000000000),bits(sizeof(__int64)*8)
183. {
184.     this->size = bitVector.size;
185.     this->bitarray = new __int64[this->size];
186.     memcpy(this->bitarray,bitVector.bitarray,sizeof(__int64)*bitVector.size);
187. }
189. const BITVector& BITVector::operator=(const BITVector& bitVector)
190. {
191.     if(this != &bitVector)
192.     {
193.         this->size = bitVector.size;
194.         delete [] this->bitarray;
195.         this->bitarray = new __int64[this->size];
196.         memcpy(this->bitarray,bitVector.bitarray,sizeof(__int64)*this->size);
197.     }
198.     return * this;
199. }