高精度加减乘除类封装模板

原创 已于 2023-07-11 10:27:03 修改 · 314 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#算法

于 2023-07-11 10:06:05 首次发布
该代码实现了一个用于高精度整数运算的bigint类，包括加、减、乘、除及比较操作，并提供了运算符重载。问题在于除法运算效率较低，且使用char存储可能造成内存浪费。寻求优化除法算法和减少内存使用的解决方案。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

高精度加减乘除类封装模板

主要功能

  1. 这个模板实现了整数加减乘除，并且可以和其他集中基本数据类型相互运算，加减乘除，比大小。

  2. bigint 类本身也实现了 +,-,*,/,%,+=,-=,*=，等常用运算符，几乎不会用在高精度中的位运算并没有重载。

  3. 支持输入输出流的 cin,cout。

  4. 主要用 vector 实现，如果想加速可以使用内置的 resize 函数预存内存。

求助

现在还有缺陷大家可以一起帮忙优化一下，

  1. 除法用二分写的，自我感觉比较慢，希望有大佬指点。
  2. 每一位是char类型，还是有内存浪费，有没有大哥给个压位的写法。

代码

无缩进版
#include<bits/stdc++.h>
using namespace std;

class bigint {
#define VC vector<char>
#define pb push_back
#define bt bigint
#define f(i, a, b) for(int i=(a);i<=(b);++i)
#define rf(i, a, b) for(int i=(a);i>=(b);--i)
public:
    int symbol = 1;std::VC _a;int size() const { return _a.size(); }
    char &operator[](int i) { return _a[i]; }
    static bt add(bt A, bt B) {if (A.size() < B.size())return add(B, A);std::VC C;int t = 0;f(i, 0, A.size() - 1) {t += A[i];if (i < B.size()) t += B[i];C.pb(t % 10);t /= 10;}if (t) C.pb(t);return {C};}
    void resize(int size) { _a.reserve(size); }
    static bigint plu(bigint A, bigint B) {if (A.symbol == -1 && B.symbol == -1) {auto t = add(A, B);t.symbol = -1;return t;}if (A.symbol == -1 && B.symbol == 1) { return sub(B, A); }if (A.symbol == 1 && B.symbol == -1) { return sub(A, B); }return add(A, B);}
    template<class T,class Y>friend bt operator+(T A, Y B) { return plu(A, B); }
    static bt sub(bt A, bt B) {A.symbol = 1, B.symbol = 1;std::VC C;if (A < B) {bt a;a = sub(B, A);a.symbol = -1;return a;}int t = 0;f(i, 0, A.size() - 1) {t = A[i] - t;if (i < B.size()) t -= B[i];C.pb((t + 10) % 10);if (t < 0) t = 1; else t = 0;}while (C.size() > 1 && C.back() == 0) C.pop_back();return bigint(C);}
    static bt SUB(bt A, bt B) {if (A.symbol == -1 && B.symbol == -1) {bigint t;t = sub(A, B);t.symbol *= -1;return t;}if (A.symbol == 1 && B.symbol == -1) { return add(A, B); }if (A.symbol == -1 && B.symbol == 1) {bigint a = add(A, B);a.symbol = -1;return a;}return sub(A, B);}
    template<class T,class Y>
    friend bt operator-(T A, Y B) { return SUB(A, B); }
    static bigint mul(bt A, bt B) {int len1 = A.size(), len2 = B.size(), cnt = len1 + len2;VC x;long long *c = new long long[len1 + len2 + 10], t = 0;f(i, 0, len1 + len2 + 8)c[i] = 0;f(i, 0, len1 - 1)f(j, 0, len2 - 1)c[i + j] += A[i] * B[j];f(i, 0, cnt - 1) {t += c[i];c[i] = t % 10;t /= 10;}while (t) {c[++cnt] = t % 10;t /= 10;}while (cnt >= 1 && c[cnt] == 0) cnt--;x.assign(c, c + cnt + 1);bigint ans(x);delete[] c;return {x};}
    friend bigint MUL(bt A, bt B) {if (A.symbol * B.symbol == 1)return mul(A, B);else {bt t = mul(A, B);t.symbol = -1;return t;}}
    template<class T,class Y>
    friend bt operator*(T A, Y B) { return MUL(A, B); }
    static bigint smilediv(bt A, int b) {char *cha = new char[A.size()], *ans = new char[A.size()];int l = A.size(), m = l - 1, x = 0;std::copy(A._a.begin(), A._a.end(), cha);rf(i, l - 1, 0) {ans[i] = (x * 10 + cha[i]) / b;x = (cha[i] + x * 10) % b;}while (!ans[m] && m >= 1)m--;bigint z(0);z._a.assign(ans, ans + m + 1);delete []cha;delete[]ans;return z;}
    static bigint div(bt A, bt B) {if (A < B)return {0};bt l = 1, r = A;while (l <= r) {if(r.symbol==-1)exit(1);bt mid = smilediv(l + r, 2);if (A < mid * B)r = mid - 1;else l = mid + 1;}return r;}
    friend bigint DIV(bt A, bt B) {bt t = div(A, B);if (A.symbol * B.symbol == -1)t.symbol = -1;return t;}
    template<class T,class Y>friend bt operator/(T A, Y B) { return DIV(A, B); }
    static bigint mod(bt A, bt B) {bt x = A / B;return A - x * B;}
    friend bigint MOD(bt A, bt B) { return mod(mod(A, B) + B, B); }
    template<class T,class Y>
    friend bt operator%(T A, Y B) { return MOD(A, B); }
    bigint(VC c) :_a(std::move(c)) { }
    bigint() { _a.assign({0}); }
    template<class T>bigint(T z) {_a.reserve(50);_a.clear();string s;if (typeid(z) != typeid(const char *) && typeid(z) != typeid(string))s = to_string((long long) z); else s = z;if (s[0] != '-') { rf(i, s.size() - 1, 0)_a.pb(s[i] - '0'); }else {rf(i, s.size() - 1, 1)_a.pb(s[i] - '0');symbol = -1;}}
    friend std::ostream &operator<<(std::ostream &os, bt cc) {if (cc.symbol == -1 && !(cc._a.size() == 1 && cc[0] == 0))os << '-';rf(i, cc.size() - 1, 0)os << int(cc[i]);return os;}
    friend std::istream &operator>>(std::istream &is, bt &cc) {cc._a.clear();std::string x;is >> x;if (x[0] == '-') {cc.symbol = -1;rf(i, x.size() - 1, 1)cc._a.pb(x[i] - '0');}else rf(i, x.size() - 1, 0)cc._a.pb(x[i] - '0');return is;}
    template<class T>bool operator<(T A) {bigint other = A;if (this->symbol == -1 && other.symbol == 1 && !(*(this) == other))return 1;if (this->size() < other.size())return 1;else if (this->size() > other.size())return 0;else if (this->size() == other.size())rf(i, this->size() - 1, 0) { if ((*this)[i] < other[i])return 1; }return 0;}
    bool operator<(bigint A) {bigint other = A;if (this->symbol == -1 && other.symbol == 1 && !(*(this) == other))return 1;if (this->size() < other.size())return 1;;if (this->size() > other.size())return 0;if (this->size() == other.size())rf(i, this->size() - 1, 0) { if ((*this)[i] < other[i])return 1;else if((*this)[i] > other[i])return 0; }return 0;}
    template<class T>bool operator==(T A) {bigint other(A);if (other._a == this->_a && other.symbol == this->symbol ||(this->size() == 1 && this->symbol == -1 && other.symbol == 1 && other.size() == 1 && (*this)[0] == 0 &&other[0] == 0))return 1;return 0;}
    template<class T>bool operator>(T A) {bigint other(A);if (*this < other == 0 && (*this == other) == 0)return true;return false;}
    template<class T>bool operator<=(T A) {bigint other(A);if (*(this) < other || *this == other)return 1;return 0;}
    template<class T>bool operator>=(T A) {bigint other(A);if (*(this) > other || *this == other)return 1;return 0;}
    bigint operator-() {auto t = *this;t.symbol *= -1;return t;}
    bigint operator+=(bt other) {*this = *this + other;return *this;}
    bigint operator-=(bt other) {*this = *this - other;return *this;}
    bigint operator*=(bt other) {*this = *this * other;return *this;}
    bigint operator/=(bt other) {*this = *this / other;return *this;}
    bigint operator%=(bt other) {*this = *this % other;return *this;}
    bigint operator++(int) {bt t = *this;*this = *this + 1;return t;}
    bigint operator++() {*this = *this + 1;return *this;}
    bigint operator--(int) {bt t = *this;*this = *this - 1;return t;}
    bigint operator--() {*this = *this - 1;return *this;}
    operator int() const {int t = 0;for (int i = _a.size() - 1; i >= 0; i--) { t = t * 10 + _a[i]; }return t;}
};
int main()
{
    bigint a,b,c,d;
    cin>>a>>b>>c>>d;
    cout<<a+b*c/d;
    return 0;
}
缩进版
#include <bits/stdc++.h>
using namespace std;
 
