只用string類且不用algorithm實現支持負數的高精度運算(包括高精度乘高精度)

好的，我可以为您提供一个简单的实现方法。

首先，我们需要定义一个高精度的数据结构，可以使用字符串来存储每一位数字。为了支持负数，我们还需要添加一个标志位来表示是否是负数。以下是一个简单的代码示例：

#include <iostream>
#include <string>

using namespace std;

class BigInteger {
public:
    string num; // 用字符串存储每一位数字
    bool isNegative; // 标志位，表示是否是负数

    BigInteger() {
        num = "";
        isNegative = false;
    }

    BigInteger(string s) {
        if (s[0] == '-') {
            isNegative = true;
            num = s.substr(1);
        } else {
            isNegative = false;
            num = s;
        }
    }

    BigInteger operator+(const BigInteger& b) const {
        BigInteger res;
        int carry = 0;
        int len1 = num.size(), len2 = b.num.size();
        int i = len1 - 1, j = len2 - 1;
        while (i >= 0 || j >= 0 || carry > 0) {
            int x = i >= 0 ? num[i] - '0' : 0;
            int y = j >= 0 ? b.num[j] - '0' : 0;
            int sum = x + y + carry;
            res.num = to_string(sum % 10) + res.num;
            carry = sum / 10;
            i--;
            j--;
        }
        res.isNegative = false;
        return res;
    }

    BigInteger operator*(const BigInteger& b) const {
        BigInteger res;
        int len1 = num.size(), len2 = b.num.size();
        for (int i = len1 - 1; i >= 0; i--) {
            int carry = 0;
            string temp = "";
            for (int j = len2 - 1; j >= 0; j--) {
                int x = num[i] - '0';
                int y = b.num[j] - '0';
                int mul = x * y + carry;
                temp = to_string(mul % 10) + temp;
                carry = mul / 10;
            }
            if (carry > 0) {
                temp = to_string(carry) + temp;
            }
            for (int k = i; k < len1 - 1; k++) {
                temp += "0";
            }
            res = res + BigInteger(temp);
        }
        res.isNegative = isNegative != b.isNegative;
        return res;
    }
};

ostream& operator<<(ostream& out, const BigInteger& b) {
    if (b.isNegative) {
        out << "-";
    }
    out << b.num;
    return out;
}

在上面的代码中，我们使用 `BigInteger` 类来表示高精度的整数，其中 `num` 字符串用来存储每一位数字，`isNegative` 标志位用来表示是否是负数。

在 `operator+` 和 `operator*` 中，我们实现了高精度加法和乘法。在高精度加法中，我们直接模拟了竖式加法的过程，从低位到高位逐位相加，并且注意进位的情况；在高精度乘法中，我们先按照乘法的定义逐位相乘，然后再将每个位上的结果累加起来，最后得到乘积。

最后，我们还重载了 `operator<<`，以便我们可以方便地输出 `BigInteger` 类型的变量。

使用示例：

int main() {
    BigInteger a("12345678901234567890");
    BigInteger b("-98765432109876543210");

    BigInteger c = a + b;
    BigInteger d = a * b;

    cout << c << endl; // 输出：-86419753208641975320
    cout << d << endl; // 输出：-12193263113702179557112601470179876100

    return 0;
}

注意，这个实现方法可能不是最优的，只是提供了一个简单的思路。如果需要更高效的实现，可以使用更高级的算法，比如 Karatsuba 乘法或 FFT 等。