实现自定义类型比较的三种改写方法 -- 以set＜Point＞为例

最新推荐文章于 2025-02-12 22:27:58 发布
最新推荐文章于 2025-02-12 22:27:58 发布
阅读量971 收藏 11
点赞数 19
CC 4.0 BY-SA版权
分类专栏： C++ 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/x_linear/article/details/142934683

前置

模板 – 打印

见 CppBaseDay21

重载 <<

os 是泛化的 std::ostream：

  • 在 operator<< 函数中，os 是 std::ostream 的引用，这意味着它可以代表任何具体的输出流，例如 std::cout、std::ofstream（文件输出流）、std::ostringstream（字符串输出流）等。
  • 当你向 operator<< 传递 std::cout 时，os 实际上就是 std::cout 的引用；但你也可以将其他流传递给 os，例如文件流对象或字符串流对象。

cout 是特定的 std::ostream 实例：

  • std::cout 是一个具体的 std::ostream 实例，它与标准输出（通常是终端/控制台）相关联。你可以直接用 std::cout 来向屏幕打印消息。
  • cout 不能替代 os，因为 os 可以是任何输出流，而 cout 仅指向标准输出。

使用namespace std { }的原因

当我们对标准库模板进行特化时，必须将特化放入 std 命名空间，因为这些模板是在 std 命名空间中定义的。如果不放在 std 命名空间中，编译器将无法将其视为对标准模板的特化，而是会当成一个独立的新模板。

第一种方式 – 模板的特化

类模板特化 template<> struct less<Point>

//类模板定义
template <class/typename T, ...>
class 类名{
//类定义．．．．．．
};

//chatgpt给出的示例：
namespace std {
    template <class T>	//less<Point> 是对模板 less<T> 的特化，Point 是 T 的具体类型
    struct less {
       ……
    };
}

//代码中的写法 
template <>
struct less<Point>//模板的特化
{
	……
}

  • template<>：这是模板特化的语法，表示我们将为模板类 std::less 提供一个特化版本，用于处理 Point 类型。

  • struct less<Point>：我们在 std::less 模板中为 Point 类型提供特化，即定义一个新的规则用于比较 Point 对象。。

这个特化会覆盖默认的 std::less 行为–在标准库中，std::less 是一个类模板，用于定义对象之间的比较操作（通常是 < 运算符）。它的默认实现会使用 < 运算符来比较对象。

struct less<Point> 是对 std::less 这个模板类的特化，这里的 Point 具体化了模板参数 T。

less 是类名，T 是一个类型参数。这个模板类可以用来创建不同类型的比较器，例如 less<int>、less<double> 等。

  • operator()：这是重载的函数调用运算符，定义了 less<Point> 如何比较两个 Point 对象。在这个例子中，我们首先比较 x 坐标，如果 x 坐标相等，则比较 y 坐标。

为什么要末尾要加const–成为const成员函数被调用

const/非const对象 以及 const/非const函数

在 const 对象上调用成员函数：

  • 只能调用 const 成员函数。
  • 不能调用非常量成员函数。

在非常量对象上调用成员函数：

  • 可以调用 const 和非 const 成员函数（优先，没有再调用const版本）。
chatgpt例子
class MyClass {
public:
    int value;

    // 非 const 成员函数
    void setValue(int v) {
        value = v; // 修改值
    }

    // const 成员函数
    int getValue() const {
        return value; // 只读
    }
};

int main() {
    MyClass obj; // 非 const 对象
    obj.setValue(5); // 可以调用
    int val = obj.getValue(); // 可以调用

    const MyClass constObj; // const 对象
    // constObj.setValue(10); // 错误，不能调用非 const 成员函数
    int constVal = constObj.getValue(); // 可以调用 const 成员函数

    return 0;
}
set源码中的成员函数operator()

看看吧。。。主要看图，格式就是这样要求的。。。

STL 容器（如 std::set、std::map）通常会使用传递的比较函数来比较元素。为了保证这些比较函数能够在使用时不改变容器中元素的状态，STL 要求这些函数必须是 可调用的（invocable）并且应该是 const 的。

以下是个人猜想。。。

