C/C++ 高精度（加减乘除）算法压位优化

已于 2023-04-23 22:40:34 修改
阅读量967 收藏 7
点赞数 2
分类专栏： c++ c语言 文章标签： 算法 c++ c语言
于 2023-01-30 22:47:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u013113678/article/details/128611361
版权
c++ 同时被 2 个专栏收录
24 篇文章 3 订阅
订阅专栏
c语言
22 篇文章 1 订阅
订阅专栏

高级精度算法系列

第一章 简单实现
第二章 压位优化(本章)
第三章 二进制优化

文章目录

前言

由于上一章《C/C++ 高精度（加减乘除）算法简单实现》实现了基本的高精度计算，数组的每个元素存储一位10进制的数字。这样的存储方式并不是最优的，32位的整型其实至少可以存储9位高精度数字，数组元素存储更多的位数就是压位优化。本文将展示压位优化的原理以及压9位的实现和性能对比。

一、基本原理

1、存储方式

压位优化就是将原本存储一位的数组元素变成存储多位，这样就可以提升运算效率，通常最高能存储9位，如下图示例为存储4位。
在这里插入图片描述

2、计算方式

采用模拟立竖式计算，比如加法的计算流程，如下图所示，20481024+80001000=100482024：

在这里插入图片描述

二、完整代码

因为接口以及使用方法与上一章《C/C++ 高精度（加减乘除）算法简单实现》是完全一致的，所以这里直接展示完整代码，省略使用示例。下面代码为压9位实现。

#include<stdio.h>
#include<string.h>
#include<math.h>
#include<stdint.h>
/// <summary>
/// 通过字符串初始化
/// </summary>
/// <param name="a">[in]高精度数组</param>
/// <param name="value">[in]字符串首地址</param>
static void loadStr(int* a, const char* value) {
	int len = strlen(value);
	int left = len % 9;
	char s[8], * p = (char*)value + left;
	a[0] = ceil(len / 9.0);
	len = len / 9.0;
	for (int i = 1; i <= len; i++)
		sscanf(p + (len - i ) * 9, "%09d", &a[i]);
	if (left){
		sprintf(s, "%%0%dd", left);
		sscanf(value, s, &a[a[0]]);
	}
}
/// <summary>
/// 输出到字符串，
/// </summary>
/// <param name="a">[in]高精度数组</param>
/// <param name="str">[out]字符串，由外部停供缓冲区，需要保证长度足够</param>
static void toStr(int* a, char* str) {
	if (!a[0]) {
		sprintf(str, "0");
		return;
	}
	sprintf(str, "%d", a[a[0]]);
	str += strlen(str);
	for (int i = a[0]-1; i > 0; i--)
		sprintf(str +( a[0] -i-1)*9, "%09d", a[i]);
	str[(a[0]-1)*9] = '\0';
}
/// <summary>
/// 通过无符号整型初始化
/// </summary>
/// <param name="a">[in]高精度数组</param>
/// <param name="value">[in]整型值</param>
static void loadInt(int* a, uint64_t value) {
	a[0] = 0;
	while (value)a[++a[0]] = value % 1000000000, value /= 1000000000;
}

/// <summary>
/// 比较两个高精度数的大小
/// </summary>
/// <param name="a">[in]第一个数</param>
/// <param name="b">[in]第二个数</param>
/// <returns>1是a>b,0是a==b,-1是a<b</returns>
static int compare(int* a, int* b) {
	if (a[0] > b[0])return 1;
	if (a[0] < b[0])return -1;
	for (int i = a[0]; i > 0; i--)
		if (a[i] > b[i])return 1;
		else if (a[i] < b[i])return -1;
	return 0;
}
/// <summary>
/// 复制
/// </summary>
/// <param name="a">[in]源</param>
/// <param name="b">[in]目标</param>
static void copy(int* a, int* b) {
	memcpy(b, a, (a[0] + 1) * sizeof(int));
}
/// <summary>
/// 打印输出结果
/// </summary>
static void print(int* a) {
	int i = a[0];
	printf("%d", a[i--]);
	for (; i > 0; i--)printf("%09d", a[i]);
}

