浮点数加减乘除，模拟二进制加减乘除，位操作

最新推荐文章于 2023-02-18 16:06:35 发布
最新推荐文章于 2023-02-18 16:06:35 发布
阅读量1.8k 收藏 8
点赞数 1
分类专栏： data structure algorithm 文章标签： float binary decimal computer
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40840234/article/details/82596531
版权

浮点数的内存形式就不说了，就符号位，指数域，尾数域。
书本可以参考计算机体系结构
不多说，代码如下：


// float.cpp: 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include "string"
#include "iostream"
#include "iomanip"
#include "stack"
#include "queue"
#include "math.h"

using namespace std;

struct Myfloat
{
	bool sign;
	int enponential;
	int leave;
	Myfloat() { sign = 0; enponential = 0x00000000; leave = 0x00000000; };//两个构造函数
	Myfloat(bool sign, int enponential, int leave) :sign(sign), enponential(enponential), leave(leave) {};
};

class yusuan
{
public:
	yusuan();
	~yusuan();
	void get_string();//字符串输入
	void to_Myfloat(Myfloat&, string&);//将字符串先转换为十进制，再转换为二进制
	void to_Myfloat();//两次调用上一个函数
	double relieve(Myfloat);//用公式将浮点数还原
	static int to_right_one(int&);//右移一位，补0（其实没有必要）
	static int to_right_one(int&, int);//右移多位，补0
	static int to_left_one(int&);//左移一位，补0（其实没有必要）
	static int to_right_one_add_one(int&);//右移一位，补1
	static int to_left_one_add_one(int&);//左移一位，补1
	static int get_one_compare(int);//去1，第n位为0，其他为1
	static int onlyone_otherIsZero(int);//补1，第n位为1，其他为0
	static Myfloat add(Myfloat&, Myfloat&);//加法
	static Myfloat substruct(Myfloat&, Myfloat&);//减法
	static Myfloat multiply(Myfloat&, Myfloat&);//乘法
	static Myfloat divide(Myfloat&, Myfloat&);//除法

	Myfloat one;//第一个数
	Myfloat two;//第二个数
	string s_one;//字符串1
	string s_two;//字符串2
};

int yusuan::onlyone_otherIsZero(int n)
{
	int  ret = 0x80000000;
	n--;
	while (n--)
	{
		to_right_one(ret);
	}
	return ret;
}

Myfloat yusuan::divide(Myfloat& one_divide, Myfloat& two_divide)//二进制除法，不断地减，直到到23位
{
	Myfloat ret;
	Myfloat t1(0, one_divide.enponential, one_divide.leave);
	Myfloat t2(0, two_divide.enponential, two_divide.leave);

	if (two_divide.enponential == 0x00000000 && two_divide.leave == 0x00000000)
	{
		cout << "被除数不能为0" << endl;
	}
	else
	{
		if (one_divide.sign && !two_divide.sign || !one_divide.sign&&two_divide.sign)
		{
			ret = divide(t1, t2);
			ret.sign = 1;
		}
		else
		{
			ret.sign = 0;
			ret.enponential = t1.enponential - t2.enponential + 127 + 2;
			to_right_one_add_one(t1.leave);
			to_right_one_add_one(t2.leave);
			to_right_one(t1.leave);
			to_right_one(t2.leave);
			unsigned int leave1 = (unsigned int)t1.leave;
			unsigned int leave2 = (unsigned int)t2.leave;
			if (leave1 == leave2)
			{
				ret.leave = 0x00000000;
			}
			else
			{
				queue<bool> q;
				while (q.size() <= 24)
				{
					if (leave1 == leave2)
					{
						q.push(1);
						break;
					}
					else if (leave1 > leave2)
					{
						q.push(1);
						leave1 -= leave2;
					}
					else
					{
						q.push(0);
					}
					leave1 <<= 1;
					leave1 &= 0xfffffffe;
				}
				while (q.front() == 0 && !q.empty())
				{
					ret.enponential--;
					q.pop();
				}
				if (!q.empty())
				{
					q.pop();
					int temp = 0x80000000;
					while (!q.empty())
					{
						if (q.front())
						{
							ret.leave |= temp;
						}
						q.pop();
						to_right_one(temp);
					}
				}
				else
				{
					cout << "Something wrong!" << endl;
				}
			}
			ret.enponential -= 2;
		}
	}
	return ret;
}

