设计模式循序渐进（9）解释器模式 Interpreter

最新推荐文章于 2024-11-11 08:32:59 发布
最新推荐文章于 2024-11-11 08:32:59 发布
阅读量97 收藏
点赞数
文章标签： 设计模式
原文链接：http://www.cnblogs.com/zhangsk/archive/2008/06/13/1219509.html
版权
通过解释器模式实现阿拉伯数字与罗马数字的相互转换。
具体的模式分析解说日后补发。
Delphi代码：
unit uInt2RomeInterpreter;
 {
单元说明：将整数转换为罗马数字
          Interpreter 解释器模式练习。
作者：张树坤
时间：2008-06-11
}
interface

type
  TInt2RomeContext  =   class ;
  TRomeCharList  =  array[ 1 .. 9 ] of  string  ;

  TInt2RomeExpression  =   class (TObject)
   private

    function GetRomeChar(index: Integer):  string ;
    procedure InitRomeCharList;  virtual ;  abstract ;
   protected
    FRomeCharList: TRomeCharList;
   public
    constructor Create;  virtual ;
    function Multiplier: Integer;  virtual ;  abstract ;
    procedure Interpret(context: TInt2RomeContext);  virtual ;
    property RomeItems[index: Integer]:  string  read GetRomeChar;
  end;

  TInt2RomeOneExp  =   class (TInt2RomeExpression)
   private
    procedure InitRomeCharList;  override ;
   public
    function Multiplier: Integer;  override ;
  end;

  TInt2RomeTenExp  =   class (TInt2RomeExpression)
   private
    procedure InitRomeCharList;  override ;
   public
    function Multiplier: Integer;  override ;
  end;

  TInt2RomeHundredExp  =   class (TInt2RomeExpression)
   private
    procedure InitRomeCharList;  override ;
   public
    function Multiplier: Integer;  override ;
  end;

  TInt2RomeThousandExp  =   class (TInt2RomeExpression)
   private
    procedure InitRomeCharList;  override ;
   public
    function Multiplier: Integer;  override ;
  end;


  TInt2RomeContext  =   class (TObject)
   private
    FOutput:  string ;
    FInput: Integer;
    procedure SetInput( const  Value: Integer);
    procedure SetOutput( const  Value:  string );
   public
    constructor Create(input: Integer);
    function BeginWith(AMultiplier: Integer): Integer;  // 个、十、百、千位的数字
    property Input: Integer read FInput write SetInput;
    property Output:  string  read FOutput write SetOutput;
  end;


implementation

 { TInt2RomeExpression }

constructor TInt2RomeExpression.Create;
begin
  inherited Create;
  InitRomeCharList;
end;

function TInt2RomeExpression.GetRomeChar(index: Integer):  string ;
begin
   if  index  in  [ 1 .. 9 ] then
    Result : =  FRomeCharList[index];
end;

procedure TInt2RomeExpression.Interpret(context: TInt2RomeContext);
var
  i: Integer;
begin
  i : =  context.BeginWith(Multiplier);
   if  i  in  [ 1 .. 9 ] then
    context.Output : =  context.Output  +  RomeItems[i]
end;


 { TContext }

function TInt2RomeContext.BeginWith(AMultiplier: Integer): Integer;
begin
  Result : =  FInput div AMultiplier;
  FInput : =  FInput mod AMultiplier;
end;

constructor TInt2RomeContext.Create(input: Integer);
begin
  FInput : =  Input;
end;

procedure TInt2RomeContext.SetInput( const  Value: Integer);
begin
  FInput : =  Value;
end;

procedure TInt2RomeContext.SetOutput( const  Value:  string );
begin
  FOutput : =  Value;
end;

 { TInt2RomeOneExp }

procedure TInt2RomeOneExp.InitRomeCharList;
 const
  tmp : TRomeCharList  =  ( ' I ' ,  ' II ' ,  ' III ' ,  ' IV ' ,  ' V ' ,  ' VI ' ,  ' VII ' ,  ' VIII ' ,  ' IX ' );
var
  i: Integer;
begin
 //   for i := 1 to 9 do
   for  i : =  Low(FRomeCharList) to High(FRomeCharList)  do
  begin
    FRomeCharList[i] : =  tmp[i];
  end;
