坑啊，求大牛设计个算法解这个问题

mas_sunjie

整一个long，把你的9~12字节放进去（注意你得一个字节一个字节的放，不然有可能顺序错），然后&F8FF取到最高的5位，取出的值[0]>>3，最高的5位就到了最低5位，可以直接拿来用了；再把你的long<<5，把取走的5位挤出去，记录下左移的次数5；然后再取你需要的下个数据，比如6位，取法还是一样的，单再次long左移的时候不一样了，你需要检测出再次左移的6位+上次的5位超出了8位，此时就必需先<<8，然后把13字节放到long[3]里，然后再<<3完成移位。     这整个功能可以封装到一个类里，就可以源源不断的取出指定位数的值。

xdsnet

只能证明楼主C语言基础有问题，没有理解位运算。

idi0t

回复 8# idi0t


        我可没说指针做位运算（不过指针类型本身也可以做位运算，可没意义），只是你说的flash解析用位运算很好实现，不懂的话你应该补补基础知识，而不是一种那样的语气，作为一名初学者，我每次回答别人的帖子都是思考过的。

pprpg

LZ该翻翻C程序设计语言(K&R C).
这个实在是算不上坑.

cobras

随手写了一个，没有文件测试。不适用于压缩的文件。

1. #include <stdlib.h>
   
2. #include <stdio.h>
   
3. 
   
4. int flash_file_get_bits_value(unsigned char *buff, int buff_len, int *io_offset, int *io_bit_index, int *io_bit_remain, int bits_len
   
5.                                                           , unsigned long *o_value)
   
6. {
   
7.         int bit_index, bit_remain;
   
8.         int offset;
   
9.         int value;
   
10. 
    
11.         offset = *io_offset;
    
12.         bit_index = *io_bit_index;
    
13.         bit_remain = *io_bit_remain;
    
14.         value = 0;
    
15.         while (bits_len > 0) {
    
16.                 if (offset >= buff_len) {
    
17.                         return -1;
    
18.                 }
    
19.                 if (bits_len >= bit_remain) {
    
20.                         value <<= bit_remain;
    
21.                         value |= buff[offset] & (1 << bit_remain);
    
22.                         bit_remain = 8;
    
23.                         bit_index = 7;
    
24.                         ++offset;
    
25.                         bits_len -= bit_remain;
    
26.                 }else {
    
27.                         value <<= bits_len;
    
28.                         value |= (buff[offset] >> (bit_remain - bits_len)) & (1 << bits_len);
    
29.                         bit_remain -= bits_len;
    
30.                         bit_index -= bits_len;
    
31.                         bits_len = 0;
    
32.                 }
    
33.         }
    
34.         *io_offset = offset;
    
35.         *io_bit_index = bit_index;
    
36.         *io_bit_remain = bit_remain;
    
37.         if (o_value != NULL) {
    
38.                 *o_value = value;
    
39.         }
    
40.         return 0;
    
41. }
    
42. 
    
43. int flash_file_get_size(unsigned char *buff, int len, unsigned long *o_left, unsigned long *o_right
    
44.                                                 , unsigned long *o_top, unsigned long *o_botton)
    
45. {
    
46.         int bits;
    
47.         int bits_index;
    
48.         int bits_remain;
    
49.         int byte_index;
    
50. 
    
51.         if (len >= 9) {
    
52.                 bits = buff[8] >> 3;
    
53.                 byte_index = 8;
    
54.                 bits_index = 7 - 5;
    
55.                 bits_remain = 8 - 5;
    
56.                 if (flash_file_get_bits_value(buff, len, &byte_index, &bits_index, &bits_remain, bits, o_left) == 0) {
    
57.                         if (flash_file_get_bits_value(buff, len, &byte_index, &bits_index, &bits_remain, bits, o_right) == 0) {
    
58.                                 if (flash_file_get_bits_value(buff, len, &byte_index, &bits_index, &bits_remain, bits, o_top) == 0) {
    
59.                                         if (flash_file_get_bits_value(buff, len, &byte_index, &bits_index, &bits_remain, bits, o_botton) == 0) {
    
60.                                                 return 0;
    
61.                                         }
    
62.                                 }
    
63.                         }
    
64.                 }
    
65.         }
    
66.         return -1;
    
67. }
    
