编译原理之词法分析（C语言描述）

最新推荐文章于 2023-01-05 18:18:04 发布
最新推荐文章于 2023-01-05 18:18:04 发布
阅读量1.7k 收藏 19
点赞数 2
文章标签： 词法分析 编译原理 编译器
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40818798/article/details/89219371
版权

实验环境

  1. 编写语言：C

  2. 测试语言：C

  3. 开发环境：Visual Studio 2019

实验过程

  • 单词分类表

单词类型

种别码

关键字

一词一码

标识符_变量名

多词一码

标识符_函数名

多词一码

标识符_数组名

多词一码

常数

多词一码

运算符与界符

一词一码

  • 关键字：auto       break    case     char        const      continue

                default    do       double   else        enum       extern

                float      for      goto     if          int        long

                register   return   short    signed      sizeof     static

                struct     switch   typedef  union       unsigned   void

                volatile    while

  • 界符：  ‘/*’、‘//’、 () { } [ ] " "  '

  • 运算符： <、<=、>、>=、=、+、-、*、/、^、

  • 对所有可数符号进行编码：

        <auto,1>...<while,32>

        <+，33><-,34><*,35></,36><<,37><<=,38><>,39><>=,40><=,41><==,42><!=,43><;,44><(,45>

        <),46><^,47><,,48><",49><',50><#,51><&,52><&&,53><|,54><||,55><%,56><~,57><<<,58>左移<>>,59>右移

        <[,60><],61><{,62><},63><\,64><.,65><?,66><:,67><!,68>"[","]","{","}

  • 算法描述

  • 预处理程序算法(去除源程序中的注释与无效字符)   

 if (r[i] == '/'&&r[i + 1] == '/')//若为单行注释“//”,则去除注释后面的东西，直至遇到回车换行
            while (r[i] != '\n')
                 i++;//向后扫描
            if (r[i] == '/'&&r[i + 1] == '*')
            {//若为多行注释“/* 。。。*/”则去除该内容
                  i += 2;
                  while (r[i] != '*' || r[i + 1] != '/')
                  {
                       i++;//继续扫描
                       if (r[i] == '\0')
                       {
                             printf("注释出错，没有找到 */，程序结束！！！\n");
                             exit(0);
                       }
                  }
                  i += 2;//跨过“*/”
            }
            if (r[i] != '\n'&&r[i] != '\t'&&r[i] != '\v'&&r[i] != '\r')
                  tmpStr[count++] = r[i];//若出现无用字符，则过滤；否则加载
            /*宏替换  未实现*/
  • 词法分析子程序 
   if (IsLetter(*tmpSrcTxt))//开头为字母或下划线
      {
            token[count++] = *tmpSrcTxt++;//收集并下移
            while (IsLetter(*tmpSrcTxt) || IsDigit(*tmpSrcTxt))//后跟字母或数字或下划线
                  token[count++] = *tmpSrcTxt++;//收集并下移
            token[count] = '\0';
            *type = searchKeyWords(KeyWords, token);//查表找到种别码
            if (*type == -1)

                  *type = ID;//若不是保留字则是标识符
      }
      else if (IsDigit(*tmpSrcTxt))//首字符为数字
      {
            while (IsDigit(*tmpSrcTxt))//后跟数字
                token[count++] = *tmpSrcTxt++;//收集
            token[count] = '\0';
            *type = CONST;//常数种别码
      }
      else if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == ';' || ch == '(' || ch == ')' || ch == '^'|| ch == ',' || ch == '\"' || ch == '\'' || ch == '~' || ch == '#' || ch == '%' || ch == '['|| ch == ']' || ch == '{' || ch == '}' || ch == '\\' || ch == '.' || ch == '\?' || ch == ':')

      {//若为运算符或者界符，查表得到结果
            token[0] = *tmpSrcTxt;
            token[1] = '\0';//形成单字符串
            for (i = 0; i < 36; i++)
            {//查运算符界符表
                  if (strcmp(token, Operator[i]) == 0)
                  {
                       *type = 33 + i;//获得种别码，使用了一点技巧，使之呈线性映射
                       break;//查到即推出
                  }
            }
            tmpSrcTxt++;//指针下移，为下一扫描做准备
      }

