第一次写博客，当作随笔留给自己看吧，如果能帮到读者，是我的荣幸。
这是 CSAPP 的配套实验 DataLab，概括的来说就是在较严格的限制条件下把 15 个函数补充完整。
本人能力没有那么强，很多题目都是借鉴了（抄袭了= =）网上大佬的做法，当然也有些题目看不懂大佬的做法，但是结合了大佬的思想，自己写了出来。
很多函数的下面都附加了自己的理解。
在 ubuntu 12.04 下测试全部通过
每次修改 bits.c 后的测试顺序
./dlc bits.c (检查编码是否符合规则）
make btest (相当于编译检查语法)
btest bits.c (测试bits.c所有函数的正确性)
注：./dlc bits.c，检查编码是否符合规则 这一步非常有必要，因为即使你后面测试函数得到了满分，但是不符合编码规则将视作零分
btest 测试单个函数的方法是 btest -f FuncName，其他更多用法请自行参考说明文件
1
/*
* bitAnd - x&y using only ~ and |
* Example: bitAnd(6, 5) = 4
* Legal ops: ~ |
* Max ops: 8
* Rating: 1
*/
int bitAnd(int x, int y) {
return ~((~x) | (~y));
}
//利用德摩根律
2
/*
* getByte - Extract byte n from word x
* Bytes numbered from 0 (LSB) to 3 (MSB)
* Examples: getByte(0x12345678,1) = 0x56
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 6
* Rating: 2
*/
int getByte(int x, int n) {
return ((x >> (n << 3)) & 0xFF);
}
//将所要取的字节移到最右端然后其余位通过与运算置0
3
/*
* logicalShift - shift x to the right by n, using a logical shift
* Can assume that 0 <= n <= 31
* Examples: logicalShift(0x87654321,4) = 0x08765432
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 20
* Rating: 3
*/
int logicalShift(int x, int n) {
int tmp = 32 + (~n);
return (x >> n) & ((1 << tmp) + (~0) + (1 << tmp));
}
//运用机器的算术右移，然后高位置0和低位保持
//右移n位后原最高位到了第31-n位，31-n表示为31+((~n)+1) = 32+(~n)
//通过与高n位全为0，第32-n位全为1的数实现高位置0和低位保持
//这个数是(1 << ((32+(~n)+1)) - 1
//由于n可能为0，这样左移32位会根据gcc编译规则左移 32 % 32(类型位长) = 0位
//故将该数表示为(1 << (32+(~n)+1)) + (~0) + (1 << (32+(~n)+1))
4
/*
* bitCount - returns count of number of 1's in word
* Examples: bitCount(5) = 2, bitCount(7) = 3
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 40
* Rating: 4
*/
int bitCount(int x) {
//造数
int _tmp1 = 0x55 | (0x55 << 8); //0x00005555
int _tmp2 = 0x33 | (0x33 << 8); //0x00003333
int _tmp3 = 0xf | (0xf <<8); //0x00000f0f
int tmp1 = _tmp1 | (_tmp1 << 16); //0x55555555
int tmp2 = _tmp2 | (_tmp2 << 16); //0x33333333
int tmp3 = _tmp3 | (_tmp3 << 16); //0x0f0f0f0f
int tmp4 = 0xff | (0xff << 16); //0x00ff00ff
int tmp5 = 0xff | (0xff << 8); //0x0000ffff
//求和
int res = 0;
res = (x & tmp1) + ((x >> 1) & tmp1);
res = (res & tmp2) + ((res >> 2) & tmp2);
res = (res & tmp3) + ((res >> 4) & tmp3);
res = (res & tmp4) + ((res >> 8) & tmp4);
res = (res & tmp5) + ((res >> 16) & tmp5);
//返回
return res;
}
//类似递归分治的思想，以统计二进制数x=10中1的个数为例
//方法是将高位移到低位和0x1相与，(x & 0x1) + ((x >> 1) & 0x1)
//造出5个数，0x55555555,0x33333333,0x0f0f0f0f,0x00ff00ff,0x0000ffff
//这五个数写成二进制，分别隔着1,2,4,8,16个0
/*
* bang - Compute !x without using !
* Examples: bang(3) = 0, bang(0) = 1
* Legal ops: ~ & ^ | + << >>
* Max ops: 12
* Rating: 4
*/
int bang(int x) {
return ((~((x | ((~x)+1)) >> 31)) & 0x1);
}
//将一个非零数的补码与其相反数的补码相或，最高位一定是1
//但如果对0进行此操作，最高位还是0
6
/*
* tmin - return minimum two's complement integer
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 4
* Rating: 1
*/
int tmin(void) {
return (0x1 << 31);
}
//最小负整数的二进制补码是1000...0000
7
/*
* fitsBits - return 1 if x can be represented as an
* n-bit, two's complement integer.
* 1 <= n <= 32
* Examples: fitsBits(5,3) = 0, fitsBits(-4,3) = 1
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 15
* Rating: 2
*/
int fitsBits(int x, int n) {
return !(((x >> (n+(~0))) + 1) >> 1);
}
//若n位能表示这个数
//正数的1只能出现在低n-1位，其余位全为0
//负数的0只能出现在低n-1位，其余位全为1
//故将该数右移n-1位后所得结果，正数全为0，负数全为1
//此时再+1后右移1位，可以得到全0
//若n位不能表示这个数，则一定不会有以上结论
//n-1表示为n+(-1)，即n+(~0)
8
/*
* divpwr2 - Compute x/(2^n), for 0 <= n <= 30
* Round toward zero
* Examples: divpwr2(15,1) = 7, divpwr2(-33,4) = -2
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 15
* Rating: 2
*/
int divpwr2(int x, int n) {
return ( x + (((x >> 31) & 0x1) << n) + (~0) + (!((x >> 31) & 0x1)) ) >> n;
}
//本题是对于标准除法/的实现，全正取下整，有负取上整
//而通过移位实现除以2的幂，都是取下整
//故对于负数要加一个偏移量(1 << n) - 1 (证明在深入理解计算机系统第9版P73)
//因为是负数才要加偏移量，所以式子中的1刚好可以用符号位((x >> 31) & 0x1)表示
//若x > 0，(((x >> 31) & 0x1) << n)的结果为0，会导致多减去了1即(~0)
//巧妙多加一个符号位的逻辑非结果即(!((x >> 31) & 0x1))，负数为0，整数为1，恰好弥补
9
/*
* negate - return -x
* Example: negate(1) = -1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 5
* Rating: 2
*/
int negate(int x) {
return ((~x) + 1);
}
//对一个数的补码进行按位取反加1就能得到其相反数的补码
10
/*
* isPositive - return 1 if x > 0, return 0 otherwise
* Example: isPositive(-1) = 0.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 8
* Rating: 3
*/
int isPositive(int x) {
return !( ((x >> 31) & 0x1) | (!(x << 1)) );
}
//正数和零的符号位为0，负数为1
//左移1位后用！，正数的结果一定为0，负数的结果可0可1,零的结果一定是1
//将以上两个结果相或，正数的结果为0,负数一定为1，零的结果一定是1
11
/*
* isLessOrEqual - if x <= y then return 1, else return 0
* Example: isLessOrEqual(4,5) = 1.
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 24
* Rating: 3
*/
int isLessOrEqual(int x, int y) {
int xSign = (x >> 31) & 0x1;
int ySign = (y >> 31) & 0x1;
int signDiff = xSign & (!ySign);
int signSame = !(((y + (~x+1)) >> 31) & 0x1) & !(xSign ^ ySign);
return signDiff | signSame;
}
//作差法判断大小
//首先要判断符号位，因为可能存在溢出
//正数符号位为0，负数符号位为1，列出x,y的真值表
//x y z
//0 0 符号相同要进行下一步作差
//0 1 0(表示x > y)
//1 0 1(表示x < y)
//1 1 符号相同要进行下一步作差
//可以看到若用一个表达式(xSign & !(ySign))可以实现只用第三种情况为1,就可以完成符号位的判断
//接下来还要看其他三种情况，通过与上!(xSign ^ ySign)保证两者同号，因为第二种不同号的情况在该表达式下结果为0，与0就置0
//前面取y-x的符号位，为0说明，y >= x，否则y < x，再取逻辑非配合与操作
12
/*
* ilog2 - return floor(log base 2 of x), where x > 0
* Example: ilog2(16) = 4
* Legal ops: ! ~ & ^ | + << >>
* Max ops: 90
* Rating: 4
*/
int ilog2(int x) {
int res = 0;
res = res + ((!!(x>>(16 + res)))<<4);
res = res + ((!!(x>>(8 + res)))<<3);
res = res + ((!!(x>>(4 + res)))<<2);
res = res + ((!!(x>>(2 + res)))<<1);
res = res + ((!!(x>>(1 + res)))<<0);
return res;
}
13
/*
* float_neg - Return bit-level equivalent of expression -f for
* floating point argument f.
* Both the argument and result are passed as unsigned int's, but
* they are to be interpreted as the bit-level representations of
* single-precision floating point values.
* When argument is NaN, return argument.
* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
* Max ops: 10
* Rating: 2
*/
unsigned float_neg(unsigned uf) {
unsigned exp = (uf >> 23) & 0xFF;
unsigned frac = uf & 0x7FFFFF;
unsigned res = uf ^ 0x80000000;
if(exp == 0xFF && frac) {
res = uf;
}
return res;
}
//取exp和frac判断是否为NaN
//异或改变符号位
14
/*
* float_i2f - Return bit-level equivalent of expression (float) x
* Result is returned as unsigned int, but
* it is to be interpreted as the bit-level representation of a
* single-precision floating point values.
* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
* Max ops: 30
* Rating: 4
*/
unsigned float_i2f(int x) {
unsigned ans;
int xSignx = x & (1 << 31);
int res = 31;
int ss = 0;
int ff = 0;
int tmp;
if(x == 0) ans = 0;
else{
if(xSignx) x = (~x) + 1;
while(!((1 << res) & x)) {
res--;
}
x = x ^ (1 << res);
if(res < 23) x = x << (23 - res);
else {
tmp = res - 24;
if(tmp >= 0) ss = (x >> tmp) & 1,ff = ((1 << tmp) - 1) & x;
x = (x >> (res-23));
}
x = x | ((res+127) << 23);
if(ff == 0) {
ss = (ss & x);
}
x = x + ss;
x = x | xSignx;
ans = x;
}
return ans;
}
15
/*
* float_twice - Return bit-level equivalent of expression 2*f for
* floating point argument f.
* Both the argument and result are passed as unsigned int's, but
* they are to be interpreted as the bit-level representation of
* single-precision floating point values.
* When argument is NaN, return argument
* Legal ops: Any integer/unsigned operations incl. ||, &&. also if, while
* Max ops: 30
* Rating: 4
*/
unsigned float_twice(unsigned uf) {
unsigned tmp = uf;
unsigned exp = (tmp >> 23) & 0xFF;
unsigned frac = tmp & 0x007fffff;
if(exp == 0x0) { //非规格化数
tmp = (tmp & 0x80000000) | (frac << 1);
}
else if(exp != 0xFF) { //规格化数
tmp += (1 << 23);
if(((tmp >> 23) & 0xFF) == 0xFF) {
tmp = tmp >> 23 << 23;
}
}
return tmp;
}
9700
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