class bigint {
#define VC vector<char>
#define pb push_back
#define bt bigint
#define f(i, a, b) for(int i=(a);i<=(b);++i)
#define rf(i, a, b) for(int i=(a);i>=(b);--i)
public:
    int symbol = 1;
    std::VC _a;
 
    int size() const { return _a.size(); }
 
    char &operator[](int i) { return _a[i]; }
 
    static bt add(bt A, bt B) {
        if (A.size() < B.size())return add(B, A);
        std::VC C;
        int t = 0;
        f(i, 0, A.size() - 1) {
            t += A[i];
            if (i < B.size()) t += B[i];
            C.pb(t % 10);
            t /= 10;
        }
        if (t) C.pb(t);
        return {C};
    }
    void resize(int size) { _a.reserve(size); }
 
    static bigint plu(bigint A, bigint B) {
        if (A.symbol == -1 && B.symbol == -1) {
            auto t = add(A, B);
            t.symbol = -1;
            return t;
        }
        if (A.symbol == -1 && B.symbol == 1) { return sub(B, A); }
        if (A.symbol == 1 && B.symbol == -1) { return sub(A, B); }
        return add(A, B);
    }
 
    template<class T,class Y>
    friend bt operator+(T A, Y B) { return plu(A, B); }
 
    static bt sub(bt A, bt B) {
        A.symbol = 1, B.symbol = 1;
        std::VC C;
        if (A < B) {
            bt a;
            a = sub(B, A);
            a.symbol = -1;
            return a;
        }
        int t = 0;
        f(i, 0, A.size() - 1) {
            t = A[i] - t;
            if (i < B.size()) t -= B[i];
            C.pb((t + 10) % 10);
            if (t < 0) t = 1; else t = 0;
        }
        while (C.size() > 1 && C.back() == 0) C.pop_back();
        return bigint(C);
    }
 