完整程序 

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
/*	
	第一类：标识符
	第二类：常数
	第三类：保留字(32)
	auto       break    case     char        const      continue
	default    do       double   else        enum       extern
	float      for      goto     if          int        long
	register   return   short    signed      sizeof     static
	struct     switch   typedef  union       unsigned   void
	volatile    while
	第四类：界符  ‘/*’、‘//’、 () { } [ ] " "  '
	第五类：运算符 <、<=、>、>=、=、+、-、*、/、^、
	对所有可数符号进行编码：
	<auto,1>...<while,32>
	<+，33><-,34><*,35></,36><<,37><<=,38><>,39><>=,40><=,41><==,42><!=,43><;,44><(,45>
	<),46><^,47><,,48><",49><',50><#,51><&,52><&&,53><|,54><||,55><%,56><~,57><<<,58>左移<>>,59>右移
	<[,60><],61><{,62><},63><\,64><.,65><?,66><:,67><!,68>"[","]","{","}"<常数99  ,数值><标识符100 ，标识符指针>
*/
#define ID 100		//标识符
#define	CONST 99 	//常量
#define	STRING 98 	//字符串
//#define	DIVIDE 5 	//分界符
//#define	ALU 6		//运算符
#define ID_A 7		//标识符_数组名
#define ID_B 8		//标识符_变量名
#define ID_F 9		//标识符_函数名
#define INVALID -1	//无效字符
#define MAXTEXT 10000	//可允许的最大文本(字符)长度
#define MAXID	1000	//可容纳的最大标识符个数
#define IDLEN	30		//可允许的标识符最大长度为30
#define MAXKEY	32		//关键字个数

//关键字表
static char KeyWords[MAXKEY][IDLEN] = 
{
	"auto", "break", "case", "char", "const", "continue",
	"default", "do", "double", "else", "enum", "extern",
	"float", "for", "goto", "if", "int", "long",
	"register", "return", "short", "signed", "sizeof", "static",
	"struct", "switch", "typedef", "union", "unsigned", "void",
	"volatile", "while"
};
//界符运算符表
static char Operator[36][10] = 
{
	"+", "-", "*", "/", "<", "<=", ">", ">=", "=", "==",
	"!=", ";", "(", ")", "^", ",", "\"", "\'", "#", "&",
	"&&", "|", "||", "%", "~", "<<", ">>", "[", "]", "{",
	"}", "\\", ".", "\?", ":", "!"
};
//标识符表——待添加
static  char IDentifierTbl[MAXID][IDLEN] = { "" };

/********查找关键字********/
int searchKeyWords(char KeyWords[][IDLEN], char *s)
{
	for (int i = 0; i < MAXKEY; i++)
	{
		if (strcmp(KeyWords[i], s) == 0)//若成功查找，则返回种别码
			return i + 1;//返回种别码
	}
	return -1;//否则返回-1，代表查找不成功，即为标识符
}

/********判断是否为字母或下划线********/
bool IsLetter(char letter)
{
	if (letter >= 'a'&&letter <= 'z' || letter >= 'A'&&letter <= 'Z' || letter == '_')
		return true;
	else
		return false;
}

/********判断是否为数字***********/
bool IsDigit(char digit)
{
	if (digit >= '0'&&digit <= '9')
		return true;
	else
		return false;
}

