QT6 源，十章绘图（3）：点 QPoint 与 QPointF 的源代码带注释

原创 已于 2025-08-03 19:59:03 修改 · 364 阅读 · 9 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#qt

于 2025-08-03 17:24:49 首次发布

（1）本章开始学习 QT 里的绘图事件 QPaint。绘图涉及了画笔 QPen 与 QBrush。但绘图最终也涉及坐标系，与点，线，矩形这些基础的经典的图形定义。 所以，先来学习一下 QT 里如何为一个坐标系中的点定义一个类 ， QPoint 与 QPointF。 本类的继承关系如下 ：

在这里插入图片描述

（2）源码显示， 本类是支持流运算操作符的 ：

在这里插入图片描述

（3） 不给这个全局模板友元函数举例，因为总是报错，我也不知道为什么，不可理解 ：

在这里插入图片描述

++以及 ：

在这里插入图片描述

（4）本类的源代码，都直接给出了 QT 自己的实现，就不再举例了，也因为时间紧迫。本类还是很容易根据源码进行理解的。举例的意义不大。重点还是画图， QPaint。 本 QPoint 类的源代码定义于 qpoint . h ：

#ifndef QPOINT_H
#define QPOINT_H

#include <QtCore/qnamespace.h>

#if defined(Q_OS_DARWIN) || defined(Q_QDOC)
struct CGPoint;
#endif

QT_BEGIN_NAMESPACE


Q_CORE_EXPORT QDataStream & operator<< (QDataStream &, const QPoint & );
Q_CORE_EXPORT QDataStream & operator>> (QDataStream &,       QPoint & );
Q_CORE_EXPORT QDebug        operator<< (QDebug       , const QPoint & );

Q_CORE_EXPORT size_t qHash(QPoint key, size_t seed = 0) noexcept;

/*
The QPoint class defines a point in the plane using integer precision.

Note: All functions in this class are reentrant.

Detailed Description ：
一个点由x坐标和y坐标指定，这些坐标可以通过x()和y()函数来访问。
如果x和y都被设置为0，则isNull()函数将返回true。
这些坐标可以通过setX()和setY()函数来设置(或修改)，
或者通过rx()和ry()函数来设置，这些函数返回坐标的引用(从而允许直接操作)。

给定一个点p，以下陈述都是等价的:
    QPoint p;

    p.setX(p.x() + 1);
    p += QPoint(1, 0);
    p.rx()++;  //可见，引用更方便

QPoint对象也可以用作向量:加法和减法定义与向量相同(每个分量分别相加).
QPoint对象也可以被整数或qreal除或乘。

此外，QPoint类提供了manhattanLength()函数，  //曼哈顿距离
该函数提供了一个廉价的近似值，用于表示QPoint对象作为向量的长度。
最后，QPoint对象既可以被流式传输，也可以被比较。


*/


class QPoint
{
private:
    friend class QTransform;
    int xp;
    int yp;

    /*
    template <bool _Test, class _Ty = void>
    struct enable_if {}; // no member "type" when !_Test

    template <class _Ty>
    struct enable_if<true, _Ty> { // type is _Ty for _Test
        using type = _Ty;
    };

    template <bool _Test, class _Ty = void>
    using enable_if_t = typename enable_if<_Test, _Ty>::type;
    */
    template <std::size_t I,    typename P,  //这里期待 P 是 QPoint 相关的类型
             std::enable_if_t<(I < 2), bool> = true,
             std::enable_if_t<std::is_same_v<std::decay_t<P>, QPoint>, bool> = true>
    friend constexpr decltype(auto) get(P && p) noexcept //这里为本类定义了一个友元全局模板函数
    {                                        //不用在模板参数里给出 P,因为可以从函数形参里得到。
        if      constexpr (I == 0)
            return (std::forward<P>(p).xp);
        else if constexpr (I == 1)
            return (std::forward<P>(p).yp);
    }

public:
    constexpr QPoint() noexcept : xp(0), yp(0) {}

    constexpr QPoint(int xpos, int ypos) noexcept : xp(xpos), yp(ypos) {}