/// <summary>
/// 加
/// </summary>
/// <param name="a">[in]被加数</param>
/// <param name="b">[in]加数</param>
/// <param name="c">[out]结果</param>
static	void plus(int* a, int* b, int* c) {
	int* p;
	if (a[0] < b[0])p = a, a = b, b = p;//确保a长度最大	
	int i = 1, alen = a[0], blen = b[0];
	c[0] = c[alen + 1] = 0;
	if (a != c)memcpy(c + blen + 1, a + blen + 1, (alen - blen) * sizeof(int));//a多出的部分直接拷贝到结果
	for (; i <= blen; i++) {
		c[i] = a[i] + b[i];
		if (c[i - 1] >= 1000000000)c[i - 1] -= 1000000000, c[i]++;//判断上一位是否进位	
	}
	i--;
	while (c[i++] >= 1000000000)c[i - 1] -= 1000000000, c[i]++;//继续判断进位
	c[0] = c[alen + 1] ? alen + 1 : alen;//记录长度
}
/// <summary>
/// 加等于
///结果会保存在a中
/// </summary>
/// <param name="a">[in]被加数</param>
/// <param name="b">[in]加数</param>
static	void plusq(int* a, int* b) {
	plus(a, b, a);
}

/// <summary>
/// 减
/// </summary>
/// <param name="a">[in]被减数,被减数必须大于等于减数</param>
/// <param name="b">[in]减数</param>
/// <param name="c">[out]结果</param>
static	void sub(int* a, int* b, int* c) {
	int i = 1, alen = a[0];
	if (a != c)memcpy(c + b[0] + 1, a + b[0] + 1, (a[0] - b[0]) * sizeof(int));//a多出的部分直接拷贝到结果
	c[0] = 1;
	for (; i <= b[0]; i++) {
		c[i] = a[i] - b[i];
		if (c[i - 1] < 0)c[i - 1] += 1000000000, c[i] --;//判断上一位是否补位		
	}
	i--;
	while (c[i++] < 0)c[i - 1] += 1000000000, c[i]--;//继续判断补位	
	while (!c[alen--]); c[0] = alen + 1;//记录长度
}
/// <summary>
/// 减法等于
///结果会保存在a中
/// </summary>
/// <param name="a">[in]被减数，被减数必须大于等于减数</param>
/// <param name="b">[in]减数</param>
static	void subq(int* a, int* b) {
	sub(a, b, a);
}

/// <summary>
/// 乘
/// </summary>
/// <param name="a">[in]被乘数</param>
/// <param name="b">[in]乘数</param>
/// <param name="c">[out]结果，数组长度必须大于等于aLen+bLen+1</param>
static	void mul(int* a, int* b, int c[]) {
	int len = a[0] + b[0], d = 0;
	memset(c, 0, sizeof(int) * (len + 1));
	b[b[0] + 1] = 0; c[0] = 1;//防止越界
	for (int i = 1; i <= a[0]; i++)
		for (int j = 1; j <= b[0] + 1; j++){
			int64_t t = (int64_t)a[i] * b[j] + c[j + i - 1] + d;
			c[j + i - 1] = t % 1000000000;
			d = t / 1000000000;
		}
	while (!c[len])len--; c[0] = len;
}
/// <summary>
/// 乘等于
/// 累乘,结果存放于a
/// </summary>
/// <param name="a">[in]被乘数，数组长度必须大于等于2aLen+bLen+1</param>
/// <param name="b">[in]乘数</param>
static	void mulq(int* a, int* b) {
	int* c = a + a[0] + b[0] + 1;
	memcpy(c, a, (a[0] + 1) * sizeof(int));
	mul(c, b, a);
}