    static bt SUB(bt A, bt B) {
        if (A.symbol == -1 && B.symbol == -1) {
            bigint t;
            t = sub(A, B);
            t.symbol *= -1;
            return t;
        }
 
        if (A.symbol == 1 && B.symbol == -1) { return add(A, B); }
        if (A.symbol == -1 && B.symbol == 1) {
            bigint a = add(A, B);
            a.symbol = -1;
            return a;
        }
 
        return sub(A, B);
    }
 
    template<class T,class Y>
    friend bt operator-(T A, Y B) { return SUB(A, B); }
 
    static bt smilemul(bt &A, char b) {
        if (b == 0)return bt(0);
        if (b == 1)return A;
        std::VC C;
        int t = 0;
        for (int i = 0; i < A.size() || t; i++) {
            if (i < A.size()) t += A[i] * b;
            C.pb(t % 10);
            t /= 10;
        }
        while (C.size() > 1 && C.back() == 0) C.pop_back();
        return {C};
    }
 
    static bigint mul(bt A, bt B) {
        int len1 = A.size(), len2 = B.size(), cnt = len1 + len2;
        VC x;
        long long *c = new long long[len1 + len2 + 10], t = 0;
        f(i, 0, len1 + len2 + 8)c[i] = 0;
        f(i, 0, len1 - 1)f(j, 0, len2 - 1)c[i + j] += A[i] * B[j];
        f(i, 0, cnt - 1) {
            t += c[i];
            c[i] = t % 10;
            t /= 10;
        }
        while (t) {
            c[++cnt] = t % 10;
            t /= 10;
        }
        while (cnt >= 1 && c[cnt] == 0) cnt--;
        x.assign(c, c + cnt + 1);
        bigint ans(x, x.size() * 2);
        delete[] c;
        return {x, int(x.size() * 2)};
    }
 