/**********编译预处理，去除无用的字符和注释************/
void filterResource(char *r, int *rLen)
{
	if (r == NULL || rLen == NULL)
		return;
	char tmpStr[MAXTEXT];
	char From[20] = { 0 };	//替换前
	char To[20] = { 0 };	//替换后
	char cur = 0;
	int count = 0;
	for (int i = 0; i <= *rLen; i++)
	{
		if (r[i] == '/'&&r[i + 1] == '/')//若为单行注释“//”,则去除注释后面的东西，直至遇到回车换行
			while (r[i] != '\n')
				i++;//向后扫描
		if (r[i] == '/'&&r[i + 1] == '*')
		{//若为多行注释“/* 。。。*/”则去除该内容
			i += 2;
			while (r[i] != '*' || r[i + 1] != '/')
			{
				i++;//继续扫描
				if (r[i] == '\0')
				{
					printf("注释出错，没有找到 */，程序结束！！！\n");
					exit(0);
				}
			}
			i += 2;//跨过“*/”
		}
		if (r[i] != '\n'&&r[i] != '\t'&&r[i] != '\v'&&r[i] != '\r')
			tmpStr[count++] = r[i];//若出现无用字符，则过滤；否则加载
		/*宏替换  未实现*/
		//if (r[i] == '#')
		//{
		//	char preCompiler[20] = { 0 };
		//	char j = 0;
		//	i++;	//跳过#
		//	while (r[i] != ' ')
		//		preCompiler[j++]=r[i++];
		//	j = 0;
		//	i++;	//跳过空格
		//	if (strcmp(preCompiler, "define")==0)
		//	{
		//		cur = i;
		//		while (r[i] != ' ')
		//			From[j++] = r[i++];
		//		j = 0;
		//		i++;
		//		
		//		while (r[i] != ' '&& r[i] != '\n')
		//			To[j++] = r[i++];
		//		j = 0;
		//		i++;
		//	}
		//	i = cur;
		//}
		//if (r[i] == *From)	//匹配到宏替换的首字符
		//{
		//	char size = strlen(From);
		//	char j = 0, k = 0;
		//	while (r[i++] == From[j++]);
		//	if (j == size+1)	//完全匹配 开启替换
		//		tmpStr[count] = To[k++];
		//}
	}
	tmpStr[count] = '\0';
	*rLen = count;	//修改净化之后源程序的长度
	strcpy(r, tmpStr);//产生净化之后的源程序
}

/****************************分析子程序，算法核心***********************/
void Scanner(int *type/*out*/, char *srcTxt/*in*/, char *token/*out*/,int *pCur/*inout*/,int pSrc)//类型号 源文件 标识符 当前指针 结束指针
{
	int i, count = 0;//count用来做token[]的指示器，收集有用字符
	char *tmpSrcTxt = srcTxt + *pCur;	//初始地址+偏移量
	char ch = *tmpSrcTxt;//作为判断使用
	if (ch == -1)	//文件结束符
	{
		*pCur = pSrc;
		*type = INVALID;
		return;
	}
	for (i = 0; i < 20; i++)//每次收集前先清零
		token[i] = '\0';
	if (IsLetter(*tmpSrcTxt))//开头为字母或下划线
	{
		token[count++] = *tmpSrcTxt++;//收集并下移
		while (IsLetter(*tmpSrcTxt) || IsDigit(*tmpSrcTxt))//后跟字母或数字或下划线
			token[count++] = *tmpSrcTxt++;//收集并下移
		token[count] = '\0';
		*type = searchKeyWords(KeyWords, token);//查表找到种别码
		if (*type == -1)
			*type = ID;//若不是保留字则是标识符
	}
	else if (IsDigit(*tmpSrcTxt))//首字符为数字
	{
		while (IsDigit(*tmpSrcTxt))//后跟数字
			token[count++] = *tmpSrcTxt++;//收集
		token[count] = '\0';
		*type = CONST;//常数种别码
	}
	else if (ch == '+' || ch == '-' || ch == '*' || ch == '/' || ch == ';' || ch == '(' || ch == ')' || ch == '^'
		|| ch == ',' || ch == '\"' || ch == '\'' || ch == '~' || ch == '#' || ch == '%' || ch == '['
		|| ch == ']' || ch == '{' || ch == '}' || ch == '\\' || ch == '.' || ch == '\?' || ch == ':')
	{//若为运算符或者界符，查表得到结果
		token[0] = *tmpSrcTxt;
		token[1] = '\0';//形成单字符串
		for (i = 0; i < 36; i++)
		{//查运算符界符表
			if (strcmp(token, Operator[i]) == 0)
			{
				*type = 33 + i;//获得种别码，使用了一点技巧，使之呈线性映射
				break;//查到即推出
			}
		}
		tmpSrcTxt++;//指针下移，为下一扫描做准备
	}
	else  if (*tmpSrcTxt == '<')
	{//<,<=,<<
		tmpSrcTxt++;//后移，超前搜索
		if (*tmpSrcTxt == '=')
			*type = 38;
		else if (*tmpSrcTxt == '<')
			*type = 58;
		else
		{
			tmpSrcTxt--;
			*type = 37;
		}
		tmpSrcTxt++;//指针下移
	}
	else  if (*tmpSrcTxt == '>')
	{//>,>=,>>
		tmpSrcTxt++;
		if (*tmpSrcTxt == '=')
			*type = 40;
		else if (*tmpSrcTxt == '>')
			*type = 59;
		else
		{
			tmpSrcTxt--;
			*type = 39;
		}
		tmpSrcTxt++;
	}
	else  if (*tmpSrcTxt == '=')
	{//=.==
		tmpSrcTxt++;
		if (*tmpSrcTxt == '=')
			*type = 42;
		else
		{
			tmpSrcTxt--;
			*type = 41;
		}
		tmpSrcTxt++;
	}
	else  if (*tmpSrcTxt == '!')
	{//!,!=
		tmpSrcTxt++;
		if (*tmpSrcTxt == '=')
			*type = 43;
		else
		{
			*type = 68;
			tmpSrcTxt--;
		}
		tmpSrcTxt++;
	}
	else  if (*tmpSrcTxt == '&')
	{//&,&&
		tmpSrcTxt++;
		if (*tmpSrcTxt == '&')
			*type = 53;
		else
		{
			tmpSrcTxt--;
			*type = 52;
		}
		tmpSrcTxt++;
	}
	else  if (*tmpSrcTxt == '|')
	{//|,||
		tmpSrcTxt++;
		if (*tmpSrcTxt == '|')
			*type = 55;
		else
		{
			tmpSrcTxt--;
			*type = 54;
		}
		tmpSrcTxt++;
	}
	else if (*tmpSrcTxt == ' ')//首字符为空格
	{
		while (*tmpSrcTxt == ' ')
			tmpSrcTxt++;
		*type = INVALID;
	}
	else//不能被以上词法分析识别，则出错。
	{	
		printf("error：there is no exist %c \n", *tmpSrcTxt);
		exit(0);
	}
	*pCur = tmpSrcTxt - srcTxt;	//确定每次扫描后的指针位置
}

