本博客为谭志虎老师的《计算机组成原理实践教程——从逻辑门到CPU》实验记录，因为目前网上并没有本书的答案，错漏在所难免,还请多多指正。
程序在给出的实验包中有，结果我自己傻傻输了一遍,emmm…

电路文件已经托管至Github，欢迎star：点这里

补码表示实验答案

1

答案：1 2 4 8 16 32 64 128 256 512
提示：二进制数做位运算看看

2

#include "stdio.h"

void char_hex_out(char a){
    
	const char HEX[] = "0123456789ABCDEF";
	int index = a&0x0f;
	printf("%c%c",HEX[(a&0xF0)>>4],HEX[a&0x0F]);
}

void four_byte_out(char *addr){
    
	char_hex_out(*(addr+3));
	char_hex_out(*(addr+2));
	char_hex_out(*(addr+1));
	char_hex_out(*(addr+0));
	printf("\n");
}

main(){
    
	int a = -1;
	int b = 2147483648;
	int c = -b;
	unsigned int d = -2147483648;
	printf("a=%u=%d=0x%x   \n",a,a,a) ;
	printf("b=%u=%d=0x%x   \n",b,b,b) ;
	printf("c=%u=%d=0x%x   \n",c,c,c) ;
	printf("d=%u=%d=0x%x   \n",d,d,d) ;
	printf("\nd's memory addr=0x%x",&d);	//这里是d不是ui，教材印错了
	printf("\nd's machine code=0x");
	four_byte_out(&d);  //这里是d
	return;
}

3

#include "stdio.h"
main(){
    
	int a = 1,b = 2147483647,d = -1,e = -2147483648;
	int c = a+b;
	int f = e+d;
	printf("c=a+b=%d+%d=%d \n",a,b,c);
	printf("f=e+d=%d+%d=%d \n",d,e,f);
	printf("e+1=%d \n",e+1);
	return;
}

原因：
-2147483647　　补码1000 0000 0000 0000 0000 0000 0000 0001

-1　　　　　　　补码1111 1111 1111 1111 1111 1111 1111 1111

得到-2147483648 补码1000 0000 0000 0000 0000 0000 0000 0000

4

#include "stdio.h"
main(){
    
	int iarray[]={
    5,4,3,2,1};
	char *iarr=(char*)iarray;
	printf("sizeof(char):%d\n",(int)sizeof(char));
	printf("sizeof(short):%d\n",(int)sizeof(short));
	printf("sizeof(int):%d\n",(int)sizeof(int));
	printf("sizeof(unsigned int):%d\n",(int)sizeof(unsigned int));
	printf("sizeof(long):%d\n",(int)sizeof(long));
	printf("sizeof(size_t):%d\n",(int)sizeof(size_t));
	printf("sizeof(long long):%d\n",(int)sizeof(long long));
	printf("sizeof(void *):%d\n",(int)sizeof(void *));
	printf("sizeof(iarray):%d\n",(int)sizeof(iarray));
	printf("sizeof(iarr):%d\n",(int)sizeof(iarr));
	return 0;
}

实验思考

（1）相等，因为二者都是1后面跟31个零
（2）不是，能，因为一个字四位
（3）反码
（4）小端 由cpu架构决定

实验四 浮点数表示实验

很多题目是csapp的，很有价值，当初没怎么认真做，现在算是补回来了（

1

		#include <iostream>  
    #include <float.h> 
    #include <limits.h>
    using namespace std;  
      
    int main()  
    {  
        cout << "float 类型能存储的最大值和最小值" << endl;  
        printf("%.1f\n",FLT_MAX);
        printf("%.308f\n",FLT_MIN);
        cout << "double 类型能存储的最大值和最小值" << endl;  
        cout << "DBL_MAX = " << DBL_MAX << endl;  
        cout << "DBL_MIN = " << DBL_MIN << endl;  
        cout << "你的32位钱：";
		printf("%.1f\n",FLT_MAX+1);
		cout << "你的64位钱：";
		printf("%.1f\n",DBL_MAX+1);
		
		
        return 0;  
    }  

从这里我们可以看出来，最大值+1不会造成溢出，只会无法显示

2

注意：此处的解释取自知乎邱昊宇的回答

16777217.0没法正常表示的问题
原因如下：因为单精度浮点数具 23 位尾数（加上隐藏位是 24 位）
16777217 的二进制数一共有 25 位：第 24 位为 0，第 25 位为 1，后续位都为 0
根据中值取偶规则：
如果第25位是0，不进位；（因为X.OY显然小于中值X.1，离X更近）如果第25位是1，
如果后续存在非0位，进位；（因为X.1Y1Z显然大于中值×.1，离X+1更近）
如果后续位都为0，
如果第24位是0，不进位；（中值×.1的X是偶数，在X和X+1中取偶数X）
如果第24位是1，进位。（中值×.1的X是奇数，在X和X+1中取偶数X+1）

