精华内容
下载资源
问答
  • 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....

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

    
    // 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语言),浮点数内存形式,二进制加减乘除(计算机体系结构)。

    展开全文
  • C语言实现超长整数的加减乘除四则运算杜丽娟;鞠宏军【期刊名称】《电脑开发与应用》【年(卷),期】2003(016)005【摘要】通过对C语言链表、字符串的应用,解决了高级程序设计语言处理数据存储空间的问题,实现了高级...

    用C语言实现超长整数的加减乘除四则运算

    杜丽娟;鞠宏军

    【期刊名称】《电脑开发与应用》

    【年(卷),期】2003(016)005

    【摘要】通过对C语言链表、字符串的应用,解决了高级程序设计语言处理数据存储空间的问题,实现了高级语言数据类型无法完成的超长整数、高精度加减乘除四则运算,并对其实现算法进行了简要的分析和介绍.

    【总页数】3页(36-38)

    【关键词】程序设计语言;链表;字符串;存储空间;长整数;四则运算

    【作者】杜丽娟;鞠宏军

    【作者单位】燕山大学,秦皇岛,053000;华北科技学院,北京,101601

    【正文语种】中文

    【中图分类】TP31

    【相关文献】

    1.用C语言字符串实现多位整数的高精度计算 [J], 蒋晓明; 徐启振

    2.C语言中实现超长整数加法运算的方法 [J], 乌兰图雅

    3.基于delphi的超长整数四则运算的实现 [J], 龚成清

    4.超长整数四则运算实现方法的研究 [J], 任治斌; 王存良; 耿国华; 李红达

    5.长二进制加减运算和长整数四则运算类 [J], 童小明

    以上内容为文献基本信息,获取文献全文请下载

    展开全文
  • c语言计算器代码(有注释),可实现、十、十六等多进制加减乘除运算,可实现界面刷新、返回、退出等多项功能
  • 用C++6.0编写的计算器,内含整数小数加减乘除二进制数组加减及求原码补码反码!#include#includeint main(){void top();void no1(),no2(),no3(),no4(),no5(),no6(),no7(),no8(),no9(),no10(),no11(),no12(),no13(),...

    用C++6.0编写的计算器,内含整数小数加减乘除、二进制数组加减及求原码补码反码!

    #include

    #include

    int main()

    {

    void top();

    void no1(),no2(),no3(),no4(),no5(),no6(),no7(),no8(),no9(),no10(),no11(),no12(),no13(),no14(),no15(),no16(),no17(),no18(),no19(),no20(),no21(),no22(),no23(),no24(),no25();

    void menu();

    int k=1;char m;

    char select;

    while(1)

    { system("cls"); //清屏

    menu();

    system("color 0a"); //绿化

    scanf("%c",&select);

    switch(select)

    {

    case'a':no1();break;

    case'b':no2();break;

    case'c':no3();break;

    case'd':no4();break;

    case'e':no5();break;

    case'f':no6();break;

    case'g':no7();break;

    case'h':no8();break;

    case'i':no9();break;

    case'j':no10();break;

    case'k':no11();break;

    case'l':no12();break;

    case'm':no13();break;

    case'n':no14();break;

    case'o':no15();break;

    case'p':no16();break;

    case'q':no17();break;

    case'r':no18();break;

    case's':no19();break;

    case't':no20();break;

    case'u':no21();break;

    case'v':no22();break;

    case'w':no23();break;

    case'x':no24();break;

    }

    scanf("%d",&k);

    if(k==0)break;

    if(k==1){printf("\n");}

    }

    return 0;

    }

    void menu()

    {

    //printf("\n 老师您好!我是通信2班的陈国昌 学号201130095092\n\n");

    printf(" 请键入字母选择功能,按其他键退出:\n\n");

    printf(" a.整数加法 h.小数乘法 o.八转十六 v.二进制加法运算\n\n");

    printf(" b.整数减法 i.小数除法 p.十进转二 w.二进制减法运算\n\n");

    printf(" c.整数乘法 j.二进转八 q.十进转八 x.二进制原补反码\n\n");

    printf(" d.整数除法 k.二进转十 r.十转十六\n\n");

    printf(" e.整除求余 l.二转十六 s.十六转二\n\n");

    printf(" f.小数加法 m.八进转二 t.十六转八\n\n");

    printf(" g.小数减法 n.八进转十 u.十六转十\n");

    }

    void no1()

    {int i,k=1,sum1=0,sum2=0;char num[20],rem[20];

    while(k==1){

    printf("整数加法,请输入第一个数:\n");

    scanf("%s",num);

    for(i=0;num[i]!=0;i++)

    {if(num[i]>47&&num[i]<58){sum1=sum1*10+num[i]-48;k=0;}

    else{printf("输入错误,输入的只能是0…9的数字,请重新输入:\n");k=1;break;}}}

    k=1;

    while(k==1){

    printf("请输入第二个数:\n");

    scanf("%s",rem);

    for(i=0;rem[i]!=0;i++)

    {if(rem[i]>47&&rem[i]<58){sum2=sum2*10+rem[i]-48;k=0;}

    else{printf("输入错误,输入的只能是0…9的数字,请重新输入:");k=1;break;}}}

    printf("%d+%d=%d\n",sum1,sum2,sum1+sum2);

    printf("键入1键继续,键入0键退出.\n");

    }

    void no2()

    {int i,k=1,sum1=0,sum2=0;char num[20],rem[20];

    while(k==1){

    printf("整数减法,请输入第一个数:\n");

    scanf("%s",num);

    for(i=0;num[i]!=0;i++)

    {if(num[i]>47&&num[i]<58){sum1=sum1*10+num[i]-48;k=0;}

    else{printf("输入错误,输入的只能是0…9的数字,请重新输入:\n");k=1;break;}}}

    k=1;

    while(k==1){

    printf("请输入第二个数:\n");

    scanf("%s",rem);

    for(i=0;rem[i

    展开全文
  • 用C++6.0编写的计算器,内含整数小数加减乘除二进制数组加减及求原码补码反码!#include#includeint main(){void top();void no1(),no2(),no3(),no4(),no5(),no6(),no7(),no8(),no9(),no10(),no11(),no12(),no13(),...

    用C++6.0编写的计算器,内含整数小数加减乘除、二进制数组加减及求原码补码反码!

    #include

    #include

    int main()

    {

    void top();

    void no1(),no2(),no3(),no4(),no5(),no6(),no7(),no8(),no9(),no10(),no11(),no12(),no13(),no14(),no15(),no16(),no17(),no18(),no19(),no20(),no21(),no22(),no23(),no24(),no25();

    void menu();

    int k=1;char m;

    char select;

    while(1)

    { system("cls"); //清屏

    menu();

    system("color 0a"); //绿化

    scanf("%c",&select);

    switch(select)

    {

    case'a':no1();break;

    case'b':no2();break;

    case'c':no3();break;

    case'd':no4();break;

    case'e':no5();break;

    case'f':no6();break;

    case'g':no7();break;

    case'h':no8();break;

    case'i':no9();break;

    case'j':no10();break;

    case'k':no11();break;

    case'l':no12();break;

    case'm':no13();break;

    case'n':no14();break;

    case'o':no15();break;

    case'p':no16();break;

    case'q':no17();break;

    case'r':no18();break;

    case's':no19();break;

    case't':no20();break;

    case'u':no21();break;

    case'v':no22();break;

    case'w':no23();break;

    case'x':no24();break;

    }

    scanf("%d",&k);

    if(k==0)break;

    if(k==1){printf("\n");}

    }

    return 0;

    }

    void menu()

    {

    //printf("\n 老师您好!我是通信2班的陈国昌 学号201130095092\n\n");

    printf(" 请键入字母选择功能,按其他键退出:\n\n");

    printf(" a.整数加法 h.小数乘法 o.八转十六 v.二进制加法运算\n\n");

    printf(" b.整数减法 i.小数除法 p.十进转二 w.二进制减法运算\n\n");

    printf(" c.整数乘法 j.二进转八 q.十进转八 x.二进制原补反码\n\n");

    printf(" d.整数除法 k.二进转十 r.十转十六\n\n");

    printf(" e.整除求余 l.二转十六 s.十六转二\n\n");

    printf(" f.小数加法 m.八进转二 t.十六转八\n\n");

    printf(" g.小数减法 n.八进转十 u.十六转十\n");

    }

    void no1()

    {int i,k=1,sum1=0,sum2=0;char num[20],rem[20];

    while(k==1){

    printf("整数加法,请输入第一个数:\n");

    scanf("%s",num);

    for(i=0;num[i]!=0;i++)

    {if(num[i]>47&&num[i]<58){sum1=sum1*10+num[i]-48;k=0;}

    else{printf("输入错误,输入的只能是0…9的数字,请重新输入:\n");k=1;break;}}}

    k=1;

    while(k==1){

    printf("请输入第二个数:\n");

    scanf("%s",rem);

    for(i=0;rem[i]!=0;i++)

    {if(rem[i]>47&&rem[i]<58){sum2=sum2*10+rem[i]-48;k=0;}

    else{printf("输入错误,输入的只能是0…9的数字,请重新输入:");k=1;break;}}}

    printf("%d+%d=%d\n",sum1,sum2,sum1+sum2);

    printf("键入1键继续,键入0键退出.\n");

    }

    void no2()

    {int i,k=1,sum1=0,sum2=0;char num[20],rem[20];

    while(k==1){

    printf("整数减法,请输入第一个数:\n");

    scanf("%s",num);

    for(i=0;num[i]!=0;i++)

    {if(num[i]>47&&num[i]<58){sum1=sum1*10+num[i]-48;k=0;}

    else{printf(&quot

    ;输入错误,输入的只能是0…9的数字,请重新输入:\n");k=1;break;}}}

    k=1;

    while(k==1){

    printf("请输入第二个数:\n");

    scanf("%s",rem);

    for(i=0;rem[i

    展开全文
  • printf("a-代表十进制转换为二进制。\n"); printf("b-代表十进制转换为八进制。\n"); printf("c-代表十进制转换为十六进制。\n"); printf("d-代表该数值开方。\n"); printf("e-代表该数值开立方。\n"); printf("f-...
  • 两个很大很大的整数(有几百位),我要把它转化成二进制数,然后每八位为一组,进行加减乘除运算。用C语言也行,用汇编也行。或者C语言里面嵌着汇编也可以。 一开始我用一个char型的数组, char a[500],来存储,...
  • 机器只懂得二进制,而程序运行依赖内存中的数据,而在内存中的数据却是十六进制的表示方式这又是为啥呢。 因为十六进制和二进制转换比较直观,做异或处理简单啊。 例如 0x1111 换成二进制就是...
  • 原标题:二进制十进制十六进制在阿程学习C语言的过程中,我的室友和我说他不懂什么是二进制,什么是十进制。在这里,阿程将告诉大家什么是二进制,十进制和十六进制:我们平时使用的数字都是由 0~9 共十个数字组成的...
  • win10系统之家今天精心准备的是《十进制转二进制计算器》,下面是详解!怎样用电脑计算器计算二进制用电脑计算器计算二进制的具体操作步骤如下:1、首先在电脑桌面上点击左下角的“开始”图案。2、然后会弹出一个...
  • 位运算实现整数加减乘除运算——C语言描述 ** 本文将从位运算的种类、原理、运用入手,详细介绍如何仅使用位运算实现整数的加减乘除运算,代码采用C语言实现。** ** 1.位运算 ** 我们知道,程序中的所有数据在计算机...
  • 思路:输入十进制数num,num对2/8/16取余,每一次的余数存放在arr[32]数组中,最后需要倒序输出数组的内容。 注意:十进制转换为十六进制时,要对每一次的余数进行判断,如果>9,则需要输出对应的大写字母A-E——...
  • 本文参考:https://blog.csdn.net/wn084/article/details/79963979原码:所谓原码就是机器数,是了一位符号位的二进制数(因为数值有正负之分),正数符号位为0,负数符号位为1.计算机中存储、处理、运算的数据通常是...
  • 十六进制数同二进制数及十进制数一样,也可以写成展开式的形式。 十进制整数转十六进制数:“除以16取余,逆序排列”(除16取余法) 例:(1765)10=C语言中十进制数和十六进制数能直接运算吗16进制数之间的加法怎么算...
  • 二进制加减法计算法则

    万次阅读 2020-02-12 14:24:09
    一、二进制加法(逢2进1) 举例:100111+11010=100001 1 0 0 1 1 1 1 1 0 1 0 —————— 1 0 0 0 0 1 十进制加法是逢十进一,二进制加法是逢二进一。 最低位:10得1。 倒数第2位:11得2,同时进1。 倒数第3位...
  • 数码:0,1基数:2二进制数的权展开式:(101.01) = 1*2²+0*2¹+1*2⁰+0*2⁻¹+1*2⁻²十进制转化为二进制: 除以二逆向取余法十进制转化为二进制(小数):乘以二顺向取整法在汇编中,在数字后字母B表示二进制数,...
  • 二进制中所有数位从右向左每三个分成一组,每组用一个0到7之间的数字替代。 这个替代结果叫做数字的八进制表示方式 0110 1010 01 101 010 152(八进制) 可以在程序中直接使用八进制方式表示数字,这个时候必须...
  • } 第二种思路:二进制乘法! 这一过程就是根据乘数的每一位为0或1时,将被乘数错位的在积上。时间复杂度为O(logN)。 (1) 判断乘数是否为0,为0跳转至步骤(4) (2) 将乘数与1作与运算,确定末尾位为1还是为0,如果...
  • 2.求两个数二进制形式不同位的个数 3.分别输出一个数二进制奇数位与偶数位 4.改写一个数二进制某一位的值 —————————————————————————————————————————————— *1.常用...
  • C语言中无符号整型在内存中直接存储整型的二进制形式。 unsigned short age = 18; sizeof(unsigned short) = 2字节 = 16位 18(10) -> 10010(2) -> 高位补0 -> 0000 0000 0001 0010 unsigned short 最大值 ...
  • 满意答案sunmuye2017.09.11采纳率:59%等级:9已帮助:713人C语言中,ASCII(pronunciation: /ˈæski/ ASS-kee,American Standard Codefor ...它主要用于显示现代英语ASCII 码使用指定的7 位或8 位二进制数组合...
  • 不用加减乘除做加法

    2017-11-09 21:18:35
    题目描述 写一个函数,求两个整数之和,要求在函数体内不得使用+、-、*、/四则...位运算是针对二进制的,我们也就以二进制再来分析一下前面的三步走策略对二进制是不是也管用。 5的二进制是101,17的二进制10001。
  • 不用加减乘除做加法位运算(&、|、^、~、>>、<<)1.位运算概述2.位运算概览3.按位与运算符(&)#4.按位或运算符(|)5.异或运算符(^)6.取反运算符 (~)7.左移运算符(<<)8.右移运算符...
  • 位运算是针对二进制的,我们就以二进制再来分析一下前面的三步走策略对二进制是不是也适用。 5的二进制是101,17的二进制是10001。 还是试着把计算分成三步:第一步各位相加但不计进位,得到的结果是10100(最后一位...
  • 位运算实现加减乘除

    2020-01-04 23:32:06
    今天就来看看怎么不使用显式“ + - * /”运算符来实现加减乘除运算。 下面我们一个一个来看。 1. 加法运算 先来个我们最熟悉的十进制的加法运算: 13 + 9 = 22 我们像这样来拆分这个运算过程: 不...
  • 大数、乘、除、余数、公倍数、公约数、进制转换目录 六、 大数取自然对数的算法 ,即我们如何快速算 log (x)这类问题 (1)假设大数很大 其实这个问题很简单,先求大数以10为底取对数,然后在结果乘以 ...
  • BigInt大整数运算库 前言 这个版本为第一个版本,未有太多优化。...数字的存储是以十进制为基础的,所以把一个char的大小定义为一个十进制存储bitDec。 而一个数字的表示采用基于bitDec的数组...
  • 题目:不用加减乘除做加法 写一个函数,求两个正数之和,要求在函数体内不能使用四则运算符号。 思路: 不能用四则运算,那只能通过位运算了。其实四则运算是针对十进制,位运算是针对二进制,都能用于运算。下面...
  • 怎样使用位操作分别实现整数的加减乘除四种运算? 2. 解决方式 须要熟练掌握一些常见功能的位操作实现,详细为: &lt;1&gt; 经常使用的等式:-n = ~(n-1) = ~n+1 &lt;2&gt; 获取整数n的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,644
精华内容 1,857
关键字:

c语言二进制加减乘除

c语言 订阅