int yusuan::to_right_one(int& temp, int n)
{
	while (n--)
	{
		to_right_one(temp);
	}
	return temp;
}

int yusuan::get_one_compare(int n)
{
	int ret = 0x7fffffff;
	n--;
	while (n--)
	{
		to_right_one_add_one(n);
	}
	return ret;
}

Myfloat yusuan::multiply(Myfloat& one_multiply, Myfloat& two_multiply)//二进制乘法
{
	Myfloat ret;
	Myfloat t1(0, one_multiply.enponential, one_multiply.leave);
	Myfloat t2(0, two_multiply.enponential, two_multiply.leave);
	int weight = 0;

	if ((!one_multiply.sign&&two_multiply.sign) || (one_multiply.sign && !two_multiply.sign))
	{
		ret = multiply(t1, t2);
		ret.sign = 1;
	}
	else
	{
		ret.sign = 0;
		ret.enponential = t1.enponential + t2.enponential - 127 + 2;
		to_right_one_add_one(t1.leave);
		to_right_one_add_one(t2.leave);
		unsigned long long leave1 = 0;
		leave1 |= (unsigned long long)t1.leave;
		leave1 &= 0x00000000ffffffff;
		unsigned long long leave2 = 0;
		leave2 |= (unsigned long long)t2.leave;
		leave2 &= 0x00000000ffffffff;
		unsigned long long add = leave1 << 23;
		unsigned long long compare = 0x0000000000000100;
		for (int i = 0; i < 24; i++)
		{
			if (compare&leave2)
			{
				leave1 += add;
			}
			leave1 >>= 1;
			leave2 >>= 1;
		}
		leave1 <<= 1;
		compare = 0x0080000000000000;
		add = 0x80000000;
		for (int i = 0; i < 24; i++)
		{
			if (compare&leave1)
			{
				ret.leave |= add;
			}
			compare >>= 1;
			add >>= 1;
		}
		for (int i = 0; i < 23; i++)
		{
			if (ret.leave & 0x80000000)
			{
				ret.enponential--;
				to_left_one(ret.leave);
				break;
			}
			ret.enponential--;
			to_left_one(ret.leave);
		}
	}

	return ret;
}

int yusuan::to_right_one_add_one(int& temp)
{
	temp >>= 1;
	temp |= 0x80000000;
	return temp;
}


int yusuan::to_left_one_add_one(int& temp)
{
	temp <<= 1;
	temp |= 0x00000001;
	return temp;
}

Myfloat yusuan::substruct(Myfloat& one_substruct, Myfloat& two_substruct)
{
	Myfloat ret;

	if (one_substruct.sign && !two_substruct.sign)//负减正
	{
		ret = two_substruct;
		ret.sign = 1;
		return add(one_substruct, ret);
	}
	else if (!one_substruct.sign && two_substruct.sign)//正减负
	{
		ret = two_substruct;
		ret.sign = 0;
		return add(one_substruct, ret);
	}
	else if (one_substruct.sign && two_substruct.sign)//负减负
	{
		ret = two_substruct;
		ret.sign = 0;
		Myfloat change(0, one_substruct.enponential, one_substruct.leave);
		return substruct(ret, change);
	}
	else//正减正
	{
		ret.sign = one_substruct.sign;
		int diffierent_of_enponential;
		int one_of_enponential = one_substruct.enponential - 127;
		int two_of_enponential = two_substruct.enponential - 127;

		diffierent_of_enponential = one_of_enponential - two_of_enponential;
		if (diffierent_of_enponential > 0)
		{
			Myfloat move_binary(two_substruct.sign, two_substruct.enponential, two_substruct.leave);
			to_right_one_add_one(move_binary.leave);
			move_binary.enponential++;
			diffierent_of_enponential--;
			for (int i = 0; i < diffierent_of_enponential; i++)
			{
				move_binary.enponential++;
				to_right_one(move_binary.leave);
			}
			ret.sign = one_substruct.sign;
			to_right_one_add_one(one_substruct.leave);
			ret.enponential = one_substruct.enponential + 1;
			to_right_one(move_binary.leave);
			ret.leave = one_substruct.leave - move_binary.leave;
			to_left_one(one_substruct.leave);
		}
		else if (diffierent_of_enponential < 0)//可以调换位置，再调用substruct,变符号
		{
			Myfloat move_binary(one_substruct.sign, one_substruct.enponential, one_substruct.leave);
			to_right_one_add_one(move_binary.leave);
			move_binary.enponential++;
			diffierent_of_enponential++;
			for (int i = 0; i < (-diffierent_of_enponential); i++)
			{
				move_binary.enponential++;
				to_right_one(move_binary.leave);
			}
			ret.sign = 1;
			to_right_one_add_one(two_substruct.leave);
			ret.enponential = two_substruct.enponential + 1;
			to_right_one(move_binary.leave);
			ret.leave = two_substruct.leave - move_binary.leave;
			to_left_one(two_substruct.leave);
		}
		else
		{
			ret.enponential = one_substruct.enponential;
			to_right_one_add_one(one_substruct.leave);
			to_right_one_add_one(two_substruct.leave);
			ret.enponential++;
			if (one_substruct.leave>two_substruct.leave)
			{
				ret.leave = one_substruct.leave - two_substruct.leave;
			}
			else
			{
				ret.leave = two_substruct.leave - one_substruct.leave;
				ret.sign = 1;
			}
			to_left_one(one_substruct.leave);
			to_left_one(two_substruct.leave);
		}
		for (int i = 0; i < 23; i++)
		{
			if (ret.leave & 0x80000000)
			{
				ret.enponential--;
				to_left_one(ret.leave);
				break;
			}
			ret.enponential--;
			to_left_one(ret.leave);
		}
	}

	return ret;
}