set底层是const修饰的，因此set的对象只能调用const 成员函数

所以bool operator()(const Point &lhs,const Point &rhs)后面要加 const

//error
bool operator()(const Point &lhs,const Point &rhs) {……}

bool operator()(const Point &lhs,const Point &rhs) const {……}

在这里插入图片描述

//默认的模板
#if 0
namespace std
{
template <class T>
struct less
{
    bool operator()(const T &lhs, const T &rhs) const
    {
        return lhs < rhs;
    }
};
}//end of namespace std
#endif

形式

template <>
struct less<Point>//模板的特化
{
	……
}

代码1

在这里插入图片描述

#include <math.h>
#include <iostream>
#include <set>

using std::cout;
using std::endl;
using std::set;

//模板 -- 打印
template <typename Container>    //typename - class 
void display(const Container & con){
    for(auto & elem : con){
        cout << elem << " ";
    }
    cout << endl;
}

class Point
{
public:
    Point(int ix = 0, int iy = 0)
    : _ix(ix)
    , _iy(iy)
    {
    }

    //计算点到原点的距离
    float getDistance() const
    {
        return hypot(_ix, _iy);
    }

    int getX() const
    {
        return _ix;
    }

    int getY() const
    {
        return _iy;
    }

    ~Point()
    {
    }

    friend std::ostream & operator<<(std::ostream & os,const Point & rhs);   //Point

private:
    int _ix;
    int _iy;
};

//由于是自定义模板，需要重载 <<
//同时由于需要访问Point类的私有成员，因此在Point类中需要把该函数声明为友元
std::ostream & operator<<(std::ostream & os,const Point & rhs){
    os << "(" << rhs._ix << "," << rhs._iy << ")";
    return os;
}


//第一种 -- 模板的特化
namespace std
{
template <>
struct less<Point>  //less是类名，T是一个类型参数。例如 less<int>、less<double> 等。
{
    //比较2个Point类对象
    bool operator()(const Point &lhs,const Point &rhs) const
    {   
        cout << "template<> struct less" << endl;
        // x 和 y均采用升序的方式比较大小
        if(lhs.getX() < rhs.getX())
        {
            return true;
        }else if(lhs.getX() == rhs.getX()){
            if(lhs.getY() < rhs.getY()){
                return true;
            }else{
                return false;
            }
        }
        else    //lhs.getX() > rhs.getX()
        {
            return false;
        }
    } 
};
}   //end of namespace std


//第二种 -- 运算符重载


//第三种 -- 函数对象



void test0(){
    set<Point> number = {
        Point(1, 2),
        Point(-1, 2),
        Point(1, 4),
        Point(1, 2),
        Point(1, -2),
        Point(3, 2),
    };

    display(number);
}

int main()
{
    test0();       
    return 0;
}

第二种方式 – 函数对象

形式

struct ComparePoint
{
	……
}

代码2

在这里插入图片描述

#include <math.h>
#include <iostream>
#include <set>

using std::cout;
using std::endl;
using std::set;

//模板 -- 打印
template <typename Container>    //typename - class 
void display(const Container & con){
    for(auto & elem : con){
        cout << elem << " ";
    }
    cout << endl;
}

class Point
{
public:
    Point(int ix = 0, int iy = 0)
    : _ix(ix)
    , _iy(iy)
    {
    }

    //计算点到原点的距离
    float getDistance() const
    {
        return hypot(_ix, _iy);
    }

    int getX() const
    {
        return _ix;
    }

    int getY() const
    {
        return _iy;
    }

    ~Point()
    {
    }

    friend std::ostream & operator<<(std::ostream & os,const Point & rhs);   //Point
    
    //friend struct ComparePoint;	//好像没将函数对象作为友元，代码运行也可以成功。。。
    								//因为使用了getX() 之类的函数，可以直接访问私有成员

private:
    int _ix;
    int _iy;
};

//由于是自定义模板，需要重载 <<
//同时由于需要访问Point类的私有成员，因此在Point类中需要把该函数声明为友元
std::ostream & operator<<(std::ostream & os,const Point & rhs){
    os << "(" << rhs._ix << "," << rhs._iy << ")";
    return os;
}

