【设计模式】状态模式、责任链模式、迭代器模式、解释器模式

最新推荐文章于 2023-09-19 17:22:55 发布
最新推荐文章于 2023-09-19 17:22:55 发布
阅读量243 收藏
点赞数
文章标签： 设计模式 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/SWELER/article/details/128748790
版权

1、状态模式

简介

事物在不同的状态下会产生不同的动作，也会从一个状态转换到另一个状态。

当状态数目不多时可以用switch/case解决，但是当状态数目很多时维护很大一组switch/case将变得困难。

将状态逻辑和动作实现分离，而不是直接将状态的代码写在动作逻辑中，以便更好的进行扩展和维护。

优点：

  • 封装了转换规则。
  • 枚举可能的状态，在枚举状态之前需要确定状态种类。
  • 将所有与某个状态有关的行为放到一个类中，并且可以方便地增加新的状态，只需要改变对象状态即可改变对象的行为。
  • 允许状态转换逻辑与状态对象合成一体，而不是某一个巨大的条件语句块。
  • 可以让多个环境对象共享一个状态对象，从而减少系统中对象的个数。

角色

  • 一个抽象的状态类，提供统一的接口
  • 若干个具体的状态，根据自己代表的状态重写父类的接口，拥有一个活动类的指针
  • 一个活动类，拥有所有的具体状态的指针，和一个当前状态的指针，拥有和状态类对应的操作接口，在调用操作接口时调用当前状态的操作接口

代码实现

模拟机器状态变化的过程。假设一个机器有三种状态，分别是正常、出错、维修中，我定义了这三种状态，活动类中有一个m_count计数器，假设这是机器的可靠指数，每次运行时消耗可靠指数，当可靠指数小于0时进入出错状态，出错状态不能运行，需要进行维修，然后进入维修状态，在维修状态运行时会再次出错，需要再次维修，则可靠指数加2，进入正常状态。

#include<iostream>
using namespace std;

class State{
public:
	virtual void ErrorHappened()=0;
	virtual bool Fix()=0;
	virtual bool Run()=0;
	virtual void show()=0;
};

class Activity;

class Normal : public State{
public:
	Normal(Activity * activity);
	void ErrorHappened();
	bool Fix();
	bool Run();
	void show();
private:
	Activity *m_activity;
};

class Error:public State{
public:	
	Error(Activity * activity);
	void ErrorHappened();
	bool Fix();
	bool Run();
	void show();

private:
	Activity *m_activity;
};

class Fixing:public State{
public:
	Fixing(Activity * activity);
	void ErrorHappened();
	bool Fix();
	bool Run();
	void show();
private:
	Activity *m_activity;
};


class Activity{
public:
	State* getState() const{
		return m_state;
	}
	void SetState(State* const state){
		m_state=state;
	}
	int getCount(){
		return m_count--;
	}
	void setCount(const int count){
		m_count=count;
	}
	State* getNormal() const{
		return m_normal;
	}
	void setNormal(State* const normal){
		m_normal=normal;
	}
	State* getError() const{
		return m_error;
	}
	void setError(State* const error){
		m_error=error;
	}
	State* getFixing()const{
		return m_fixing; 
	}
	Activity(int count){
		m_count=count;
		m_error=new Error(this);
		m_normal=new Normal(this);
		m_fixing=new Fixing(this);
		m_state=getNormal();

	}
	void ErrorHappened(){
		m_state->ErrorHappened();
	}
	void Fix(){
		m_count+=2;
		m_state->Fix();
	}
	void Run(){
		if(m_count>0)
			m_count--;
		if(m_count<=0){
			cout<<"Low avialibality "<<endl;
			m_state->ErrorHappened();
			return;
		}
		m_state->Run();

	}
	void show(){
		m_state->show();
	}
private:
	State* m_state;
	int m_count;
	State* m_error;
	State* m_fixing;
	State* m_normal;
};

Normal::Normal(Activity * activity){
	m_activity=activity;
}
void Normal::ErrorHappened(){
	m_activity->SetState(m_activity->getError());
}
bool Normal::Fix(){
	cout<<"No need to fix"<<endl;
	return false;
}
bool Normal::Run(){
	cout<<"Run successfully"<<endl;
	return true;
}
void Normal::show(){
	cout<<"Normal"<<endl;
}

