C++ 高精度浮点数运算结构体代码要求重载运算符+-等常用运算符还有+= -= = =之类的

下面是一个简单的C++高精度浮点数运算结构体的代码示例：

#include <iostream>
#include <cmath>
#include <vector>

struct HighPrecisionFloat {
    std::vector<int> integerPart;  // 整数部分
    std::vector<int> decimalPart;  // 小数部分
    int decimalPlaces;  // 小数位数

    HighPrecisionFloat() {
        decimalPlaces = 6;  // 默认小数位数为6
    }

    HighPrecisionFloat(std::string numStr) {
        decimalPlaces = 6;
        parseString(numStr);
    }

    void parseString(std::string numStr) {
        // 解析整数部分
        size_t integerEnd = numStr.find('.');
        if (integerEnd == std::string::npos) {
            integerPart.push_back(std::stoi(numStr));
        } else {
            std::string integerStr = numStr.substr(0, integerEnd);
            for (int i = integerStr.length() - 1; i >= 0; i--) {
                integerPart.push_back(integerStr[i] - '0');
            }

            // 解析小数部分
            std::string decimalStr = numStr.substr(integerEnd + 1);
            for (int i = 0; i < decimalStr.length(); i++) {
                decimalPart.push_back(decimalStr[i] - '0');
            }
        }
    }

    std::string toString() {
        std::string result = "";
        // 整数部分
        for (int i = integerPart.size() - 1; i >= 0; i--) {
            result += std::to_string(integerPart[i]);
        }
        // 小数部分
        if (!decimalPart.empty()) {
            result += ".";
            for (int i = 0; i < decimalPart.size(); i++) {
                result += std::to_string(decimalPart[i]);
            }
        }
        return result;
    }

    HighPrecisionFloat operator+(const HighPrecisionFloat& other) const {
        HighPrecisionFloat result;
        int carry = 0;
        int maxDecimalPlaces = std::max(decimalPlaces, other.decimalPlaces);
        // 将两个浮点数的小数部分对齐
        std::vector<int> alignedDecimalPart1 = decimalPart;
        std::vector<int> alignedDecimalPart2 = other.decimalPart;
        while (alignedDecimalPart1.size() < maxDecimalPlaces) {
            alignedDecimalPart1.push_back(0);
        }
        while (alignedDecimalPart2.size() < maxDecimalPlaces) {
            alignedDecimalPart2.push_back(0);
        }

        // 小数部分相加
        for (int i = 0; i < maxDecimalPlaces; i++) {
            int sum = alignedDecimalPart1[i] + alignedDecimalPart2[i] + carry;
            result.decimalPart.push_back(sum % 10);
            carry = sum / 10;
        }

        // 整数部分相加
        int maxLength = std::max(integerPart.size(), other.integerPart.size());
        for (int i = 0; i < maxLength; i++) {
            int sum = (i < integerPart.size() ? integerPart[i] : 0)
                      + (i < other.integerPart.size() ? other.integerPart[i] : 0)
                      + carry;
            result.integerPart.push_back(sum % 10);
            carry = sum / 10;
        }
        if (carry > 0) {
            result.integerPart.push_back(carry);
        }

        return result;
    }

    HighPrecisionFloat operator-(const HighPrecisionFloat& other) const {
        HighPrecisionFloat result;
        int borrow = 0;
        int maxDecimalPlaces = std::max(decimalPlaces, other.decimalPlaces);
        // 将两个浮点数的小数部分对齐
        std::vector<int> alignedDecimalPart1 = decimalPart;
        std::vector<int> alignedDecimalPart2 = other.decimalPart;
        while (alignedDecimalPart1.size() < maxDecimalPlaces) {
            alignedDecimalPart1.push_back(0);
        }
        while (alignedDecimalPart2.size() < maxDecimalPlaces) {
            alignedDecimalPart2.push_back(0);
        }

        // 小数部分相减
        for (int i = 0; i < maxDecimalPlaces; i++) {
            int diff = alignedDecimalPart1[i] - alignedDecimalPart2[i] - borrow;
            if (diff < 0) {
                diff += 10;
                borrow = 1;
            } else {
                borrow = 0;
            }
            result.decimalPart.push_back(diff);
        }

        // 整数部分相减
        int maxLength = std::max(integerPart.size(), other.integerPart.size());
        for (int i = 0; i < maxLength; i++) {
            int diff = (i < integerPart.size() ? integerPart[i] : 0)
                       - (i < other.integerPart.size() ? other.integerPart[i] : 0)
                       - borrow;
            if (diff < 0) {
                diff += 10;
                borrow = 1;
            } else {
                borrow = 0;
            }
            result.integerPart.push_back(diff);
        }
        while (result.integerPart.size() > 1 && result.integerPart.back() == 0) {
            result.integerPart.pop_back();
        }

        return result;
    }