end;

function TInt2RomeOneExp.Multiplier: Integer;
begin
  Result : =   1 ;
end;

 { TInt2RomeTenExp }

procedure TInt2RomeTenExp.InitRomeCharList;
 const
  tmp : TRomeCharList  =  ( ' X ' ,  ' XX ' ,  ' XXX ' ,  ' XL ' ,  ' L ' ,  ' LX ' ,  ' LXX ' ,  ' LXXX ' ,  ' XC ' );
var
  i: Integer;
begin
   for  i : =  Low(FRomeCharList) to High(FRomeCharList)  do
  begin
    FRomeCharList[i] : =  tmp[i];
  end;
end;

function TInt2RomeTenExp.Multiplier: Integer;
begin
  Result : =   10 ;
end;

 { TInt2RomeHundredExp }

procedure TInt2RomeHundredExp.InitRomeCharList;
 const
  tmp : TRomeCharList  =  ( ' C ' ,  ' CC ' ,  ' CCC ' ,  ' CD ' ,  ' D ' ,  ' DC ' ,  ' DCC ' ,  ' DCCC ' ,  ' CM ' );
var
  i: Integer;
begin
   for  i : =  Low(FRomeCharList) to High(FRomeCharList)  do
  begin
    FRomeCharList[i] : =  tmp[i];
  end;
end;

function TInt2RomeHundredExp.Multiplier: Integer;
begin
  Result : =   100 ;
end;

 { TInt2RomeThousandExp }

procedure TInt2RomeThousandExp.InitRomeCharList;
 const
  tmp : TRomeCharList  =  ( ' M ' ,  ' MM ' ,  ' MMM ' ,  '' ,  '' ,  '' ,  '' ,  '' ,  '' );
var
  i: Integer;
begin
   for  i : =  Low(FRomeCharList) to High(FRomeCharList)  do
  begin
    FRomeCharList[i] : =  tmp[i];
  end;
end;

function TInt2RomeThousandExp.Multiplier: Integer;
begin
  Result : =   1000 ;
end;

end.


unit uRomeInterpreter;
 {
单元说明：将罗马数字转换为整数
          Interpreter 解释器模式练习。
作者：张树坤
时间：2008-06-11
}
interface

type
  TContext  =   class ;

  TAbstractExpression  =   class (TObject)
   public
    function Five:  string ;  virtual ;  abstract ;
    function Four:  string ;  virtual ;  abstract ;
    function Nine:  string ;  virtual ;  abstract ;
    function One:  string ;  virtual ;  abstract ;
    function Multiplier: Integer;  virtual ;  abstract ;
    procedure Interpret(context: TContext);  virtual ;
  end;

  TOneExp  =   class (TAbstractExpression)
   public
    function Five:  string ;  override ;
    function Four:  string ;  override ;
    function Nine:  string ;  override ;
    function One:  string ;  override ;
    function Multiplier: Integer;  override ;
  end;

  TTenExp  =   class (TAbstractExpression)
   public
    function Five:  string ;  override ;
    function Four:  string ;  override ;
    function Nine:  string ;  override ;
    function One:  string ;  override ;
    function Multiplier: Integer;  override ;
  end;

  THundredExp  =   class (TAbstractExpression)
   public
    function Five:  string ;  override ;
    function Four:  string ;  override ;
    function Nine:  string ;  override ;
    function One:  string ;  override ;
    function Multiplier: Integer;  override ;
  end;

  TThousandExp  =   class (TAbstractExpression)
   public
    function Five:  string ;  override ;
    function Four:  string ;  override ;
    function Nine:  string ;  override ;
    function One:  string ;  override ;
    function Multiplier: Integer;  override ;
  end;

  TContext  =   class (TObject)
   private
    FInput:  string ;
    FOutput: Integer;
    procedure SetInput( const  Value:  string );
    procedure SetOutput( const  Value: Integer);
   public
    constructor Create(input:  string );
    function BeginWith(value:  string ): Boolean;
    property Input:  string  read FInput write SetInput;
    property Output: Integer read FOutput write SetOutput;
  end;