Error::Error(Activity * activity){
	m_activity=activity;
}
void Error::ErrorHappened(){
	cout<<"Already Error"<<endl;
}
bool Error::Fix(){
	m_activity->SetState(m_activity->getFixing());
	return true;
}
bool Error::Run(){
	cout<<"Can't run"<<endl;
	return false;
}
void Error::show(){
	cout<<"Error"<<endl;
}

Fixing::Fixing(Activity* activity){
	m_activity=activity;
}
void Fixing::ErrorHappened(){
	m_activity->SetState(m_activity->getError());
}
bool Fixing::Fix(){
	m_activity->SetState(m_activity->getNormal());
	return true;
}
bool Fixing::Run(){
	cout<<"Can't run"<<endl;
	return false;
}
void Fixing::show(){
	cout<<"Fixing"<<endl;
}


int main(){
	Activity* ac=new Activity(1);
	for(int i=0;;i++){
		 cout<<"time: "<<i<<" state:";
		 ac->show();
		 cout<<endl;
		 cout<<"Input 1.Run   2.Fix  "<<endl;
		 int j=0;
		 cin>>j;
		 if(j==1){
		 	ac->Run();
		 }else if(j==2){
		 	ac->Fix();
		 }else{
		 	cout<<"Wrong operation"<<endl;
		 }

	}
	return 0;
}

2、责任链模式

简介

责任链模式为请求创建了一个接收者对象的链。每个接受者都含有另一个接收者的引用，如果一个接收者不能处理他的请求，就会把这个请求发送给他的下一个接受者了，以此类推。

客户只需要将请求发送到责任链上就可以了，不必关心请求处理的细节和请求的传递过程，实现了请求的发送者和请求的处理者解耦。

优点：

  • 将请求和处理分开，实现解耦，提高系统的灵活性
  • 简化了对象，使对象不需要知道链的结构
  • 调试不方便。采用了类似递归的方式，调试时逻辑可能比较复杂
  • 最佳应用场景：有多个对象可以处理同一个请求时，比如：多级请求、请假/加薪等审批流程、Java Web中Tomcat对Encoding的处理、拦截器

请添加图片描述

角色

  • 一个请求类，包含了请求的各种信息
  • 一个抽象的请求接收者类，拥有一个其他接收者的引用，一个处理请求的接口
  • 若干个不同类型的具体的请求接收者类，重写处理请求的接口

代码实现

模拟公司采购审批的过程。先定义一个采购请求类，包含了采购的金额，再定义一系列有顺序的审批员R1R2R3R4,按照各自的审批金额限制处理采购请求，如前一个不能审批，则传递给下一个审批员。

#include<iostream>
using namespace std;

class Purchase{
public:
	int getType()const{
		return type;
	}
	float getPrice()const{
		return price;
	}
	int getId()const{
		return id;
	}
	Purchase(const int type,const float price,const int id):
	type(type),price(price),id(id){}
private:
	int type;
	float price=0.f;
	int id=0;
};

class Approver{
public:
	void setApprover(Approver* approval){
		this->approval=approval;
	}
	explicit Approver(const string& name):name(name){
	}
	virtual void processRequest(Purchase* purchase)=0;
	string name;
	Approver* approval;
};

class R1:public Approver{
public:
	explicit R1(const string name):Approver(name){}
	void processRequest(Purchase* purchase){
		if(purchase->getPrice()<=5000){
			cout<<"id: "<<purchase->getId()<<
			" are dealed by "<<this->name<<" rank R1"<<endl;
		}else{
			approval->processRequest(purchase);
		}
	}
};

class R2:public Approver{
public:
	explicit R2(const string name):Approver(name){}
	void processRequest(Purchase* purchase){
		if(purchase->getPrice()>5000&&purchase->getPrice()<10000){
			cout<<"id: "<<purchase->getId()<<
			" are dealed by "<<this->name<<" rank R2"<<endl;
		}else{
			approval->processRequest(purchase);
		}
	}
};

