【C++小项目】实现一个日期计算器

已于 2023-08-25 15:30:25 修改
阅读量1.3k 收藏 17
点赞数 20
分类专栏： C++ 文章标签： c++ 开发语言
于 2023-08-24 22:43:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2301_76540463/article/details/132483424
版权

目录

Ⅰ. 引入

Ⅱ. 列轮廓

Ⅲ. 功能的实现

构造函数

判断是否相等 == | !=

➡️==:

➡️!=:

判断大小 > | >= | < | <=

➡️>：

➡️<=：

➡️>=：

➡️<：

加减天数 + | += | - | -=

➡️+=：

➡️+：

➡️-：

➡️-=：

自增/自减 ++ | --

➡️前置++

➡️后置++

➡️前置--

➡️后置--

日期减日期

➡️Way1（推荐）

➡️Way2（ 这个思路繁杂很多）

Ⅰ. 引入

本篇我们用C++来实现一个日期计算器。

想知道迄今为止你在地球上一共度过了多少天吗？距离寒假还有多少天呢？一百天后会是几月几号呢？

解开这些问题的答案，只需来写一个日期计算器~👻

日期计算器是C++入门以来的第一个小项目，亲自实践一遍，我们在C++上的经验值将⬆️⬆️⬆️

🚩我们将分三步：

Step1：在头文件中把日期类的大体轮廓列出来

Step2：把声明的功能一一实现

Step3：逐个测试。我们写一点，测一点。

这样，就可顺利把日期计算器写出个七七八八。

在遇到较复杂的算法时，我会提供思路。

至于某些锦上添花的功能，我们后续想到了，再添上去。

Ⅱ. 列轮廓

🤔我们先来定义一个日期类，同时看看要实现哪些功能：

#pragma once
#include<iostream>
using namespace std;
​
class Date {
public:
    Date(int year = 1900, int month = 1, int day = 1);  //构造函数：用于初始化
​
    void Print();   //打印日期，便于测试
​
    //功能的具体实现
    bool operator==(const Date& d);  //判断俩date是否相等
    bool operator!=(const Date& d);  
​
    bool operator>(const Date& d);    //date间比较大小
    bool operator>=(const Date& d);
    bool operator<(const Date& d);
    bool operator<=(const Date& d);
​
    Date operator+(int day);     //加(减)天数，今夕是何年
    Date& operator+=(int day);
    Date operator-(int day);
    Date& operator-=(int day);
​
    Date& operator++();     //date的自增/自减
    Date operatoe++(int);
    Date& operator--();
    Date operatoe--(int);
​
    int operator-(const Date& d);  //算两个date间差多少天
​
private:
    int _year;
    int _month;
    int _day;
};

Ⅲ. 功能的实现

构造函数

➡️我们实现一个全缺省的构造函数：

class Date{
public:
    Date(int year = 1900, int month = 1, int day = 1) {  
        _year = year;
        _month = month;
        _day = day;
    }
    
private:
    int _year;
    int _month;
    int _day;
}

每次实例化出一个对象，都要调用构造函数，调用频率非常高。

所以，我们干脆就把这短短的几行定义在类里，做内联函数。

❓你可能会疑惑：为啥_year可以直接拿来用，不需要this->year嘛？

后者当然可以写，但没必要。因为我们在使用类的成员函数or成员变量时，this指针会默认加上的。

我们就不用一一手动加啦✌

Print

➡️Print，写在Date.c里：

void Date::Print() {
    printf("%d-%d-%d\n", _year, _month, _day);
}

❓为啥要加Date::呢？

要知道，类定义了一个全新的作用域。类里类外，是有一层屏障的。

正因为类域的存在，我们不能直接从外部访问类的成员。

因此，把成员函数拿到类外定义时，要指明作用域，即加上Date::

❓我们不是学了cout嘛，为啥不直接cout输出，还得用printf？

这个问题我们先保留着，下一趴再讲。🤪

🔬🧪这俩函数先测试一波：

void Test1() {
    Date d1(2023, 8, 23);
    Date d2;
    d1.Print();
    d2.Print();
}
int main()
{
    Test1();
    return 0;
}

结果：

判断是否相等 == | !=