//第一种 -- 模板的特化

//第二种 -- 函数对象
struct ComparePoint
{
    //比较2个Point类对象
    bool operator()(const Point &lhs,const Point &rhs) const
    {   
        cout << "struct ComparePoint" << endl;
        // x 和 y均采用升序的方式比较大小
        if(lhs.getX() < rhs.getX())
        {
            return true;
        }else if(lhs.getX() == rhs.getX()){
            if(lhs.getY() < rhs.getY()){
                return true;
            }else{
                return false;
            }
        }
        else    //lhs.getX() > rhs.getX()
        {
            return false;
        }
    } 
};

//第三种 -- 运算符重载



void test0(){
    set<Point,ComparePoint> number = {
        Point(1, 2),
        Point(-1, 2),
        Point(1, 4),
        Point(1, 2),
        Point(1, -2),
        Point(3, 2),
    };

    display(number);
}

int main()
{
    test0();       
    return 0;
}

第三种方式 – 运算符重载

形式

bool operator<(const Point & lhs,const Point & rhs)
{
	……
}

代码

在这里插入图片描述

#include <math.h>
#include <iostream>
#include <set>

using std::cout;
using std::endl;
using std::set;

//模板 -- 打印
template <typename Container>    //typename - class 
void display(const Container & con){
    for(auto & elem : con){
        cout << elem << " ";
    }
    cout << endl;
}

class Point
{
public:
    Point(int ix = 0, int iy = 0)
    : _ix(ix)
    , _iy(iy)
    {
    }

    //计算点到原点的距离
    float getDistance() const
    {
        return hypot(_ix, _iy);
    }

    int getX() const
    {
        return _ix;
    }

    int getY() const
    {
        return _iy;
    }

    ~Point()
    {
    }

    friend std::ostream & operator<<(std::ostream & os,const Point & rhs);   //Point

    friend bool operator<(const Point &lhs, const Point &rhs);  // < 运算符重载

private:
    int _ix;
    int _iy;
};

//由于是自定义模板，需要重载 <<
//同时由于需要访问Point类的私有成员，因此在Point类中需要把该函数声明为友元
std::ostream & operator<<(std::ostream & os,const Point & rhs){
    os << "(" << rhs._ix << "," << rhs._iy << ")";
    return os;
}

//第一种 -- 模板的特化

//第二种 -- 函数对象

//第三种 -- 运算符重载
bool operator<(const Point & lhs,const Point & rhs){
    cout << "bool operator<" << endl;
    if(lhs.getX() < rhs.getX())
        {
            return true;
        }else if(lhs.getX() == rhs.getX()){
            if(lhs.getY() < rhs.getY()){
                return true;
            }else{
                return false;
            }
        }
        else    //lhs.getX() > rhs.getX()
        {
            return false;
        }
}



void test0(){
    set<Point> number = {
        Point(1, 2),
        Point(-1, 2),
        Point(1, 4),
        Point(1, 2),
        Point(1, -2),
        Point(3, 2),
    };

    display(number);
}

int main()
{
    test0();       
    return 0;
}

补充

如果模板的特化 和 运算符重载同时存在

优先调用 模板的特化

在这里插入图片描述

完整版代码

//setPoint_three.cc

#include <math.h>
#include <iostream>
#include <set>

using std::cout;
using std::endl;
using std::set;

template <typename Container>
void display(const Container &con)
{
    for(auto &elem : con)
    {
        cout << elem << "  ";
    }
    cout << endl;
}

class Point
{
public:
    Point(int ix = 0, int iy = 0)
    : _ix(ix)
    , _iy(iy)
    {
    }

    //计算点到原点的距离
    float getDistance() const
    {
        return hypot(_ix, _iy);
    }

    int getX() const
    {
        return _ix;
    }

    int getY() const
    {
        return _iy;
    }

    ~Point()
    {
    }

    friend std::ostream &operator<<(std::ostream &os, const Point &rhs);
    friend bool operator<(const Point &lhs, const Point &rhs);
    friend struct ComparePoint;

private:
    int _ix;
    int _iy;
};