Myfloat yusuan::add(Myfloat& one_add, Myfloat& two_add)
{
	Myfloat ret;

	if (one_add.sign && !two_add.sign)//负加正
	{
		ret = one_add;
		ret.sign = 0;
		return substruct(two_add, ret);
	}
	else if (!one_add.sign && two_add.sign)//正加负
	{
		ret = two_add;
		ret.sign = 0;
		return substruct(one_add, ret);
	}
	else if (one_add.sign && two_add.sign)//负加负
	{
		ret = one_add;
		ret.sign = 0;
		Myfloat change(0, two_add.enponential, two_add.leave);
		ret = add(ret, change);
		ret.sign = 1;
		return ret;
	}
	else
	{
		int diffierent_of_enponential;

		ret.sign = one_add.sign;

		int one_of_enponential = one_add.enponential - 127;
		int two_of_enponential = two_add.enponential - 127;

		diffierent_of_enponential = one_of_enponential - two_of_enponential;
		if (diffierent_of_enponential > 0)
		{
			Myfloat move_binary(two_add.sign, two_add.enponential, two_add.leave);
			to_right_one_add_one(move_binary.leave);
			move_binary.enponential++;
			diffierent_of_enponential--;
			for (int i = 0; i < diffierent_of_enponential; i++)
			{
				move_binary.enponential++;
				to_right_one(move_binary.leave);
			}
			ret.enponential = one_add.enponential + 2;
			to_right_one_add_one(one_add.leave);
			to_right_one(move_binary.leave);
			ret.leave = to_right_one(one_add.leave) + to_right_one(move_binary.leave);
			to_left_one(one_add.leave);
			to_left_one(one_add.leave);
		}
		else if (diffierent_of_enponential < 0)//可以one和two换位置，用上面的计算
		{
			Myfloat move_binary(one_add.sign, one_add.enponential, one_add.leave);
			to_right_one_add_one(move_binary.leave);
			move_binary.enponential++;
			diffierent_of_enponential++;
			for (int i = 0; i < (-diffierent_of_enponential); i++)
			{
				move_binary.enponential++;
				to_right_one(move_binary.leave);
			}
			ret.enponential = two_add.enponential + 2;
			to_right_one_add_one(two_add.leave);
			to_right_one(move_binary.leave);
			ret.leave = to_right_one(two_add.leave) + to_right_one(move_binary.leave);
			to_left_one(two_add.leave);
			to_left_one(two_add.leave);
		}
		else
		{
			ret.enponential = one_add.enponential + 2;
			to_right_one_add_one(one_add.leave), to_right_one_add_one(two_add.leave);
			ret.leave = to_right_one(one_add.leave) + to_right_one(two_add.leave);
			to_left_one(one_add.leave);
			to_left_one(two_add.leave);
			to_left_one(one_add.leave);
			to_left_one(two_add.leave);
		}
		for (int i = 0; i < 23; i++)
		{
			if (ret.leave & 0x80000000)
			{
				ret.enponential--;
				to_left_one(ret.leave);
				break;
			}
			ret.enponential--;
			to_left_one(ret.leave);
		}
	}
	return ret;
}