int main()
{	
	char srcTxt[MAXTEXT] = { 0 };	//打开一个文件，读取其中的源程序,以字符形式存储在srcTxt[MAXTEXT]中
	char token[20] = { 0 };
	int type = -1;	//初始化
	int pSrc = 0;	//源程序指针
	int pCur = 0;	//程序所读到的指针位置
	char idTurn = 0;	//为1时标识符进入可转换状态
	char tmpStr[IDLEN] = { 0 };	//保存此次标识符
	FILE *fpSrc=NULL, *fpPre=NULL, *fpAfterCiFa=NULL;	//源文件，预编译后的文件，词法分析后的文件
	//-------------------
	if ((fpSrc = fopen("F:\\test.txt", "r")) == NULL)	//打开源程序文件
	{
		cout << "can't open this file";
		exit(0);
	}
	while ( (srcTxt[ pSrc++ ] = fgetc(fpSrc) ) != EOF );//将源程序读入srcTxt[]数组
	srcTxt[pSrc] = '\0';
	fclose(fpSrc);
	//--------------------
	cout << "源程序为:" << endl;
	cout << srcTxt << endl;

	filterResource(srcTxt, &pSrc);	//对源程序进行过滤
	--------------------
	//if ((fpPre = fopen("F:\\Precompile.txt", "w")) == NULL)	//生成预编译文件
	//{
	//	cout << "can't open this file";
	//	exit(0);
	//}
	//while ((fputc(fpPre) = srcTxt[pSrc++]) != EOF);//将预处理后的程序写到预编译文件
	//fclose(fpSrc);
	---------------------
	cout << endl << "过滤之后的程序:" << endl;
	cout << srcTxt << endl;
	
	if ((fpAfterCiFa = fopen("F:\\AfterCiFa.txt", "w")) == NULL)	//打开词法分析文件
	{
		cout << "can't open this file";
		exit(0);
	}
	while (pCur < pSrc)	//当文件不结束时
	{
		//启动扫描  类型号 源文件 标识符 当前指针 结束指针
		Scanner(&type, srcTxt, token, &pCur, pSrc);	//返回当前指针位置，判断是否到文件结束
		if (type == INVALID)	//若type为无效字符，则跳过本次循环
			continue;
		switch (type)
		{
			case ID:
				for (int i = 0; i < 1000; i++)
				{//插入标识符表中
					if (strcmp(IDentifierTbl[i], token) == 0)
						break;
					if (strcmp(IDentifierTbl[i], "") == 0)
					{//查找空间
						strcpy(IDentifierTbl[i], token);
						break;
					}
				}
				strcpy(tmpStr, token);	//保存此次标识符
				idTurn = 1;	//开启可转换标志 因为当前为标识符  可转化为数组名 变量名 函数名等
				Scanner(&type, srcTxt, token, &pCur, pSrc);
				if (idTurn == 1 && strcmp(token, "(") == 0)	//函数名
				{
						printf("(函数名,%s)\n", tmpStr);
						fprintf(fpAfterCiFa, "(函数名,%s)\n", tmpStr);
						idTurn = 0;
				}
				else if (idTurn == 1 && strcmp(token, "[") == 0)
				{
					printf("(数组名,%s)\n", tmpStr);
					fprintf(fpAfterCiFa, "(数组名,%s)\n", tmpStr);
					idTurn = 0;
				}
				else
				{
					printf("(变量名,%s)\n", tmpStr);
					fprintf(fpAfterCiFa, "(变量名,%s)\n", tmpStr);
					idTurn = 0;
				}
				break;
			case STRING:	//字符串
				break;
			case CONST:		//常量
				printf("(常数,%s)\n", token);
				fprintf(fpAfterCiFa, "(常数,%s)\n", token);
				break;
			//case DIVIDE:	//分界符
			//	break;
			default:
				break;
		}
		if (type >= 1 && type <= 32)	//关键字
		{
			printf("(关键字%d,%s)\n", type, KeyWords[type - 1]);
			fprintf(fpAfterCiFa, "(关键字%d,%s)\n", type, KeyWords[type - 1]);
		}
		else if (type >= 33 && type <= 68)//运算符
		{
			printf("(界符运算符%d,%s)\n", type, Operator[type - 33]);
			fprintf(fpAfterCiFa, "(界符运算符%d,%s)\n", type, Operator[type - 33]);
		}
	}
	fclose(fpAfterCiFa);
	return 0;
}
//bool readFile(FILE *p, char*buffer)	//将文件内容读到buffer
//{
//}
//bool writeFile(FILE *p, char*buffer)//将buffer内容写入文件
//{
//}

 