    friend bigint MUL(bt A, bt B) {
        if (A.symbol * B.symbol == 1)return mul(A, B);
        else {
            bt t = mul(A, B);
            t.symbol = -1;
            return t;
        }
    }
 
    template<class T,class Y>
    friend bt operator*(T A, Y B) { return MUL(A, B); }
 
    static bigint smilediv(bt A, int b) {
        char *cha = new char[A.size()], *ans = new char[A.size()];
        int l = A.size(), m = l - 1, x = 0;
        std::copy(A._a.begin(), A._a.end(), cha);
        rf(i, l - 1, 0) {
            ans[i] = (x * 10 + cha[i]) / b;
            x = (cha[i] + x * 10) % b;
        }
        while (!ans[m] && m >= 1)m--;
        bigint z(0);
        z._a.assign(ans, ans + m + 1);
        delete []cha;
        delete[]ans;
        return z;
    }
 
    static bigint div(bt A, bt B) {
        if (A < B)return {0};
        bt l = 1, r = A;
        while (l <= r) {
            if(r.symbol==-1)exit(1);
            bt mid = smilediv(l + r, 2);
            if (A < mid * B)r = mid - 1;
            else l = mid + 1;
        }
        return r;
    }
 
    friend bigint DIV(bt A, bt B) {
        bt t = div(A, B);
        if (A.symbol * B.symbol == -1)t.symbol = -1;
        return t;
    }
 
    template<class T,class Y>
    friend bt operator/(T A, Y B) { return DIV(A, B); }
 
    static bigint mod(bt A, bt B) {
        bt x = A / B;
        return A - x * B;
    }
 
    friend bigint MOD(bt A, bt B) { return mod(mod(A, B) + B, B); }
 
    template<class T,class Y>
    friend bt operator%(T A, Y B) { return MOD(A, B); }
 
 
    bigint(VC c, int maxsize) : _a(std::move(c)) {  }
 
    bigint(VC c) :_a(std::move(c)) { }
 
    bigint() { _a.assign({0}); }
 
    template<class T>
    bigint(T z, int maxsize)  {
        _a.clear();
        unsigned long long x = z;
        string s = to_string(x);
        if (s[0] != '-')rf(i, s.size() - 1, 0)_a.pb(s[i] - '0');
        else {
            rf(i, s.size() - 1, 1)_a.pb(s[i] - '0');
            symbol = -1;
        }
    }
 
    template<class T>
    bigint(T z) {
        _a.clear();
        string s;
        if (typeid(z) != typeid(const char *) && typeid(z) != typeid(string))s = to_string((long long) z); else s = z;
        if (s[0] != '-') { rf(i, s.size() - 1, 0)_a.pb(s[i] - '0'); }
        else {
            rf(i, s.size() - 1, 1)_a.pb(s[i] - '0');
            symbol = -1;
        }
    }
 
    friend std::ostream &operator<<(std::ostream &os, bt cc) {
        if (cc.symbol == -1 && !(cc._a.size() == 1 && cc[0] == 0))os << '-';
        rf(i, cc.size() - 1, 0)os << int(cc[i]);
        return os;
    }
 
    friend std::istream &operator>>(std::istream &is, bt &cc) {
        cc._a.clear();
        std::string x;
        is >> x;
        if (x[0] == '-') {
            cc.symbol = -1;
            rf(i, x.size() - 1, 1)cc._a.pb(x[i] - '0');
        }
        else
            rf(i, x.size() - 1, 0)cc._a.pb(x[i] - '0');
        return is;
    }
 
