编译原理 语法分析

最新推荐文章于 2021-11-18 18:22:24 发布
最新推荐文章于 2021-11-18 18:22:24 发布
阅读量526 收藏 3
点赞数
分类专栏： 编译原理 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/nyist_yangguang/article/details/114585052
版权

 

上接词法分析 


递归下降的方法实现算术表达式的语法分析器：

三个函数在词法分析的基础上，反复调用，指针沿着词法分析得到的二元组一直后移，

中间加一些判断条件  不符合就报错。

 

测试程序：

// pL/0语言词法分析器
#include<bits/stdc++.h>
using namespace std;

ifstream infile("c.txt");//词法分析的结果或语法分析的输入
string str;//string变量进行字符识别
string sym; //指针
string sym1;
int temp=0;

void expressionAnalysis();//表达式分析
void termAnaysis();//项分析
void factorAnalysis();//因子分析
int advance();

int conterr=0;//记录错误
int lpnum=0;//记录左括号
int found;//提取字符串中指针的位置
int flag=0;//记录往后移动一个指针SYM是否正确
string s;//用来保存要分析的字符串
struct _2tup
{
    string token;
    int id;
};

int advance() //SYM的移动
{
    if(!getline(infile,str)) //从文件中提取字符
    {
        return 0;
    }
    found=str.find(',',0);

    if(found==-1) //当为error的时候，没有‘，’
    {
        conterr++;
        cout<<"语法错误 识别字符错误"<<endl;
        return -1;
    }
    if(temp==1)
        sym1=sym;
    sym=str.substr(1,found-1);

//    cout<<str.substr(found+1,4)<<endl;

    if(temp==0)
    {
        sym1=sym;
        temp=1;
    }
//    cout<<sym<<"  "<<sym1<<endl;
   if(sym=="23" && sym1=="24")
   {
       conterr++;
       cout<<"')'和'('中间缺少运算符\n";
       return -1;
   }
   if(sym=="24" && sym1=="23")
   {
       conterr++;
       cout<<"'('和')'中间缺少项\n";
       return -1;
   }
   if(sym=="24"&&(sym1!="28"&&sym1!="29"))
   {
       conterr++;
       cout<<"')'前面缺少项\n";
       return -1;
   }
   if(sym1=="24"&&(sym=="28"||sym=="29"))
   {
       conterr++;
       cout<<"')'后缺少运算符\n";
       return -1;

   }
   if(sym1=="23"&&(sym=="12"||sym=="13"||sym=="14"||sym=="15"))
   {
       conterr++;
       cout<<"'('后缺少项\n";
       return -1;

   }



//    cout<<sym<<endl;
    return 1;
}

void factorAnalysis()
{
//    cout<<"factor\n"<<sym<<endl;
//    cout<<sym<<endl;
    if(sym=="28"||sym=="29") //如果是标识符和无符号整数，指针就往后移动
    {
        flag=advance();
        if(conterr)
        {
            return;
        }
        if(sym=="23")
        {
            conterr++;
            cout<<"'('前缺少运算符\n";
            return;
        }
        if(lpnum==0&&sym=="24")
        {
            conterr++;
            cout<<"语法错误 ')'不匹配"<<endl;
            return;
        }
    }
    else if(sym=="23") //如果是左括号，就要接下来判断是否为表达式，指针往后移动
    {
//        cout<<"hello"<<sym1<<endl;
        if(sym1=="28"||sym1=="29")
        {
            cout<<"(前面缺少运算符"<<endl;
            conterr++;
            return ;
        }
        lpnum++;
//        cout<<lpnum<<endl;
        flag=advance();
        if(conterr)
        {
            return;
        }
        if(flag==0) //当为最后一个标志的时候，若没有右括号匹配就错误
        {
            conterr++;
            cout<<"语法错误 '('后缺少表达式"<<endl;
            return;
        }
//        cout<<sym<<endl;
        expressionAnalysis();
        if(conterr)
        {
            return;
        }
        if(flag==0||sym!="24")
        {
            conterr++;
            cout<<"语法错误 表达式后面缺少')'"<<endl;
            return;
        }
        else
        {
            lpnum--;
            flag=advance();
            if(conterr)
            {
                return;
            }
            if(flag==0)
            {
                return;
            }
        }
    }
    else
    {
        cout<<"语法错误 因子首部不为<标识符>|<无符号整数>|'('"<<endl;
        conterr++;
        return;
    }
    return;
}

