A. 【程序填空】大整数计算（运算符重载）时间限制1s内存限制128MB题目描述定义大整数类CBigInteger（假设最长支持1000位），数据成员为字符串类

题目描述

定义大整数类CBigInteger（假设最长支持1000位），数据成员为字符串类型（用字符指针或string都可以）。成员函数或友元函数包括：

1）带参构造函数，为字符指针动态分配1001个字符空间。根据参数初始化大整数。

2)  无参构造函数，为字符指针动态分配1001个字符空间。

3）重载运算符+，实现两个大整数的加法。

4）重载运算符-，实现两个大整数的减法。

5）重载运算符*，实现两个大整数的乘法。

6）重载输入，输入大整数。

7）重载输出，输出大整数。

8）析构函数，如果字符指针，释放分配的空间，不可屏蔽。

主函数输入大整数，完成大整数的加、减、乘。主函数代码如下，请补充CBigInteger类。

输入

测试次数

每组测试数据一行： 大整数1 运算符 大整数2

输出

对每组测试数据输出表达式和计算结果，具体格式见样例。

IO模式

本题IO模式为标准输入/输出(Standard IO)，你需要从标准输入流中读入数据，并将答案输出至标准输出流中。

样例查看模式 

正常显示查看格式

输入样例1 <-复制

3
100 * -100
-123456789 + 123456
0001 - -123

输出样例1

100 * (-100) = (-10000)
(-123456789) + 123456 = (-123333333)
1 - (-123) = 124

//补充CBigInteger类和头文件
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
using namespace std;
struct CBigInteger {
	static const int Base = 10000;
	static const int WIDTH = 4;
	vector<int> s;

	CBigInteger(long long num = 0) { *this = num; }
	CBigInteger operator = (long long num) {
		s.clear();
		do {
			s.push_back(num % Base);
			num /= Base;

		} while (num > 0);
		return *this;
	}
	CBigInteger operator = (const string& str) {
		string str1;
		str1.resize(str.length());
		int flg = 0;
		int i, j;
		for (i = 0, j = 0; i < str.length(); i++) {
			if (str[i] != '0')flg = 1;
			if (flg) { str1[j++] = str[i]; }
		}
		str1.resize(j);
		s.clear();
		int x, len = (str1.length() - 1) / WIDTH + 1;
		for (int i = 0; i < len; i++) {
			int end = str1.length() - i * WIDTH;
			int start = max(0, end - WIDTH);
			sscanf(str1.substr(start, end - start).c_str(), "%d", &x);
			s.push_back(x);
		}
		return *this;
	}

	CBigInteger operator + (const CBigInteger& b) {
		CBigInteger c;
		c.s.clear();
		for (int i = 0, g = 0;; i++) {
			if (g == 0 && i >= s.size() && i >= b.s.size())break;
			int x = g;
			if (i < s.size())x += s[i];
			if (i < b.s.size())x += b.s[i];
			c.s.push_back(x % Base);
			g = x / Base;
		}
		return c;
	}

	CBigInteger operator-(const CBigInteger& b) const {
		CBigInteger c;
		c.s.clear();
		bool negative = false; // 是否结果为负数
		int borrow = 0;

		// 确保被减数大于等于减数
		if (*this < b) {
			negative = true;
			CBigInteger tmp = b;
			tmp = tmp - *this; // 递归调用本函数，确保两数相减结果为正数
			return tmp;
		}

		// 大数相减的主要逻辑
		for (int i = 0; i < s.size(); ++i) {
			int diff = s[i] - borrow;
			if (i < b.s.size()) {
				diff -= b.s[i];
			}
			if (diff < 0) {
				diff += Base;
				borrow = 1;
			}
			else {
				borrow = 0;
			}
			c.s.push_back(diff);
		}

		// 移除结果前导零
		while (c.s.size() > 1 && c.s.back() == 0) {
			c.s.pop_back();
		}

		// 如果结果为负数，在结果前添加负号
		if (negative) {
			c.s.back() *= -1;
		}

		return c;
	}
	CBigInteger operator *(long long num)const {
		CBigInteger c;
		c.s.clear();
		int i;
		long long g = 0;
		for (i = 0;; i++) {
			long long x = g;
			if (g == 0 && i >= s.size())break;
			if (i < s.size())x += s[i] * num;
			c.s.push_back(x % Base);
			g = x / Base;
		}
		return c;
	}

	CBigInteger operator *(const CBigInteger& b) const {
		CBigInteger C;
		C.s.clear();
		int i;
		for (i = 0; i < s.size(); i++) {
			CBigInteger D;
			D = b * s[i];
			int j = i;
			while (j--) {
				D = D * Base;

			}
			C = C + D;
		}
		return C;
	}

	bool operator < (const CBigInteger& b) const {
		if (s.size() != b.s.size())return s.size() < b.s.size();
		int i;
		for (i = s.size() - 1; i >= 0; i--) {
			if (s[i] != b.s[i])
				return s[i] < b.s[i];
		}
		return false;
	}
	bool operator >(const CBigInteger& b)const { return b < *this; }
	bool operator <=(const CBigInteger& b)const { return !(b < *this); }
	bool operator >=(const CBigInteger& b)const { return !(*this < b); }
	bool operator !=(const CBigInteger& b)const { return (b < *this) || (*this < b); }
	bool operator ==(const CBigInteger& b) const { return !(b < *this) && !(*this < b); }

};
ostream& operator <<(ostream& out, const CBigInteger& x) {
	if (x.s.back() < 0)
	{
		out << "(" << x.s.back() ;
		for (int i = x.s.size() - 2; i >= 0; i--) {
		char buf[20];
		sprintf(buf, "%04d", x.s[i]);
		out << buf;	
	}
		out << ")";
	}
	else
	{
out << x.s.back();
for (int i = x.s.size() - 2; i >= 0; i--) {
	char buf[20];
	sprintf(buf, "%04d", x.s[i]);
	out << buf;
}
	}
	
	return out;
}
istream& operator >> (istream& in, CBigInteger& x) {
	string s;
	if (!(in >> s)) return in;
	x = s;
	return in;

}


int main()
{
    int t;
    char op;
    CBigInteger bigNum1;
    CBigInteger bigNum2;
    
    cin >> t;
    while(t--)
    {
        cin >> bigNum1 >> op >> bigNum2;
        cout << bigNum1 << " " << op << " " << bigNum2 << " = ";
        if(op == '+')
            cout << bigNum1 + bigNum2 << endl;
        else if(op == '-')
            cout << bigNum1 - bigNum2 << endl;
        else if(op == '*')
            cout << bigNum1 * bigNum2 << endl;
    }
    return 0;
}