    template<class T>
    bool operator<(T A) {
        bigint other = A;
        if (this->symbol == -1 && other.symbol == 1 && !(*(this) == other))return 1;
        if (this->size() < other.size())return 1;
        else if (this->size() > other.size())return 0;
        else if (this->size() == other.size())rf(i, this->size() - 1, 0) { if ((*this)[i] < other[i])return 1; }
        return 0;
    }
    bool operator<(bigint A) {
        bigint other = A;
        if (this->symbol == -1 && other.symbol == 1 && !(*(this) == other))return 1;
        if (this->size() < other.size())return 1;;
       if (this->size() > other.size())return 0;
        if (this->size() == other.size())rf(i, this->size() - 1, 0) { if ((*this)[i] < other[i])return 1;else if((*this)[i] > other[i])return 0; }
        return 0;
    }
    template<class T>
    bool operator==(T A) {
        bigint other(A);
        if (other._a == this->_a && other.symbol == this->symbol ||
            (this->size() == 1 && this->symbol == -1 && other.symbol == 1 && other.size() == 1 && (*this)[0] == 0 &&other[0] == 0))return 1;
        return 0;
    }
 
    template<class T>
    bool operator>(T A) {
        bigint other(A);
        if (*this < other == 0 && (*this == other) == 0)return true;
        return false;
    }
 
    template<class T>
    bool operator<=(T A) {
        bigint other(A);
        if (*(this) < other || *this == other)return 1;
        return 0;
    }
 
    template<class T>
    bool operator>=(T A) {
        bigint other(A);
        if (*(this) > other || *this == other)return 1;
        return 0;
    }
 
    bigint operator-() {
        auto t = *this;
        t.symbol *= -1;
        return t;
    }
 
    bigint operator+=(bt other) {
        *this = *this + other;
        return *this;
    }
 
    bigint operator-=(bt other) {
        *this = *this - other;
        return *this;
    }
 
    bigint operator*=(bt other) {
        *this = *this * other;
        return *this;
    }
 
    bigint operator/=(bt other) {
        *this = *this / other;
        return *this;
    }
 
    bigint operator%=(bt other) {
        *this = *this % other;
        return *this;
    }
 
    bigint operator++(int) {
        bt t = *this;
        *this = *this + 1;
        return t;
    }
 
    bigint operator++() {
        *this = *this + 1;
        return *this;
    }
 