std::ostream &operator<<(std::ostream &os, const Point &rhs)
{
    os << "(" << rhs._ix
       << ", " << rhs._iy
       << ")";

    return os;
}

bool operator<(const Point &lhs, const Point &rhs)
{
    cout << "bool operator<" << endl;
    if(lhs.getDistance() < rhs.getDistance())
    {
        return true;
    }
    else if(lhs.getDistance() == rhs.getDistance())
    {
        if(lhs._ix < rhs._ix)
        {
            return true;
        }
        else if(lhs._ix == rhs._ix)
        {
            if(lhs._iy < rhs._iy)
            {
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
    else
    {
        return false;
    }
}

struct ComparePoint
{
    bool operator()(const Point &lhs, const Point  &rhs) const
    {
        cout << "struct ComparePoint" << endl;
        if(lhs.getDistance() < rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs._ix < rhs._ix)
            {
                return true;
            }
            else if(lhs._ix == rhs._ix)
            {
                if(lhs._iy < rhs._iy)
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }

    }
};

#if 0
namespace std
{
template <class T>
struct less
{
    bool operator()(const T &lhs, const T &rhs) const
    {
        return lhs < rhs;
    }
};
}//end of namespace std
#endif

//命名空间的扩展
namespace  std
{

template <>
struct less<Point>//模板的特化
{
    bool operator()(const Point &lhs, const Point &rhs) const
    {
        cout << "template<> struct less" << endl;
        if(lhs.getDistance() < rhs.getDistance())
        {
            return true;
        }
        else if(lhs.getDistance() == rhs.getDistance())
        {
            if(lhs.getX() < rhs.getX())
            {
                return true;
            }
            else if(lhs.getX() == rhs.getX())
            {
                if(lhs.getY() < rhs.getY())
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }
};

}//end of namespace std
 
void test()
{
    set<Point> number = {
    /* set<Point, ComparePoint> number = { */
        Point(1, 2),
        Point(-1, 2),
        Point(1, 4),
        Point(1, 2),
        Point(1, -2),
        Point(3, 2),
    };
    display(number);
}

int main(int argc, char *argv[])
{
    test();
    return 0;
}
C++ PTA 6-4 Point类的声明和实现
Moriafly的博客
06-02 3729
C++ PTA 6-4 Point类的声明和实现 定义一个Point类，代表平面上的一个点，其横坐标和纵坐标分别用x和y表示，设计Point类的成员函数，实现并测试这个类。 主函数中输入两个点的坐标，计算并输出了两点间的距离。请根据主函数实现Point类。 裁判测试程序样例： #include <iostream> #include <iomanip> #include <cmath> using namespace std; //你的代码将被嵌在这里 int mai
干货--Hadoop自定义数据类型和自定义输入输出格式整合项目案例
热门推荐
至道
05-03 1万+
数据输入格式（InputFormat） 用于描述MapReduce作业的数据输入规范。MapReduce框架依靠数据输入格式完成输入规范检查(比如输入文件目录的检查)、对数据文件进行输入分块(也叫分片，InputSplit)，以及提供从输入分块(分片)中将数据记录逐一读出，并转化为Map过程的输入键值对等功能 Hadoop提供了丰富的内置数据输入格式。最常用的数据输入格式包括：TextInputFormat和KeyValueInputFormat TextInputFormat是系统默认的数据输入格式，可
set 自定义比较函数
诗子黎的博客
10-26 570
set的底层为红黑树。
STL:set中使用自定义比较操作
yang20141109的专栏
06-29 2572
set关联容器对关键字类型有一些限制，关键字类型必须定义比较操作，默认情况下，标准库使用关键字类型的<运算符来比较两个关键字。当关键字类型是用户自定义类型时，为了容器中关键字类型正确，我们有三种方式提供正确的关键字类型。 第一中方式：在关键字类型中对#include #include using namespace std; class Node { public: int star
set如何自定义比较方式
aiwangyi6的博客
09-15 490
注意的点就是函数参数需要加const,并且参数后的括号外也需要加const。修改比较方式就是在定义set时尖括号内加上结构体名。可以用结构体,重载()运算符。
std::set自定义排序比较函数
janeqi1987的专栏
07-10 6621
std::set默认是通过std::less函数来比较key值的。 #include <iostream> #include <set> void main() { std::set<int> mySet; // mySet.insert(10); // 默认比较函数为less mySet.insert(20); // 从小到大排序 for(auto it:mySet) { st
【c++】 自定义排序和比较函数（适用于set，sort等需要排序/去重的地方）
xll_bit的博客
09-25 1709
当对自定义类（如下面的代码）进行排序或者将自定义类放入set结构时，就需要自定义比较函数，否则会报错。对基本数据类型排序或者放入set时不需要此函数，因为是STL中自定义了比较函数，会默认调用，无需自定义。 #include<iostream> #include<set> using namespace std; class A{ public: int a,b,c...
python3+PyQt5 图形项的自定义和交互--实现page Designer应用程序
xiaoyangyang20的博客
03-06 7479
本文通过Python3+PyQt5实现《python Qt Gui 快速编程》这本书的page Designer应用程序，采用QGraphicsView，QGraphicsScene，QGraphicsItem，这个程序包含有多个文本，图片和框的页面。有些图形类在PyQt5已过时，所以本代码改动幅度比较大。
spring cloud config+自动更新配置+多数据源druid+读写分离（类上自定义注解，通过AOP获取标识区分主从数据库）
LUNG108的博客
07-11 3002
公司有个spring config的预想开发。（已经实现Spring Cloud Eureka），正好这段时间闲来无事，就先自己搭一个单独的config的demo（本例中没有整合Eureka，后面慢慢更新，因为它不是本次重点）。 项目是springboot的，maven管理，git上的数据库配置文件信息。 共有两个spring boot项目： 1. config-server（提供获取git...
自定义InvokeMouseCommandAction类，用于WPF中的鼠标事件到prism:DelegateCommand的绑定
就在昨天之技术点滴
03-14 1583
可以实现鼠标事件绑定到DelegateCommand的功能，对prism中的InvokeCommandAction进行改写，得到InvokeMouseCommandAction类。 该类使用很简单，就是<local:InvokeMouseCommandAction Command="{Binding MouseDownCommand}"/>，在xaml中的详细语句如下： ...
stl中的自定义比较函数详解, 各类自定义排序方法
2301_76841210的博客
06-03 615
标准库函数中的setmap等容器都可以保证一定的大小顺序, 并且可以覆盖默认的比较函数实现自定义的排序需求. 在各类博文中, 有大量不同方式自定义排序函数并实现相关需求的方式, 作为一名c++小白, 决定将各种方式学习一下, 彻底弄懂自定义比较函数的相关问题.我们以set为例详细说明.set是c++标准库提供的一个容器, 他提供了一个保序的集合, 集合中的元素不可重复. 具体模板声明如下其中Key是保存的元素类型;Compare是比较器的类型, 也是本文讨论的重点;Allocator。
【c语言】字符串比较 | API仿真
努力让自己的能力配得上梦想.
05-06 975
字符串比较 目录 一、字符串比较 二、strncmp仿真 声明： 指针方式定义： 调用测试： 运行结果：
C字符串库函数（一）【自用】
qq_52150515的博客
03-22 696
c语言常用字符串库函数。strlen strcpy strcmp strcat strstr
C语言，(自定义函数）字符串的拷贝、连接、比较（综合性）
weixin_58064203的博客
10-27 1353
一个C语言程序是由一个主程序和若干子程序组成。(程序 函数)函数是一组一起执行一个任务的语句。每个 C 程序都至少有一个函数，即主函数main()，所有子程序（子函数）在主函数中进行声明（执行main函数时，搜索到若干个子程序，并调用，得到返回值(根据类型的不同，例：void类型，适用于地址传递，无需返回值)，再次回到主函数中）函数是C程序的基本单位，被调用的函数可以是系统提供的库函数，也可以是用户根据需要自己定义的函数。您可以把代码划分到不同的函数中。
如何从std :: ostream派生实现自定义的输出流类
aflyeaglenku的博客(QQ1010316426）
07-14 3693
本文为博主原创文章，未经博主允许不得转载。（合作洽谈请联系QQ：1010316426） 缘起： 笔者的项目产品上一般使用C风格的库记录运行日志，日志库的接口是如printf样式。近日，需要引入其他模块（不同途径获取）的代码，但是发现这个模块记录日志是使用C++的流式风格。因代码里巨大，手动修改费时费力（不符合程序员做事风格），于是笔者想到是否可以将流式的log只通过替换其日志宏 从而实现在不修改代码的前提下将流式转为printf式，从而完成log部分的整合。 //printf风格 void write_.
C语言自定义函数比较字符串,C语言中处理字符串的各种自定义函数.doc
weixin_35665984的博客
05-17 387
C语言中处理字符串的各种自定义函数关于strcpy,strcmp,strcat,strlen的自定义函数，它是为了避免调用库函数对代码兼容的局限性。要注意如下一些问题：1． 检查输入的两个指针是否有效；2． 检查两个字符串是否以NULL结尾；3． 检查目标指针的空间是否大于等于原字符串的空间。一． strcpy自定义char * sef_strcpy(char *str1,char *str2){...
自定义比较方法1 仿函数（set，map）
最新发布
2301_78094384的博客
02-12 289
需要一个类型来作为它的比较器，而函数不是类型。即使你有一个函数，你也需要将其包装在一个仿函数中才能作为模板参数使用。不过，C++ 提供了一种方式来简化这一过程——通过使用标准库中的。自己写的类，必须自定义比较方法才能使用，为 set 自定义比较方法，及第二个参数，只能使用仿函数，不能使用函数。但是，通常更简单和推荐的方法是直接定义一个仿函数结构体或类，并将其作为模板参数。或者自定义仿函数封装函数指针。
C++ STL set详解
qq_34999565的博客
03-23 2641
template< class Key, class Compare = std::less<Key>, class Allocator = std::allocator<Key> > class set; std::set是一种关联型容器，是一个排序集合，可以用来存放Key类型的对象。set集合里的对象都是唯一的，所以通常可以用set来做去重。其中排序是通过Compare这个对比函数对象来完成的，因为要排序，对于自定义类型需要告诉编译器这个...
C++ostream的使用
sinat_31608641的博客
09-05 4771
在 C++中，ostream表示输出流，英文”output stream“的简称。在 C++中常见的输出流对象就是标准输出流cout，很少自定义ostream的对象，更多的是直接使用cout。那么 ostream 有什么用呢，来看一个场景： class CPoint { public: CPoint(int x_,int y_):x(x_),y(y_){} int x,y; }; 这里定义了一个简单的类CPoint，如果我们实例化该类过后，想要打印对象的值： CPoint po.
C语言怎么改写public static HashSet<Point> set = new HashSet<Point>();
03-20
抱歉，C语言中没有public static关键字，也没有HashSet类。但是，我们可以使用结构体和指针来实现类似的功能。以下是一个示例代码： ``` #include <stdio.h> #include <stdlib.h> struct Point { int x; int y; }; struct HashSet { struct Point* points; int size; }; void add(struct HashSet* set, struct Point point) { for (int i = 0; i < set->size; i++) { if (set->points[i].x == point.x && set->points[i].y == point.y) { return; } } set->size++; set->points = (struct Point*)realloc(set->points, set->size * sizeof(struct Point)); set->points[set->size - 1] = point; } int main() { struct HashSet set = { NULL, 0 }; struct Point p1 = { 1, 2 }; struct Point p2 = { 3, 4 }; add(&set, p1); add(&set, p2); printf("Set size: %d\n", set.size); printf("Set contents: "); for (int i = 0; i < set.size; i++) { printf("(%d, %d) ", set.points[i].x, set.points[i].y); } printf("\n"); free(set.points); return 0; } ``` 这个代码使用了一个结构体HashSet来存储点的集合，其中包含一个指向Point结构体数组的指针和一个表示集合大小的整数。add函数用于向集合中添加一个点，如果点已经存在于集合中，则不进行任何操作。在main函数中，我们创建了两个点并将它们添加到集合中，然后输出集合的大小和内容。最后，我们释放了动态分配的内存。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值