    HighPrecisionFloat operator*(const HighPrecisionFloat& other) const {
        HighPrecisionFloat result;
        int maxDecimalPlaces = decimalPlaces + other.decimalPlaces;
        result.decimalPlaces = maxDecimalPlaces;

        // 小数部分相乘
        std::vector<int> tempDecimalPart(maxDecimalPlaces, 0);
        for (int i = 0; i < decimalPart.size(); i++) {
            for (int j = 0; j < other.decimalPart.size(); j++) {
                tempDecimalPart[i + j] += decimalPart[i] * other.decimalPart[j];
            }
        }

        // 处理小数部分的进位
        int carry = 0;
        for (int i = 0; i < maxDecimalPlaces; i++) {
            int sum = tempDecimalPart[i] + carry;
            result.decimalPart.push_back(sum % 10);
            carry = sum / 10;
        }

        // 整数部分相乘
        std::vector<int> tempIntegerPart(integerPart.size() + other.integerPart.size(), 0);
        for (int i = 0; i < integerPart.size(); i++) {
            for (int j = 0; j < other.integerPart.size(); j++) {
                tempIntegerPart[i + j] += integerPart[i] * other.integerPart[j];
            }
        }

        // 处理整数部分的进位
        carry = 0;
        for (int i = 0; i < tempIntegerPart.size(); i++) {
            int sum = tempIntegerPart[i] + carry;
            result.integerPart.push_back(sum % 10);
            carry = sum / 10;
        }
        while (result.integerPart.size() > 1 && result.integerPart.back() == 0) {
            result.integerPart.pop_back();
        }

        return result;
    }

    HighPrecisionFloat operator/(const HighPrecisionFloat& other) const {
        if (other.integerPart.size() == 1 && other.integerPart[0] == 0 && other.decimalPart.empty()) {
            throw std::runtime_error("Divide by zero");
        }

        HighPrecisionFloat result;
        int maxDecimalPlaces = decimalPlaces + other.decimalPlaces;
        result.decimalPlaces = maxDecimalPlaces;

        // 小数部分相除
        std::vector<int> tempDecimalPart(maxDecimalPlaces, 0);
        for (int i = 0; i < decimalPart.size(); i++) {
            for (int j = 0; j < maxDecimalPlaces; j++) {
                if (j < other.decimalPart.size()) {
                    tempDecimalPart[i + j] += decimalPart[i] / other.decimalPart[j];
                } else {
                    tempDecimalPart[i + j] += decimalPart[i] / 1;  // 补0进行除法
                }
            }
        }

        // 处理小数部分的进位
        int carry = 0;
        for (int i = maxDecimalPlaces - 1; i >= 0; i--) {
            int quotient = (tempDecimalPart[i] + carry) / 10;
            carry = (tempDecimalPart[i] + carry) % 10;
            result.decimalPart.insert(result.decimalPart.begin(), carry);
            carry = quotient;
        }

        // 整数部分相除
        std::vector<int> tempIntegerPart(integerPart.size(), 0);
        for (int i = 0; i < integerPart.size(); i++) {
            for (int j = 0; j < other.integerPart.size(); j++) {
                if (j < other.integerPart.size()) {
                    tempIntegerPart[i + j] += integerPart[i] / other.integerPart[j];
                } else {
                    tempIntegerPart[i + j] += integerPart[i] / 1;  // 补0进行除法
                }
            }
        }

        // 处理整数部分的进位
        carry = 0;
        for (int i = tempIntegerPart.size() - 1; i >= 0; i--) {
            int quotient = (tempIntegerPart[i] + carry) / 10;
            carry = (tempIntegerPart[i] + carry) % 10;
            result.integerPart.insert(result.integerPart.begin(), carry);
            carry = quotient;
        }
        while (result.integerPart.size() > 1 && result.integerPart.back() == 0) {
            result.integerPart.pop_back();
        }

        return result;
    }

    HighPrecisionFloat& operator+=(const HighPrecisionFloat& other) {
        *this = *this + other;
        return *this;
    }

    HighPrecisionFloat& operator-=(const HighPrecisionFloat& other) {
        *this = *this - other;
        return *this;
    }

    HighPrecisionFloat& operator*=(const HighPrecisionFloat& other) {
        *this = *this * other;
        return *this;
    }

    HighPrecisionFloat& operator/=(const HighPrecisionFloat& other) {
        *this = *this / other;
        return *this;
    }
};

// 测试代码
int main() {
    HighPrecisionFloat a("123.456");
    HighPrecisionFloat b("789.012");
    std::cout << "a = " << a.toString() << std::endl;
    std::cout << "b = " << b.toString() << std::endl;

    HighPrecisionFloat c = a + b;
    std::cout << "a + b = " << c.toString() << std::endl;

    HighPrecisionFloat d = a - b;
    std::cout << "a - b = " << d.toString() << std::endl;

    HighPrecisionFloat e = a * b;
    std::cout << "a * b = " << e.toString() << std::endl;

    HighPrecisionFloat f = a / b;
    std::cout << "a / b = " << f.toString() << std::endl;

    a += b;
    std::cout << "a += b: a = " << a.toString() << std::endl;

    a -= b;
    std::cout << "a -= b: a = " << a.toString() << std::endl;

    a *= b;
    std::cout << "a *= b: a = " << a.toString() << std::endl;

    a /= b;
    std::cout << "a /= b: a = " << a.toString() << std::endl;

    return 0;
}

这个代码定义了一个HighPrecisionFloat结构体，其中包含了整数部分和小数部分，以及小数位数。结构体中重载了+、-、*、/等常用运算符，以及+=、-=、*=、/=等复合赋值运算符。此外，还提供了parseString函数用于将浮点数字符串解析为HighPrecisionFloat对象，以及toString函数用于将HighPrecisionFloat对象转换为字符串表示形式。在main函数中，对这些运算符进行了测试