➡️==:

bool Date::operator==(const Date& d) {
    return _year == d._year
        && _month == d._month
        && _day == d._day;
}

➡️!=:

bool Date::operator!=(const Date& d) {
    return !(*this == d);
}

有没有发现，其实我们只实现了==，

写!=时直接套用了==的功能，这叫做复用。

复用可以减少工作量，提高代码的重用性。

❓为啥只有一个形参？

其实有两个形参：第一个形参是隐形的：this指针。只有第二个形参可见。

“d1!=d2; ” 就相当于在调用函数 “d1.operator!=(d2); ”

此函数的this指针指向d1，形参的d即d2。

🔬🧪测试一下：

void Test2() {
    Date d1(2023, 8, 23);
    Date d2(2000, 1, 1);
    if (d1 != d2) {
        cout << "unequal"<<endl;
    }
}
int main()
{
    //Test1();
    Test2();
    return 0;
}

结果：

判断大小 > | >= | < | <=

日期的大小，听着蛮抽象。其实就是日期的先后：2023年1月1日比2000年1月1日要大（后）。

➡️>：

bool Date::operator>(const Date& d) {
    if (_year > d._year
        || _year == d._year && _month > d._month
        || _year == d._year && _month == d._month && _day > d._day) {
        return true;
    }
    else {
        return false;
    }
}

这种算法的思路是：

写完>，先不急着写<，因为>的对立面是<=，那我们可以把这段代码复用到<=👻

➡️<=：

bool Date::operator<=(const Date& d) {
    return !(*this > d);
}

➡️>=：

bool Date::operator>=(const Date& d) {
    return *this > d || *this == d;
}

➡️<：

bool Date::operator<(const Date& d) {
    return !(*this >= d);
}

🔬🧪测试一下：

void Test3() {
    Date d1(2023, 8, 23);
    Date d2(2000, 1, 1);
    cout << (d1 > d2) << endl;
    cout << (d1 <= d2)<<endl;
}
​
int main()
{
    //Test1();
    //Test2();
    Test3();
    return 0;
}

结果：

加减天数 + | += | - | -=

➡️+=：

日期加天数要考虑进位的问题。我举个例子，先顺下思路：

2023-12-21往后推40天

61相比当月的31已经溢出了，

怎么判断是否溢出呢？

写个函数GetMonthDay()，取到每月的天数进行比对

GetMonthDay()实现如下：