#include <stdio.h>  
#include <float.h> 
#include <limits.h>

int main(int argc,char**argv)  
{
      
	float f1=16777216.0;
	float f2=16777217.0;
	float f3=1677218.0;
	printf("16,777,216:%f\n",f1);
	printf("16,777,217:%f\n",f2);
	printf("16,777,218:%f\n",f3);
	printf("f1==f2?%s",f1==f2?"true":"false");
    return 0;  
}  

3

结果直接停止运行

4

5

#include <stdio.h>  
#include <float.h> 
#include <limits.h>
union
{
    
	char c[4];
	float f;
	int i;
}t1,t2;

int main()  
{
      
	t1.i=0x80000000;
	t2.i=0x00000000;
	if(t1.f==t2.f)
		printf("float data is equal\n");
	if(t1.i!=t2.i)
		printf("int data is not equal\n");
}  

这个就有点莫名其妙，int并没有超出存储范围，这里不涉及溢出
0x80000000 的2进制是1000,0000,0000,0000,0000,0000,0000,0000
取反后111,1111,1111,1111,1111,1111,1111,1111，十进制是2147483648，当然不相等

6

#include <stdio.h>  
#include <float.h> 
#include <limits.h>
union
{
    
	char c[4];
	float f;
	int i;
}t1,t2;

int main(int argc,char**argv)  
{
      
	double a=0.1;
	double b=0.2;
	double c=0.3;
	double d=a+b;
	printf("a(0.1):%.30g\n",a);
	printf("b(0.2):%.30g\n",b);
	printf("c(0.3):%.30g\n",c);
	printf("d(0.3):%.30g\n",d);
	printf("c==d?%s\n",c==d?"true":"false");
	printf("c<d?%s\n",c<d?"true":"false");
	return 0;
}  

只能无限逼近但不是准确的。

7

double比float精度更低

#include <stdio.h>  
#include <float.h> 
#include <limits.h>
test_float_cal(){
    
	float a,b,c;
	b=3.3;
	c=1.1;
	int d;
	a=b/c;
	d=b/c;
	printf("a=%f,d=%d",a,d);
	if(3.0==a)
		printf("\nFloat a=3.3/1.1==3.0");
}
test_double_cal(){
    
	double a,b,c;
	int d;
	b=3.3;
	c=1.1;
	a=b/c;
	d=b/c;
	printf("\n\na=%f,d=%d",a,d);
	if(3.0!=a)
		printf("\nDouble a=3.3/1.1!=3.0");
}

main(){
    
	test_float_cal();
	test_double_cal();
}

8

#include <stdio.h>  
#include <float.h> 
#include <limits.h>

int main(int argc,char **argv){
    
	float a=3.14;
	float b=1e20;
	printf("(3.14+1e20)-1e20=%f\n",(a+b)-b);
	printf("3.14+(1e20-1e20)=%f\n",a+(b-b));
	return 0;
}

9

#include <stdio.h>  
#include <float.h> 
#include <limits.h>

union{
    
	char c[4];
	float f;
	int i;
}t1,t2,t3,t4;

void char_hex_out(char a){
    
	const char HEX[] = "0123456789ABCDEF";
	int index = a&0x0f;
	printf("%c%c",HEX[(a&0xF0)>>4],HEX[a&0x0F]);
}

void four_byte_out(char *addr){
    
	char_hex_out(*(addr+3));
	char_hex_out(*(addr+2));
	char_hex_out(*(addr+1));
	char_hex_out(*(addr+0));
	printf("\n");
}

void float_add_overflow(){
    
	t1.i=0x7E000000;
	t2.i=0x7F000000;
	t3.f=t1.f+t2.f;
	char_hex_out(&t1.f);
	char_hex_out(&t2.f);
	char_hex_out(&t3.f);
	printf("t1=%.60f\n",t1.f);
	printf("t2=%.60f\n",t2.f);
	printf("t1+t2=%.60f\n",t3.f);
}

void float_sub_overflow(){
    
	t1.i=0x00c00000;
	t2.i=0x00800000;
	t3.f=t1.f-t2.f;
	char_hex_out(&t1.f);
	char_hex_out(&t2.f);
	char_hex_out(&t3.f);
	printf("t1=%.61f\n",t1.f);
	printf("t2=%.61f\n",t2.f);
	printf("t1+t2=%.61f\n",t3.f);
}

main(){
    
	float_add_overflow();
	float_sub_overflow();
}

实验思考略

汉字编码实验

区位码+A0A0H=G2312码
现在找出-A0A0H的补码
二进制数原码： 1010000010100000（对于16位数而言符号位溢出了）
二进制数反码： 1101111101011111（符号位不溢出）
二进制数补码： 1101111101100000
也就是df60

因为区号和尾号范围是1~94所以用7bit存储
很简单，，，
测试视频：点这里