    constexpr inline bool    isNull() const noexcept { return xp == 0 && yp == 0; }
    constexpr inline int          x() const noexcept { return xp; }
    constexpr inline int          y() const noexcept { return yp; }
    constexpr inline int   &     rx()       noexcept { return xp; }
    constexpr inline int   &     ry()       noexcept { return yp; }
    constexpr inline void      setX(int x)  noexcept { xp = xpos; }
    constexpr inline void      setY(int y)  noexcept { yp = ypos; }

    constexpr inline int  manhattanLength() const    { return qAbs(x()) + qAbs(y()); }
    //注意，曼哈顿距离是坐标的 x + y，而不是 x^2 + y^2

    constexpr        QPoint   transposed() const noexcept { return {yp, xp}; } //坐标转置

    constexpr static inline int dotProduct(const QPoint & p1, const QPoint & p2)
    { return p1.xp * p2.xp + p1.yp * p2.yp; } //矢量乘法

    constexpr inline QPoint & operator+=(const QPoint & p     )
    {   xp += p.xp;
        yp += p.yp;
        return  * this;
    }
    constexpr inline QPoint & operator-=(const QPoint & p     )
    {   xp -= p.xp;
        yp -= p.yp;
        return  * this;
    }

    constexpr inline QPoint & operator*=(      float    factor)
    {   xp = qRound(xp * factor);
        yp = qRound(yp * factor);
        return  * this;
    }
    constexpr inline QPoint & operator*=(      double   factor)
    {   xp = qRound(xp * factor);
        yp = qRound(yp * factor);
        return  * this;
    }
    constexpr inline QPoint & operator*=(      int      factor)
    {   xp = xp * factor;
        yp = yp * factor;
        return  * this;
    }

    constexpr inline QPoint & operator/=(       qreal   divisor)
    {   xp = qRound(xp / divisor);
        yp = qRound(yp / divisor);
        return  * this;
    }

//*************************************************************************
//****************以下是关于本类的全局友元符号运算符函数*************************
//*************************************************************************

    friend constexpr inline    //点的相等比较
    bool   operator== (const QPoint & p1, const    QPoint & p2) noexcept
    { return p1.xp == p2.xp && p1.yp == p2.yp; }

    friend constexpr inline    //点的不等比较
    bool   operator!= (const QPoint & p1, const    QPoint & p2) noexcept
    { return p1.xp != p2.xp || p1.yp != p2.yp; }

    friend constexpr inline    //点的坐标相加
    QPoint operator+  (const QPoint & p1, const    QPoint & p2) noexcept
    { return QPoint(p1.xp + p2.xp, p1.yp + p2.yp); }

    friend constexpr inline    //点的坐标相减
    QPoint operator-  (const QPoint & p1, const    QPoint & p2) noexcept
    { return QPoint(p1.xp - p2.xp, p1.yp - p2.yp); }

    friend constexpr inline    //点的线性乘法
    QPoint operator*  (const QPoint & p ,           float   factor)
    { return QPoint(qRound(p.xp * factor), qRound(p.yp * factor)); }

    friend constexpr inline    //点的线性乘法
    QPoint operator*  (const QPoint & p,            double  factor)
    { return QPoint(qRound(p.xp * factor), qRound(p.yp * factor)); }

    friend constexpr inline    //点的线性乘法
    QPoint operator*  (const QPoint & p,            int      factor) noexcept
    { return QPoint(p.xp * factor, p.yp * factor); }

    friend constexpr inline    //点的线性乘法
    QPoint operator*  (      float    factor, const QPoint & p)
    { return QPoint(qRound(p.xp * factor), qRound(p.yp * factor)); }

    friend constexpr inline    //点的线性乘法
    QPoint operator*  (      double   factor, const QPoint & p)
    { return QPoint(qRound(p.xp * factor), qRound(p.yp * factor)); }

    friend constexpr inline    //点的线性乘法
    QPoint operator*  (      int      factor, const QPoint & p) noexcept
    { return QPoint(p.xp * factor, p.yp * factor); }

    friend constexpr inline   //点的线性除法
    QPoint operator/  (const QPoint & p, qreal c)
    { return QPoint(qRound(p.xp / c), qRound(p.yp / c)); }