int Date::GetMonthDay(int year, int month) {
    int days[13]={ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    int ret = days[month];
​
    //考虑闰年的2月是29天的情况
    //闰年，要么能被4整除&&不能被100~；要么能被400整除
​
    if (month == 2
        && (year % 4 == 0 && year % 100 == 0
            || year % 400 == 0)) {
        ret += 1;
    }
​
    return ret;
}

☑️operator+=实现如下：

Date& Date::operator+=(int day) {
    _day += day;
    int MaxDay = GetMonthDay(_year, _month);
​
    while (_day > MaxDay) {
        _day -= MaxDay;
        _month++;
​
        //防止month溢出
        if (_month == 13) {
            _month = 1;
            _year++;
        }
​
        MaxDay = GetMonthDay(_year, _month);
    }
​
    return *this;
}

➡️+：

有了+=，+就直接复用~👻

Date Date::operator+(int day) {
    Date ret = *this;
    ret+=day;
    return ret;
}

🤔❓下面这种写法会导致程序崩溃。为啥不能这样写？

Date Date::operator+(int day) {
    Date ret = *this+day;
    return ret;
}

我们进入这个函数看一下：

！陷入死循环了。

我写了一个operator+，我现在要用operator+...

用operator+的话，得去调用我写的那个operator+...

调用函数operator+时，我又用到了operator+...

陷入死循环了...

💡这是因为：

上面那位因为有了+=，+就可以直接复用。

而这里我们本身就是在写+，+没法复用。

ret不是内置类型，它是我们自定义的。

自定义类型的加减 是需要我们自己去实现 运算符重载的。

之所以写成这样是正确的：

Date ret = *this;
    ret += day;
    return ret;

是因为我们先前就定义了Date类型的+=。

如果现在把+=给注释掉，那这一段同样会出问题，编译不过去。

➡️-：

加要考虑进位，减要考虑借位。

举例：2023-3-2 往前40天

思路：

🌀你可能有点晕：-38为什么要借2月的28？

可以把2023-3-2往前40天视为2023-3-0往前38天。

此时要借位，我们没法从3月借，因为它是空的。只能从2月借。

☑️实现：

Date& Date::operator-=(int day) {
    _day -= day;
​
    while (_day <= 0) {
        _month--;
​
        if (_month == 0) {
            _month = 12;
            _year--;
        }
        int BorrowDay = GetMonthDay(_year, _month);
        _day += BorrowDay;
    }
​
    return *this;
}

➡️-=：

同样，复用🥰

Date Date::operator-(int day) {
    Date ret = *this;
    ret -= day;
    return ret;
}

🔬🧪测试一下：

void Test4() {
    Date d1(2023, 12, 21);   //+  +=
    Date d2(d1);
    (d1 + 40).Print();
    (d2 += 700).Print();
    
    Date d3(d1);   //-  -=
    Date d4(2023, 3, 2);
    (d3 -= 400).Print();
    (d4 - 40).Print();
}

结果：

自增/自减 ++ | --

我们用参数占位来区分前置/后置++：

前置：operator++( )

后置：operator++( int )

❓前置++和后置++的区别是什么？

这俩都能实现自增，但返回值不同。

前置：++d; 先加加，再使用。返回的是加加后的值。

后置：d++;先使用，再加加。返回的是加加前的值。

假设d=0，d++：返回1，d=1

++d：返回0，同时实现自增，d=1

所以说，后置加加是不能引用返回的。而前置可以。

➡️前置++

Date& Date::operator++() {
    return *this += 1;
}

➡️后置++

Date Date::operator++(int) {
    Date ret = *this;
    *this += 1;
    return ret;
}

➡️前置--

Date& Date::operator--() {
    return *this -= 1;
}

➡️后置--

Date Date::operator--(int) {
    Date ret = *this;
    *this -= 1;
    return ret;
}

🔬🧪测试一下：

void Test5() {
    Date d1(2023, 1, 1);   //++
    Date d2(d1);
    (++d1).Print();
    (d2++).Print();
​
    Date d3(2023, 1, 1);  //--
    Date d4(d3);
    (--d3).Print();
    (d4--).Print();
}

结果：

日期减日期

距离新年还有多少天呢？

Date(2024,1,1) - Date(2023,8,24) =❓天

➡️Way1（推荐）

我们刚刚不是写了好多功能嘛，复用起来~👻

实现：

int Date::operator-(const Date& d) {
    Date More = *this;  //先把date标个大小
    Date Less = d;
​
    if (Less > More) {
        More=d;
        Less=*this;
    }
​
    int count = 0;    //用计数法算差值
    while (Less<More) {
        Less++;    //复用🥰👻
        count++;
    }
​
    int flag = 1;      //我们不知道是大-小or小-大
    if (More == d) {    //为了区分结果的正负，引入flag
        flag = -1;  
    }
​
    return count*flag;
}

这种方法虽然思路简单，但是深度复用了代码，效率会下降。

➡️Way2（ 这个思路繁杂很多）

（❗这个方法效率会⬆️，但是较复杂，可略过不看！）

Q: 2023-2-13到2024-1-15，要过多少天？、

思路：

Step1：把月、日转化成总天数；

Step2：年与年之间相减，天与天之间相减

Step3：全化成天

实现：

Step1 我们先写一个把月、日转换成天数的函数ConverttoDay( )

如下：

int Date::ConverttoDay(int year, int month, int day) {
    int MonthtoDay = 0;
    month -= 1;
​
    while (month) {
        MonthtoDay += GetMonthDay(year, month);
        month--;
    }
​
    int ret = MonthtoDay + day;
    return ret;
}

Step2 实现operator-函数

int Date::operator-(const Date& d) {
    //先判断日期的大小
    Date BigDate = *this;
    Date SmallDate = d;
​
    if (BigDate < SmallDate) {
        Date tmp = SmallDate;
        SmallDate = BigDate;
        BigDate = tmp;
    }
​
    //把月、日都转换成天
    int BigDay = ConverttoDay(BigDate._year, BigDate._month, BigDate. _day);
    int SmallDay = ConverttoDay(SmallDate._year, SmallDate._month, SmallDate._day);
​
​
    int RetofDay = BigDay - SmallDay;  //天之间相减，大天-小天
    
    int BigYear = BigDate._year;
    int SmallYear = SmallDate._year;
​
    //年之间相减，大年-小年
    int CountDay = 0;
​
    while (SmallYear < BigYear) {
        CountDay += 365;
​
        if (SmallYear % 4 == 0 && SmallYear % 100 != 0  //考虑闰年
            || SmallYear % 400 == 0) {
            CountDay += 1;
        }
​
        SmallYear++;
    }
​
    //把两者的天数合一
    int ret = RetofDay + CountDay;
​
    int flag = 1;
    if (*this == BigDate) {
        flag = -1;
    }
​
    return flag * ret;
}

🔬🧪测试一下：

void Test6() {
    Date d1(2023, 8, 24);
    Date d2(2024, 1, 1);
​
    printf("%d\n", d2 - d1);
}

结果：

完整代码

Date.h

#pragma once
#include<iostream>
using namespace std;

class Date {
public:
	Date(int year = 1900, int month = 1, int day = 1) {   //构造函数：用于初始化
		_year = year;
		_month = month;
		_day = day;
	}

	void Print();   //打印日期，便于测试
	int GetMonthDay(int year, int month);

	//功能的具体实现
	bool operator==(const Date& d);  //判断俩date是否相等
	bool operator!=(const Date& d);  

	bool operator>(const Date& d);    //date间比较大小
	bool operator>=(const Date& d);
	bool operator<(const Date& d);
	bool operator<=(const Date& d);

	Date operator+(int day);     //加(减)天数，今夕是何年
	Date& operator+=(int day);
	Date operator-(int day);
	Date& operator-=(int day);

	Date& operator++();     //date的自增/自减
	Date operator++(int);
	Date& operator--();
	Date operator--(int);

	int operator-(const Date& d);  //算两个date间差多少天

private:
	int _year;
	int _month;
	int _day;
};

Date.cpp

#include"Date.h"
void Date::Print() {
	printf("%d-%d-%d\n", _year, _month, _day);
}

bool Date::operator==(const Date& d) {
	return _year == d._year
		&& _month == d._month
		&& _day == d._day;
}

bool Date::operator!=(const Date& d) {
	return !(*this == d);
}

bool Date::operator>(const Date& d) {
	if (_year > d._year
		|| _year == d._year && _month > d._month
		|| _year == d._year && _month == d._month && _day > d._day) {
		return true;
	}
	else {
		return false;
	}
}

bool Date::operator>=(const Date& d) {
	return *this > d || *this == d;
}

bool Date::operator<(const Date& d) {
	return !(*this >= d);
}

bool Date::operator<=(const Date& d) {
	return !(*this > d);
}

int Date::GetMonthDay(int year, int month) {
	int days[13]={ 0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
	int ret = days[month];

	//考虑闰年的2月是29天的情况
	//闰年，要么能被4整除&&不能被100~；要么能被400整除

	if (month == 2
		&& (year % 4 == 0 && year % 100 != 0
			|| year % 400 == 0)) {
		ret += 1;
	}

	return ret;
}

Date Date::operator+(int day) {
	Date ret = *this;
	ret += day;
	return ret;
}

Date& Date::operator+=(int day) {
	_day += day;
	int MaxDay = GetMonthDay(_year, _month);

	while (_day > MaxDay) {
		_day -= MaxDay;
		_month++;

		//防止month溢出
		if (_month == 13) {
			_month = 1;
			_year++;
		}

		MaxDay = GetMonthDay(_year, _month);
	}

	return *this;
}

Date Date::operator-(int day) {
	Date ret = *this;
	ret -= day;
	return ret;
}

Date& Date::operator-=(int day) {
	_day -= day;

	while (_day <= 0) {
		_month--;

		if (_month == 0) {
			_month = 12;
			_year--;
		}
		int BorrowDay = GetMonthDay(_year, _month);
		_day += BorrowDay;
	}

	return *this;
}

Date& Date::operator++() {
	return *this += 1;
}

Date Date::operator++(int) {
	Date ret = *this;
	*this += 1;
	return ret;
}

Date& Date::operator--() {
	return *this -= 1;
}

Date Date::operator--(int) {
	Date ret = *this;
	*this -= 1;
	return ret;
}

int Date::operator-(const Date& d) {
	Date More = *this;  //先把date标个大小
	Date Less = d;

	if (Less > More) {
		More=d;
      Less=*this;
	}

	int count = 0;    //用计数法算差值
	while (Less<More) {
		Less++;
		count++;
	}

	int flag = 1;
	if (More == d) {
		flag = -1;  //*this-d，如果*this更小，那结果应为负值
	}

	return count*flag;
}

Test.cpp

#include"Date.h"
void Test1() {
	Date d1(2023, 8, 23);
	Date d2;
	d1.Print();
	d2.Print();
}

void Test2() {
	Date d1(2023, 8, 23);
	Date d2(2000, 1, 1);
	if (d1 != d2) {
		cout << "unequal"<<endl;
	}
}

void Test3() {
	Date d1(2023, 8, 23);
	Date d2(2000, 1, 1);
	cout << (d1 > d2) << endl;
	cout << (d1 <= d2)<<endl;
}

void Test4() {
	Date d1(2023, 12, 21);   //+  +=
	Date d2(d1);
	(d1 + 40).Print();
	(d2 += 700).Print();
	
	Date d3(d1);   //-  -=
	Date d4(2023, 3, 2);
	(d3 -= 400).Print();
	(d4 - 40).Print();
}

void Test5() {
	Date d1(2023, 1, 1);   //++
	Date d2(d1);
	(++d1).Print();
	(d2++).Print();

	Date d3(2023, 1, 1);
	Date d4(d3);
	(--d3).Print();
	(d4--).Print();
}

void Test6() {
	Date d1(2023, 8, 24);
	Date d2(2024, 1, 1);

	printf("%d\n", d2 - d1);
}

void Test7() {
	Date d1(2023, 2,13);
	Date d2(2025, 1,15);
	printf("%d\n", d1-d2);
}

int main()
{
	//Test1();
	//Test2();
	//Test3();
	//Test4();
	//Test5();
	//Test6();
	Test7();
	return 0;
}

OK, 到这我们的日期计算器已经完成啦~🥰👻

掉毛小公鸡1234567
关注
  • 20
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 16
    评论
专栏目录
新手必看！【C++】简单的日期计算器实现
不会编程的程序圆 的博客
06-17 722
码字不易，对你有帮助 点赞/转发/关注 支持一下作者 微信搜公众号：不会编程的程序圆 看更多干货，获取第一时间更新 这个计算器用 C++ 基础的语法（构造，运算符重载等）实现，功能很简易，适合新手学习。 我们先来看一下效果： 计算器的功能 计算器一共有 四个 主要的功能： // 打印菜单 static void menu(); // 创建一个新的对象，由用户输入初始化 static Date newDate(); // 计算日期差 void daysBetweenTwoDates(.
【C++】关于日期的计算
lanlanla的成长历程
10-19 1345
代码： #include <cstdio> int month[13][2]={{0,0},{31,31},{28,29},{31,31},{30,30}, {31,31},{30,30},{31,31},{31,31},{30,30},{31,31},{30,30},{31,31}}; bool Isleap(int year) { return ((year%4==0...
计算日期的程序
05-18
计算日期的小程序，很初级的代码，给菜鸟级的人看的
算法笔记之日期计算（c/c++）
qq_61875563的博客
01-21 1754
算法笔记之日期计算
最全C++模拟实现-----日期计算器（超详细解析，小白一看就会！，2024年最新C C++面试项目包装
最新发布
2401_84976207的博客
05-16 633
return ret;//法二：复用日期 += 天数ret += day;return ret;这里实现 += 其实有两种方案前面我实现的日期+天数，仔细观察我的代码，这里调用拷贝构造，是为了不在*this本身上做变动，只在ret上进行操作，其理由是日期+天数得到的是另一个日期，而不用拷贝构造直接在*this上做改动只会导致原有的日期也变化，而这个变化正是我日期 += 天数的需求**++=好+=+好****，答案是用****+=两次拷贝****，而****+=
【C++】实现一个日期计算器
学了就忘是正常现象
10-09 3355
类和对象使用练习
【 C++ 】日期计算器
bit_zyx的博客
06-08 3015
目录 一、前言 二、日期类的实现 检查日期的合法性 <运算符重载 == 运算符重载 <= 运算符重载 >运算符重载 >= 运算符重载 != 运算符重载 改进和优化 日期 + 天数 日期 += 天数 日期 -= 天数 日期 - 天数 前置.........
Python——日期计算器
m0_60867520的博客
12-10 1022
介绍python标准库中的datetime使用方法，实现一个日期计算器的小程序
日期计算器
04-02
MFC是微软为Windows应用程序设计的一个C++类库，它提供了一系列的类来简化Win32 API的使用，使得开发者能够更容易地构建用户界面和应用程序逻辑。 在这个项目中，主要包含以下几个关键知识点： 1. **日期表示**：...
自己编写的C++日期计算器
11-01
这个项目中提供的`CalTime`可能是实现日期计算器功能的源代码文件，包含了上述类的定义和具体实现。通过阅读和学习这个源码，我们可以深入了解如何在C++中处理日期和时间，以及如何设计和实现自定义数据结构和操作符...
C++MFC计算器
03-19
C++ MFC（Microsoft Foundation Classes）计算器项目是一个深入理解C++编程、Windows应用程序开发以及MFC库运用的绝佳实践。MFC是微软提供的一套面向对象的C++类库，用于简化Windows API的使用，使得开发者能够更...
C++模拟实现-----日期计算器（超详细解析，小白一看就会！）
weixin_45031801的博客
10-28 1187
在之前的博客学习中，我们已经详细的讲解了C++中的引用、缺省函数、this指针、构造函数、析构函数、拷贝构造函数、运算符重载等非常重要的知识，但是对于这些知识如何如何的使用还没有进行讲解，所以本次博客将以日期计算器为例，将以上知识融合起来讲解，帮助大家更好的理解。
c++获取日历时间
qq_18076309的博客
11-24 547
c++获取日历时间
【C++】日期类的实现
m0_69023444的博客
10-20 449
1.类的创建 2.拷贝构造函数 3.'='运算符重载 4.‘==’ 与 ’!=‘运算符重载 5.’
C++入门级练手项目——日期类的计算
Britney_dark的博客
05-22 866
只要付出真心去对待对方就可以了。
C＋＋实现日期推算
m0_67718152的博客
04-10 4082
【问题描述】 设计一个程序用于向后推算指定日期经过n天后的具体日期。 【输入形式】 输入为长度为8的字符串str和一个正整数n，str前四位表示年份，后四位表示月和日。 【输出形式】 当推算出的年份大于4位数时，输出"out of limitation!"，否则输出8位的具体日期。 #include<iostream> #include<string> using namespace std; int month[12] = { 31,28,31,30,3
利用C++日期类实现简单的日期计算器
weixin_34342905的博客
03-04 385
网络上有一个日期计算器可以通过输入的日期来计算天数，或者通过日期加减天数来计算出相应的日期。这个小工具对在我们生活中还是非常有用的，它的代码实现是不是很难呢？其实用我们学习过的C++类来处理问题就变得很简单了。参考代码：（加强版）#include<iostream> #include<cstdlib> usingnamespacestd; cla...
【C++】日期计算器
m0_64224788的博客
10-27 1128
在我们的日常生活中，我们可能需要计算几天后的日期，或计算日期差等，现如今计算日期的方式有很多，简单粗暴的直接查看日历，快捷点的直接使用日期计算器来求得，这里我们实现一个日期计算器。
用c++实现一个计算器
09-07
好的，下面是一个使用 C 语言实现的简单计算器代码： ``` #include int main() { double num1, num2; char operation; ### 回答2： 实现一个计算器的程序主要包括以下几个步骤： 1. 需要定义一个主函数，...
评论 16
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值