/// <summary>
/// 除法
/// 依赖减法subq
/// </summary>
/// <param name="a">[in]被除数,被除数必须大于除数</param>
/// <param name="b">[in]除数</param>
/// <param name="c">[out]商，数组长度大于等于3aLen-bLen+1</param>
/// <param name="mod">[out]余数，可以为NULL，数组长度大于等于aLen</param>>
static void div(int* a, int* b, int* c, int* mod) {
	int len = a[0] - b[0] + 1, times, hTimes[32], * temp = c + a[0] + 1;
	if (!mod)mod = temp + 2*(a[0] + 1)+1;//缓冲区
	memcpy(mod, a, (a[0] + 1) * sizeof(int));
	memset(c, 0, sizeof(int) * (len + 1));
	memset(temp, 0, sizeof(int) * len);
	c[0] = 1;//防止while越界
	for (int i = len; i > 0; i--) {
		memcpy(temp + i, b + 1, sizeof(int) * b[0]);//升阶	
		temp[0] = b[0] + i - 1;
		while (compare(mod, temp) != -1) {
			if (times = (mod[mod[0]] * ((mod[0] - temp[0]) ? 1000000000ll : 1)) / (temp[temp[0]] + (temp[0] == 1 ? 0 : 1)))//升倍数
			{
				loadInt(hTimes,times);
				mulq(temp, hTimes);
			}
			else times = 1;
			while (compare(mod, temp) != -1)subq(mod, temp), c[i] += times;	//减法
			memcpy(temp + i, b + 1, sizeof(int) * b[0]);//还原	
			temp[0] = b[0] + i - 1;
		}
	}
	while (!c[len])len--; c[0] = len;
}
/// <summary>
/// 除等于
/// 商保存在a
/// 依赖div
/// </summary>
/// <param name="a">[in]被除数,被除数必须大于除数</param>
/// <param name="b">[in]除数</param>
/// <param name="mod">[out]余数，可以为NULL，数组长度大于等于aLen</param>>
static void divq(int* a, int* b, int* mod) {
	div(a, b, a, mod);
}

三、性能对比

测试平台：Windows 11
测试设备：i7 8750h
测试方式：测试5次取均值
表1、测试用例

测试用例描述
1整型范围数字计算500000次
2长数字与整型范围数字计算500000次
3长数字与长数字计算500000次

基于上述用例编写程序进行测试，测试结果如下表
表2、测试结果

计算测试用例1位实现（上一章）耗时9位优化（本章）耗时
加法测试用例10.003926s0.002620s
加法测试用例20.026735s0.005711s
加法测试用例30.029378s0.005384s
累加测试用例10.003255s0.002536s
累加测试用例20.017843s0.002592s
累加测试用例30.034025s0.006474s
减法测试用例10.004237s0.002078s
减法测试用例20.024775s0.004939s
减法测试用例30.027634s0.004929s
累减测试用例10.004272s0.002034s
累减测试用例20.0054070.001942s
累减测试用例30.019363s0.004282s
乘法测试用例10.043608s0.004751s
乘法测试用例20.479071s0.028358s
乘法测试用例33.375447s0.064259s
累乘测试用例1 只计算1000次0.001237s0.000137s
累乘测试用例2 只计算1000次0.001577s0.000187s
累乘测试用例3 只计算1000次5.792887s0.081988s
除法测试用例10.025391s0.024763s
除法测试用例25.292809s0.516090s
除法测试用例30.395773s0.073812s
累除测试用例1 只计算1000次0.059054s0.035722s
累除测试用例2 只计算1000次0.103727s0.060936s
累除测试用例3 只计算500次89.748837s25.126072s

将上表数据进行分类相同类型取均值计算出提升速度如下图所示，仅作参考。

图1、速度提升
在这里插入图片描述

总结

以上就是今天要讲的内容，压位优化性能提升是比较显著的，而且实现也很容易，大部分逻辑是一致的只是底数变大了而已。从性能测试结果来看所有计算至少由4倍的提升，乘法性能提升较大有可能是测试方法不严谨，这个待以后验证。总的来说，对高精度运算进行压位优化还是很有必要的，尤其是对时间和空间有要求的场景还是比较适用的。

附录

1、性能测试代码