誓约胜利之舰
关注
  • 2
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【编译原理】词法分析程序设计（C语言）
qq_55930097的博客
07-09 1780
输入字符串后主函数调用judge()，其中code为种别码，i的值不能超过输入字符串的最大长度，s为输入的字符串；输入if(a>=0) sum+=1 ，第一行输出(种别码，单词符号)，第二行输出关键字“if”的种别码105和自己本身的符号，第三行输出界符“(”的种别码301和自己本身的符号，往下依次完成了该输入字符串的识别。（2）为了判别单词字符的类型，我们可以将整个程序分成五个部分：主函数，核心子程序，判断关键字函数，判断字母函数，判断数字函数。五大类，并输出各个单词的种别码和单词符号自身的值。
【编译原理】词法分析C++/C语言
qq_41094194的博客
04-20 917
/*需要的库和全局变量、函数及主程序*/ #include <stdio.h> //包含库所用的某些宏和变量 #include <stdlib.h> //包含库 #include <string.h> //包含字符串处理库 #define _KEY_WORD_END "waiting for your expanding" //定义关键字结束标志 /...
c语言编译英文,现代编译原理——C语言描述(英文版)
weixin_42297519的博客
05-18 258
ContentsPreface viiPart I Fundamentals of Compilation 1 Introduction 31.1 Modules and interfaces 41.2 Tools and software 51.3 Da...
c语言实现词法分析器
热门推荐
zmm0628的博客
11-17 3万+
词法分析器的功能:输入源程序，输出单词字符。单词字符一般可以分为下面五种。 （1）关键字 是由程序语言定义的具有固定意义的标识符。有时称这些标识符为保留字或者基本字。例如c语言中的int,char,define,strcut,double,if,else.等等 （2）标识符 用来表示各种名字，如变量名，数组名，过程名。 （3）常数 常数的类型一般有整形，实型，布尔型等 （4）运算符 如+，-，*，/。 （5）界符 如逗号，分号，括号，%，//，等。 词法分析器的目标就是把程序分成一个一个单词。并给出单词符号
【编译原理】类C语言词法分析器的设计
老北京的热干面
05-10 9008
1.实验要求输入为一个以类C语言编写的源程序输出为一组二元组序列构成的文本文件，一行为一个二元组，二元组中间以逗号隔开实验报告上要求附上DFA   2.语言说明：保留字：unsigned、break、return、void、case、float、char、for、while、continue、if、default、do、int、switch、double、long、else运算符：+，-，*，/，...
编译原理——SLR（1）语法分析器（C/C++代码实现）
最新发布
qq_58773908的博客
01-05 8640
实现LR语法分析器,执行过程举例：分析id+id*id，根据PPT上的预测分析表，输入id+id*id#，分析出栈和输出的内容。 文法：E'->E，E->E+T， E->T，T->T*F，T->F，F->(E)，F->id
词法分析器（纯c语言）
qq_35853567的博客
12-27 6214
编译原理 简单词法分析器(纯C语言)
编译原理实验C语言词法分析器
05-24
编译原理 简单的词法分析器 输入为源程序代码，输出（单词，种别码）序列
C语言词法分析程序(编译原理)
06-21
总之，本项目提供的“C语言词法分析程序”旨在让学生或开发者深入理解编译原理，通过实际操作学习词法分析的过程。这不仅有助于提升编程技能，也能增强对底层语言机制的理解，为将来设计更复杂的编译器或解析器打下...
编译原理 C语言实现词法分析
10-05
通过设计编制调试一个具体的词法分析程序，加深对词法分析原理的理解。并掌握在对程序设计语言源程序进行扫描过程中将其分解为各类单词的词法分析方法。 编制一个读单词过程，从输入的源程序中，识别出各个具有独立...
现代编译原理：c语言描述
08-30
现代编译原理:C语言描述》全面讲述了现代编译器的结构 编译算法和实现方法 是Andrew w．Apple的“虎书” Modern Compiler Implementation “红 蓝 绿”三序列之一
编译原理，词法分析代码实现，C语言程序，保证能运行
09-21
总结来说，这个 C 语言实现的词法分析程序展示了如何根据编译原理的基本概念，对输入的源程序进行词法分析，识别出各种单词符号，并输出它们的类别和值。这种程序对于理解和实现编译器的早期阶段至关重要。通过编写...
c语言 编译原理（第4版）刘铭 词法分析器
01-10
总之，《C语言 编译原理（第4版）》中的词法分析器部分，结合了理论与实践，是学习编译技术的绝佳起点，对于想要深入理解程序语言内部机制的开发者来说，是一份不可多得的学习资料。通过实际操作，读者可以亲身体验...
编译原理——语法分析器（C/C++代码实现）
qq_58773908的博客
01-03 1万+
根据编译原理理论课中学习的算术表达式文法，以及该文法LL（1）分析表，用C语言编写接受算术表达式为输入的语法分析器，以控制台（或文本文件，也可以结合词法分析器完成）为输入，控制台（或文件）输出产生式序列形式的分析结果。
【编译原理】简单词法分析程序的实现C语言
qq_51639901的博客
03-27 1万+
编译原理课程的实验二：编制简单词法分析程序。 实验内容：通过了解词法分析程序的功能，设计词法分析程序，通过逐个字符的扫描和分解，能够识别出一个一个单词以及单词的分类；删除注释并进行词法检查，报告所发现的错误（比如标识符不能以数字开头，123aaa就不是合法的标识符），建立符号表。 实验说明：单词通常分为五种类型： （1）基本字：（关键字，保留字）如if else int break等 （2）运算符：如+ - * / = ...
编译原理词法分析器——C语言实现
秋刀鱼丢了水蜜桃
10-31 6974
词法分析器 （一）基本内容 实现一个可以识别C语言（子集）词法的程序，识别源代码中的每个词，并且将结果保存下来。 可识别的词包括 头文件：以#include开头的过滤为头文件 保留字：“auto”, “break”, “case”, “char”, “const”, “continue”, “default”, “do”, “double”, “else”, “enum”, “extern”,“f...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值