C++ 写一个日期类的注意事项

已于 2023-10-31 13:29:08 修改
阅读量104 收藏
点赞数
分类专栏： C++ 文章标签： c++ 算法 开发语言
于 2023-10-28 15:44:29 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_65143871/article/details/134089720
版权

目录

成员变量的命名风格

类的实例化

拷贝构造

解决方法

引用

Data类拷贝构造

指针

Stack的拷贝构造

ps

运算符重载

ps

operator==  operator>=  operator!=

题目

用运算符重载函数写一个日期相加

那我们如何正确实现一个operator+呢？

空容器

复用+=

成员变量的命名风格

下文这样来初始化一个日期类的成员变量

#include<iostream>
using namespace std;


class Data
{
public:
	void Init(int year,int month,int day)
	{
		year = year;
		month = month;
		day = day;

	}


private:
	int year;
	int month;
	int day;
};
int main()
{

	Data T;
	T.Init(2003,11,29);
	return 0;
}

我们发现并没有初始化上：

 原因：

这样写加以区分：

#include<iostream>
using namespace std;


class Data
{
public:
	void Init(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;

	}


private:
	int _year;
	int _month;
	int _day;
};
int main()
{

	Data T;
	T.Init(2003,11,29);
	return 0;
}

类的实例化

有这样一个日期类：



class Data
{
public:
	void Init(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;

	}


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

即然有类域，那我们可以这样访问吗？
 

Data::_year;
Data._year;

不可以，因为我们私有的成员变量只是一个声明：

 只有声明是不能直接拿来用的，我们需要定义：

	Data T;

现在定义了一个变量T，就开辟了一块空间，_year，_month,_day的空间也被一把开出来了。

拷贝构造

有如下这么两个类，一个日期类，一个栈类

typedef int DataType;
class Stack
{
public:
	Stack(size_t capacity = 3)
	{
		cout << "Stack()" << endl;
	}