    operator int() const {
        int t = 0;
        for (int i = _a.size() - 1; i >= 0; i--) { t = t * 10 + _a[i]; }
        return t;
    }
};
int main()
{
    bigint a,b,c,d;
    cin>>a>>b>>c>>d;
    cout<<a+b*c/d;
    return 0;
}
smile6a6a
关注
封装高精度整数模板(Bigint): +加 -减 *乘 /除 %模 (带一点点解释)
weixin_45488021的博客
02-11 1115
本代码支持： 重载运算符 + - * / % 正负整数(%没有） 全高精度 我菜狗我直接放代码： #include<bits/stdc++.h> #define ll long long using namespace std; namespace Bigint{ const int maxn=2e4+2; struct bigint{ int len, a[maxn]; bool symbol; // 数字长度， 数字， 符号 /
一个简单的C++大数运算包装类（类似高精度）
qq_29322325的博客
10-16 615
C++:一个类高精度的封装
C++ 高精度封装模板
08-27
此模板为已封装模板，包含 高精度的+，-，*，/，不包含小数 by LAZ
[模板]高精度封装运算
蒟蒻柴犬首相的博客
11-10 747
我只是在这备份下……忘记的时候再来看。。#include<bits/stdc++.h> #define maxn 12000 using namespace std; char s1[maxn],s2[maxn]; namespace Bignum { struct bignum { int len,num[maxn]; bignum()
高精封装模板
weixin_30887919的博客
11-16 142
1 #include<iostream> 2 #include<string.h> 3 #include<stdio.h> 4 #include<cstdlib> 5 #include<algorithm> 6 #define base 100000 7 #define cut 5 8 #...
高精度加法、减法、乘法、除法（C++）
weixin_73378557的博客
07-29 848
首先是定义输入的两个数字,在这里采用vector储存两个加数是为了能够动态的存储数字，并将他们的顺序逆过来(逆过来是为了让他们从个位开始相加)。然后调用add方法(该方法是一个模板)，首先设置一个数组(去储存两数相加的结果)和一个变量(表示两个数字相加的进位)，对每一位的数字进行加法运算。
c++算法竞赛常用模板
07-28
高精度算法的核心在于模拟手工算术运算的过程，将大数存储为字符串或者数位数组的形式，然后逐位进行加减乘除等运算，必要时还需要处理进位和借位。这些高精度算法通常是封装好的函数或类，可以直接在代码中调用，...
C++实现大数运算工具：加减乘除与指数等
3. 高精度算法实现：大数运算通常伴随着高精度算法的实现，例如在进行大数乘法时，需要一个能够处理长乘法（long multiplication）的算法，即通过逐步计算每一位的乘积然后累加得到最终结果。 4. 模运算算法：模指...
用C++实现（使用结构体封装高精度数）加，减，乘，除（高精除低精），取模。完整代码
最新发布
08-01
我们被要求实现一个高精度计算的结构体，包括加法、减法、乘法、除法（高精除低精）和取模运算。我们将参考引用中的结构体设计，并实现所有操作。 设计思路： 1. 使用结构体`BigInteger`，内部使用`vector<int>`...
输出C++高精度算法重载模版
04-23
用户需要的是如何在高精度类中重载运算符，比如加减乘除等。 用户之前的代码是用函数处理运算，比如add、sub等，但用户现在希望用类来封装，并通过重载+、-、*、/等运算符，使得代码更符合C++的习惯用法。因此，我...
高精度加减乘除模板（只供参考）
12-13
这是我自己写的高精度加减乘除模板，加减乘运算只是模拟手算过程，除法利用了加速原理，测试的数据都过了，但也不敢保证一定正确，喜欢的可以看一下，如果注释不是很好，可以加我QQ772103942，我也是算法爱好者，大家可以一起学习，进步，若发现错误，请及时告知，我会把资源删除，免得害人，呵呵
高精度类（压位）C++实现
06-03
高精度压位 #include #include #include using namespace std; const int maxleng=500; class BigInt { private: int leng; int num[maxleng]; public:
c++高精模板
刘皓东的博客
10-29 155
【代码】c++高精模板。
高精度模板汇总
eternal风度
09-18 1250
高精度模板汇总 标签: 算法——高精度 高精加高精 很简单,直接做就行了 string S; struct GJ{ int s[N],L; void Print() { for(int i=L;i&gt;1;--i) printf("%d",s[i]); printf("%d\...
C++高精度（加/减/乘/除）【封装】
KPRF2009的专栏
01-05 1347
<br />#include<iostream> #define maxsize 1020 #define MAX(A,B) (A>B?A:B) char str[maxsize]; struct longnum{ int sign,size; long long data[maxsize]; longnum(){ sign=1;size=0; } longnum(char str[]){ char *p; sign=1;size=0;
高精度模板
qq_52441682的博客
08-05 987
文章目录一、高精度加法1.分析2.代码二、高精度减法1.分析2.代码三、高精度与低精度乘法1.分析2.代码四、高精度与低精度除法1.分析2.代码五、高精度乘法1.分析2.代码六、高精度除法 一、高精度加法 1.分析 大整数加法 大整数存储：用数组从个位开始存储，方便补位操作，同时最好用vector，方便空间处理和访问大小。 操作：从个位开始操作，每一位由加数，被加数和进位所决定，最后对最高位是否有进位进行判断。 前导0处理：不考虑前导0则可以直接逆序输出，若考虑则先进行判断，找到第一个非0位，保证结果长.
基于类和对象的高精度算法封装
weixin_30387423的博客
08-16 206
hi 这是使用类和对象的高精度计算封装实现，这能够进行面向对象的高精度计算编程。 #include<iostream> #include<cstring> using namespace std; class BIGINT{ public: int num[505]; int length; ...
高精度加法、减法、乘法的函数封装
m0_73020012的博客
08-16 513
在c++的运算中，我们有的时候会用到非常大的数据，以至于__int128也无法存下，这个时候，我们就需要使用高精度数进行运算。但是，高精度数的写法非常的不方便，所以，本文主要讲解如何把高精度数封装为结构体类型，如何把高精度数的计算封装为通用函数。
[c++]封装高精度运算
stary_yan的博客
06-22 1140
高精度运算 此文主要给出了高精度运算的实现细节，并将此封装。 #include <string.h> #include <iostream> using namespace std; #define max 1000 /* * This class implements addition, substraction, multiple operation, * which aim to
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值