class R3:public Approver{
public:
	explicit R3(const string name):Approver(name){}
	void processRequest(Purchase* purchase){
		if(purchase->getPrice()<=10000&&purchase->getPrice()<50000){
			cout<<"id: "<<purchase->getId()<<
			" are dealed by "<<this->name<<" rank R3"<<endl;
		}else{
			approval->processRequest(purchase);
		}
	}
};

class R4:public Approver{
public:
	explicit R4(const string name):Approver(name){}
	void processRequest(Purchase* purchase){
		
		cout<<"id: "<<purchase->getId()<<
		" are dealed by "<<this->name<<" rank R4"<<endl;
		
	}
};

int main(){
	Purchase * p=new Purchase(1,100000,1);
	Approver* r1=new R1("jack");
	Approver* r2=new R2("bob");
	Approver* r3=new R3("dask");
	Approver* r4=new R4("ammb");
	r1->setApprover(r2);
	r2->setApprover(r3);
	r3->setApprover(r4);
	r1->processRequest(p);
	return 0;

}

3、迭代器模式

简介

迭代器模式提供一种遍历集合中所有对象的统一的方式，不需要知道集合对象的底层表示，即不暴露其内部结构。

角色

  • 一个抽象的迭代器类，提供返回第一个、返回下一个、返回当前元素、是否遍历完毕等接口。
  • 一个具体的迭代器类，拥有一个某种数据结构的指针和该数据结构的元素个数。
  • 一个抽象的数据结构类，声明了增加、删除元素、创建迭代器、返回数量等接口。
  • 一个具体的数据结构类，封装原始的数据结构，拥有一个对应的迭代器指针。

代码实现

介绍同上，在需要遍历数据结构的元素时使用该封装过的数据结构里的迭代器进行遍历。

#include<iostream>
#include<string>
#include<vector>

using namespace std;

class Iterator{
public:
	Iterator(){}
	virtual ~Iterator(){}
	virtual string First()=0;
	virtual string Next()=0;
	virtual string Current()=0;
	virtual bool IsDone()=0;
};

class Aggregate{
public:
	virtual int Count()=0;
	virtual void Push(const string& strValue)=0;
	virtual string Pop(const int nIndex)=0;
	virtual Iterator* CreateIterator()=0;
};

class ConcreteIterator:public Iterator{
public:
	ConcreteIterator(Aggregate* paggregate):m_Aggregate(paggregate),m_nCurrent(0),Iterator(){
		
	}
	string First(){
		return m_Aggregate->Pop(0);
	}
	string Next(){
		string strret;
		m_nCurrent++;
		if(m_nCurrent<m_Aggregate->Count()){
			strret=m_Aggregate->Pop(m_nCurrent);
		}
		return strret;
	}
	string Current(){
		return m_Aggregate->Pop(m_nCurrent);
	}

	bool IsDone(){
		return ((m_nCurrent>=m_Aggregate->Count())?true:false);
	}

private:
	Aggregate* m_Aggregate;
	int m_nCurrent;
};

class ConcreteAggregate:public Aggregate{
public:
	ConcreteAggregate():m_pIterator(NULL){
		m_vecItem.clear();
	}
	~ConcreteAggregate(){
		if(m_pIterator !=NULL){
			delete m_pIterator;
			m_pIterator = NULL;
		}
	}
	Iterator* CreateIterator(){
		if(m_pIterator ==NULL){
			m_pIterator=new ConcreteIterator(this);
		}
		return m_pIterator;
	}
	int Count(){
		return m_vecItem.size();
	}
	void Push(const string& strval){
		m_vecItem.push_back(strval);
	}
	string Pop(const int nIndex){
		string strret="";
		if(nIndex<Count()){
			strret=m_vecItem[nIndex];
		}
		return strret;
	}
private:
	vector<string> m_vecItem;
	Iterator* m_pIterator;
};

int main(){
	ConcreteAggregate *pName=NULL;
	pName=new ConcreteAggregate();
	if(pName!=NULL){
		pName->Push("hello");
		pName->Push("world");
		pName->Push("good");
	}
	Iterator* iter=NULL;
	iter=pName->CreateIterator();
	if(iter!=NULL){
		string stritem=iter->First();
		while(!iter->IsDone()){
			cout<<iter->Current()<<endl;
			iter->Next();
		}
	}
	return 0;
}