void termAnalysis()
{
//    cout<<"term\n"<<sym<<endl;
    factorAnalysis();
    if(conterr)
    {
        return;
    }
    while((sym=="14")||(sym=="15")) //当为'*'或'/'的时候，一直往后识别因子并循环
    {
        flag=advance();
        if(conterr)
        {
            return;
        }
        if(flag==0)
        {
            conterr++;
            cout<<"语法错误 <乘法运算符>后缺因子"<<endl;
            return;
        }
        if(conterr)
        {
            return;
        }
        factorAnalysis();
        if(conterr)
        {
            return;
        }
    }
    return;
}

void expressionAnalysis()
{
//    cout<<"expression!\n"<<sym<<endl;
    if(conterr)
    {
        return;
    }
    if((sym=="14")||(sym=="15")) //当为'*'或'/'的时候
    {
        flag=advance();
        if(!conterr)
        {
            return;
        }
        if(flag==0)
        {
            cout<<"语法错误 <加法运算符>后缺项"<<endl;
            conterr++;
            return;
        }
    }
    termAnalysis();

     if((sym=="14")||(sym=="15")) //当为'*'或'/'的时候
    {
        flag=advance();
        if(!conterr)
        {
            return;
        }
        if(flag==0)
        {
            cout<<"语法错误 <加法运算符>后缺项"<<endl;
            conterr++;
            return;
        }
    }

    if(conterr)
    {
        return;
    }
    while((sym=="12")||(sym=="13")) //当为'+'或'-'的时候，一直往后识别项并循环
    {
//        cout<<str.substr(found+1,4)<<endl;



        flag=advance();
        if(conterr)
        {
            return;
        }
        if(flag==0)
        {
            cout<<"语法错误 <加法运算符>后缺项"<<endl;
            conterr++;
            return;
        }
        termAnalysis();
        if(conterr)
        {
            return;
        }
    }
    return;
}

bool is_blank(char ch)
{
    return ch == ' ' || ch == '    ';//空格或控制字符
}
bool gofor(char& ch, string::size_type& pos, const string& prog)//返回指定位置的字符
{
    ++pos;
    if (pos >= prog.size())
    {
        return false;
    }
    else
    {
        ch = prog[pos];
        return true;
    }
}