double yusuan::relieve(Myfloat f)//不要传引用，传值
{
	double ret = 1;
	int compare = 0x80000000;

	if (f.enponential == 0x00000000 && f.leave == 0x00000000)return 0;

	int enponential = f.enponential - 127;

	ret *= pow(2, enponential--);
	for (int i = 0; i < 32; i++)
	{
		if (compare&f.leave)
		{
			ret += pow(2, enponential);
		}
		enponential--;
		to_right_one(compare);
	}
	return f.sign ? -ret : ret;
}

int yusuan::to_right_one(int& temp)
{
	temp >>= 1;
	temp &= 0x7fffffff;
	return temp;
}

int yusuan::to_left_one(int& temp)
{
	temp <<= 1;
	temp &= 0xfffffffe;
	return temp;
}

void yusuan::to_Myfloat()
{
	to_Myfloat(one, s_one);
	to_Myfloat(two, s_two);
}

void yusuan::to_Myfloat(Myfloat& f, string &s)
{
	char point;
	stack<bool> t;
	int temp = 0;

	point = (char)s.find('.');
	if (s.at(0) == '0' && point == string::npos)
	{
		f.enponential = 0x00000000;
		f.leave = 0x00000000;
		return;
	}
	if (s.at(0) != '-')
	{
		f.sign = 0;
		if (point == string::npos)//整数
		{
			for (int i = 0; i < s.size(); i++)//
			{
				temp = temp * 10 + s.at(i) - '0';
			}
			while (temp != 0)
			{
				t.push(temp % 2);
				temp /= 2;
			}
			f.enponential = t.size();//指数
			temp = 0x80000000;
			t.pop();
			for (int i = 0; !t.empty(); i++)
			{
				if (t.top())
				{
					f.leave |= temp;
				}
				t.pop();
				to_right_one(temp);
			}
		}
		else
		{
			queue<bool> q;
			int compare = 0;
			for (int i = 0; i < point; i++)
			{
				temp = temp * 10 + s.at(i) - '0';
			}
			while (temp != 0)
			{
				t.push(temp % 2);
				temp /= 2;
			}
			f.enponential = t.size();//未调整指数
			for (int i = 0; i < s.size() - point - 1; i++)
			{
				temp = temp * 10 + s.at(point + 1 + i) - '0';//将小数string化为整数乘2，不用float
				compare = i + 1;//记录位数
			}
			compare = (int)pow(10, compare);
			for (int j = 0; j < 23; j++)//尾部
			{
				temp *= 2;
				if (temp == compare)
				{
					q.push(1);
					break;
				}
				else if (temp > compare)
				{
					q.push(1);
					temp -= compare;
				}
				else
				{
					q.push(0);
				}
			}
			int i;
			temp = 0x80000000;
			if (f.enponential != 0)
			{
				t.pop();
				for (i = 0; !t.empty() && i <= 23; i++)
				{
					if (t.top())
					{
						f.leave |= temp;
					}
					t.pop();
					to_right_one(temp);
				}
			}
			else
			{
				while (q.front() != 1)
				{
					f.enponential--;
					q.pop();
				}
				q.pop();
				i = 0;
			}
			for (; !q.empty() && i <= 23; i++)
			{
				if (q.front())
				{
					f.leave |= temp;
				}
				to_right_one(temp);
				q.pop();
			}
		}
		f.enponential = f.enponential - 1 + 127;
	}
	else
	{
		s.erase(0, 1);
		to_Myfloat(f, s);
		f.sign = 1;
	}
}

void yusuan::get_string()
{
	cout << "请输入第一个数：";
	cin >> s_one;
	cout << "请输入第二个数：";
	cin >> s_two;
}

yusuan::yusuan()
{
}

yusuan::~yusuan()
{
}

int main()
{
	yusuan test;

	test.get_string();
	cout << test.s_one << "  " << test.s_two << endl;

	test.to_Myfloat();
	cout << test.one.sign << " " << test.one.enponential << " " << test.one.leave << endl;
	cout << fixed << setprecision(7) << test.relieve(test.one) << endl;
	cout << test.two.sign << " " << test.two.enponential << " " << test.two.leave << endl;
	cout << fixed << setprecision(7) << test.relieve(test.two) << endl;

	cout << fixed << setprecision(7) << "加法：" << test.relieve(test.add(test.one, test.two)) << endl;
	cout << fixed << setprecision(7) << "减法：" << test.relieve(test.substruct(test.one, test.two)) << endl;
	cout << fixed << setprecision(7) << "乘法：" << test.relieve(test.multiply(test.one, test.two)) << endl;
	cout << fixed << setprecision(7) << "除法：" << test.relieve(test.divide(test.one, test.two)) << endl;

	system("pause");

	return 0;
}