4、解释器模式

介绍

解释器模式是指给定一个语言(表达式)，定义它的文法的一种表示，并定义一个解释器，使用该解释器来解释语言中的句子(表达式)。

应用场景：
1、应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
2、一些重复出现的问题可以用一种简单的语言来表达
3、一个简单语法需要解释的场景
4、这样的例子还有，比如编译器、运算表达式计算、正则表达式、机器人等。

优点：

可扩展性比较好，灵活。
增加了新的解释表达式的方式。
易于实现简单文法。

缺点：

可利用场景比较少。
对于复杂的文法比较难维护。
解释器模式会引起类膨胀。
解释器模式采用递归调用方法。

角色

  • 一个封装内容的类，拥有一份未解释的内容和一份解释过的内容，以及对它们的获取和设置操作。
  • 一个抽象的表达式的类，声明一个对内容进行解释的功能。
  • 若干个不同的具体的表达式类，每种具体的表达式类都代表一种解释方法，重写相对应的解释操作。

代码实现

模拟加密解密过程。内容类中包含一个原始数字和一个解释后的数字，两种解释操作分别是将原始数字加一和将原始数字减一（假设这分别代表加密和解密）。

#include<iostream>
#include<string>

using namespace std;

class Context{
public:
	Context(int num):m_num(num){
	}

	void setNum(int num){
		m_num=num;
	}
	int getNum(){
		return m_num;
	}	
	void setRes(int res){
		m_res=res;
	}
	int getRes(){
		return m_res;
	}

private:
	int m_num;
	int m_res;
};


class Expression{
public:
	virtual void interpreter(Context* context)=0;
};

class PlusExpression:public Expression{
public:
	virtual void interpreter(Context* context){
		int num=context->getNum();
		num++;
		context->setNum(num);
		context->setRes(num);
	}
};

class MinusExpression:public Expression{
public:
	virtual void interpreter(Context* context){
		int num=context->getNum();
		num--;
		context->setNum(num);
		context->setRes(num);
	}
};

int main(){
	Context* pcxt=new Context(10);
	Expression* e1=new PlusExpression();
	e1->interpreter(pcxt);

	cout<<"plusExpression: "<<pcxt->getRes()<<endl;

	Expression* e2=new MinusExpression();
	e2->interpreter(pcxt);
	cout<<"MinusExpression: "<<pcxt->getRes()<<endl;
	return 0;
}

后记：设计模式的学习到此告一段落，谢谢观看。明天开启新的学习计划。

