精华内容
下载资源
问答
  • 通过C语言实现小数整数求原码、反码、补码判断输入的值是整数还是小数,是正是负求纯整数不含符号的原码求纯小数不含符号的原码完善整个原码(符号、小数整数合在一起)将求原码的函数封装在一个函数里求反码的...

    判断输入的值是整数还是小数,是正是负

    j、k都是用来标记的

    void judge(double x){
    	double i=x;
    	//判断是正是负 
    	if(i<0){
    		j=1;
    		i=-i;
    	}
    	else j=0;
    	//判断是纯小数还是纯整数 
    	int n=i/1;
    	double l=i-n;
    	if(n>=1&&l==0){
    		//printf("纯整数\n");
    		k=1;
    	}
    	else if(n==0&&l>0){
    		//printf("纯小数\n"); 
    		k=-1;
    	}
    	else {
    		//printf("请输入纯小数或者纯整数\n");
    		k=0;
    	}
    } 
    

    求纯整数不含符号的原码

    这里采用了递归的方法求整数原码,函数名起的有点草率
    a数组是用来存储整数原码的数组

    void digui(int i){
    	if(i==0){
    		return;
    	}
    	else {
    		digui(i/2);
    		a[s++]=i%2;
    		return;
    	}
    }
    

    求纯小数不含符号的原码

    方法主要是while中的方法,b数组是用来存储小数原码的数组,

    void digui1(double i){
    	int ss=0;
    	double x=i;
    	while(x!=0){
    		x=x*2;
    		if(x>1){
    			x=x-(int)x;
    			b[ss++]=1;
    		}
    		else if(x<1){
    			b[ss++]=0;
    		}}
    	if(ss>20) ss=20;//限制小数位数
    	for(int m=0;m<ss;m++)//在该方法直接输出小数原码结果
    		printf("%d",b[m]);
    	for(int m=0;m<ss;m++)//结果存入c数组
    		c[cc++]=b[m]+'0';
     
    }
    

    完善整个原码(符号、小数、整数合在一起)

    通过K的值来判断是纯小数还是纯整数或者是整数小数一体
    通过j的值来判断输入的值是正是负,进而输出对应的0 或 1

    if(k==1){
    		int i1=i;
    		if(i<0) 
    			i1=-i1;
    		s=0;
    		digui(i1);
    		int s1=s; s=0;
    		if(j==1){
    			printf("1,");
    			c[0]='1';
    			c[1]=',';
    		}
    		else{
    			printf("0,"); 
    			c[0]='0';
    			c[1]=',';
    		} 
    		cc=2;
    		for (int m=0;m<s1;m++)
    			printf("%d",a[m]);
    		printf("\n");
    		for(int m=0;m<s1;m++)
    			c[cc++]=a[m]+'0';
    	}
    	else if(k==-1){
    		double i2=i;
    		if(i<0) 
    			i2=-i2;
    		if(j==1){
    			printf("1.");
    			c[0]='1';
    			c[1]='.';
    		}
    		else{
    			printf("0."); 
    			c[0]='0';
    			c[1]='.';
    		}
    		cc=2;
    		//printf("i2的值:%lf\n",i2); 
    		digui1(i2);
    		printf("\n");
    	}
    	else if(k==0){
    		int i3=i;
    		double i4=i-i3;
    		if(i3<0) {
    			i3=-i3;
    			i4=-i4;
    		}
    		if(j==1){
    			printf("1,");
    			c[0]='1';
    			c[1]=',';
    		}
    		else{
    			printf("0,"); 
    			c[0]='0';
    			c[1]=',';
    		} 
    		cc=2;s=0;
    		digui(i3);
    		for(int l=0;l<s;l++){
    			printf("%d",a[l]);
    		}
    		for(int l=0;l<s;l++){
    			c[cc++]=a[l]+'0';
    		}
    		c[cc++]='.';
    		printf(".");
    		digui1(i4);
    		printf("\n");
    	}
    	
    }
    

    将求原码的函数封装在一个函数里

    void Binary_source(double n){
    	judge(n); 
    	Original(n);
    }
    

    求反码的函数

    void Fbinary_source(char a[]){
    	if(c[0]=='0'){
    		for(int m=0;m<cc;m++){
    		printf("%c",c[m]);
    	}
    	}
    	else {
    		for(int m=2;m<cc;m++){
    		if(c[m]=='1') c[m]='0';
    		else if(c[m]=='0') c[m]='1';
    		
    	}
    	for(int m=0;m<cc;m++){
    		printf("%c",c[m]);
    	}
    	
    	}printf("\n");
    	
    }
    

    求补码的函数

    负数的补码=反码+1
    实现满2进1,直接从末尾开始找1,遇见1就变0,遇到0就变1 再跳出循环。

    void Complement_number(char a[]){
    
    	if(c[0]=='0'){
    		for(int m=0;m<cc;m++){
    		printf("%c",c[m]);
    	}
    	}
    	else {
    		for(int m=cc-1;m>2;m--){
    		if(c[m]=='1') c[m]='0';
    		else if(c[m]=='0') {
    			c[m]='1';
    			break;
    		}
    		
    	}
    	for(int m=0;m<cc;m++){
    		printf("%c",c[m]);
    	}
    	
    	}printf("\n");
    	
    }
    

    main函数

    0是特殊情况,单独拿出来写了

    int main(){
    	while(true){
    	double n;
    	printf("请输入十进制真值:");
    	scanf("%lf",&n);
    	if(n==0){
    		printf("+0:\n"); 
    		printf("原码:00000000\n反码:00000000\n补码:00000000\n");
    		printf("-0:\n"); 
    		printf("原码:10000000\n反码:11111111\n补码:00000000\n");
    		continue;
    	}
    	printf("原码:"); 
    	Binary_source(n);
    	printf("C[]中的值:");
    	c[cc]='\0';
    //	for(int i=0;i<2;i++) printf("%s",c[i]);
    	puts(c);
    	printf("反码:");
    	Fbinary_source(c);
    	printf("补码:");
    	Complement_number(c);
    	}
    } 
    

    整个实现代码

    #include<stdio.h>
    int j,k;//标识输入的数纯整数还是纯小数 
    int a[200],s=0,b[200],cc=0;
    char c[1000];
    void judge(double x){
    	double i=x;
    	//判断是正是负 
    	if(i<0){
    		j=1;
    		i=-i;
    	}
    	else j=0;
    	//判断是纯小数还是纯整数 
    	int n=i/1;
    	double l=i-n;
    	if(n>=1&&l==0){
    		//printf("纯整数\n");
    		k=1;
    	}
    	else if(n==0&&l>0){
    		//printf("纯小数\n"); 
    		k=-1;
    	}
    	else {
    		//printf("请输入纯小数或者纯整数\n");
    		k=0;
    	}
    } 
    //递归求纯整数不含符号的二进制原码 
    void digui(int i){
    	if(i==0){
    		return;
    	}
    	else {
    		digui(i/2);
    		a[s++]=i%2;
    		return;
    	}
    }
    //求纯小数不含符号的二进制原码 
    void digui1(double i){
    	int ss=0;
    	double x=i;
    	while(x!=0){
    		x=x*2;
    		if(x>1){
    			x=x-(int)x;
    			b[ss++]=1;
    		}
    		else if(x<1){
    			b[ss++]=0;
    		}}
    	if(ss>20) ss=20;
    	for(int m=0;m<ss;m++)
    		printf("%d",b[m]);
    	for(int m=0;m<ss;m++)
    		c[cc++]=b[m]+'0';
     
    }
    //完整的二进制原码 
    void Original(double i){
    	if(k==1){
    		int i1=i;
    		if(i<0) 
    			i1=-i1;
    		s=0;
    		digui(i1);
    		int s1=s; s=0;
    		if(j==1){
    			printf("1,");
    			c[0]='1';
    			c[1]=',';
    		}
    		else{
    			printf("0,"); 
    			c[0]='0';
    			c[1]=',';
    		} 
    		cc=2;
    		for (int m=0;m<s1;m++)
    			printf("%d",a[m]);
    		printf("\n");
    		for(int m=0;m<s1;m++)
    			c[cc++]=a[m]+'0';
    	}
    	else if(k==-1){
    		double i2=i;
    		if(i<0) 
    			i2=-i2;
    		if(j==1){
    			printf("1.");
    			c[0]='1';
    			c[1]='.';
    		}
    		else{
    			printf("0."); 
    			c[0]='0';
    			c[1]='.';
    		}
    		cc=2;
    		//printf("i2的值:%lf\n",i2); 
    		digui1(i2);
    		printf("\n");
    	}
    	else if(k==0){
    		int i3=i;
    		double i4=i-i3;
    		if(i3<0) {
    			i3=-i3;
    			i4=-i4;
    		}
    		if(j==1){
    			printf("1,");
    			c[0]='1';
    			c[1]=',';
    		}
    		else{
    			printf("0,"); 
    			c[0]='0';
    			c[1]=',';
    		} 
    		cc=2;s=0;
    		digui(i3);
    		for(int l=0;l<s;l++){
    			printf("%d",a[l]);
    		}
    		for(int l=0;l<s;l++){
    			c[cc++]=a[l]+'0';
    		}
    		c[cc++]='.';
    		printf(".");
    		digui1(i4);
    		printf("\n");
    	}
    	
    }
    void Binary_source(double n){
    	judge(n); 
    	Original(n);
    }
    void Fbinary_source(char a[]){
    	if(c[0]=='0'){
    		for(int m=0;m<cc;m++){
    		printf("%c",c[m]);
    	}
    	}
    	else {
    		for(int m=2;m<cc;m++){
    		if(c[m]=='1') c[m]='0';
    		else if(c[m]=='0') c[m]='1';
    		
    	}
    	for(int m=0;m<cc;m++){
    		printf("%c",c[m]);
    	}
    	
    	}printf("\n");
    	
    }
    void Complement_number(char a[]){
    
    	if(c[0]=='0'){
    		for(int m=0;m<cc;m++){
    		printf("%c",c[m]);
    	}
    	}
    	else {
    		for(int m=cc-1;m>2;m--){
    		if(c[m]=='1') c[m]='0';
    		else if(c[m]=='0') {
    			c[m]='1';
    			break;
    		}
    		
    	}
    	for(int m=0;m<cc;m++){
    		printf("%c",c[m]);
    	}
    	
    	}printf("\n");
    	
    }
    int main(){
    	while(true){
    	double n;
    	printf("请输入十进制真值:");
    	scanf("%lf",&n);
    	if(n==0){
    		printf("+0:\n"); 
    		printf("原码:00000000\n反码:00000000\n补码:00000000\n");
    		printf("-0:\n"); 
    		printf("原码:10000000\n反码:11111111\n补码:00000000\n");
    		continue;
    	}
    	printf("原码:"); 
    	Binary_source(n);
    	printf("反码:");
    	Fbinary_source(c);
    	printf("补码:");
    	Complement_number(c);
    	}
    } 
    

    测试数据结果

    在这里插入图片描述

    展开全文
  • 是1084751872 把这个内存里面的值转为十进制小数就很简单了: //1,首先判断S表示的正负 + //2,计算出E实际表示的指数 1000 0001 = 129 129 - 127 = 2 //3,根据M写出二进制小数形式 1.0101 * 2^2 = ...

    8ebea89b80be8e592efd1e6ef1ad40ee.png

    什么是进制

    进制也就是进位计数制,是人为定义的带进位的计数方法。对于任何一种进制---N进制,就表示每一位置上的数运算时都是逢N进一位。

    数数相信大家都会了,比如0 1 2 3 4 5 6 7 8 9 10 11 12 13...,在数数时某一位数量满10了就向前进位,这种逢十进一的进位制,就叫十进制。

    不过在日常生活中,并不止这一种进位制,比如1小时有60分钟,1分钟有60秒,满60进一,这就是六十进制。

    而在计算机中常用的进制除了十进制,还有二进制、八进制、十六进制

    二进制

    组成:0 1

    规则:逢二进一

    表示方式:二进制数1000010可写成(1000010)2或写成1000010B

    八进制

    组成:0 1 2 3 4 5 6 7

    规则:逢八进一

    表示方式:八进制数520可写成(520)8或写成520O

    十六进制

    组成:0 1 2 3 4 5 6 7 8 9 A B C D E F

    规则:逢十六进一

    表示方式:十六进制的520可以写成(520)16或写成520H

    为什么在计算机中,有这么多种进制表示方式?

    方便:二进制数中只有两个数码0和1,可用具有两个不同稳定状态的元器件来表示一位数码。

    简单:二进制数运算简单,大大简化了计算中运算部件的结构,0+0=0,0+1=1,1+0=1,1+1=10。

    真假:二进制天然兼容逻辑运算。

    缺点:二进制计数在日常使用上有个不便之处,就是位数往往很长,读写不便,如:把十进制的100000D写成二进制就是11000011010100000B,所以计算机领域我们实际采用的是十六进制。二进制数转换为十六进制数时,长度缩减为原先的约四分之一,把十进制的100000写成八进制就是303240。十六进制的一个数位可代表二进制的四个数位。这样,十进制的100000写成十六进制就是186A0。

    存储单位

    我们平常使用的程序,如:Windows操作系统、打字软件、游戏软件等。一般安装在硬盘等外存上,但仅此是不能使用其功能,必须把它们调入内存中运行,才能真正使用其功能。

    因为内存的读写速度相对于外存来说非常快,但是内存是暂时存储程序以及数据的地方。当我们使用WPS处理文稿时,当你在键盘上敲入字符时,它被存入内存中。当你选择存盘时,内存中的数据才会被存入硬(磁)盘。

    内存是由无数个晶体管组成的(可以理解为灯泡),一个晶体管作为一比特(bit)的存储器。每个晶体管可以存储一个二进制0或1,比特通常也叫做位。

    位(bit): 计算机存储的最小单位

    字节(byte): 数据表示的最小单位

    一个字节通常8位长 1byte = 8 bit

    千字节(KB):

    1KB = 1024byte

    为什么是1024,而不是1000呢?二的十次方刚好是1024,就这么表示啦~

    字节以上的转换单位都是1024,只有一个字节等于八个位是不一样的...

    思考:为什么硬盘标注的容量与实际的容量不一样?

    买的256G硬盘实际上只有238.4G,咱们一起来换算一下:

    硬盘厂商十进制计算:256G = 256,000MB = 256,000,000KB = 256,000,000,000Byte 以1000为单位换算操作系统二进制计算: 256G = 262,144MB = 268,435,456KB = 274,877,906,944Byte 以1024为单位换算那么256G实际容量:256,000,000,

    000Byte/1024MB/1024MB/1024MB = 238.4G

    所以,买256G硬盘实际上只有238.4G,而且容量越大差距也就越大了。

    进制转换

    十进制转其他进制:短除法

    以十进制数520为例,分别转换为二进制、八进制和十六进制,转换过程如下:

    其他进制转十进制:位权相加

    就以上面的520D的二进制、八进制和十六进制为例

    首先,需要对其他进制从右往左依次开始编号,0 1 2 3 4 5 ...

    然后,把每一位的数通过这个公式【数值 * 基数^编号】计算,然后把结果相加,即得到转换结果

    二进制10 0000 1000 转十进制

    98 7654 3210 编号

    10 0000 1000 B

    1*2^9 + 0 + 1*2^3 = 512 + 0 + 8 = 520 D

    八进制1010 转十进制

    3210 编号

    1010 O

    1*8^3 + 0 +1*8^0  = 520 + 8 =520 D

    十六进制208 转十进制

    210 编号

    208 H

    2*16^2 + 0 + 8*16^0 = 2*256 + 8 = 520 H

    八进制、十六进制与二进制相互转换:拆位

    八进制与二进制

    一个八进制数可以拆分为3个二进制数,3个二进制数可以合成一个八进制数

    //二进制转八进制

    001 000 001 000 B

    1   0   1   0   O

    //八进制转二进制

    1   3   1   4   5   2   0    O

    001 011 001 100 101 010 000  B

    十六进制与二进制

    一个八进制数可以拆分为4个二进制数,4个二进制数可以合成一个八进制数

    //二进制转十六进制

    0010 0000 1000 B

    2    0    8    H

    //十六进制转二进制

    1    3    1    4    5    2    0    H

    0001 0011 0001 0100 0101 0010 0000 B

    为什么可以这样拆位呢?

    三位二进制数表示的范围是[0 - 8) -> 2^3 对于八进制来说刚刚好

    四位二进制数表示的范围是[0 - 16) -> 2^4 对于十六进制来说刚刚好

    整数的存储方式

    一,机器数和机器数的真值

    1,机器数

    一个数在计算机中的二进制表示形式,叫做这个数的机器数。机器数是带符号的,在计算机用机器数的最高位存放符号,正数为0,负数为1。

    比如,十进制中的数 +3 ,计算机字长为8位,转换成二进制就是0000 0011,如果是 -3 ,就是 100 00011 。

    那么,这里的 0000 0011 和 1000 0011 就是机器数。

    2,机器数的真值

    因为第一位是符号位,所以机器数的形式值就不等于真正的数值。

    例如上面的有符号数 1000 0011,其最高位1代表负,其真正数值是 -3,而不是形式值131(1000 0011转换成十进制等于131)。所以,为区别起见,将带符号位的机器数对应的真正数值称为机器数的真值。

    例:0000 0001的真值 = +000 0001 = +1,1000 0001的真值 = –000 0001 = –1

    二,原码, 反码, 补码

    让我们先了解原码、反码和补码的概念。对于一个数,计算机要使用一定的编码方式进行存储,原码、反码、补码是机器存储一个具体数字的编码方式。

    1,原码

    原码就是机器数,即用第一位表示符号,其余位表示值。比如:如果是8位二进制:

    [+1]原= 0000 0001

    [-1]原= 1000 0001

    第一位是符号位,因为第一位是符号位,所以8位二进制数的取值范围就是:(即第一位不表示值,只表示正负。)

    [1111 1111 , 0111 1111] 即 [-127 , 127]

    原码是人脑最容易理解和计算的表示方式。

    2,反码

    正数的反码是其本身;

    负数的反码是在其原码的基础上,符号位不变,其余各个位取反。

    [+1] = [0000 0001]原 = [0000 0001]反

    [-1] = [1000 0001]原 = [1111 1110]反

    可见如果一个反码表示的是负数,人脑无法直观地看出来它的数值。通常要将其转换成原码再计算。

    3,补码

    正数的补码就是其本身;

    负数的补码是在其原码的基础上,符号位不变,其余各位取反,最后+1。(也即在反码的基础上+1)

    [+1] = [0000 0001]原 = [0000 0001]反 = [0000 0001]补

    [-1] = [1000 0001]原 = [1111 1110]反 = [1111 1111]补

    对于负数,补码表示方式也是人脑无法直观看出其数值的。通常也需要转换成原码再计算其数值。

    三,为何要使用原码、反码和补码

    人脑可以知道第一位是符号位,在计算的时候我们会根据符号位,选择对真值区域的加减。(真值的概念在本文最开头) 但是对于计算机,加减乘数已经是最基础的运算,要设计得尽量简单,计算机辨别"符号位"显然会让计算机的基础电路设计变得十分复杂!

    于是人们想出了将符号位也参与运算的方法。我们知道,根据运算法则减去一个正数等于加上一个负数,即:1-1 = 1 + (-1) = 0, 所以机器可以只有加法而没有减法,这样计算机运算的设计就更简单了。

    我们以计算十进制表达式:1 - 1 = 0为例

    首先来看原码:

    1 - 1 = 1 + (-1) = [0000 0001]原+ [1000 0001]原= [1000 0010]原= -2

    如果用原码表示,让符号位也参与计算,显然对于减法来说,结果是不正确的。这也就是为何计算机内部不使用原码表示一个数。

    为了解决原码做减法的问题, 出现了反码:

    1 - 1 = 1 + (-1) = [0000 0001]原+ [1000 0001]原= [0000 0001]反+ [1111 1110]反= [1111 1111]反= [1000 0000]原= -0

    发现用反码计算减法,结果的真值部分是正确的。而唯一的问题其实就出现在"0"这个特殊的数值上,虽然人们理解上+0和-0是一样的,但是0带符号是没有任何意义的,而且会有[0000 0000]原和[1000 0000]原两个编码表示0。

    于是补码的出现,解决了0的符号问题以及0的两个编码问题:

    1-1 = 1 + (-1) = [0000 0001]原+ [1000 0001]原= [0000 0001]补+ [1111 1111]补= [1 0000 0000]补=[0000 0000]补=[0000 0000]原注意:进位1不在计算机字长里。

    这样0用[0000 0000]表示,而以前出现问题的-0则不存在了。而且可以用[1000 0000]表示-128:-128的由来如下:

    (-1) + (-127) = [1000 0001]原+ [1111 1111]原= [1111 1111]补+ [1000 0001]补= [1000 0000]补

    -1-127的结果应该是-128,在用补码运算的结果中,[1000 0000]补就是-128,但是注意因为实际上是使用以前的-0的补码来表示-128,所以-128并没有原码和反码表示。(对-128的补码表示[1000 0000]补,算出来的原码是[0000 0000]元,这是不正确的)

    使用补码,不仅仅修复了0的符号以及存在两个编码的问题,而且还能够多表示一个最低数。这就是为什么8位二进制,使用原码或反码表示的范围为[-127, +127],而使用补码表示的范围为[-128, 127]。

    整数的存储是将十进制为的整数转换成其相应的补码后存储。

    小数的存储方式

    现如今的计算机中浮点数的存储都是遵循IEEE754/854标准,以二进制的科学计数法存放到内存中。

    对于浮点数在计算机中有两种存储的精度,即单精度和双精度,单精度是32位,双精度是64位。

    符号S:0为正,1为负

    尾数M:小数点后面的部分

    指数E:即阶码,指明了小数点在数据中的位置

    为了让指数表示正、负引入了偏差码,float的为127,double的为1024

    十进制小数转二进制小数

    先把整数部分转化为二进制

    再把小数部分转化为二进制(用2乘以小数部分,每次将结果整数取出,然后用剩余小数部分继续乘以2,直到小数部分为零,或者达到要求的精度为止)

    以float f = 5.25为例

    整数部分:5 -> 101

    小数部分:0.25 -> 0.01

    0.25 * 2 = 0.5--- 0

    0.5  * 2 = 1.0  --- 1

    从上往下取值:0.01

    最后结果:101.01 = 1.0101 * 2^2

    可见指数实际值为2,加上偏差码127,2 + 127 = 129,129的二进制为10000001B,因此不难得到,8.25在内存中的存储情况为:

    bc9327fb4990d5c14b575348a8f42c19.png

    如果把这个值作为整型使用,将是一个很大的数字,是1084751872

    把这个内存里面的值转为十进制小数就很简单了:

    //1,首先判断S表示的正负     +

    //2,计算出E实际表示的指数   1000 0001 = 129   129 - 127 = 2

    //3,根据M写出二进制小数形式 1.0101 * 2^2 = 101.01

    //4,对二进制小数以小数点为界限开始编号

    210 -1-2 编号

    101. 0 1 B

    1*2^2 + 0 + 1*2^0 + 0*2^(-1) + 1*2^(-2) = 4 + 1 +  0.25 =5.25

    注意:

    在二进制,第一个有效数字必定是“1”,因此这个“1”并不会存储。

    浮点数不能精确表示其范围内的所有数。

    可精确表示的数不是均匀分布的,越靠近0越稠密。

    【编辑推荐】

    【责任编辑:姜华 TEL:(010)68476606】

    点赞 0

    展开全文
  • 这个要看小数按什么格式输入。如果按%s输入,也就是按字符串格式输入,先找到小数点的位置,然后统计下小数点后数字的长度。具体实现可参考:#include?#include?#include?int?main(int?argc,?char*?argv[]){????char...

    这个要看小数按什么格式输入。如果按%s输入,也就是按字符串格式输入,先找到小数点的位置,然后统计下小数点后数字的长度。具体实现可参考:#include?#include?#include?int?main(int?argc,?char*?argv[]){????char?a[128];????while(scanf("%s",a)!=EOF)????{????????if(strstr(a,"。

    ")!=NULL)????????printf("%d

    ",strlen(strstr(a,"。")+1));????????else?????????printf("0

    ");????}????system("pause");????return?0;?}如果按%f(对应float类型小数)或者%lf(double类型的小数)方式读入,则需要先去掉整数部分,然后看小数部分一直乘10减去整数部分,知道等于0,统计,乘了几次10,但是由于浮点数在计算机中存的并不是准确值,这个往往得不到正确的结果。

    可以使用sprintf(str,"%g",f);,然后由于f毕竟不是准确值,还是会出现有些问题,源码如下:#include?#include?#include?int?main(int?argc,?char*?argv[]){????char?a[128];????float?f;????while(scanf("%f",&f)!=EOF)????{????????sprintf(a,"%g",f);????????if(strstr(a,"。

    ")!=NULL)????????printf("%d

    ",strlen(strstr(a,"。

    ")+1));????????else?????????printf("0

    ");????}????system("pause");????return?0;?}这是最后一个已经出现错误,所以遇到要精确判断小数点的位数,最好直接按字符串读入,这和图灵机的工作原理暗暗相合。

    全部

    展开全文
  • c语言中,输入一个数字,怎么判断那个数字是整数还是实数,代码如下,输入实数后出现了死循环int main(void){SEQLIST a;int b;//用于保存输入选择的数字a.len=0;while(1){printf("*******************\n");printf(" ...

    c语言中,输入一个数字,怎么判断那个数字是整数还是实数,代码如下,输入实数后出现了死循环

    int main(void)

    {

    SEQLIST a;

    int b;//用于保存输入选择的数字

    a.len=0;

    while(1)

    {

    printf("*******************\n");

    printf("      0.创建       \n");

    printf("      1.显示       \n");

    printf("      2.插入       \n");

    printf("      3.删除       \n");

    printf("      4.定位       \n");

    printf("      5.退出       \n");

    printf("*******************\n");

    do{

    printf("请输入以上的整数,选择想要的操作\n");

    scanf("%d",&b);

    if(b<0||b>5)

    {

    printf("你所输入的操作错误,只能输入0到5之间的整数!\n");

    }

    }while(b<0||b>5);

    switch(b)

    {

    case 0: create(&a); break;

    case 1: display(&a); break;

    case 2: insert(&a); break;

    case 3:

    int b;

    if(a.len==0){

    printf("该线性表为空表,请先创建\n");

    break;}

    do{

    printf("请输入要删除第几个数据\n");

    scanf("%d",&b);

    if(a.len

    printf("输入数据错误\n");

    }while(a.len

    mydelete(&a,b);break;

    case 4: search(&a); break;

    case 5: exit(0);break;

    }

    }

    return 0;

    }

    展开全文
  • 在C中来判断输入的是浮点数是整数的DEMO。通过表达式m-(int)m是否大于0来判断或者把输入作为字符串读入,然后检索字符串中是否有"."来判断#include #define FIRST_DEMO //计算浮点数的位数//#define SECOND_DEMO//#...
  • 整数怎样转2进制,小数怎样转2进制就不说了。12.5:1. 整数部分12,二进制为1100; 小数部分0.5, 二进制是.1,先把他们连起来,从第一个1数起取24位(后面补0):1100.10000000000000000000这部分是有效数字。(把小数点...
  • 分离整数和小数部分

    千次阅读 2016-10-25 20:45:14
    编写一个程序,其功能为:从键盘上输入一个浮点数(小数点后有三位数),然后分别输出该数的整数部分和小数部分。
  • 第一章C语言中,字符数据用格式说明"%c"来输出,字符串数据用格式说明"%s"来输出。TC语言中,关键字及编译预处理命令用小写字母书写。T二元运算符均可以赋值运算符构成复合的赋值运算符。TC语言中,不能在变量名、...
  • C语言 分数化小数

    千次阅读 2017-01-27 13:50:09
    输入正整数a,b,c,输出a/b的小数形式,精确到小数点后c位。a,b≤10 6 ,c≤100。输入包含多组数据, 结束标记为a=b=c=0。样例输入:1 6 40 0 0样例输出:Case 1: 0.1667这道题靠计算机本身来做除法是会出现精度问题的,...
  • 时常有判断整数的需求,但查了下,实现判断整数需求的方法都有点复杂,自己想了个,挺简单,应该很早就有人用了。 int main(void) { float n1; int n; scanf("%f",&n1); n = n1; if(n==n1) { printf...
  • C++判断一个数是整数还是小数

    千次阅读 2020-08-09 09:12:01
    2、判断整数还是小数:定义接收内容的字符串bai string s,调用C++的getline方法,格式如下:getline(cin,s),getline可以接收空格,遇到换行zhi输入结束。然后依次判断字符串中的字符,是否为数字,如果遇到一个非...
  • 假设我们的环境只能存储得下 32 位的有符号整数,第1位为符号位后32位,其数值范围为 [−2^31 , 2^31 − 1]。 根据这个假设,如果反转后整数溢出那么就返回 0。 例: 输入: 12345 输出: 54321 解析: 第1位为符号...
  • C语言判断一个double型数是否为数学上的整数 例:判断整数x的平方根是否为整数(即判断x是否为完全平方数) #include <stdio.h> #include <math.h> int main () { int x; double m,n,k; scanf("%d",&x...
  • 一、整数类型(int)整数就是没有小数部分的数字,Python中的整数包括正整数、0 整数。有些强类型的编程语言会提供多种整数类型,每种类型的长度都不同,能容纳的整数的大小也不同,开发者要根据实际数字的大小...
  • 整数在内存中的存储 整型数就是通常使用的整数,分为无符号整数和带符号整数两大类。
  • // 判断小数还是整数 if(parseInt(num) == parseFloat(num)){//如果相等,就是整数 alert(num + '是整数'); }else{//否则就是小数 alert(num + '是小数'); } Number.isInteger = Number.isInteger || ...
  • #includeint main(){int num,s=1;scanf("%d",&...}扩展资料:三个循环的异同点:用whiledo…while循环时,循环变量的初始化的操作应在循环体之前,而for循环一般在语句1中进行的;while循环...
  • C语言中获取整数和浮点数的符号位

    千次阅读 2015-03-19 19:05:51
    很多时候,我们需要判断数值的正负,来做相应的逻辑处理。条件判断语句可以很好的完成这个需求。有时候会有下面的情况, if (x > 0) { x = x - 1; } else { x = 1 - x; } if (x ) { x = -x; } 正负只是数值的...
  • ’,s).group()里面的正则表达式匹配整数和小数,(.\d+)?判断有无小数,有则匹配,没有则只匹配整数 2.今天在写一个找出寻找文本(用C语言打印的内容输出到txt)里的变量的最大最小值的小脚本时,遇到传入si,sj两个...
  • 函数名称:整数转字符串,加入4位小数小数点 函数功能:将整数保存是字符数组中,字符数组大小是16位char,最后一位是0x00 入口参数:str,字符指针,value,需要转换的数据,precision小数点保留的位数 出口...
  • 教学目的:使学生掌握小数的连乘、乘加、乘减的运算顺序,能正确地进行计算,培养学生的迁移类推能力。教学重点:小数的连乘、乘加、乘减的运算顺序。教学难点:正确地计算小数的连乘、乘加、乘减的式题。教学过程:...
  • 最近在开发一个业务规则的项目,遇到一个问题,就是要判断一个无符号整数的有效二进制位数是多少。例如,5的二进制形式为101b,有3个二进制位,17的二进制形式为1 0001b,有5个二进制位。问题:已知n∈[0, pow(2, 31...
  • 整数显示无异常,小数显示有点异常(小数会有精度问题,后面在处理,先给大家贴出来代码)。 本次,使用了数组用来存放要显示的数值。 用单独的数码管显示函数进行显示,之前把数码管显示函数放在数据处理里面了...
  • C语言数组实现读入.txt各行超长整数小数相加并输出.txt 算是作为一个新手吧,这个代码因为一些语法错误以及情况考虑不周全因素导致调了很久,写的很繁琐,但是还是放在这里留念一下,具体我有在别的博客看到很简洁...
  • 例如,字符串"+100","5e2","-123","...思路:对每个字符进行判断,其中设置一个小数点的标志p指数e的个数标志eflag位置标志epos,分别用来表示字符串中e出
  • 1、C语言实验学生版(最新版)实验一:简单的C程序设计(2学时)一、实验方式:一人一机二、实验目的:1、了解C语言程序的编译环境编写过程。2、掌握C语言程序在Visual C+ 6.0环境下的调试过程。3、初步了解C语言程序...
  • c语言 判断回文数

    2020-03-06 13:07:16
    判断一个 5 位数是不是回文数。例如 12321 是一个回文数,即它的个位与万位相同,十位与千位相同。。 输入格式: 直接输入一个 5 位数正整数。 输出格式: 输出 “yes” 或 “no”。此处均为小写字母 我的答案 #...
  • c语言上机题库(阅读)1、给定n个数据, 求最小值出现的位置(如果最小值出现多次,求出第一次出现的位置即可)。2、编写程序求无理数e的值并输出。计算公式为:e=1+1/1!+1/2!+1/3!+......+1/n!当1/n!<0.000001时e=2....

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 14,440
精华内容 5,776
关键字:

c语言判断整数和小数

c语言 订阅