主要运用位操作（C语言），浮点数内存形式，二进制加减乘除（计算机体系结构）。

ruchuer
关注
专栏目录
c语言浮点数（float double）内存存储方式------移位存储
Clown_pan的博客
07-06 2776
最近偶然看到一段程序： #include<stdio.h> int main(){ int a=9; float *p; p=&a; printf("a数值为：%d\n",a); printf("float形式为：%f\n",*p); *p=9.0; printf("a数值为：%d\n",a); printf("float形式为：%f\n",*p); retu...
二进制浮点数以及二进制浮点数算术运算
热门推荐
nbu_dahe的博客
12-19 1万+
二进制浮点数以及二进制浮点数算术运算二进制浮点数表示半精度浮点数单精度浮点数双精度浮点数特殊情况浮点数的运算步骤一、对阶二、尾数运算三、结果规格化左规操作右规操作四、 舍入处理五、 溢出判断六、例子二进制浮点数加法二进制浮点数减法浮点运算逻辑电路Reference 二进制浮点数表示 阶码（指数）就是指数位存储的值，而偏阶（移码）则不同精度的浮点数的偏阶也各不相同，具体可以查看指数偏差。 Bias=2k−1−1Bias=2^{k-1}-1Bias=2k−1−1, 其中k是指数中的位数。 半精度浮点数 半精度
计组上机4/5 FPU：浮点数加减乘除运算
m0_53632564的博客
12-17 657
文章目录programming-03 *浮点数除法浮点数加法浮点数减法浮点数乘法浮点数除法 programming-03 *浮点数除法 浮点数加法 1、处理边界情况(NaN, 0, INF) 2、提取符号、阶码、尾数 重点在这里的对阶！！！ 3、模拟运算得到中间结果 难点在这里的尾码加法是原码加法！！ 4、规格化并舍入后返回 分为对尾码加法后上溢的判断和规格化数/非规格化数格式的判断 我的实现中难点在非规格化数->规格化数：需要判断隐藏位为1但阶码为0，此时把阶码改为1 浮点数减
浮点数的二进制计算-乘法及移位运算
weixin_43627680的博客
02-18 1943
浮点数bfloat16二进制存储形式及二进制计算
浮点数二进制运算
hnzyycsdn的博客
11-30 371
用StringBuilder进行字符串拼接，对输入的浮点数进行2倍运算，判断其是否大于1，如果大于1，那么字符串尾部加1，否则加0，若字符串长度大于32，那么输出Error，否则继续循环，最后输出字符串。 import java.util.Scanner; public class Yu { public static void main(String[] args) { ...
FPGA浮点数加减乘除基于verilogHDL
05-12
综上所述，基于Verilog HDL的FPGA浮点数加减乘除设计是一个涉及理论知识和实践技能的综合任务。从理解和表示浮点数，到编写Verilog代码，再到验证和实现，每一个步骤都需要深入理解和细致的工作。对于初学者和大学...
用MIPS整数运算指令实现浮点数的加减乘除
01-21
在MARS4.5中成功编译运行。有人机交互的字符界面，可供用户进行功能选择，用户输入浮点数，选择加减乘除功能，输出十进制，二进制，十六进制的结果。
fpga实现浮点数加减乘除四则运算
06-11
在 FPGA（Field-Programmable Gate Array）设计中，实现浮点数的加减乘除四则运算是一项挑战性的工作，因为浮点数运算涉及到复杂的数值处理和精度控制。这里我们将详细探讨根据IEEE754浮点数标准进行四则运算的原理...
详解js加减乘除精确计算
10-17
JavaScript中的加减乘除运算在处理浮点数时可能会出现精度丢失的问题，这是由于计算机内部存储和计算浮点数的方式导致的。浮点数在计算机内存中是以二进制表示的，某些十进制小数转换成二进制时无法精确表示，从而...
解决JS浮点数(小数)计算加减乘除的BUG
最新发布
01-04
== 0.3`，这是因为`0.1`和`0.2`在二进制表示下无法精确表示，它们的近似值在相加后与`0.3`存在微小的差距。这种现象在JavaScript以及其他使用IEEE 754标准的编程语言中都很常见。 为了解决这个JS浮点数计算的bug，...
浮点数的加减乘除运算
10-25
浮点数的加减乘除运算 白中英，科技出版社的课件
浮点数二进制互转小工具
01-10
浮点数转二进制，二进制转浮点数，E，PI转二进制小工具
计算机基础：20、二进制--浮点数的乘除法运算
weixin_36020178的博客
06-14 3050
计算机基础：20、二进制--浮点数的乘除法运算浮点数乘法公式浮点数的除法公式例子 浮点数乘法公式 浮点数的除法公式 例子 浮点数的乘除法运算也是分成阶码运算、尾数运算、尾数规格化、舍入、溢出判断这几个过程的。 ...
浮点数二进制计算
weixin_38249353的博客
05-11 2985
十进制的小数转换成二进制：小数部分和2相乘，取整数，不足1取0，每次相乘都是小数部分，顺序看取整后的数就是转化结果 比如：0.432*2=0.864取整0 0.864*2=1.728取1 让都是截取小数部分 0.728*2=1.456 因为0.432只有三位，所以只需取三位 0.432的二进制数为：0.011 ...
C语言中的移位运算乘法,C语言中 移位操作运算
weixin_31354669的博客
05-17 1209
移位规律：左移时总是移位和补零。右移时无符号数是移位和补零，此时称为逻辑右移;而有符号数大多数情况下是移位后补最左边的位(也就是补最高有效位)，移几位就补几位,此时称为算术右移。(其实跟扩展逻辑一样)。C语言中的移位操作，内容不多。不过有些地方你不注意，就疏忽了。先做两个小题先。(1)unsigned char x=3;x<<1是多少？x>>1是多少？(2)char x=3...
c语言乘法如何用移位实现,使用乘法器实现各种移位操作
weixin_36407256的博客
05-19 1554
实现的框图如下所示：考虑对32位数据处理核心器件就是一个乘法器。a是输入的32位数据，num是移位的5位数据b是乘法器的64位输出下面是实现各种移位的算法：1、逻辑左移：结果取D2、逻辑右移：num取反加1，结果取C3、算术右移：num取反加1，结果取C。如果A[31]为1，A取反，在对结果C取反即可。为0，结果取C。4、循环右移：num取反加1，结果取C|D。看似是很简单的，而且算法也还是挺奇特...
float转换为二进制
蓝格子云
03-11 2405
float在计算机中占32-bit，从左到右为：符号位（1-bit）、指数位（8-bit）、底数位（23-bit）。 说明：符号位：负1，正0             指数位：在得到指数后，+127             底数位：移动小数点到只剩1位整数，小数点左侧换为二进制，小数点右侧从左到右位的权重分别为：1/2、1/4、1/8...换算完后，省略掉第一个数字1
c语言中计算浮点数乘以正整数,深入计算机系统----整型与浮点型---2018.09.25
weixin_30611227的博客
05-20 2775
一、各种进制的相互转换先比比一下二进制的缺点，移植性差。一、正整数的十进制转换二进制：要点：除二取余，倒序排列解释：将一个十进制数除以二，得到的商再除以二，依此类推直到商等于一或零时为止，倒取将除得的余数，即换算为二进制数的结果例如把52换算成二进制数，计算结果如图：52除以2得到的余数依次为：0、0、1、0、1、1，倒序排列，所以52对应的二进制数就是110100。由于计算机内部表示数的字节单位...
C语言编写浮点乘法函数,C语言实现 加减乘除四则运算（小数）
weixin_29352517的博客
05-17 3080
没什么可说的，很简单，写出加减乘除函数，在用switch....case语句调用就行了；代码实现如下：#includefloat add(float a,float b){return a+b;}float sub(float a,float b){return a-b;}float mul(float a,float b){return a*b;}float div(float a,float ...
编译器可以算最大多少位的加减乘除
09-24
例如，32位编译器可以处理32位二进制数的加减乘除运算。这意味着它可以处理范围在-2^31到2^31-1之间的整数运算。超出此范围的数值可能导致溢出错误或意想不到的结果。 而64位编译器可以处理64位二进制数的加减乘除...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值