#include<Windows.h>
#include <iostream>
static int a[819200];
static int b[819200];
static int c[819200];
static int mod[819200];
static char str[81920];
/// <summary>
/// 返回当前时间
/// </summary>
/// <returns>当前时间，单位秒，精度微秒</returns>
static double  getCurrentTime()
{
	LARGE_INTEGER ticks, Frequency;
	QueryPerformanceFrequency(&Frequency);
	QueryPerformanceCounter(&ticks);
	return  (double)ticks.QuadPart / (double)Frequency.QuadPart;
}
/// <summary>
/// 性能测试
/// </summary>
static void test() {
	double d = getCurrentTime();
	loadStr(a, "50000");
	loadInt(b, 50000);
	for (int64_t i = 1; i <= 500000; i++) {
		plus(a, b, c);
	}
	printf("plus  performence   1: %llfs\n", getCurrentTime() - d);
	d = getCurrentTime();
	loadStr(a, "999999999999999999999999999999999999999999999999999999999999999999");
	loadInt(b, 5);
	for (int64_t i = 1; i <= 500000; i++) {
		plus(a, b, c);
	}
	printf("plus  performence   2: %llfs\n", getCurrentTime() - d);

	d = getCurrentTime();
	loadStr(a, "999999999999999999999999999999999999999999999999999999999999999999");
	loadStr(b, "11111111111111111111111111111111111111");
	for (int64_t i = 1; i <= 500000; i++) {
		plus(b, a, c);
	}
	printf("plus  performence   3: %llfs\n", getCurrentTime() - d);


	d = getCurrentTime();
	loadStr(a, "50000");
	loadInt(b, 50000);
	for (int64_t i = 1; i <= 500000; i++) {
		plusq(a, b);
	}
	printf("plusq performence   1: %llfs\n", getCurrentTime() - d);

	d = getCurrentTime();
	loadStr(a, "999999999999999999999999999999999999999999999999999999999999999999");
	for (int64_t i = 500000000; i <= 500000000 + 500000; i++) {
		loadInt(b, i);
		plusq(a, b);
	}
	printf("plusq performence   2: %llfs\n", getCurrentTime() - d);

	d = getCurrentTime();
	loadStr(b, "999999999999999999999999999999999999999999999999999999999999999999");
	for (int64_t i = 500000000; i <= 500000000 + 500000; i++) {
		loadInt(a, i);
		plusq(a, b);

	}
	printf("plusq performence   3: %llfs\n", getCurrentTime() - d);


	d = getCurrentTime();
	loadStr(a, "50000");
	loadInt(b, 10000);
	for (int64_t i = 1; i <= 500000; i++) {
		sub(a, b, c);
	}
	printf("sub   performence   1: %llfs\n", getCurrentTime() - d);



	d = getCurrentTime();
	loadStr(a, "100000000000000000000000000000000000000000000000000000000000000000");
	loadInt(b, 11111);
	for (int64_t i = 1; i <= 500000; i++) {
		sub(a, b, c);
	}
	printf("sub   performence   2: %llfs\n", getCurrentTime() - d);


	d = getCurrentTime();
	loadStr(a, "100000000000000000000000000000000000000000000000000000000000000000");
	loadStr(b, "11111111111111111111111111111111111111");
	for (int64_t i = 1; i <= 500000; i++) {
		sub(a, b, c);
	}
	printf("sub   performence   3: %llfs\n", getCurrentTime() - d);



	d = getCurrentTime();
	loadStr(a, "50000000000");
	loadInt(b, 500000);
	for (int64_t i = 1; i <= 500000; i++) {
		subq(a, b);
	}
	printf("subq  performence   1: %llfs\n", getCurrentTime() - d);

	d = getCurrentTime();
	loadStr(a, "100000000000000000000000000000000000000000000000000000000000000000");
	loadInt(b, 11111);
	for (int64_t i = 1; i <= 500000; i++) {
		subq(a, b);
	}
	printf("subq  performence   2: %llfs\n", getCurrentTime() - d);


	
	d = getCurrentTime();
	loadStr(a, "100000000000000000000000000000000000000000000000000000000000000000");
	loadStr(b, "11111111111111111111111111111111111111");
	for (int64_t i = 1; i <= 500000; i++) {
		subq(a, b);
	}
	printf("subq  performence   3: %llfs\n", getCurrentTime() - d);


	d = getCurrentTime();
	loadStr(a, "50000");
	loadInt(b, 12345);
	for (int64_t i = 1; i <= 500000; i++) {
		mul(a, b, c);
	}
	printf("mul   performence   1: %llfs\n", getCurrentTime() - d);

	d = getCurrentTime();
	loadStr(a, "999999999999999999999999999999999999999999999999999999999999999999");
	loadInt(b, 12345);
	for (int64_t i = 1; i <= 500000; i++) {
		mul(a, b, c);
	}
	printf("mul   performence   2: %llfs\n", getCurrentTime() - d);

	d = getCurrentTime();
	loadStr(a, "999999999999999999999999999999999999999999999999999999999999999999");
	loadStr(b, "11111111111111111111111111111111111111");
	for (int64_t i = 1; i <= 500000; i++) {
		mul(b, a, c);
	}
	printf("mul   performence   3: %llfs\n", getCurrentTime() - d);


	d = getCurrentTime();
	loadStr(a, "2");
	loadInt(b, 2);
	for (int64_t i = 1; i <= 1000; i++) {
		mulq(a, b);
	}
	printf("mulq  performence   1: %llfs\n", getCurrentTime() - d);
	d = getCurrentTime();
	loadStr(a, "999999999999999999999999999999999999999999999999999999999999999999");
	loadInt(b, 2);
	for (int64_t i = 1; i <= 1000; i++) {
		mulq(a, b);
	}
	printf("mulq  performence   2: %llfs\n", getCurrentTime() - d);

	d = getCurrentTime();
	loadStr(a, "999999999999999999999999999999999999999999999999999999999999999999");
	loadStr(b, "11111111111111111111111111111111111111");
	for (int64_t i = 1; i <= 1000; i++) {
		mulq(b, a);
	}
	printf("mulq  performence   3: %llfs\n", getCurrentTime() - d);



	d = getCurrentTime();
	loadStr(a, "50000");
	loadInt(b, 12345);
	for (int64_t i = 1; i <= 500000; i++) {
		div(a, b, c, mod);
	}
	printf("div   performence   1: %llfs\n", getCurrentTime() - d);

	d = getCurrentTime();
	loadStr(a, "100000000000000000000000000000000000000000000000000000000000000000");
	loadInt(b, 12345);
	for (int64_t i = 1; i <= 500000; i++) {
		div(a, b, c, NULL);
	}
	printf("div   performence   2: %llfs\n", getCurrentTime() - d);

	d = getCurrentTime();
	loadStr(a, "100000000000000000000000000000000000000000000000000000000000000000");
	loadStr(b, "11111111111111111111111111111111111111");
	for (int64_t i = 1; i <= 500000; i++) {
		div(a, b, c, mod);
	}
	printf("div   performence   3: %llfs\n", getCurrentTime() - d);



	loadStr(a, "1");
	loadStr(b, "2");
	for (int64_t i = 1; i <= 1000; i++) {
		mulq(a, b);
	}
	d = getCurrentTime();
	for (int64_t i = 1; i <= 1000; i++) {
		divq(a, b, mod);
	}
	printf("divq  performence   1: %llfs\n", getCurrentTime() - d);

	loadStr(a, "999999999999999999999999999999999999999999999999999999999999999999");
	loadStr(b, "2");
	for (int64_t i = 1; i <= 1000; i++) {
		mulq(a, b);
	}
	d = getCurrentTime();
	for (int64_t i = 1; i <= 1000; i++) {
		divq(a, b, mod);
	}
	printf("divq  performence   2: %llfs\n", getCurrentTime() - d);



	loadStr(a, "999999999999999999999999999999999999999999999999999999999999999999");
	loadStr(b, "11111111111111111111111111111111111111");
	for (int64_t i = 1; i <= 500; i++) {
		mulq(a, b);
	}
	d = getCurrentTime();
	for (int64_t i = 1; i <= 500; i++) {
		divq(a, b, mod);
	}
	printf("divq  performence   3: %llfs\n", getCurrentTime() - d);
}
CodeOfCC
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 1
    评论