	// s1(s)
	Stack(const Stack& s)
	{
		cout << "Stack(Stack& s)" << endl;
	
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;
	}
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;
};
class Data
{
public:
	void Init(int year,int month,int day)
	{
		_year = year;
		_month = month;
		_day = day;

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

现在还有一个fun函数，我们把栈类的值拷贝给这个fun函数：

void fun(Data a)
{

}

int main()
{
	
	Data T;
	T.Init(2003,11,29);
	fun(T);


	return 0;
}

如果我们把日期类拷贝给fun函数就不会蹦：


void fun1(Data s)
{

}


int main()
{
	Data T;
	T.Init(2003,11,29);
	fun1(T);

return 0;
}

如果我们把栈来拷贝给fun函数就会蹦：

void fun2(Stack s)
{

}



int main()
{
   Stack s1;
	
	fun2(s1);

return 0;

}

我们可以画图解析一下：

如图，stack的int*_a是在堆上面开辟的空间，内容存在堆上的，_a指向堆。

fun是stack的浅拷贝，fun的_a也指向同一块地址。

 fun后调用，先结束生命周期，先调用析构。此时就把这块空间释放掉了，那么轮到stack的时候会再次调用析构，会再把这块空间释放一次。

看下面这个图，a和s1的_array都指向堆上的同一块地址：

（ps:调试技巧：先给fun2（）调用打断点，跳到fun2()调用之后再f11跳fun2（）定义）

fun函数先析构：

stack再去析构的时候就会报错，因为stack的_a此时是一个野指针，指向了一块已经被释放了的空间：

解决方法

引用

void fun2(Stack& a)
{

}

int main()
{
Stack s1;
	
fun2(s1);

return 0;
}

引用的话我就是你，也就不存在析构两次的问题了。

但是这个方法仍然有弊端，那就是如果我想通过a的值的改变但是不影响s1呢？

下面这段代码 apush值肯定会改变s1

void fun2(Stack& a)
{
	a.Push(1);
	a.Push(2);
}

int main()
{
Stack s1;
	
fun2(s1);

return 0;
}

c++提供了拷贝构造函数来解决这个问题

Data类拷贝构造

拷贝构造函数和函数名和类名一致，参数类型也和类名一致，就是自己拷贝自己。

如下，我们现在就可以不用fun了，直接d2拷贝d1,通过拷贝构造函数：

Data(Data d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

调拷贝构造有两种方法

d2,d3分别用不同方法拷贝d1:


	Data d1(2003,11,29);
	

	Data d2(d1);

    Data d3=d1;
	//fun1(d2);

但是会有报错：

也就是说拷贝构造函数参数必须为引用，这是因为如果不引用就会无穷无尽的拷贝。

怎么理解这句话呢？

内置类型可以直接传参，但是c++有自定义类型，列入栈这种，如果直接传参会面临析构两次的问题

于是c++规定自定义类型传参需要调用拷贝构造，如果直接传参会造成无限拷贝：

 所以我们要通过引用传参：

	Data(Data& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

引用是一种别名，所以引用没有拷贝。

指针

同样的，用指针也可以解决这个问题，因为指针只是传个地址嘛，并没有拷贝值


void fun1(Data* s)
{

}

int main()
{
fun1(&d1);
return 0;
}

Stack的拷贝构造

栈类的拷贝构造就没有日期类的拷贝构造那么简单了，因为涉及到了扩容的问题。

栈对拷贝构造实际上就是把栈的构造函数给copy一份，包括空间和内容，这个也叫做深拷贝。

//构造函数


	Stack(size_t capacity = 3)
	{
		cout << "Stack()" << endl;

		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

//拷贝构造


Stack(const Stack& s)
	{
		//cout << "Stack(Stack& s)" << endl;
		// 深拷贝
		_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		memcpy(_array, s._array, sizeof(DataType) * s._size);
		_size = s._size;
		_capacity = s._capacity;
	}

 没写拷贝构造时的：

写了拷贝构造之后的：

 小结：

比如MYqueue类，我们什么都不写，直接让编译器用默认生成的，全去拿栈的用。

构造函数：默认生成，析构函数:默认生成，拷贝构造函数：默认生成。


class MYqueue
{
	Stack pushst;
	Stack Popst;
};



typedef int DataType;
class Stack
{
public:

	
	Stack(size_t capacity = 3)
	{
		cout << "Stack()" << endl;

		_array = (DataType*)malloc(sizeof(DataType) * capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		_capacity = capacity;
		_size = 0;
	}

	 //s1(s)
	Stack( Stack& s)
	{
		cout << "Stack(Stack& s)" << endl;
		// 深拷贝
		_array = (DataType*)malloc(sizeof(DataType) * s._capacity);
		if (NULL == _array)
		{
			perror("malloc申请空间失败!!!");
			return;
		}

		memcpy(_array, s._array, sizeof(DataType) * s._size);
		_size = s._size;
		_capacity = s._capacity;
	}

	void Push(DataType data)
	{
		// CheckCapacity();
		_array[_size] = data;
		_size++;
	}

	~Stack()
	{
		cout << "~Stack()" << endl;

		free(_array);
		_array = nullptr;
		_size = _capacity = 0;
	}
private:
	// 内置类型
	DataType* _array;
	int _capacity;
	int _size;
};

int main()
{
	
	
	MYqueue a;
	MYqueue d = a;
return 0；

}

ps

拷贝构造我们一般加const。

例如：

	Data(const Data& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
		cout << "拷贝构造" << endl;
	}

这是因为万一有人写反了，把拷贝构造变成被别的成员变量赋值，编译器还看不出来错误：
而加个const就是权力的缩小，拷贝构造不能被修改，它只能修改别人：

运算符重载

比如我们想定义两个日期类的大小，我们像下面这样比较：

 编译器就会报错，因为Data是自定义类型，比较复杂，编译器没与办法直接比较。

我们只能自己手动比较：

C++给给所有的运算符比较的函数起了个统一的名称：运算符重载函数，就好比给所有初始化函数起名为构造函数，所有destory函数起名为析构函数一样。运算符重载函数用operator来表示.

运算符重载是什么意思呢？

就是说我们两个自定义类型不能直接比较，只能通过函数比较，再通过函数的返回值得到比较结果。

但是我们可以把这个比较函数重载为一个操作符，我们直接拿这个操作符用就可以实现这个函数的功能。

如下，重载为“>"操作符：

operator<

bool operator>(Data  d1, Data d2)

 这个时候我们就可显示调用operato>函数，或者直接比较d1,d2的值，都可以：

加括号之后：

如果我们不用运算符重载，而就用函数名的话就不能直接比较，只能通过调用函数的方式来比较：

原理：

ps

如果我们把operator>写为Data内部成员函数需要注意几点，如果我们直接放进去会报错：

 C++规定运算符重载函数作为类内部成员函数时，看起来的参数要比实际用到的参数少一个。

什么意思呢？但是这样写就不能这样显示调用operator>了只能这样调用：

 当然，使用运算重载后的操作符照样可以：

复用 operator<实现operator==  operator>=  operator!=

ok，接下来我们再写operator==

	bool operator==(Data d2)
	{
		return _year == d2._year
		     && _month == d2._month
			 && _day == d2._day;
	}

再来写operator>=

我们把将才写的operator<=和operator==改一下符号吗？变成下面这样：

bool operator<=( Data d2)
	{
		if (_year <=d2._year)
		{
			return true;
		}
		if (_year<=d2._year && _month <=d2._month)
		{
			return true;
		}
		if (_year<= d2._year && _month <= d2._month && _day <= d2._day)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

可以时可以，但是太麻烦，下面还要operator!= ,operator>,每个都这样拿代码就太冗余了。

我们可以复用，

我这里要写operator>=,我直接调用operator<和operator==就可以了。

怎么调用呢？用this指针，this是省略值的地址，解引用得到省略值，我们可以看下列代码：

bool operator>=(Data d2)
	{
		return *this > d2 || *this == d2;
	}

同样，写operator<，只需要对operator<=取反就行了：

	bool operator<(Data d2)
	{
		return !(*this >= d2);
	}

写operator!=，对operator==取反即可：

bool operator!=(Data d2)
	{
		return !(*this == d2);
	}

赋值运算符重载

如下，d1的日期为非法日期，d3为合法日期，我把d3的日期赋值给d1，让d1也成为合法日期：

Data d1(2003,11,33);
Data d3(2003,11,30);
	d1 = d3;
	d3.print();
	d1.print();

但是两个类之家是不能之间进行赋值的，这个可以运行是因为编译器默认生成了赋值运算符重载，将d3的成员变量的值逐个复制给d1的成员变量。需要注意的是，当类中存在指针类型的成员变量时，使用默认的赋值运算符重载函数可能会导致浅拷贝问题。在这种情况下，你需要自己编写赋值运算符重载函数，以确保进行深拷贝操作，避免出现内存错误。

我们自己可以写一下赋值运算符重载：

 赋值运算符重载和拷贝构造区别

内置类型我们可以像这样进行赋值:它的原理实际上是这样：注意：优先级问题，还需要再加个括号：但是自定义类型就不可以了：

那我们可以按照内置类型的思路：先让d4复制给d3,再返回一个值，把这个值再赋值给d1.

返回的这个值也要是Data类型，因为要返回一个日期，把这个日期再赋值给d1. 

Data& Data::operator=(const Data& d3)
{
	this->_year = d3._year;
	this->_month = d3._month;
	this->_day = d3._day;

	return *this;
}
Data d1(2003, 11, 33);
	Data d3(2003, 11, 22);
	Data d4(2000, 12, 3);
	d1 = d3 = d4;
	d1.print();
	d3.print();
	d4.print();

解析：

题目

用运算符重载函数写一个日期相加

思路：日期类相加，先day和day相加，满28/29/30/31就往月进，月满了往下个月进，月满13了往年进。

闰年二月是29填，需要特殊处理：


	bool operator+()
	{

	}

	int Getmonth(int year,int month)
	{
		int GetArry[13] = {0, 31,28,30,31,30,31,30,31,30,31,30,31 };
		
		if (month==2&&(month % 4 == 0 && month % 100 != 0 || month % 400 == 0))
		{
			return 29;
		}
	return GetArry[month];
	}

 看一下operator+怎么写：

Data d1(2003,11,29);

d1+100;
Data(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}

 所以此时_year=2003,_month=11,_day=29.

bool operator+(int  day)
	{
//天数相加
		_day += day;

//如果月满了
		while (_day > Getmonth(_year, _month))
		{

//天数减去满月的天数
			_day -= Getmonth(_year, _month);

//从当前月进入下一个月
			++_month;
		}


//如果12个月都满了
		if (_month == 13)
		{

//当前年进入下一年
			++_year;

//把月置为下一年的一月
			_month = 1;
		}


	}

把我们的传参再拿过来看看：

Data d1(2003,11,29);

d1+100;

d1+100是一个什么类型，日期+日期还是一个日期

所以：

Data ret=d1+100;

那operator+也应该用Data类型：

   Data operator+(int  day)
	{
		_day += day;
		while (_day > Getmonth(_year, _month))
		{
			_day -= Getmonth(_year, _month);
			++_month;
		}

		if (_month == 13)
		{
			++_year;
			_month = 1;
		}


	}

operator+该返回什么呢？

返回*this

Data d1(2003,11,29);
	Data ret = d1 + 50;
	d1.Print();
	ret.Print();

 我们发现结果虽然运算正确，但是d1的值也被改为了ret的值，这说明

这是一个operator+=,而不是一个operator+

那我们如何正确实现一个operator+呢？

空容器

我们可以用用拷贝构造拷贝一份到空类里面，改变这个空容器，最后返回这个空容器就可以了。

 Data operator+(int  day)
	{
		Data temp(*this);
		temp._day += day;
		while (temp._day > Getmonth(_year, _month))
		{
			temp._day -= Getmonth(_year, _month);
			++temp._month;


			if (temp._month == 13)
		{
			++temp._year;
			temp._month = 1;
		}



		}

		
		return temp;

	}

复用+=

 Data operator+=(int  day)
	{
		
		_day += day;
		while (_day > Getmonth(_year, _month))
		{
			_day -= Getmonth(_year, _month);
			_month++;


			if (_month == 13)
		{
			_year++;
			_month = 1;
		}



		}

		
		return *this;

	}
	 Data operator+(int  day)
	 {
		 Data temp(*this);
		 temp += day;
		 return temp;

	 }

operator-=

实现两个日期类相减：

-=是一种借位思想，如果2020 7 27-27还好，如果day-200呢，那不成了-173，欠债了。

 这个时候就往前一个月借，当前月的已经光了，还欠了债，需要上个月来补，--_month.

当day<=0时都是不合法日期，day<0不合法是欠债了，需要往上一个月借，=0不合法是因为一个月没有0号。

当month=0时说明月借光了，再问年借，--_year;

再把month重置为去年的12月份。

_day要借的是上个月的day，借到_day.value不为负值，说明还完债了。

这时候把还完债后的年月日返回。

Date& Date:: operator-=(int  day)
{
	_day -= day;
	while (_day <=0)
	{
		--_month;

		if (_month == 0)
		{
			_year;

			_month = 12;
		}
		_day += Getmonth(_year, _month);
	}

	return *this;
}


	Date d1(2003, 11, 29);
	d1 -= 100;
	d1.print();

 把数变大一点再测：


	Date d1(2003, 11, 29);
	d1 -= 20000;
	d1.print();

这肯定错了，20000多天都50多年了

 肯定是_year没有--，改一下：

看一下计算器算的：

孙鹏宇.
关注
专栏目录
C/C++ 两个日期之间的天数算法详解及源码
希望我的博客，能帮上你解决学习中工作中所遇到的问题
05-07 7544
【代码】C/C++ 两个日期之间的天数算法详解及源码。
C++手动实现一个日期类
陌意随影的博客
07-22 1142
手动实现一个Date类进行日期的加减计算 笔者在之前的文章手动实现一个String中已经详细介绍过了关于重载和运算符重载的基本概念和要注意的事项，这是那篇文章的链接：添加链接描述 在实现这个Date类之前如果对操作运算符重载不是很熟悉的看官可以参考参考这篇文章。 在实现这个Date类之前先说明的是：在标准的系统封装好的Date类中是以1970年1月1日为起点，1970年1月1日之后的日期为正值，1...
【C++】类和对象大总结
学了就忘是正常现象
10-16 1908
看了就会的类和对象要点详细汇总。
C++运算符的重载--日期类的实现
Hxbupaixu的博客
06-25 1202
在学习中,用C++编程的都知道，C++提供了一个非常强大的操作符重载机制，利用操作符重载，我们可以为我们自定义的类增加更多非常有用的功能,本文就是结合自己所学过的知识,对日期类函数进行模拟实现.目录1.Date.h2.Date.cpp2.1 GetMonthDay()2.2 IsInvalid()2.3 运算符重载=2.4 this指针2.5 运算符重载==2.6 运算符重载!=2.7 运算符重载> 2.8 运算符重载2.10 运算符重载>= ...
C++——类与对象（一）
2301_80401288的博客
09-04 1165
C++——类与对象（一） 求点赞收藏评论关注！！！ 感谢大佬！！！
【C++实战项目】Date日期类 --- 运算符重载的深入探索
深入解析C/C++编程技巧，带你探索高效开发之路
03-06 1782
本文深入探讨了C++中自定义Date日期类如何运用运算符重载来增强类的功能和使用体验。通过重载输入输出运算符（``），我们实现了日期的便捷输入与格式化输出。同时，通过重载算术运算符（如`+`和`-`），我们为日期类增加了日期加减的直观操作，使日期计算更为简便。
C++类和对象注意事项（上）（类的对象大小计算和this指针）
qq_45755259的博客
04-16 1011
this指针存放位置：堆是malloc出来的，静态区存放静态数据和全局数据，常量区存放常量，栈存放形参，形参和局部变量都存在栈上，函数调用，建立栈帧，this指针是形参一般是存放在栈上，有些地方会直接放在寄存器里面，因为寄存器访问特别块，一般情况是栈。类实例化的每个对象中的成员变量是不同的，但是调用同一份函数，调用的成员函数地址都是一样的，如果每个对象内部都放一份，会造成大大的浪费。小端（存储）模式：是指数据的低位字节内容保存在内存的低地址处，而数据的高位字节内容，保存在内存的高地址处。
4.3 C++ Boost 日期时间操作库
CSDN
08-18 4530
当涉及到日期时间和目录的操作时，Boost提供了`boost::posix_time`库，该库可以实现日期时间的解析、格式化、差值计算等常见操作。此外，该库还提供了许多常见的时间表示方式，如`time_duration`表示时间长度，`ptime`表示时间点，以及`time_period`表示时间段等。
C++类和对象（二）—— 类的6个默认成员函数及日期类的实现
2021dragon的博客
06-01 7066
文章目录类的6个默认成员函数构造函数构造函数的概念构造函数的特性析构函数析构函数的概念析构函数的特性拷贝构造函数拷贝构造函数的概念拷贝构造函数的特性赋值运算符重载运算符重载赋值运算符重载日期类的实现const成员const修饰类的成员函数取地址及const取地址操作符重载 类的6个默认成员函数  如果一个类中什么成员都没有，我们简称其为空类。但是空类中真的什么都没有吗？其实不然，任何一个类，即使我们什么都不写，类中也会自动生成6个默认成员函数。 class Date {}; //空类 构造函数 构造函数
C++类的六个默认成员函数（详细解析与总结）
2301_79698419的博客
03-28 1054
c++六大默认成员函数
C++第三方库xlnt-用于读写Excel文件
03-06
xlnt是一个C++库，专为处理Microsoft Excel文件而设计，提供读取和写入功能。这个库使得在C++程序中操作Excel数据变得简单，无需依赖Microsoft Office或COM接口。下面将详细介绍xlnt库的核心功能、使用方法以及它...
物品库存管理系统，一个用C++写的小程序
11-26
根据给定的信息，我们可以推断出这是一个简单的物品库存管理系统的代码片段，该系统使用 C++ 编程语言实现。下面将详细介绍与这个项目相关的几个重要知识点。 ### 1. C++编程基础 #### (1) 文件包含（Include ...
C++类和对象实例：定义、成员与注意事项
首先，我们从类和类的定义开始，理解类是如何作为一个模板来组织数据和行为的。 3.1 类和类的定义 类的定义是创建新数据类型的关键步骤，它定义了数据成员（私有、保护和公共）和成员函数。私有数据成员只能在类的...
c_cpp_properties.json文件的作用
程序员黄老师的精品课！
10-10 228
IntelliSense 是 VS Code 中内置的一个有用工具，它提供各种代码编辑功能，可帮助您更快、更高效地编写代码。例如，代码完成、参数信息、语法突出显示、代码操作（灯泡）和成员列表都是使用 IntelliSense 生成的。IntelliSense 配置存储在文件中，该文件在您的工作区中自动创建。如何产生 c_cpp_properties.json文件？这里配置一下头文件，就可以自动提示了，以OpenCV为例子。其中的属性可以在界面上改,文件会自动同步。
PyQt 的Tree Widget中拖放和点击的异常行为
weixin_44617651的博客
10-10 462
在 PyQt 的 ​​QTreeWidget​​ 中，如果你遇到 拖放 和 点击 的异常行为，可能是由于信号处理、事件拦截、拖放设置或树结构配置等问题导致的。以下是一些可能的常见问题和解决方案。
数组综合应用（下标计数）C++
hjxxlsx的博客
10-08 985
HJ小学信息学社团每个同学都有且仅有一个数字编号（1~1000），现在帅气的吴老师准备举办n个学习项目，信息学社团的每个同学都参加项目且可以参加多个项目。,9共 9个数分成三组，分别组成三个三位数，且使这三个三位数的比例是 A:B:C，试求出所有满足条件的三个三位数，若无解，输出。n，表示参战的士兵数，1<=n<=1000000，第二行为n个整数，表示每位士兵的战功值（战功值<=1000000）。50、80、50、30分，则80分的士兵为第一名，50分的两名士兵均为第二名，30分的士兵为第四名。
C++的随机数操作
最新发布
lch_001的博客
10-13 110
如果不引入种子，它的随机数不是随机数，是固定的一串数字。首先想到的肯定是rand()函数，但是这个有点问题。srand()函数，产生随机的种子。引入头文件<stdlib.h>产生0-99的随机数。
windows C++-创建数据流代理(三)
苏洛的博客
10-08 325
控制流指的是程序中操作的执行顺序。 控制流是通过使用条件语句、循环等控制结构调节的。 此外，数据流指的是一种编程模型，在这种模型中，只有当所有需要的数据都可用时，才会进行计算。 数据流编程模型与消息传递这一概念相关，其中程序的独立组件通过发送消息相互通信。 异步代理同时支持控制流和数据流编程模型。 尽管控制流模型适用于许多情况，但数据流模型也适用于其他一些情况，例如，当代理接收数据并执行基于该数据的有效负载的操作时。
c语言：二叉树的创建、前序遍历、中序遍历、后续遍历
Narnat的博客
10-08 405
代码中创建的二叉树如下图。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

孙鹏宇.

你的鼓励将是我创作的最大动力

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

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

打赏作者

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

抵扣说明：

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

余额充值