_2tup scanner(const string& prog, string::size_type& pos, const map<string, int>& keys, int& row)
{
    /*
    if
        标示符
    else if
        数字
    else
        符号
    */
    _2tup ret;
    string token;
    int id = 0;

    char ch;
    ch = prog[pos];

    while(is_blank(ch))
    {
        ++pos;
        ch = prog[pos];
    }
    // 判断标示符、关键字
    if ((ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_')
    {

        map<string, int>::const_iterator cit;
        //保证读取一个单词
        while((ch >= '0' && ch <= '9') || (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z') || ch == '_')
        {
            token += ch;//追加标示符、关键字
            if (!gofor(ch, pos, prog))
            {
                break;
            }
            if(token=="odd")
            {
                id=cit->second;
                goto end;
            }
        }
        // 这里先看做都是其他标示符
        id = keys.size();
        // 验证是否是关键字
        cit = keys.find(token);//根据string类型的token返回int类型的id赋值给cit

        if (cit != keys.end())
        {
            id = cit->second;//此时是关键字，记录他的id
//            if(id<=10)
//            cout<<cit->first<<"is true!"<<cit->second<<endl;
        }
    }
    // 识别常数
    else if ((ch >= '0' && ch <= '9'))
    {
        while (ch >= '0' && ch <= '9' )
        {
            token += ch;
            if (!gofor(ch, pos, prog))
            {
                break;
            }
        }
        id = keys.size() - 1;
        int dot_num = 0;
        for (string::size_type i = 0; i != token.size(); ++i)
        {
            if (token[i] == '.')
            {
                ++dot_num;
            }
        }
        if (dot_num > 1)
        {
            id = -1;
        }
    }
    else
    {
        map<string, int>::const_iterator cit;
        switch (ch)
        {
        case '-': // - 操作符
            token += ch;
            gofor(ch,pos,prog);
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            break;
        case ':':
            token += ch;
            if (gofor(ch, pos, prog))
            {
                if (ch == '=') // -- 操作符
                {
                    token += ch;
                    gofor(ch, pos, prog);  //不让:=  中的=重复使用
                }
            }
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            break;

        case '=':
            token += ch;
            gofor(ch,pos,prog);
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            break;

        case '/': // / 操作符
            token += ch;
            gofor(ch,pos,prog);
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            break;
        case '+':
            token += ch;
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            gofor(ch, pos, prog);
            break;

        case '<':
            token += ch;
            if (gofor(ch, pos, prog))
            {
                if (ch == '>')
                {
                    token += ch;
                    gofor(ch,pos,prog);
                }
                else if (ch == '=')
                {
                    token += ch;
                    gofor(ch, pos, prog);
                }
            }
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            break;

        case '>':
            token += ch;
            if (gofor(ch, pos, prog))
            {
                if (ch == '=')
                {
                    token += ch;
                    gofor(ch, pos, prog);
                }
            }
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            break;
        case '(': // / 操作符
            token += ch;
            gofor(ch,pos,prog);
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            break;
        case ')': // / 操作符
            token += ch;
            gofor(ch,pos,prog);
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            break;


        case '*':
            token += ch;
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            gofor(ch, pos, prog);
            break;

        case ',':
        case '.':
        case ';':
            token += ch;
            gofor(ch, pos, prog);
            //++pos;
            //ch = prog[pos];
            cit = keys.find(token);
            if (cit != keys.end())
            {
                id = cit->second;
            }
            break;

        case '\n':
            token += "换行";
            ++pos;
            ch = prog[pos];
            id = -2;
            break;
        default:
            token += "错误";
            ++pos;
            ch = prog[pos];
            id = -1;
            break;
        }
    }
end:

    ret.token = token;
    ret.id    = id;

    return ret;
}

void init_keys(const string& file, map<string, int>& keys)//读取单词符号和种别码
{
    ifstream fin(file.c_str());//.c_str返回的是当前字符串的首地址
    if (!fin)
    {
        cerr << file << " doesn't exist!" << endl;//cerr不经过缓冲而直接输出,一般用于迅速输出出错信息
        //  exit(1);
    }
    keys.clear();//清空map对象里面的内容
    string line;
    string key;
    int id;
    while (getline(fin, line))//这个函数接收两个参数：一个输入流对象和一个string对象，getline函数从输入流的下一行读取，并保存读取的内容到string中
    {
        istringstream sin(line);//istringstream sin(s);定义一个字符串输入流的对象sin,并调用sin的复制构造函数，将line中所包含的字符串放入sin 对象中！
        sin >> key >> id;//读取里面的字符串每一行一个key id
        keys[key] = id;
    }
}

void read_prog(const string& file, string& prog) //读取代码，并追加到prog上
{
    ifstream fin(file.c_str());
    if (!fin)
    {
        cerr << file << " error!" << endl;
        //  exit(2);
    }
    prog.clear();
    string line;
    while (getline(fin, line))
    {
        prog += line + '\n';
    }
}

void cifafenxi()
{
    map<string, int> keys;
    init_keys("a.txt", keys);

    string prog;
    read_prog("b.txt", prog);

    vector< _2tup > tups;
    string token, id;

    string::size_type pos = 0;//size_type属于string标准库，作用可看做相当于unsigned·int
    int row  = 1;

    _2tup tu;
    int no = 0;
//    freopen("CON", "w", stdout);//结果在控制台上输出
    freopen("c.txt","w",stdout);

    do
    {
        tu = scanner(prog, pos, keys, row);

        switch (tu.id)
        {
        case -1://返回的是错误
            ++no;
            cout << no << ": ";
            cout << "Error in row" << row << "!" << '<' << tu.token<< "," << tu.id << '>' << endl;
            tups.push_back(tu);
            break;
        case -2:
            ++row;
            // cout << '<' << tu.token<< "," << tu.id << '>' << endl;
            break;
        default:

            s=prog;
            cout << '(' << tu.id<< "," << tu.token << ')' << endl;

            tups.push_back(tu);
            break;
        }
    }
    while (pos < prog.size());

}

void yufafenxi()//语法分析
{
    freopen("CON", "w", stdout);//结果在控制台上输出
    flag=advance();
    if(flag)
    {
        expressionAnalysis();
    }
    if(flag!=-1 && !conterr)
    {
        cout<<"正确："<<s<<endl;
    }

}
int main()
{
    cifafenxi();
    yufafenxi();
    return 0;
}


测试结果：

 

 

 

a.txt

 

b.txt

 

c.txt

 

程序猿的探索之路
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
利用编译原理中的语法分析进行表达式求值
chusky的专栏
11-27 2188
通过语法分析进行表达式求值记得大二刚学C++时，老师给的表达式求值作业，当时括号都没有要求，后来学数据结构，表达式求值用的是算符优先法，后来学了编译原理，真是深深地佩服计算机科学的前辈们，我觉得编译原理中的自动机和自下而上的语法分析方法非常厉害，刚开始学C,完全就是靠自己的那点机灵去琢磨程序，后来学了数据结构，可以说对思想是一个洗礼，不管解决什么问题，首先想到的都是数据结构，然后再是算法，而不像以
编译原理—语法分析
readonlyfile
06-10 2015
PS 多年前写的了，放在草稿箱里… 现在发出来了 上周完成了编译实验课程的语法分析部分，周末玩去了，今天稍稍整理一下。 首先我们是采用语法制导翻译来做的编译，书上对于语法制导翻译的解释是，将静态检查和中间代码生成结合到语法分析中进行的技术。大概就是指把词法分析、语义分析都结合到语法分析中来，一切都围绕着语法分析展开吧。 所以，完整的语法分析程序，应该是将词法分析的输出作为输入，在进行每一次归
词法分析（c语言实现）程序代码+报告
11-13
一、 实验目的 调试并完成一个词法分析程序，加深对词法分析原理的理解。 二、 实验要求 1、 待分析的简单语言的词法 （1） 关键字： begin if then while do end 所有关键字都是小写。 （2） 运算符和界符： := + – * / < <= > >= = ; ( ) # (3) 其他单词是标识符（ID）和整型常数（NUM），通过以下正规式定义： ID=letter（letter| digit）* NUM=digit digit * (4)空格由空白、制表符和换行符组成。空格一般用来分隔ID、NUM,运算符、界符和关键字，词法分析阶段通常被忽略。 2、 各种单词符号对应的种别码 单词符号 种别码 单词符号 种别码 begin 1 : 17 if 2 := 18 then 3 > 20 while 4 21 do 5 <= 22 end 6 = 24 digit digit * 11 = 25 * 13 ; 26 / 14 ( 27 + 15 ) 28 - 16 # 0 3、 词法分析程序的功能 输入：所给文法的源程序字符串。 输出：二元组（syn，token或sum）构成的序列。 其中：syn为单词种别码； token为存放的单词自身字符串； sum为整型常数。
语法分析程序--编译原理
immense的博客
05-22 7574
语法分析程序 实验目的和内容 理解语法分析的功能和实现机制。掌握递归向下的语法分析方法。 实验要求 1. 完成实验的要求 附录是一个简单的算法表达式文法，如a+b*c－b/d就是一个该文法所表示的合法的表达式。请你为该文法编写一个递归向下的语法分析程序。 输入：字符串或者文本文件 输出：“合法表达式”或者“非法表达式” 例如：输入a+b*c－b/d则显示或者输出“合法表达式”，...
算术表达式的语法和语义分析（算符优先分析方法生成三元式的中间代码）
热门推荐
黄飞的博客专栏
07-25 1万+
1.系统描述 1.1目的 通过设计、编制、调试一个算术表达式的语法及语义分析程序，加深对语法及语义分析原理的理解，并实现词法分析程序对单词序列的词法检查和分析。 1.2设计内容和步骤 对算数表达式的运行过程描述：算数表达式总体上服从从左至右的运行过程，但不同运算符的优先级不同，首先要对输入的算数表达式进行词法分析，该过程是编制一个读单词的过程，从输入的源程序中，识别出各个具有独立意义的单词
中科大 编译原理 从零开始的编译原理（第四单元：语法分析（Part I） 算术表达式的语法分析器）
Love 6's Private Blog
11-18 1063
文章目录前引第四单元：语法分析（Part I）1、任务介绍2、实现思路3、代码实现4、示例输入 + 实现效果 前引 刚刚才发现这个作业真的挺不错的 如果对于想要自己实现正则引擎的hxd们 应该先来看一下这个十分简单的作业 对基本的递归下降分析有个初步的认识 再去实现 个人认为这个任务有个地方老师给错了 就是第二个检查点 e = (3+4*5)) 应该改成e = (3+4*5) 后面多个括号 我刚开始还以为里面让我们加个对多余括号的判断 在处理中 对于哪里出错的地方自然而然进行 \0的操作 从此处断开
编译原理之语法分析
liulangdeyue的专栏
04-18 2595
在编译原理的前端部分最核心的便是语法分析
编译原理 语法分析 语法树生成
12-30
压缩包中的“编译原理语法树”文件可能包含了使用yacc和lex构建的C++语法分析器的示例，以及它分析C++源代码后生成的语法树的可视化表示。通过查看这些示例，开发者可以更深入地理解编译器的工作原理，学习如何构建...
编译原理语法分析
11-25
编译原理语法分析 在编译原理中，语法分析是指对源程序的语法正确性进行检查和分析的过程。这个过程的主要目的是为了检查源程序是否满足语言的语法规则，从而确保编译器能够正确地翻译源程序。 在这个实验报告中，...
编译原理 语法分析
07-03
编译原理是计算机科学中的一个重要领域，主要研究如何将高级编程语言转换为机器可以理解的低级语言，即机器码。这个过程分为多个阶段，包括词法分析、语法分析、语义分析、优化以及目标代码生成。在这个压缩包中，...
编译原理语法分析LL1文法c++代码
04-10
在编程领域，编译原理是理解计算机语言底层工作机制的关键学科。它涉及到将高级语言转换为机器可执行的指令的过程。语法分析是编译器设计中的一个重要阶段，它负责将输入的源代码分解成符合语法规则的结构，通常称为...
实现算术表达式的语法分析器
weixin_30345055的博客
04-22 2222
前言：本实验采用自上而下的方法实现算术表达式的语法分析器。只是实现了对加减乘数和带括号的语法分析，判断语法的正确性。 一 实验要求： （1）程序通过标准输入按行读取用户输入，表达式在1行内读完。 （2）程序对用户输入的内容首先进行词法分析处理（可以复用实验一的部分代码，由于词法规则更简单，可以大大简化），词法分析得到的词法单位对应文法中的终结符。//代码太长直接就用词法分析的结果进行语法分析...
解析编译原理主要过程
hello world
08-20 3046
编译过程包括：词法分析-》语法分析-》语义分析
编译原理实践：C++实现语义分析器（学习笔记）
XXX
06-23 7871
编译原理实践：C++实现语义分析器（学习笔记）实践说明输入举例（input.txt）输出举例（output.txt）编程平台代码实现基本思路语义分析部分预定义主函数定义语义分析部分函数语法分析主函数语句串分析函数语句分析函数(等号右边的)表达式分析函数项分析函数因子分析函数 实践说明 【题目要求】 基于已编写的C++语法分析器，分析当前目录下input.txt文件中的语义并生成中间代码。 input.txt中的待分析代码必须以begin开头、以end结尾，文件最后以#结束。 输出结果存放到当前目录下的out
PYTHON实现算术表达式的词法语法语义分析（编译原理应用）
Just for fun的专栏
07-27 2930
本学期编译原理的一个大作业，我的选题是算术表达式的词法语法语义分析，当时由于学得比较渣，只用了递归下降的方法进行了分析。   首先，用户输入算术表达式，其中算术表达式可以包含基本运算符，括号，数字，以及用户自定义变量。 词法分析，检查单词变量是否正确；语法分析，检查算术表达式语法是否正确并输出生成语法树；语义分析，输出四元表达式。   最终效果图： 例如输入：   词法分析结果： ...
编译原理：语法分析（算术表达式的扩充）
weixin_41708020的博客
06-29 3365
实验二 语法分析（算术表达式的扩充） 一·、实验题目 算术表达式文法扩充如下： E→E+E| E-E|E*E |E/E| (E) | I 试根据该文法重新设计LR分析表，并修改语义加工程序，最后验证修改的结果。 二、实验过程 （1）代码设计 由于一开始没有用实验要求的文法设计的表（最主要是实验要求的文法有很多左递归的文法造成对于还没充分认识LR的我来说，存在很大的难度。所以查找一些假设LR构造的表已经设计出来的，看看LR语法分析的流程），所以等我了解了LR构造的流程以后，我就想设计一个更加符合要求的。
语法分析实现--表达式解析
sui_feng_piao_guo的博客
11-18 5622
语法分析实现 1. 目标及代码 目标： 实现表达式的语法树构建（加减乘除的表达式解析） 如： 将 a = 1+2*5等表达式解析为语法树的形式 代码地址： git代码仓库 注意： 本文章主要目的是记录个人学习历程，如有不对的地方欢迎大家评论指出 2. 语法分析阶段做什么？ 语法分析阶段主要的功能就是把词法分析的结果构建一颗语法树， 此法阶段就相当于找到了一个一个的单词而语法阶段要做的就是按照文法规则将这些单词组织起来 此处采用的方法为递归下降法， 文法部分内容太偏数学如果有兴趣可自行搜
编译原理公式计算器C语言,GitHub - ykaidong/calc: 编译原理实战之表达式计算器
weixin_36078245的博客
05-18 696
calc编译原理实战之表达式计算器前言整理硬盘时翻出之前写的一个简单的表达式计算器, 想想当初为了理解这东西也费了不少功夫, 所以想写一篇笔记, 希望能给当初像我一样的菜鸟一点帮助. 原来只打算写表达式解析计算的方法, 写了一半后发现就光靠那点东西不一定使人看得懂代码, 所以干脆从头开始写起了.考虑有表达式:12 + 34 - 5它将做为一个字符串输入计算机, 为了方便处理, 要对它先做词法分析....
自下而上语法分析-----编译原理------c++
wacyy的博客
07-21 1816
实验三. 自下而上语法分析 1. 实验目的 (1) 给出 PL/0 文法规范，要求编写 PL/0 语言的语法分析程序。 (2) 通过设计、编制、调试一个典型的自下而上语法分析程序，实现对 词法分析程序所提供的单词序列进行语法检查和结构分析，进一步 掌握常用的语法分析方法。 (3) 选择最有代表性的语法分析方法，如算符优先分析法、LR 分析法； 或者调研语法分析器的自动生成工具 YACC 的功能与工作原理，使用 YACC 生成一个自底向上的语法分析器。 2. 实验准备 微机安装好 C 语言，或 C++，或 V
编译原理语法分析过程
最新发布
06-05
编译原理中，语法分析是将输入的源程序分解成一系列语法单位，并根据语法规则构造语法分析树的过程。语法分析的主要任务是判断源程序是否符合语法规则，如果不符合，需要报告相应的错误信息。常见的语法分析方法有自...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

程序猿的探索之路

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

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

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

打赏作者

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

抵扣说明：

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

余额充值