implementation

 { TAbstractExpression }

procedure TAbstractExpression.Interpret(context: TContext);
begin
   // 将罗马数字转换为阿拉伯数字
   if  Length(context.Input)  =   0  then
    Exit;

   if  context.BeginWith(Nine) then
  begin
    context.Output : =  context.Output  +   9   *  Multiplier;
    context.Input : =  Copy(context.Input,  3 , (Length(context.Input)  -   2 ) );
  end
   else   if  context.BeginWith(Five) then
  begin
    context.Output : =  context.Output  +   5   *  Multiplier;
    context.Input : =  Copy(context.Input,  2 , (Length(context.Input)  -   1 ));
  end
   else   if  context.BeginWith(Four) then
  begin
    context.Output : =  context.Output  +   4   *  Multiplier;
    context.Input : =  Copy(context.Input,  3 , (Length(context.Input)  -   2 ));
  end;
   while  context.BeginWith(One)  do
  begin
    context.Output : =  context.Output  +   1   *  Multiplier;
    context.Input : =  Copy(context.Input,  2 , (Length(context.Input)  -   1 ));
  end;  
end;

 { TContext }

function TContext.BeginWith(value:  string ): Boolean;
var
  i: Integer;
begin
  i : =  Length(value);
   // (i > 0表示非空字符串);进行字符匹配计算
   if  (i  >   0 ) and (Copy(FInput,  0 , i)  =  value) then
    Result : =  True
   else
    Result : =  False;
end;

constructor TContext.Create(input:  string );
begin
  FInput : =  input;
end;

procedure TContext.SetInput( const  Value:  string );
begin
  FInput : =  Value;
end;

procedure TContext.SetOutput( const  Value: Integer);
begin
  FOutput : =  Value;
end;

 { TOneExp }

function TOneExp.Five:  string ;
begin
  Result : =   ' V ' ;
end;

function TOneExp.Four:  string ;
begin
  Result : =   ' IV ' ;
end;

function TOneExp.Multiplier: Integer;
begin
  Result : =   1 ;
end;

function TOneExp.Nine:  string ;
begin
  Result : =   ' IX ' ;
end;

function TOneExp.One:  string ;
begin
  Result : =   ' I ' ;
end;

 { TTenExp }
// X，XL，L，XC
function TTenExp.Five:  string ;
begin
  Result : =   ' L ' ;
end;

function TTenExp.Four:  string ;
begin
  Result : =   ' XL ' ;
end;

function TTenExp.Multiplier: Integer;
begin
  Result : =   10 ;
end;

function TTenExp.Nine:  string ;
begin
  Result : =   ' XC ' ;
end;

function TTenExp.One:  string ;
begin
  Result : =   ' X ' ;
end;

 { THundredExp }
// C，CD，D，M
function THundredExp.Five:  string ;
begin
  Result : =   ' D ' ;
end;

function THundredExp.Four:  string ;
begin
  Result : =   ' CD ' ;
end;

function THundredExp.Multiplier: Integer;
begin
  Result : =   100 ;
end;

function THundredExp.Nine:  string ;
begin
  Result : =   ' CM ' ;
end;

function THundredExp.One:  string ;
begin
  Result : =   ' C ' ;
end;

 { TThousandExp }

function TThousandExp.Five:  string ;
begin
  Result : =   '' ;
end;

function TThousandExp.Four:  string ;
begin
  Result : =   '' ;
end;

function TThousandExp.Multiplier: Integer;
begin
  Result : =   1000 ;
end;

function TThousandExp.Nine:  string ;
begin
  Result : =   ''
end;

function TThousandExp.One:  string ;
begin
  Result : =   ' M ' ;
end;

end.

unit Unit1;

 interface

uses
  Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,
  Dialogs, StdCtrls, uRomeInterpreter, uInt2RomeInterpreter;

type
  TForm1  =   class (TForm)
    edtRome: TEdit;
    btn1: TButton;
    lblRome2Int: TLabel;
    btnInt2Rome: TButton;
    lblInt2Rome: TLabel;
    edtInt: TEdit;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure btn1Click(Sender: TObject);
    procedure btnInt2RomeClick(Sender: TObject);
   private
     { Private declarations }
    Parse: TList;
    Int2RomeParse: TList;
   public
     { Public declarations }
  end;