    friend constexpr inline   //这不是加法， 这是正号， +8
    QPoint operator+  (const QPoint & p) noexcept { return p; }

    friend constexpr inline   //这不是减法， 这是负号， -8
    QPoint operator-  (const QPoint & p) noexcept
    { return QPoint(-p.xp, -p.yp); }


}; // 完结 class QPoint

Q_DECLARE_TYPEINFO(QPoint, Q_PRIMITIVE_TYPE);

QT_END_NAMESPACE

/*****************************************************************************
  QPoint/QPointF tuple protocol
 *****************************************************************************/

namespace std
{
    template <>
    class tuple_size<QT_PREPEND_NAMESPACE(QPoint)>
        : public integral_constant<size_t, 2> {};

    template <>
    class tuple_element<0, QT_PREPEND_NAMESPACE(QPoint)>
    { public: using type = int; };

    template <>
    class tuple_element<1, QT_PREPEND_NAMESPACE(QPoint)>
    { public: using type = int; };

    template <>
    class tuple_size<QT_PREPEND_NAMESPACE(QPointF)>
        : public integral_constant<size_t, 2> {};

    template <>
    class tuple_element<0, QT_PREPEND_NAMESPACE(QPointF)>
    { public: using type = QT_PREPEND_NAMESPACE(qreal); };

    template <>
    class tuple_element<1, QT_PREPEND_NAMESPACE(QPointF)>
    { public: using type = QT_PREPEND_NAMESPACE(qreal); };

}

#endif // QPOINT_H

（5） 给出浮点 QPointF 的源码，不再如同 QPoint 那样详细整理了 ：

size_t qHash(QPointF, size_t seed = 0) = delete;
//QPointF stream functions
Q_CORE_EXPORT QDataStream &operator<<(QDataStream &, const QPointF &);
Q_CORE_EXPORT QDataStream &operator>>(QDataStream &, QPointF &);
Q_CORE_EXPORT QDebug operator<<(QDebug d, const QPointF &p);

class QPointF
{
private:
    friend class QTransform;

    qreal xp;
    qreal yp;

    template <std::size_t I,
             typename P,
             std::enable_if_t<(I < 2), bool> = true,
             std::enable_if_t<std::is_same_v<std::decay_t<P>, QPointF>, bool> = true>
    friend constexpr decltype(auto) get(P &&p) noexcept
    {
        if      constexpr (I == 0)
            return (std::forward<P>(p).xp);
        else if constexpr (I == 1)
            return (std::forward<P>(p).yp);
    }

public:
    constexpr QPointF() noexcept;
    constexpr QPointF(const QPoint & p) noexcept;
    constexpr QPointF(qreal xpos, qreal ypos) noexcept;

    inline           bool    isNull() const noexcept;
    constexpr inline qreal        x() const noexcept;
    constexpr inline qreal        y() const noexcept;
    constexpr inline qreal &     rx() noexcept;
    constexpr inline qreal &     ry() noexcept;
    constexpr inline void      setX(qreal x) noexcept;
    constexpr inline void      setY(qreal y) noexcept;

    constexpr inline qreal manhattanLength() const;
    constexpr QPointF transposed() const noexcept { return {yp, xp}; }

    constexpr QPoint  toPoint() const;

    constexpr inline QPointF & operator+=(const QPointF & p); //也有这些复合运算符成员函数

    constexpr inline QPointF & operator-=(const QPointF & p);

    constexpr inline QPointF & operator*=(      qreal     c);

    constexpr inline QPointF & operator/=(      qreal     c);

    constexpr static inline qreal dotProduct(const QPointF & p1, const QPointF & p2)
    {
        return p1.xp * p2.xp + p1.yp * p2.yp;
    }

    QT_WARNING_PUSH
    QT_WARNING_DISABLE_FLOAT_COMPARE
    friend constexpr inline bool operator==(const QPointF & p1, const QPointF & p2)
    {
        return ((!p1.xp || !p2.xp)
                ? qFuzzyIsNull(p1.xp - p2.xp)
                : qFuzzyCompare(p1.xp, p2.xp)) && (
                   (!p1.yp || !p2.yp)
                       ? qFuzzyIsNull(p1.yp - p2.yp)
                       : qFuzzyCompare(p1.yp, p2.yp)
                                                    );
    }