专栏目录
C/C++ 高精度（加减乘除）算法二进制优化
04-23
上一章《C/C++ 高精度（加减乘除）算法压位优化》实现了优化的高精度计算，采用int32的整型数组每个元素可以储存9个10进制数字，想要再进一步优化计算速度，可以改变数据存储方式，采用二进制存储数字。依然采用int...
python中高精度除法_【算法笔记】 压位高精度整除法
weixin_39525097的博客
12-08 354
算法介绍主要是模拟竖式计算的过程。可以扩展为 BASE 进制数的高精度整除除问题。不考虑负数问题。记：BASE为x(一般情形下为10)被除数为 \(A = a_p x^p + a_{p-1} x^{p-1} + ...... + a_1 x + a_0\)除数为 \(B = b_q x^q + ...... +b_1 x + b_0\)当 \(A此处，我们主要考虑 \(A \geq B\)这种情形...
C++ 大整数运算 高精度除法
weixin_44215992的博客
04-08 2718
这篇文章主要是对于大整数类的设计过程中，如何实现并改进长除法(模拟竖式法)的一个总结。
c语言实现加减乘除
weixin_44876693的博客
01-09 6600
可使用回调函数优化 #include<stdio.h> int min(int x,int y); int mul(int x,int y); int div(int x,int y); /*计算2个正整数的和、差、积、商并输出。 输入格式： 输入在一行中给出2个正整数A和B。 输出格式： “A 运算符 B = 结果”顺序输出和、差、积、商。*/ int add(int x,int y) { return x+y; } int min(int x,int y) { return
C代码优化方案
新州隐士专栏
05-20 2566
C代码优化方案                     华中科技大学计算机学院   姓名：    王全明 QQ：       375288012 Email：     quanming1119@163.com 目录目录__ 2 C代码优化方案__ 4 1、选择合适的算法和数据结构__ 4 2、使用尽量小的数据类型__
【C++】C++代码性能优化的方法（全网最适用）
测试开发自动化
05-05 9001
本文将总结并详细介绍C++代码性能优化的方法，旨在为C++开发者提供一个全面、实用的性能优化指南。无论你是刚入门的新手，还是有经验的开发者，都能从中找到适用于你的优化技巧。
C/C++高精度算法的实现
08-25
C/C++高精度算法的实现 在计算机科学中，高精度算法是指可以处理大数的算法，例如大整数的加减乘除、乘幂、阶乘等运算。在C/C++语言中，高精度算法的实现是通过将大数拆分成若干固定长度的块，然后对每一块进行相应...
C++高精度模板（加减乘除模）
最新发布
02-04
C++竞赛高精度模板 优点：包含四则运算 抛弃传统数组，使用vector 缺点：乘法没有使用FFT算法，复杂度O(N^2) 在某些编辑器上可能无法使用资源中定义的常量，需要手动创建（CE的话可能是这个问题） 没有运算符...
高精度加减乘除算法.doc
05-07
高精度加法算法是计算机科学中处理大整数或大数运算的一种技术，它涉及到的主要是如何处理超出...在实际编程中，可以使用现成的大数库，如Java的`BigInteger`或C++的`GMP`库，这些库已经实现了高效且优化的高精度运算。
单片机c语言除法运算,针对小容量单片机程序优化方式--乘除法篇
weixin_29202213的博客
05-17 4903
原标题：针对小容量单片机程序优化方式--乘除法篇目前单片机的市场竞争很激烈，许多应用出于性价比的考虑，选择使用程序存储空间较小(如1K，2K)的小资源8位MCU芯片进行开发。一般情况下，这类MCU没有硬件乘法、除法指令，在程序必须使用乘除法运算时，如果单纯依靠编译器调用内部函数库来实现，常常会有代码量偏大、执行效率偏低的缺点。上海晟矽微电子推出的MC30、MC32系列MCU，采用了RISC架构，在...
C/C++高精度运算(大整数运算)详解（含压位）
热门推荐
帅比王的博客
04-22 2万+
1.高精度加法 1.1 高精度加法 高精度运算的基本运算就是加和减。和算数的加减规则一样，模拟竖式计算，考虑错位运算与进位处理。下面是我老师给的代码，目前比网上其他的代码要精简和巧妙。 #include <cstdio> #include <cstring> int main() { char a[202]={0}, b[202]={0...
高精度除法【c++实现】超详细讲解
m0_54615144的博客
02-14 2470
高精度除低精度，原理是模拟竖式除法，和高精度其他算法一样都可以手动计算来感受一下实现方法。下面来一个较为简单的例子：1532 ÷ 21 = 72......20。高精度算法分为两种，高精除以低精和高精除以高精。不要看都是除法，就认为原理类似，其实是有很大差距的。让我们一起来学习吧！有句话说在前面，如果除数等于0，就不要算了，不成立。
【C++学习笔记】 模拟竖除法
qq_65021355的博客
04-22 249
在每次除以除数时，需要先比较这一步中的被除数和除数的大小关系，如果被除数大于除数，那么每次减去除数，知道被除数小于除数。同时，在高精度除以高精度中，被除数会直接用来减去除数，因此我们需要一个辅助数组来为除数补‘0’，使得被除数的位数和除数的位数相同。这种情况比较简单，只需要将被除数的每一位存储到一个int类型的数组中。数组num[100]保存被除数的每一位，为了方便起见，可以用num[0]保存被除数的长度。第二次除法：往后借一位，11/9，此时b=2，结果11/9 = 1保存到新的数组中。
C/C++编译器并行优化技术：并行优化针对多核处理器和多线程环境进行优化，以提高程序的并行度
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
04-19 3461
C-C++编译器并行优化技术：并行优化针对多核处理器和多线程环境进行优化，以提高程序的并行度
高精度计算（+-*/）（压位计算）（c++实现）
weixin_60257971的博客
11-24 941
进来的时候如果没看见除法，说明我也还不会，会了的话我会补充上去的。如果要看的除法的，得去看别人的了。 目录 初始化： 加法： 减法： 乘法： 输出：这个是重点！！！！！！！！！！！ 完整代码： 如果你是从我的“P1601 A+B Problem（高精）”这篇文章来的话，可以看一下压位计算，更加的快捷方便。 高精度计算就是因为超过了数据表达的类型，从用其他的方式来进行计算。 压位就是说将一长串的数字分割开来，来单独进行保存，从而不会发生超过范围。 初始化： 可以看到 k 其...
C/C++用移位实现乘除法运算,提高运行效率
02-27 2808
<!-- alimama_pid="mm_10249644_1605763_4929893"; alimama_titlecolor="707070"; alimama_descolor ="CCCCCC"; alimama_bgcolor="FFFFFF"; alimama_bordercolor="FFFFFF"; alimama_linkcolor="DADA
c++用字符串实现高精度计算
zx1772874955的博客
11-13 1277
有些计算要求高精度，希望计算机可以计算长度超过LONG LONG类型的数据，比如几十位或者几百位。请利用字符串来试一试完成一个高精度的整数加法运算。 例如：加数“1234567891234567”被加数“2233445566778899” 分析： 1.注意加法需要个位对齐，而数组的下标以字符串读入时，下标0对应最高位，因此最后将字符串转置即个位在下标0处 2.字符串读入后，所有数字均为ASCII码，需要转换为对应的数字。 3.以上两个问题解决过程中，可以将原始加数被加数字符串，转换如对应的整数数组进行存放和
C语言执行效率如何保证，看这一文就够了！
C语言与CPP编程的博客
12-23 7379
来自公众号：嵌入式ARM嵌入式开发基本都会选择C语言这是因为C语言有出色的可移植性能在多种不同体系结构的软/硬平台上运行虽然代码的复用性差代码的维护性差扩展性很差但，C语言简洁紧凑使用灵...
用C++写一个高精度加减乘除
03-28
我可以给出一个示例：#include <stdio.h> int main() { double a, b, c; char op; printf("请输入算式（例如：2 + 3）: "); scanf("%lf %c %lf", &a, &op, &b); switch(op) { case '+': c = a + b; break; case '-': c = a - b; break; case '*': c = a * b; break; case '/': c = a / b; break; default: printf("无效的运算符\n"); break; } printf("%.2lf %c %.2lf = %.2lf\n", a, op, b, c); return 0; }

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

CodeOfCC

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值