var
  Form1: TForm1;

implementation

 {$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject);
begin
  Parse : =  TList.Create;
  Parse.Add(TThousandExp.Create);
  Parse.Add(THundredExp.Create);
  Parse.Add(TTenExp.Create);
  Parse.Add(TOneExp.Create);

  Int2RomeParse : =  TList.Create;
  Int2RomeParse.Add(TInt2RomeThousandExp.Create);
  Int2RomeParse.Add(TInt2RomeHundredExp.Create);
  Int2RomeParse.Add(TInt2RomeTenExp.Create);
  Int2RomeParse.Add(TInt2RomeOneExp.Create);
end;

procedure TForm1.FormDestroy(Sender: TObject);
var
  i: Integer;
begin
   for  i : =   0  to Parse.Count  -   1   do
  begin
    TAbstractExpression(Parse.Items[i]).Free;
  end;
  Parse.Clear;
  Parse.Free;
end;

procedure TForm1.btn1Click(Sender: TObject);
var
  context: TContext;
  i: Integer;
begin
  context : =  TContext.Create(edtRome.Text);
   for  i : =   0  to Parse.Count  -   1   do
  begin
    TAbstractExpression(Parse.Items[i]).Interpret(context);
  end;
  lblRome2Int.Caption : =  IntToStr(context.output);
  context.Free;
end;

procedure TForm1.btnInt2RomeClick(Sender: TObject);
var
  context: TInt2RomeContext;
  i: Integer;
begin
  context: =  TInt2RomeContext.Create(strtointdef(edtInt.text,  1 ));
   for  i : =   0  to Int2RomeParse.Count  -   1   do
  begin
    TInt2RomeExpression(Int2RomeParse.Items[i]).Interpret(context);
  end;
  lblInt2Rome.Caption : =  context.Output;
  context.Free;
end;

end.

dfm

 

object  Form1: TForm1
  Left  =   192
  Top  =   107
  Width  =   696
  Height  =   480
  Caption  =   ' Form1 '
  Color  =  clBtnFace
  Font.Charset  =  DEFAULT_CHARSET
  Font.Color  =  clWindowText
  Font.Height  =   - 11
  Font.Name  =   ' MS Sans Serif '
  Font.Style  =  []
  OldCreateOrder  =  False
  OnCreate  =  FormCreate
  OnDestroy  =  FormDestroy
  PixelsPerInch  =   96
  TextHeight  =   13
   object  lblRome2Int: TLabel
    Left  =   360
    Top  =   80
    Width  =   56
    Height  =   13
    Caption  =   ' lblRome2Int '
  end
   object  lblInt2Rome: TLabel
    Left  =   360
    Top  =   136
    Width  =   56
    Height  =   13
    Caption  =   ' lblInt2Rome '
  end
   object  edtRome: TEdit
    Left  =   128
    Top  =   72
    Width  =   121
    Height  =   21
    TabOrder  =   0
    Text  =   ' MCMLXVIII '
  end
   object  btn1: TButton
    Left  =   264
    Top  =   72
    Width  =   75
    Height  =   25
    Caption  =   ' btnRome2Int '
    TabOrder  =   1
    OnClick  =  btn1Click
  end
   object  btnInt2Rome: TButton
    Left  =   264
    Top  =   136
    Width  =   75
    Height  =   25
    Caption  =   ' btnInt2Rome '
    TabOrder  =   2
    OnClick  =  btnInt2RomeClick
  end
   object  edtInt: TEdit
    Left  =   128
    Top  =   136
    Width  =   121
    Height  =   21
    TabOrder  =   3
    Text  =   ' 5 '
  end
end

转载于:https://www.cnblogs.com/zhangsk/archive/2008/06/13/1219509.html