    friend constexpr inline bool operator!=(const QPointF & p1, const QPointF & p2)
    {
        return !(p1 == p2);
    }
    QT_WARNING_POP

    friend constexpr inline QPointF operator+(const QPointF & p1, const QPointF & p2)
    { return QPointF(p1.xp + p2.xp, p1.yp + p2.yp); }

    friend constexpr inline QPointF operator-(const QPointF & p1, const QPointF & p2)
    { return QPointF(p1.xp - p2.xp, p1.yp - p2.yp); }

    friend constexpr inline QPointF operator*(const QPointF & p , qreal c)
    { return QPointF(p.xp * c, p.yp * c); }

    friend constexpr inline QPointF operator*(qreal c, const QPointF & p)
    { return QPointF(p.xp * c, p.yp * c); }

    friend constexpr inline QPointF operator/(const QPointF & p , qreal divisor)
    {
        Q_ASSERT(divisor < 0 || divisor > 0);
        return QPointF(p.xp / divisor, p.yp / divisor);
    }

    friend constexpr inline QPointF operator+(const QPointF & p) { return p; }

    friend constexpr inline QPointF operator-(const QPointF & p)
    { return QPointF(-p.xp, -p.yp); }


}; //完结 class QPointF

Q_DECLARE_TYPEINFO(QPointF, Q_PRIMITIVE_TYPE);


/*****************************************************************************
  QPointF inline functions
 *****************************************************************************/

constexpr inline QPointF::QPointF() noexcept : xp(0), yp(0) { }

constexpr inline QPointF::QPointF(qreal xpos, qreal ypos) noexcept : xp(xpos), yp(ypos) { }

constexpr inline QPointF::QPointF(const QPoint &p) noexcept : xp(p.x()), yp(p.y()) { }

constexpr inline qreal QPointF::manhattanLength() const
{
    return qAbs(x()) + qAbs(y());
}

inline bool QPointF::isNull() const noexcept
{
    return qIsNull(xp) && qIsNull(yp);
}

constexpr inline qreal QPointF::x() const noexcept
{
    return xp;
}

constexpr inline qreal QPointF::y() const noexcept
{
    return yp;
}

constexpr inline void QPointF::setX(qreal xpos) noexcept
{
    xp = xpos;
}

constexpr inline void QPointF::setY(qreal ypos) noexcept
{
    yp = ypos;
}

constexpr inline qreal &QPointF::rx() noexcept
{
    return xp;
}

constexpr inline qreal &QPointF::ry() noexcept
{
    return yp;
}

constexpr inline QPointF &QPointF::operator+=(const QPointF &p)
{
    xp += p.xp;
    yp += p.yp;
    return *this;
}

constexpr inline QPointF &QPointF::operator-=(const QPointF &p)
{
    xp -= p.xp;
    yp -= p.yp;
    return *this;
}

constexpr inline QPointF &QPointF::operator*=(qreal c)
{
    xp *= c;
    yp *= c;
    return *this;
}

constexpr inline QPointF &QPointF::operator/=(qreal divisor)
{
    Q_ASSERT(divisor > 0 || divisor < 0);
    xp /= divisor;
    yp /= divisor;
    return *this;
}

constexpr inline QPoint QPointF::toPoint() const
{
    return QPoint(qRound(xp), qRound(yp));
}

（6）

谢谢