68. 
    
69. int flash_file_load(unsigned char **o_buff, int *o_buff_len, const char *file)
    
70. {
    
71.         FILE *fp;
    
72.         long file_len;
    
73.         unsigned char *buf;
    
74. 
    
75.         fp = fopen(file, "rb");
    
76.         if (fp != NULL) {
    
77.                 fseek(fp, 0, SEEK_END);
    
78.                 file_len = ftell(fp);
    
79.                 fseek(fp, 0, SEEK_SET);
    
80.                 buf = (unsigned char *)malloc(file_len);
    
81.                 if (buf != NULL) {
    
82.                         if (fread(buf, file_len, 1, fp) == 1) {
    
83.                                 fclose(fp);
    
84.                                 *o_buff = buf;
    
85.                                 *o_buff_len = (int)file_len;
    
86.                                 return 0;
    
87.                         }
    
88.                         free(buf);
    
89.                 }
    
90.                 fclose(fp);
    
91.         }
    
92.         return -1;
    
93. }
    
94. 
    
95. int main(void)
    
96. {
    
97.         unsigned char *buf;
    
98.         int buf_len;
    
99.         unsigned long left, right, top, botton;
    
100. 
     
101.         if (flash_file_load(&buf, &buf_len, "test.swf") == 0) {
     
102.                 if (flash_file_get_size(buf, buf_len, &left, &right, &top, &botton) == 0) {
     
103.                         printf("left: %lu\n", left);
     
104.                         printf("right: %lu\n", right);
     
105.                         printf("top: %lu\n", top);
     
106.                         printf("botton: %lu\n", botton);
     
107.                         free(buf);
     
108.                         return 0;
     
109.                 }
     
110.                 free(buf);
     
111.         }
     
112.         return -1;
     
113. }
     

复制代码

901001

楼主你读2进制文件，肯定也是一个一个字节读的吧。楼主的问题应该是要跨字节拼接数据对吧？每个字节都是8位2进制数（0-255）你把它想想成字符串，按照逻辑截取，拼接就可以了，实在不明白，网上搜搜一些压缩算法的源代码。

Frahm

没太懂问题所在，如果要读位的话，不用那么麻烦，我写了下。

1. 
   
2. 
   
3. int getbit(size_t num, int i) {
   
4.   return (num & (0x1 << i)) >> i;  
   
5. }
   
6. 
   
7. 
   
8. int main() {
   
9.   size_t num = 0x8fffffff;
   
10.   for(int i = sizeof(size_t) * 8 - 1; i >=0 ; --i) {
    
11.    std::cout << getbit(num, i);
    
12.   }
    
13.   std::cout << '\n';
    
14. }

复制代码

Frahm

又看了下，感觉你要的是这个吧.

1. unsigned getBitValue(char num, int i) {
   
2.   return (num & (0x1 <<i));
   
3. }
   
4. 
   
5. unsigned readBits(char* buf, int index, int count) {
   
6.   unsigned val = 0;
   
7.   int i = index; //bits index of buf
   
8.   int j = index - (index & ~7); //bits index within current byte
   
9.   int bi = 0; //byte index of val
   
10.   for(; i < index + count; ++i) {
    
11.     val |= getBitValue(buf[i >> 3], j) << bi;
    
12.     if(++j == 8) { //next byte
    
13.       bi += 8;
    
14.       j = 0;
    
15.     }
    
16.   }
    
17.   return val;
    
18. }
    
19. 
    
20. int main() {
    
21.   char buf[2] = {0xc0, 0x05};
    
22.   unsigned a = readBits(buf, 6, 5);
    
23.   for(int i = 31; i >=0; --i) {
    
24.     std::cout << getbit(a,i); //这个是上一楼我发的那个函数，用来打印结果的
    
25.     if((i&~7) == i) {
    
26.       std::cout << ' ';
    
27.     }
    
28.   }
    
29.   std::cout << '\n';
    
30. }

复制代码

输出:
00000000 00000000 00000101 11000000

noword2k

我当年写的批判文章:
http://bbs.chinaunix.net/thread-3661233-1-1.html

noword2k

flash的乌龟速度，与这种奇葩的数据结构有着直接的关系。