概述
可能看到这个标题,大家还是比较疑惑,不是很明白想表达什么意思,不着急,接着往下看就知道了.
假定有这样一个需求:
0-7 位这8个bit 存储 整形变量count的值,那么整形变量count的取值范围可以是(0,255).
8-13位 这6个bit 存储 整形变量second的值,那么整形变量second的取值范围是(0,63).
14-19位 6个bit 存储 整形变量minute得值,取值范围同上.
20-31位 这个12个bit 存储整形变量hour的值,那么其取值范围是(0,4095).
同时现在我们是知道hour,minute,second,count这个四个变量的值的.
分析
我们来分析一下怎么做,我们可以这样,把这四个变量的值分别转化成二进制,然后用字符数组存起来,就获得了对应的4个二进制数组,然后再用memcpy函数,把这四个数组按顺序copy到一个新的数组里不就行了嘛.
说干就干
首先我们先写一个函数,专门用来进行整数型->二进制数组的转换.这里可以有多种算法,大家可自行选择实现.
char* getBinaryArray(unsigned long value,int length){
int len = length;
int index = len - 1;
char *binary = (char*)malloc(sizeof(char)*len);
memset(binary,'0',sizeof(char)*len);
int r_value;
r_value = value%2;
*(binary+index) = r_value==0?'0':'1';
int n = value/2;
while(n>=2){
r_value = n%2;
index--;
*(binary+index) = r_value==0?'0':'1';
n = n/2;
}
r_value = n%2;
index--;
*(binary+index) = r_value==0?'0':'1';
return binary;
}
上面函数第一个参数的类型,可以是int,long,unsigned int ,第二个参数表示生成数组的长度.
我们来测试一下,这个函数有没有达到我们的要求.
#include <time.h>
#include <iostream>
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
using namespace std;
int main(){
char* getBinaryArray(unsigned long value,int length);
printf("size = %ld",sizeof(unsigned long));
printf("\n");
char* d = getBinaryArray(8,12);
for(int i=0;i<12;i++){
printf("d[%d] = %c -- ",i,*(d+i));
}
printf("\n");
}
char* getBinaryArray(unsigned long value,int length){
int len = length;
int index = len - 1;
char* binary = (char*)malloc(sizeof(char)*len);
memset(binary,'0',sizeof(char)*len);
int r_value;
r_value = value%2;
*(binary+index) = r_value==0?'0':'1';
int n = value/2;
while(n>=2){
r_value = n%2;
index--;
*(binary+index) = r_value==0?'0':'1';
n = n/2;
}
r_value = n%2;
index--;
*(binary+index) = r_value==0?'0':'1';
return binary;
}
命令行编译运行一下:
g+±4.8 -o getbinaryarraytest.out GetBinaryArrayTest.cpp
./getbinaryarraytest.out
结果如下:
size = 8
d[0] = 0 – d[1] = 0 – d[2] = 0 – d[3] = 0 – d[4] = 0 – d[5] = 0 – d[6] = 0 – d[7] = 0 – d[8] = 1 – d[9] = 0 – d[10] = 0 – d[11] = 0 –
这边因为我的设备是64位的,所以unsigned long型是8个字节,重点的是下面的输出结果.
000000001000
结果是我们想要的,没毛病.利用这个方法我们就可以得到其他几个值的二进制表示.
然后我们再利用memcpy函数把这几个二进制表示拼接起来就可以了.代码如下:
1 #include <time.h>
2 #include <iostream>
3 #include <string.h>
4 #include <stdlib.h>
5 #include <stdio.h>
6 #include <sstream>
7 #include <math.h>
8 using namespace std;
9
10 int main(){
11
12 char* getBinaryArray(unsigned long value,int length);
13 printf("\n");
14 printf("\n");
15 char* d = getBinaryArray(8,12);
16 for(int i=0;i<12;i++){
17 printf("d[%d] = %c -- ",i,*(d+i));
18 }
19 printf("\n");
20 char* e = getBinaryArray(12,6);
21 for(int i=0;i<6;i++){
22 printf("e[%d] = %c -- ",i,*(e+i));
23 }
24 printf("\n");
25 char* f = getBinaryArray(33,6);
26 for(int i=0;i<6;i++){
27 printf("f[%d] = %c -- ",i,*(f+i));
28 }
29 printf("\n");
30 char* g = getBinaryArray(28,8);
31 for(int i=0;i<8;i++){
32 printf("g[%d] = %c -- ",i,*(g+i));
33 }
34 printf("\n");
35 char* kk=(char*)malloc(sizeof(char)*32);
36 int hl=sizeof(char)*12;
37 int ml = sizeof(char)*6;
38 int sl = sizeof(char)*6;
39 int fl = sizeof(char)*8;
40 memcpy(kk,d,hl);
41 memcpy(kk+hl,e,ml);
42 memcpy(kk+hl+ml,f,sl);
43 memcpy(kk+hl+ml+sl,g,fl);
44
45 for(int i=0;i<32;i++){
46 printf(" %c ",*(kk+i));
47 }
48
49 unsigned long sum = 0;
50 for(int i=0;i<32;i++){
51 if(*(kk+i) == '1'){
52 sum = sum + 1*(long)pow(2,31-i);
53 }
54 }
55 printf("\n");
56 printf("sum=%ld",sum);
57 return 0;
58 }
59
60 char* getBinaryArray(unsigned long value,int length){
61 int len = length;
62 int index = len - 1;
63 char* binary = (char*)malloc(sizeof(char)*len);
64 memset(binary,'0',sizeof(char)*len);
65 int r_value;
66 r_value = value%2;
67 *(binary+index) = r_value==0?'0':'1';
68 int n = value/2;
69 while(n>=2){
70 r_value = n%2;
71 index--;
72 *(binary+index) = r_value==0?'0':'1';
73 n = n/2;
74 }
75 r_value = n%2;
76 index--;
77 *(binary+index) = r_value==0?'0':'1';
78 return binary;
79 }
编译运行后结果如下:
d[0] = 0 – d[1] = 0 – d[2] = 0 – d[3] = 0 – d[4] = 0 – d[5] = 0 – d[6] = 0 – d[7] = 0 – d[8] = 1 – d[9] = 0 – d[10] = 0 – d[11] = 0 –
e[0] = 0 – e[1] = 0 – e[2] = 1 – e[3] = 1 – e[4] = 0 – e[5] = 0 –
f[0] = 1 – f[1] = 0 – f[2] = 0 – f[3] = 0 – f[4] = 0 – f[5] = 1 –
g[0] = 0 – g[1] = 0 – g[2] = 0 – g[3] = 1 – g[4] = 1 – g[5] = 1 – g[6] = 0 – g[7] = 0 –
0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 1 0 0 1 0 0 0 0 1 0 0 0 1 1 1 0 0
sum=8593692
上面加粗的结果就是最终的,我们想要的二进制表示,它的十进制表示值是8593692.
上面的方法,确实实现了我们的需求,但是吧,这也太麻烦了吧.首先,需要把整型值转化成二进制表示,并用char 数组存起来,然后在内存拷贝进行拼接,最后如果想得到十进制的结果还需要再转化一下…比较麻烦,那能不能有简单点的方法呢? 我们可以用位操作运算来实现. 代码如下:
1 #include<iostream>
2 #include<stdio.h>
3 int main(){
4 unsigned int value = 0;
5 unsigned int count = 28;
6 unsigned int second = 33;
7 unsigned int minute = 12;
8 unsigned int hour = 8;
9 //从低位到高位
10 //set count
11 value = 0 | count;
12 //set second
13 value = value | (second << 8);
14 //set minute
15 value = value | (minute << 14);
16 //set hour
17 value = value | (hour << 20);
18 printf("%d",value);
19 }
编译运行结果如下:
8593692
结果和上面的一样,但是思路完全不一样,代码量是不是少很多.通过这种方式,如果后端要求怎么控制32位的格式或者64位,我们都可以很方便的做到.
扫码加入我的个人微信公众号：Android开发圈 ，一起学习Android知识！！