banpan4793
关注
设计模式--可复用面向对象软件的基础（第一章 引言）
我与黑夜
06-15 649
第一章 引言一、什么是设计模式二、SmalltalkMVCSmalltalk MVCSmalltalkMVC中的设计模式三、描述设计模式四、设计模式的编目五、组织编目六、设计模式怎样解决设计问题七、怎样选择设计模式八、怎样使用设计模式 一、什么是设计模式 一般而言，一个模式有四个基本要素： 1、模式名 一个助记名，它用一两个词来描述模式的问题、解决方案和效果； 2、问题 描述了应该在何时使用模式，它解释了设计问题和问题存在的前因后果； 3、解决方案 描述了设计的组成成分、它们之间的相互关系及各自的职责和协作
C++ 设计模式.pdf
08-23
设计模式的学习是一个循序渐进的过程，需要不断地实践和总结。通过对23种设计模式的学习，可以显著提高软件开发者的编程技巧和设计思维。在实际项目中灵活运用这些模式，不仅能提高代码的质量，还能增强系统的可扩展...
设计模式实战 - 解释器模式（Interpreter Pattern）
weixin_34248118的博客
11-26 125
源码 github.com/Wasabi1234/… 0 讲讲运算的核心——模型公式及其如何实现 0.1 业务需求：输入一个模型公式（加、减运算），然后输入模型中的参数，运算出结果 设计要求 ● 公式可以运行时编辑，并且符合正常算术书写方式，例如a+b-c ● 高扩展性，未来增加指数、开方、极限、求导等运算符号时较少改动 ● 效率可以不用考虑，晚间批量运算 需求不复杂，若仅仅对数字采用四则运算，每...
解释器模式练习-数据库备份
maqinghui的博客
11-10 1836
最近看了设计模式，解释器模式自定义语言的实现——解释器模式（六）_刘伟技术博客-CSDN博客，来做一下老师留的练习题。 练习 Sunny软件公司欲为数据库备份和同步开发一套简单的数据库同步指令，通过指令可以对数据库中的数据和结构进行备份，例如，输入指令“COPY VIEW FROM srcDB TO desDB”表示将数据库srcDB中的所有视图(View)对象都拷贝至数据库desDB；输入指令“MOVE TABLE Student FROM srcDB TO desDB”表示将数据库src...
java_247_GOF23设计模式_解释器模式_访问者模式_数学表达式动态解析库_练习
weixin_45339692的博客
07-24 153
解释器模式lnterpreter 这节课了解即可;对学员用处不大 访问者模式Visitor: 用的比较少了解即可
Java设计模式--解释器模式
weixin_34204057的博客
09-19 153
解释器模式 给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 Interpreter Pattern Given a language, define a representation for its grammar along with an interpreter that ...
【23种设计模式之】23.解释器模式
学习中
04-22 165
练习源码：https://github.com/liaoooyx/Design-Patterns
设计模式精解 设计模式精解
06-11
学习设计模式是一个循序渐进的过程，它不仅仅是理论上的学习，更需要实践的验证。随着经验的积累，开发者会逐渐领悟到每种模式背后的精髓，并能在实际项目中恰当地运用它们。 ### 1. 创建型模式 创建型模式关注的...
23种设计模式(C++)
05-11
设计模式的学习和掌握是一个循序渐进的过程，需要不断地实践和反思。通过深入理解和灵活运用这些模式，开发者可以提高软件的可维护性、可扩展性和性能，同时减少代码的复杂度和缺陷。在实际项目中，选择合适的设计...
设计模式精解－GoF 23种设计模式解析附C++实现源码
01-08
设计模式的学习是一个循序渐进的过程，需要不断地实践和思考。通过本文档的学习，读者不仅能够了解每种设计模式的基本概念和应用场景，还能够掌握其实现方法。更重要的是，理解设计模式背后的思想，有助于培养出更好...
设计模式复习-解释器模式
天使也掉毛
07-15 138
#pragma once #include "stdafx.h" #include<map> #include<set> #include<list> #include<string> #include<iostream> using namespace std; /* 设计模式-解释器模式（interpreter） 给定一个...
设计模式学习（十六）：解释器模式
Rain_Mic的博客
07-18 230
目录一、前言二、解释器模式三、示例介绍四、结构与参与者五、总结5.1 优缺点5.2 应用场景 一、前言 本周参加了第十一次设计模式研讨会，主题是解释器模式，接下来我们来看看该模式的具体内容。 二、解释器模式 解释器模式：它提供了评估语言的语法或表达式的方法，实现一个表达式接口，该接口解析一个特定的上下文。 意图：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。 主要解决：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言
设计模式学习笔记四十六、解释器模式
promiseful的博客
05-28 122
一、问题 1、通过解释器模式来实现四则运算，比如计算a+b+c的值 2、先输入表达式的形式，比如a+b+c+d+e 要求表达式的字母不能重复 3、最后求结果 二、基本介绍 1、在编译原理中，一个算术表达式通过词法分析形成词法单元，而后这些词法单元再通过与法分析器构建语法分析树，最终形成一颗抽象的语法分析树。这里的词法分析和语法分析可以看作是解释器模式。 2、解释器模式（Interpreter Pattern）:是指给定一个语言（表达式），定义他的文法的一种表示，并定义一个解释器，使用该解释器来解
大话设计模式-解释器模式学习总结
晓风残月龙
01-11 515
一、概念解释器模式,给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。二、类图及基本代码//抽象表达式 public abstract class AbstractExpression { public abstract void Interpret(Context context);}public class Context { pri
【设计模式学习笔记】解释器模式、迭代器模式案例详解（C++实现）
仅以此博客记录日常学习工作中所思所得，水平有限，难登大雅，万望海涵。
04-26 918
行为型设计模式之解释器模式、迭代器模式简介及C++案例实现。
解释器模式的简单使用
Must_Do的博客
12-20 1125
前言解释器模式使用频率比较少，顾名思义解释器模式就是给定一个语言，定义它的语法，然后解释器根据协议来解释这个语言，得到结果。类似于翻译吧。我觉得用的最多的就是计算表达式了：“A+B”，解释器就是按着操作符区分变量和运算符，然后得到A+B的结果。适用模式某个语言需要解析执行，比如解析XML之类的，可以用到解释器模式。再者如果特定场景不断重复这个场景，可以提取语法，抽象出解释其模式。角色扮演Abstra
23种设计模式（14）：解释器模式
java开发指南博客 【转载】
06-15 462
定义：给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。 类型：行为类模式 类图： 解释器模式是一个比较少用的模式，本人之前也没有用过这个模式。下面我们就来一起看一下解释器模式。 解释器模式的结构 抽象解释器：声明一个所有具体表达式都要实现的抽象接口（或者抽象类），接口中主要是一个interpret()方法，称为解释操作。具体解释任务...
接口类和抽象类在设计模式中的一些应用
Joshua的专栏
11-09 1383
需要接口类：职责链模式通过定义处理请求的接口，将多个处理者链接在一起，使得请求可以沿着链进行传递，直到被处理为止。需要接口类：状态模式通过定义状态的接口，使得对象的行为可以根据其内部状态的改变而改变。原因：组合模式需要定义一个通用的组件接口，使得叶子节点和组合节点可以被统一处理。原因：职责链模式需要定义一个通用的处理者接口，使得不同的处理者可以被统一处理。原因：命令模式需要定义一个通用的命令接口，使得不同的命令对象可以被统一处理。原因：状态模式需要定义一个通用的状态接口，使得不同的状态对象可以被统一处理。
【设计模式】工厂模式
最新发布
weixin_56520780的博客
11-11 550
把对象的创建封装在一个接口函数里面，通过传入不同的标识，返回创建的对象。客户不用自己负责new对象，不用了解对象创建的详细过程把有关联关系的，属于一个产品簇的所有产品创建的接口函数，放在一个抽象工厂里面AbstractFactory，派生类（具体产品的工厂）应该负责创建该产品簇里面所有的产品。假如一类工厂如宝马工厂多做了一项业务如轮胎，那么就得在抽象工厂里面增加一个创建轮胎的产品接口（纯虚函数），所有的工厂都得重写该接口，否则都成了抽象类...
C#设计模式：行为型 Interpreter 解释器模式详解
解释器模式（Interpreter Pattern）是一种行为型设计模式，它在C#面向对象设计模式中占有重要地位，尤其是在软件开发中处理特定领域问题和规则变化频繁的情况下。本篇讨论的核心在于理解动机、意图以及其实现结构。 ...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值