Sweler*19
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Java设计模式之迭代模式（Iterator模式）介绍
09-03
此外，迭代器模式也支持多种遍历策略，如深度优先或广度优先，只要实现相应的迭代器接口即可。 总结来说，迭代模式是设计模式中的一种，主要用于遍历聚合对象的元素。在Java中，通过接口和实现类的方式，我们能够...
设计模式第六讲：责任链模式和迭代器模式详解
a410974689的博客
02-15 440
(1). 定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条链传递，直到有对象处理它为止。PS：责任链模式也叫职责链模式。在责任链模式中，客户只需要将请求发送到责任链上即可，无须关心请求的处理细节和请求的传递过程，所以责任链将请求的发送者和请求的处理者解耦了。(2). 优点：A. 降低了对象之间的耦合度。
Java设计模式-状态模式
小薯条的博客
05-24 858
状态模式是一种优雅地管理对象状态的设计模式。它通过将对象的状态封装在独立的状态类中，实现了状态和行为的解耦，提高了代码的可维护性和可扩展性。状态模式与其他设计模式有着明显的区别，如策略模式和责任链模式。虽然状态模式有一些缺点，但在需要管理对象状态并根据状态改变行为的场景下，它是一种强大的工具。通过合理运用状态模式，我们可以使系统更加灵活和可维护，提升软件开发的质量和效率。
责任链模式和状态模式的区别
pzysoft的博客
03-18 2168
责任链模式：当客户提交一个请求时，请求是沿链传递直至有一个ConcreteHander对象负责处理它。接收者和发送者都没有对方的明确信息，且链中的对象自己并不知道链的结构，在运行时自动确定。结果是职责链可简化对象的相互连接，它们仅需保持一个指向其后继者的引用或指针，而不需要保持它所有的候选接受者。这也就大大降低了耦合度了。也就是说，我们可以随时地增加或修改处理一个请求的结构。增强了给对象指派职责的灵
责任链模式、状态模式
erose的博客
12-06 649
责任链模式 定义：为了避免请求发送者与多个请求处理者耦合在一起，将所有请求的处理者通过前一对象记住其下一个对象的引用而连成一条链；当有请求发生时，可将请求沿着这条传递链，知道有对象处理它为止。 优缺点 优点： 降低了对象之间的耦合度。该模式使得一个对象无需知道是哪一个对象处理其请求以及链的结构，发送者和接收者也无需拥有对方明确的消息。 增强了系统的可扩展性。可以根据需要增加新的请求处理类，满足开闭原则； 增强了给对象指派职责的灵活性。当工作流程发生变化，可以动态地改变链内的成员或者调动他们的次序，也可以动
设计模式详细解释.zip
最新发布
03-21
例如，策略模式（Strategy）定义一组可相互替换的算法，命令模式（Command）将请求封装为一个对象，责任链模式（Chain of Responsibility）让多个对象都有机会处理请求，迭代器模式（Iterator）提供一种顺序访问集合...
清华大学出版 基于java程序语言的java设计模式课程 18-解释器模式（共25页）.pptx
11-13
基于java程序语言的设计java模式课程 18-解释器模式（共25页）.pptx 基于java程序语言的设计java模式课程 19-迭代器模式（共27页）.pptx 基于java程序语言的设计java模式课程 20-中介者模式（共29页）.pptx 基于java...
C++常用的22种设计模式解释及示例
01-30
21. **解释器模式（Interpreter）**：给定一种语言，定义它的文法表示，并定义一个解释器来使用该文法来解释语言中的句子。 22. **中介者模式（Mediator）**：用一个中介对象来封装一系列的对象交互。中介者使各...
java软件设计模式期末总结
05-21
- **解释器模式**：给定一种语言，定义它的文法表示，并提供一个解释器来处理这种语言中的句子。 - **迭代器模式**：提供一种方法顺序访问聚合对象的元素，而又不暴露其底层表示。 - **备忘录模式**：在不破坏...
JAVA设计模式之行为模式 责任链模式和状态模式
05-28
击鼓传花是一种热闹而又紧张的饮酒游戏。在酒宴上宾客依次坐定位置，由一人击鼓，击鼓的地方与传花的地方是分开的，以示公正。开始击鼓时，花束就开始依次传递，鼓声一落，如果花束在某人手中，则该人就得饮酒，这是很典型的行为责任链模式。 State模式主要解决的是在开发中时常遇到的根据不同的状态需要进行不同的处理操作的问题，而这样的问题，大部分人是采用switch-case语句进行处理的，这样会造成一个问题：分支过多，而且如果加入一个新的状态就需要对原来的代码进行编译。
使用设计模式改写if/else或switch/case语句
u010178395的博客
09-19 1525
相比传统的if/else语句，使用策略模式后代码体现出了面向对象的特性，扩展性更强，但是还是存在一些缺陷，需要一个map，而且需要new出每个实现类的实例。APPLE("苹果", "apple"), PINEAPPLE("菠萝", "pineapple"), PEAR("梨", "pear");System.out.println("又酸又甜的菠萝");System.out.println("又酸又甜的菠萝");System.out.println("又酸又甜的菠萝");
状态模式与责任链模式
qq_38515961的博客
09-23 740
文章目录一、状态模式 一、状态模式 状态模式定义：当一个对象的内在状态改变时允许其改变行为，这个对象看起来像是改变了其类。 状态模式主要解决的是当控制一个对象状态转换的条件表达式过于复杂时，把状态的判断逻辑转移到表示不同状态的一系列类当中，可以把复杂的逻辑简化。 State抽象状态类： public abstract class State{ public abstract void handle(Context context); } Context类，维护了一个State类型的对象，这个
责任链模式和状态模式对比（转）
weixin_30912051的博客
05-15 232
概述 　　常用23中设计模式中，有三种模式容易混淆，这三种模式即责任链模式、状态模式以及策略模式。现在想深入了解下这3种设计模式的区别，在网上找找之后，发现有一篇博客写的相对清晰。先将内容整理转载如下，也算是对知识的记载和传承； 状态模式与策略模式比较 1、定义： 　　　　状态模式：通过改变对象的内部状态而改变对象自身的行为，这个对象表现得就好像修改了它的类一样。 　　　 策略模式：定...
状态模式&责任链模式&观察者模式&策略模式
weixin_66277385的博客
04-23 395
状态模式(State) 角色 Context：环境角色：用于维护 State 实例,这个实例定义当前状态 State：抽象状态角色：聚合到Context环境角色中 ConcreteState ：具体的状态角色 ConcreteStateA ConcreteStateB ConcreteStateC UML类图 案例：抽奖活动项目设计 public class State { // 当前的状态 private int state; // 供抽奖.
【设计模式系列19】状态模式原理分析及其和策略模式，责任链模式的区别
zwx900102的博客
10-21 2202
状态模式原理分析前言什么是状态模式状态模式示例状态模式角色状态模式与责任链模式状态模式与策略模式状态模式应用场景状态模式优缺点总结 前言 状态对于我们开发者而言是相当熟悉的，平常开发中总是离不开对象的状态，比如我们审核流程，就是一个状态不断流转的过程，订单流程也是一个状态不断流转的过程，而状态模式就是为了更好地解决我们状态流转过程中的业务处理逻辑。 什么是状态模式 状态模式(State Pattern)也称为状态机模式(State Machine Pattern)，是允许对象在内部状态发生改变的同时改变对象
【23种设计模式】行为型模式（责任链、命令、解释器模式）
随心所欲的博客
08-17 237
13.责任链【Chain Of Responsibility】 【释义】责任链模式：执行者的不确定性 在责任链模式中，很多对象由每一个对象对其下家的引用而接起来形成一条链。请求在这个链上传递，直到链上的某一个对象决定处理此请求。客户并不知道链上的哪一个对象最终处理这个请求，系统可以在不影响客户端的情况下动态的重新组织链和分配责任。处理者有两个选择：承担责任或者把责任推给下家。一个请求可以最终不被任...
状态模式 VS 职责链模式
忠麦一生
12-05 3936
这次合作开发过程中我们使用了一些设计模式，经过讨论对其理解深刻不少。之前在学习之中，我本以为自己已经理解了一些设计模式。但在这次的使用过程中，因为各自的理解不一造成了一定的碰撞，之后才发现自己的理解根本就站不住脚。于是，反复经过我们的讨论——实施——再讨论，发现理解的偏差，解决之。然后，才有了目前我们认为的比较稳定的，符合逻辑的理解。本篇博客要说的是我对状态模式和职责链模式的理解。这两个设计模式看
C#设计模式之责任链模式
BraveRunTo的博客
07-16 892
责任链模式 文章目录责任链模式模式分类模式产生的原因模式类图代码实现责任链模式总结责任链模式的优点：责任链模式的缺点： 本篇博客将介绍责任链模式，责任链模式是行为型设计模式，行为型模式关注对象之间的交互，研究系统在运行时对象之间的相互通讯和协作，进一步明确对象的职责。当我们的系统中存在多个对象可以处理同一个请求的时候，我们就可以通过责任链模式将这些处理请求的对象连成一条链，让请求可以沿着这个链传播。如果链上的对象可以处理该请求就处理，否则就转发给下家。 模式分类 行为型设计模式。 模式产生的原因 在很多情况
Java23种设计模式(总结).doc
09-18
- **解释器模式**：给定一个语言，定义其文法的一种表示，并且提供一个解释器，用于解释该语言中的句子。 - **迭代器模式**：提供一种方法顺序访问聚合对象的元素，而又不暴露其底层表示。 - **中介者模式**：用...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值