Qt的坐标QPoint与几何图形QRect
xiaobai_cpp的博客
08-07 1345
例如，mapToGlobal(QPoint(0,0))将给出小部件左上角像素的全局坐标。将小部件坐标pos从父部件的坐标系统转换为该小部件的坐标系统。父组件不能为nullptr，必须是调用小部件的父组件。如果小部件是一个窗口，则该位置是小部件在桌面上的位置，包括它的框架。将父小部件坐标pos转换为小部件坐标。将小部件坐标pos转换为父小部件中的坐标。将父小部件坐标pos转换为小部件坐标。父组件不能为nullptr，必须是调用小部件的父组件。返回这个小部件的父部件，如果没有父部件，则返回nullptr。...
Qt基础类01--坐标类QPoint
2974786048的专栏
08-28 1154
1.本文测试验证了QT中的QPoint基础类的各成员和属性 2.本文对照着QT的帮助文档，对QPoint的基础知识，相对比较全面。 3.本文提供了QT5的QPoint的测试程序，上传到了优快云，供网友参考，请自行下载。
Qt-QPointer的使用
lzqd1314的博客
05-04 407
在使用Qt的时候，你是否遇到过这样的场景，从外部传来一个QObject的指针，当使用这个指针的时候，害怕它已经被释放了？如果我们在一个对象A中引用了另一个对象B，当对象B被析构的时候，A对象其实是不知道B已经被析构。当第二次调用showWidget的时候，w已经被释放了，所以会打印出"The widget has been destroyed"。如果m_widget在其他地方被释放掉了，再调用showWidget就是导致崩溃，因为m_widget == nullptr肯定是false。
Qt 常用类 （4）—— QPoint
u012803067的博客
07-16 2769
Qt 常用类 （4）—— QPoint 标签： qt 2012-05-12 11:48 7201人阅读 评论(0) 收藏 举报 分类： Qt开发（33） 版权声明：本文为博主原创文章，未经博主允许不得转载。     QPoint 类代表一个坐标点，实现在 QtCore 共享库中。它可以认为是一个整型的横坐标和一个整型的纵坐标
Qt常用类——Qpoint
weixin_30412577的博客
09-29 1114
QPoint 类代表一个坐标点，实现在 QtCore 共享库中。它可以认为是一个整型的横坐标和一个整型的纵坐标的组合。 构造 QPoint 类支持以下两种构造方式： QPoint(); // 构造横纵坐标均为 0 的 QPoint 对象 QPoint(int x, int y); // 构造横纵坐标分别为 x 和 y 的 QPont 对象 属性 通过以...
QT6 点 QPoint 与 QPointF 的源代码带注释
08-03
QT6 点 QPoint 与 QPointF 的源代码带注释
Qt5 的类 QPoint，QPointF（相关的方法，不会的都在）
weixin_57165154的博客
04-26 1万+
QPoint QPoint官网链接 简介 QPoint 类使用整数精度来定义平面中的一个点 包含的成员 我觉得你可能看不懂的成员使用的方法： 1、dotProduct(const QPoint &, const QPoint &):int，参数是两个点的坐标，return 他们两点之间的距离。 QPoint p( 3, 7); QPoint q(-1, 4); int lengthSquared = QPoint::dotProduct(p, q); // lengt
Qt5的QPoint 和 QPointF
热门推荐
Joeferyの博客
08-21 1万+
QPoint Class ： QPoint表示一个平面上整数精度的点坐标，可以通过x(),y()等函数方便的进行存取操作，另外也重载了大量的运算符，使其可以作为一般的常数一样进行运算。另外其也可以表征为向量，可进行向量的相关运算例如乘除以及长度的计算。 公有函数： QPoint() QPoint(int xpos,int ypos)
no matching function for call to ‘QWheelEvent::QWheelEvent(QPointF, QPointF, QPoint, QPoint, Qt::MouseButtons, Qt::KeyboardModifiers, Qt::ScrollPhase, bool, Qt::MouseEventSource)’ e->modifiers(), e->phase(), e->inverted(), e->source());
最新发布
10-21
`no matching function for call to ‘QWheelEvent::QWheelEvent(QPointF, QPointF, QPoint, QPoint, Qt::MouseButtons, Qt::KeyboardModifiers, Qt::ScrollPhase, bool, Qt::MouseEventSource)’` 错误通常表示在...
Qt几何数据类型：QPoint类型详解（基础向）
R6bandito的博客
11-28 1700
虽然 Qt 有自己的图形和绘图 API，但是有些开发者可能需要使用 Core Graphics 框架的特定功能，而且有的第三方库可能使用的是CGPoint类型的坐标点。用一个简单的例子来说：假如你在城市街道中从一个十字路口走到另一个十字路口，你只能沿街道的直线方向（横或竖）行走，不能直接穿过建筑物。曼哈顿距离特别适合在网格状空间或离散的环境中使用，它的名称来源于曼哈顿市的街道布局，因为它模拟了在城市的直角网格街道中，从一个点到另一个点的最短路径。但是欧几里得距离的计算涉及平方与开平方，计算效率是比较低的。
0017：Qt常用类 - QPoint
-- You only get better by playing --
05-14 3056
1 开发环境 在介绍内容之前，先说明一下开发环境，如下图： Qt版本：Qt5.3.2； Qt开发工具：Qt Creater 3.2.1； Qt构建工具：Desktop Qt 5.3 MinGW 32bit； Qt开发平台：Windows 7 64bit。 2 QPoint QPoint是Qt中表示点的坐标类，用整型值来表示某个点的x坐标和y坐标。首先，将QPoint中的常用接口整理出来，分为初始...
「QT」几何数据类 之 QPoint 整型点类
何曾参静谧的博客
11-09 1150
默认构造函数：创建一个横纵坐标均为0的QPoint对象。QPoint();参数化构造函数：创建一个横纵坐标分别为指定值的QPoint对象。QPoint类提供了多个共有函数，用于获取和设置点的坐标、进行向量运算等。：获取点的横坐标。：获取点的纵坐标。：设置点的横坐标。：设置点的纵坐标。：将当前点与另一个点相加，结果存储在当前点中。：将当前点与另一个点相减，结果存储在当前点中。：计算当前点作为向量时的曼哈顿长度（即横纵坐标绝对值之和）。QPoint类还提供了一个静态函数dotProduct。
《QT从基础到进阶·十四》QPoint，QPen，QPainter，QFont，焦点事件使用
cs1395293598的博客
11-05 571
函数QPainter::isActive()的作用是：指示绘制程序是否处于活动状态。painter由begin()函数和接受QPaintDevice参数的构造函数激活，end()函数和析构函数将停用它。这里有个特殊情况，要说明一下，按照我们的理解，如果setWidth（0）的话，应该是线条宽度为0，应该是不显示线条啊。可是实际不是这样，当设置为线条宽度为0的时候，默认画笔的宽度一直是1像素宽。使用setColor(QColor(255, 0, 0, 100))定义画笔的颜色。
Qt中的位置和尺寸
好好学习，天天向上
06-20 2271
Qt中的位置和尺寸
Qt：QPointer类
OceanStar的博客
04-09 1951
QPointer类是一个模板类，它提供了指向QObject的guarded pointer。 template <typename T> class QPointer 头文件： #include <QPointer> cmake: find_package(Qt6 COMPONENTS Core REQUIRED) target_link_libraries(mytarget PRIVATE Qt6::Core) qmake： QT += core 详细说明 g
QPoint类详细介绍
wanglaqqqq的博客
04-14 627
QPoint是 PyQt5 中用于表示的类，广泛用于图形绘制、控件定位和几何计算。
【QT常用类】QPoint、QSize，QRect
qt，c++，java啥都学啥都不会本人
05-10 2344
QPoint: QPoint p(int x,int y) // 构造一个横坐标x纵坐标y的QPoint对象p p.rx( ) // 得到横坐标（可直接修改） p.setX(int x) // 设置横坐标 p.x( ) // 获得横坐标（只读） ... // 同理y也一样 支持加减法赋值 QSize: QSize m(int x,int y) // 构造一个宽为x高为y的QSize对象 m.rwidth( ) // 得到宽度（可直接修改） m.setwidth( ) // 设置宽度 m.width( ).
QPoint
xie__jin__cheng的博客
11-10 569
QPoint
【QT教程】QT6图形系统揭秘
QT性能优化QT原理源码QT界面美化
05-15 691
QT6图形系统简介QT6图形系统简介QT6是挪威Trolltech公司（后被Nokia收购，之后又转手给了Digia，最终由The Qt Company继续开发）开发的跨平台C++图形用户界面应用程序框架的最新版本。作为一个QT技术培训专家，我编写这本书旨在为读者揭秘QT6图形系统的核心概念、功能和使用方法。QT6图形系统是一个功能丰富的框架，它支持应用程序在各种操作系统上运行，包括Windows、Mac OS、Linux、iOS和Android等。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zhangzhangkeji

谢谢支持

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

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

打赏作者

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

抵扣说明：

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

余额充值