精华内容
下载资源
问答
  • 【典型例题精解】1、在C语言程序中,main()函数的位置可以放在任意位置。2、算法的5个基本特征:输入、输出、有穷性、确定性、有效性。3、自顶向下、逐步求精和模块化设计是结构化程序设计方法中最典型、最具有代表...

    2、C语言源程序文件的扩展名是“.c”,经过compile(编译)后生成的文件扩展名为“.obj”,经过Build(连接)后生成的文件扩展名为“.exe”。

    【典型例题精解】

    1、在C语言程序中,main()函数的位置可以放在任意位置。

    2、算法的5个基本特征:输入、输出、有穷性、确定性、有效性。

    3、自顶向下、逐步求精和模块化设计是结构化程序设计方法中最典型、最具有代表性的方法。

    4、面向对象程序设计的主要特征是:封装性、继承性、和多态性。封装性是指把对象的属性和行为封装在一起,并尽可能隐藏对象的内部细节。继承性是指特殊类的对象拥有其一般类的属性和行为的类与类之间的层次关系。多态性是指不同对象收到相同消息时可以产生多种不同的行为方式。

    5、注释说明必须括在/*XXXX*/之间,注释说明被计算机编译系统忽略,注释符/和*之间不能有空格。

    6、Visual C++6.0 IDE的编辑窗口的主要功能是建立并修改程序。

    7、编辑和运行可以不在VC++6.0编译系统环境下进行。

    8、C语言程序中的关键字必须是小写字母。

    9、标准函数存放在库文件中。

    10、C语言源程序属于文本类型的文件,因而可以使用具有文本编辑功能的任何编译器来编辑。

    第二章基本程序设计

    2.1 C语言中最基本的数据类型包括整型、字符型、实型。(P24)

    2.2.3 字符常量:用单引号括起来的一个字符。

    例如:合法的字符常量:‘*’、‘\n’、‘3’、‘\\’,‘A’;

    不合法的:‘bcd’

    (常用的转义字符理解)

    2.2.4字符串常量:用双引号括起来的一串字符。(P24)

    字符串常量以‘\0’为结束标志,如字符串“welcome”在内存中占的字节数是9,而不是8。

    2.2.5 符号常量(P28)

    可以使用#define或const来定义符号常量。

    2.3.2 整型变量(P29)

    1、整型变量的分类,数类型包括:int、short int(或以short表示)、

    long int(或以long表示)。

    设short类型的数据长度为2个字节,

    unsigned short类型数据的取值范围是0~65535即(0~2^16-1)(P31)

    2、整形数据的溢出(什么时候溢出):一个整型变量只能容纳一个范围的数,当数据超过此

    范围时,就会发生溢出,但运行时并不报错。

    下列语句的结果是什么?(P31)

    执行语句“int b=32767 ;printf(”%3d”,b);”结果是32767

    展开全文
  • void gotoxy(int x, int y) //定义gotoxy函数(功能:将光标移动到指定位置说明:gotoxy(x,y)将光标移动到指定行y和列x。设置光标到文本屏幕指定位置,其中参数x,y为文本屏幕坐标。) { COORD coord = {x...
  • 片段: C语言词汇  在C语言中使用...注释可出现在程序中任何位置注释用来向用户提示或解释程序意义。在调试程序中对暂不使用语句也可用注释符括起来,使翻译跳过不作处理,待调试结束后再去掉注释符。
  • 词法分析程序 目录 一、 实验题目 二、 实验要求 三、 程序设计说明 四、 源程序 五、 可执行程序 六、 测试报告: ...检查源程序中存在的词法错误,并报告错误所在的位置。 对源程序中出现的错误进行适当的恢复

    词法分析程序


    目录

    一、 实验题目
    二、 实验要求
    三、 程序设计说明
    四、 源程序
    五、 可执行程序
    六、 测试报告:
    1. 输入
    2. 输出
    3. 分析说明


    一、实验题目

    C语言词法分析程序的设计与实现


    二、实验要求
    1. 可以识别出用C语言编写的源程序中的每个单词符号,并以记号的 形式输出每个单词符号。
    2. 可以识别并跳过源程序中的注释。
    3. 可以统计源程序中的语句行数、各类单词的个数、以及字符总数,并输出统计结果。
    4. 检查源程序中存在的词法错误,并报告错误所在的位置。
    5. 对源程序中出现的错误进行适当的恢复,使词法分析可以继续进行, 对源程序进行一次扫描,即可检查并报告源程序中存在的所有词法错误。

    三、程序设计说明

    1.语言说明
    (1)标识符:以字母或者下划线开头且由字母,数字,下划线组成的符号串
    (2)关键字(c语言常用的32个关键字)

    (3)无符号数:由整数部分,可选的小数部分和可选的指数部分构成。
    (4)关系运算符:<,<=,>,>=,==,!=,&&,||;
    (5)算术运算符:+,+=,-,-=,=,/,/=,%
    (6)逻辑运算符:&,|,!,^,~,?
    (7)标点符号:(,),{,},[,],:,;,
    (8)赋值符号:=
    (9)注释标记:以“/”开始,以“/”结束;“//”
    (10)分隔符:tab,enter,space

    2. 在状态转换图(如下附图),然后进行每一个状态对应一小段程序,构造相应的词法分析程序。
    (1)在开始状态时,首先要读入一个字符。若读入的字符是一个空格(包括blank,tab)就跳过它,继续读字符,直到对你一个非空字符为止。接下来功的工作就是根据所读的非空字符转相应的程序进行处理。
    (2)在标识符状态,识别并组合出一个标识符之后,还必须加入一些动作,如查关键字表,以确定识别出的单词符号是关键字还是用户的自定义标识符,并输出相应的记号和属性。
    (3)在无符号数状态,可识别出各种常数,包括整数,小数和无符号数。
    (4)在’<’状态,若读进的下一个字符是“=”,则输出关系运算符“<=”;若读进的下一个字符是“<”,则输出关系运算符“<<”;否则输出关系运算符“<”。
    (5)在“/”状态,若读进的下一个字符是’*‘ 则进人注释处理状态,词法分析程序要做的工作是跳过注释,具体做法就是不断地读字符,直到遇到“*/”为止,然后转开始状态,继续识别和分析下一个单词;若读进的下一个字符不是“*”,而是“/”,那么即为双斜杠注释符,跳过注释,直到读到该行的回车符,再进行新的字符的读入;如读入的是“=”,那么即为“/=”;否则则输出斜杠“/”。
    (6)在“!”状态﹐若读进的下一个字符是“=”,则输出不等号“!=”;否则,输出感叹号“!”。
    (7)在“=”状态﹐若读进的下一个字符是“=”,则输出相等号“==”;否则,输出等号“=”。
    (8)在“+”状态﹐若读进的下一个字符是“=”,则输出“+=”;否则,输出“+”。
    (9)在“-”状态﹐若读进的下一个字符是“=”,则输出“-=”;否则,输出“-”。
    (10)在“*”状态﹐若读进的下一个字符是“=”,则输出“=”;否则,输出“”。
    (11)在“\n”状态﹐将行数加一,并跳转到新的开始进行读取字符。
    (12)在“””状态,一直读取到相匹配的““”即可。
    (13)在“‘”状态,一直读取到相匹配的“’”即可。
    (14)在“&”状态﹐若读进的下一个字符是“&”,则输出“&&”;否则,输出“&”。
    (15)在“|”状态﹐若读进的下一个字符是“|”,则输出“||”;否则,输出“|”。
    (16)在“#”状态﹐若读进的下一个字符串是“include”或者“define”,则进入头文件的处理。此程序中的头文件处理暂时只支持“include”与“define”两种关键字的识别,并且头文件需要满足“header.h”的格式,否则都会判断为不正确的头文件,并记录错误的行号。
    (17)在其他标点符号状态,只需输出其相应的记号即可。
    (18)若进入错误处理状态,表示词法分析程序从源程序中读入了一个不合法的字符。所谓不合法的字符是指该语言不包括以此字符开头的单词符号。词法分析程序发现不合法字符时,要做错误处理,其主要工作是记录改错行与打印错误信息﹐并跳过这个字符,然后转开始状态继续识别和分析下一个单词符号。
    (19)为了判断是否已经读到单词符号的右端字符,有时需要向前多读人一个字符,比如在标识符状态和无符号数状态,在返回调用程序之前,应将向前指针后退一个字符。
    (20)如果读取的字符是文件结束符,那么即退出词法分析程序,结束分析。

    3.状态转化图(自动机)
    在这里插入图片描述

    4.输入输出形式
    (1)在文件输入与输出,并且格式按照 <行号,记号,单词> 输出。其中关键字不需要属性输出,其记号唯一代表一个关键字。
    对照表见附件“Makert_table.txt”
    (2)输出中包含总字节数,各类单词的个数,语句行数
    (3)输出错误的位置的行号。

    5.定义全局变量和过程
    (1)state:整型变量,当前状态指示。
    (2)ch:字符变量,存放当前读取的字符
    (3)constexpr auto Buffer_len = 2048;
    (4)constexpr auto Half_Buffer_len = 1024;
    (5)//表达式于记号表
    vector<pair<string, string> > MaketTable;
    (6)//记录每一个单词的数量
    map<string, int> NumOfWord;
    (7)//记录错误的位置
    set<int> Errorlocation;
    (8)//记录程序中的字符总数
    long int char_num;
    (9)//记录源程序中的语句行数
    long int statement_lines;
    (10)//符号表
    map<string,int> SymbolTable;
    (11)//符号表指针
    int SymbolPtr = 0;
    (12)//提取字符
    char ExtractingWords(int& StartPointer, int& ForwardPointer, int& cnt, char* Buffer);
    (13)//将字符连接在token之后
    void cat(string& token, const char& ch);
    (14)//判断是否是字符
    bool Is_letter(const char& ch);
    (15)//判断是否是数字
    bool Is_digit(const char& ch);
    (16)//向前指针后退一个字符
    void retract(const char* Buffer, int& ForwardPointer);
    (17)//判断是否是关键字
    string CheckKey(const string &token);
    (18)//文件输出分析后的单词
    void FileOutResult(const string& str,string sttribute = "-");
    (19)//错误处理(方法:记录当前错误地行号,并且跳过当前地字符)
    void error();
    (20)//输出统计结果
    void ShowResult();

    四、源程序
    (附件中包含下列代码的.c文件)

    #define _CRT_SECURE_NO_WARNINGS
    #include<iostream>
    #include<fstream>
    #include<iomanip>
    #include<algorithm>
    #include<string>
    #include<vector>
    #include<cstring> 
    #include<map>
    #include<set>
    using namespace std;
    
    constexpr auto Buffer_len = 2048;
    constexpr auto Half_Buffer_len = 1024;
    
    //表达式于记号表
    vector<pair<string, string> > MaketTable;
    //记录每一个单词的数量
    map<string, int> NumOfWord;
    //记录错误的位置
    set<int> Errorlocation;  
    //记录程序中的字符总数
    long int char_num;
    //记录源程序中的语句行数
    long int statement_lines;
    //符号表
    map<string,int> SymbolTable;
    //符号表指针
    int SymbolPtr = 0;
    //提取字符
    char ExtractingWords(int& StartPointer, int& ForwardPointer, int& cnt, char* Buffer);
    //将字符连接在token之后
    void cat(string& token, const char& ch);
    //判断是否是字符
    bool Is_letter(const char& ch);
    //判断是否是数字
    bool Is_digit(const char& ch);
    //向前指针后退一个字符
    void retract(const char* Buffer, int& ForwardPointer);
    //判断是否是关键字
    string CheckKey(const string &token);
    //文件输出分析后的单词
    void FileOutResult(const string& str,string sttribute = "-");
    //错误处理(方法:记录当前错误地行号,并且跳过当前地字符)
    void error();
    //输出统计结果
    void ShowResult();   
    //分析后的结果输出到该文件
    ofstream F_Out("result.txt", ios::out);
    
    int main()
    {
    	//记号表存储初始化与数据读取
    	ifstream F_MaketTable("Makert_table.txt", ios::in);
    
    	string expression = "", mark = "";
    	if (!F_MaketTable.is_open())
    		cout << "Open file failure" << endl;
    	while (!F_MaketTable.eof()){            // 若未到文件结束一直循环
    		F_MaketTable >> expression >> mark;
    		MaketTable.push_back(make_pair(expression, mark));
    	}
    	F_MaketTable.close();   //关闭文件
    
    	char_num = 0, statement_lines = 1;
    	char ch;
    
    	/**变量声明
    	* left_len : 左缓冲区数量剩余容量
    	* right_len : 右缓冲区数量剩余容量
    	* StartPointer : 开始指针
    	* ForwardPointer : 向前指针
    	* state : 状态
    	*/
    	int cnt = 0, StartPointer = 0, ForwardPointer = Buffer_len - 1, state = 0;
    	char Buffer[Buffer_len];  //缓冲区数组
    	memset(Buffer, '\0', sizeof(Buffer));
    
    	//将输入流定向于文件
    	if (NULL == freopen("test.txt", "r", stdin)) {
    		cout << "test.txt打开失败" << endl;
    		cout << "FAILED!" << endl;
    		return 0;
    	}
    
    	F_Out << "词法分析结果如下所示:" << endl;
    	F_Out << "[Line " << statement_lines << "]:" << endl;
    	string token;	//存储临时提取的单词
    	do {
    		switch (state) {
    		case 0:{
    			token = "";
    			//反复调用TakeWord,去掉空格
    			do {
    				ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			} while (ch == ' ' || ch == '\t');
    			switch (ch) {
    				//设置标识符状态
    				case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':case 'g':case 'h':case 'i':case 'j':
    				case 'k':case 'l':case 'm':case 'n':case 'o':case 'p':case 'q':case 'r':case 's':case 't':
    				case 'u':case 'v':case 'w':case 'x':case 'y':case 'z':case '_':
    				case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':case 'G':case 'H':case 'I':case 'J':
    				case 'K':case 'L':case 'M':case 'N':case 'O':case 'P':case 'Q':case 'R':case 'S':case 'T':
    				case 'U':case 'V':case 'W':case 'X':case 'Y':case 'Z':state = 1; break;
    				//设置常数状态
    				case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':
    				state = 2; break;
    				//设置运算符状态
    				case '<':state = 8; break;
    				case '>':state = 9; break;
    				/*  ?/:/^/&/|/%/(/)/[/]/{/}/,/;  */
    				case'?':case':':case'^':case'%':case'(':case')':case'[':case']':case'{':
    				case'}':case',':case';':case '~':{
    					string temp_ch = "";
    					temp_ch += ch;
    					NumOfWord[temp_ch] += 1;   //统计单词个数
    					FileOutResult(temp_ch);
    					state = 0;
    					break;
    				}
    				case '=':state = 10; break;    //等号或者判断是否相等时的逻辑符号
    				case '+':state = 11; break;    //加或者加等或者加加
    				case '-':state = 12; break;    //减或者减等或者减减
    				case '*':state = 13; break;    //乘或者乘等符号
    				case '/':state = 14; break;    //解释符号或者除号处理
    				case '!':state = 17; break;    //否或者不等号处理
    				case '\n':state = 18; break;   //回车处理
    				case '"':state = 19; break;    //(字符串)语句处理
    				case '&':state = 20; break;    //逻辑与或者取地址
    				case '|':state = 21; break;    //或与逻辑或
    				case '#':state = 22; break;    //头文件等处理
    				case '\'':state = 23; break;   //处理单引号标志
    				default:state = 24; break;     
    			}
    			break;
    		}
    		case 1: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			if (Is_letter(ch) || Is_digit(ch)) state = 1;
    			else {
    				//后退一步前向指针
    				retract(Buffer,ForwardPointer);
    				//转向读取新的单词
    				state = 0;
    				//判断是否是关键字
    				string ans = CheckKey(token);
    				//是关键字时,输出到文件中
    				if (ans != "") {
    					NumOfWord[token] += 1;   //统计单词个数
    					FileOutResult(ans);
    				}
    				//不是关键字而是标识符时
    				else {
    					NumOfWord["id"] += 1;   //统计单词个数
    					string attribute = "";
    					auto mptr = SymbolTable.find(token);
    					//存在时,即提取出属性(入口指针)
    					if (mptr != SymbolTable.end()) {
    						attribute = to_string(mptr->second);
    					}
    					//不存在时,插入,并分配入口指针
    					else {
    						SymbolTable.insert(pair<string,int>(token, SymbolPtr));
    						attribute = to_string(SymbolPtr);
    						SymbolPtr++;
    					}
    					FileOutResult(CheckKey("id"),token);
    				}
    			}
    			break;
    		}
    		case 2: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			switch (ch) {
    				//后面跟着数字
    				case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':state = 2; break;
    				//小数
    				case '.':state = 3; break;
    				//科学计数法
    				case 'E':state = 5; break;
    				default: {
    					NumOfWord["num"] += 1;   //统计单词个数
    					//后退一步前向指针
    					retract(Buffer, ForwardPointer);
    					//转向读取新的单词
    					state = 0;
    					FileOutResult(CheckKey("num"),token);
    					break;
    				}
    			}
    			break;
    		}
    		case 3: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			if (Is_digit(ch)) { state = 4; break; }   //如果是数字,则跳转到状态4 
    			//遇到错误 
    			else {
    				error();
    				state = 0;
    			}
    			break;
    		}
    		case 4: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			switch (ch) {
    				case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':state = 4; break;
    				case 'E':case 'e':state = 5; break;    //后面为数字或者字母E or e 
    				default: {
    					retract(Buffer, ForwardPointer);
    					state = 0;
    					NumOfWord["num"] += 1;   //统计单词个数
    					FileOutResult(CheckKey("num"),token);
    					break;
    				}
    			}
    			break;
    		}
    		case 5: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			switch (ch) {
    				case '0':case '1':case '2':case '3':case '4':case '5':case '6':case '7':case '8':case '9':state = 7; break;
    				case '+':case'-':state = 6; break;    //后面跟着+ or -或者数字时 
    				default: {
    					retract(Buffer, ForwardPointer);   //回退一个 
    					error();   //记录错误行号 
    					state = 0;
    					break;
    				}
    			}
    			break;
    		}
    		case 6: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			if (Is_digit(ch)) { state = 7; break; }   //遇到数字,则跳转到状态7 
    			else {
    				retract(Buffer, ForwardPointer);    //回退一个 
    				error();       //记录错误行号 
    				state = 0;
    				break;
    			}
    			break;
    		}
    		case 7: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			if (Is_digit(ch)) { state = 7; break; }
    			else {
    				NumOfWord["num"] += 1;   //统计单词个数
    				FileOutResult(CheckKey("num"),token);
    				retract(Buffer, ForwardPointer);
    				state = 0;
    			}
    			break;
    		}
    		case 8: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			switch (ch) {
    				//存在小于或者小于等于地两种情况时 
    				case '<':cat(token, ch); NumOfWord[token] += 1; state = 0; FileOutResult(CheckKey("<<")); break;
    				case '=':cat(token, ch); NumOfWord[token] += 1; state = 0; FileOutResult(CheckKey("<=")); break;
    				default: {
    					NumOfWord[token] += 1;
    					FileOutResult(CheckKey("<"));
    					retract(Buffer, ForwardPointer);
    					state = 0;
    					break;
    				}
    			}
    			break;
    		}
    		case 9: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			switch (ch) {
    				//存在大于或者大于等于时 
    				case '>':cat(token, ch); NumOfWord[token] += 1; state = 0; FileOutResult(CheckKey(">>")); break;
    				case '=':cat(token, ch); NumOfWord[token] += 1; state = 0; FileOutResult(CheckKey(">=")); break;
    				default: {
    					NumOfWord[token] += 1;
    					FileOutResult(CheckKey(">"));
    					retract(Buffer, ForwardPointer);
    					state = 0;
    					break;
    				}
    			}
    			break;
    		}
    		case 10: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			//存在等于或者判断是否相等地符号时 
    			if (ch == '=') {
    				cat(token, ch); NumOfWord[token] += 1;state = 0; FileOutResult(CheckKey("=="));
    			}
    			else {
    				NumOfWord["assign-op"] += 1;
    				FileOutResult(CheckKey("="));
    				retract(Buffer, ForwardPointer);
    				state = 0;
    			}
    			break;
    		}
    		case 11: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			switch (ch) {
    				//判断加号或者加+=时 
    				case '+':cat(token, ch);state = 0; FileOutResult(CheckKey("++")); break;
    				case '=':cat(token, ch);state = 0; FileOutResult(CheckKey("+=")); break;
    				default: {
    					FileOutResult(CheckKey("+"));
    					retract(Buffer, ForwardPointer);
    					state = 0;
    					break;
    				}
    			}
    			NumOfWord[token] += 1;
    			break;
    		}
    		case 12: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			switch (ch) {
    				//判断-=或者减号时 
    				case '-':cat(token, ch); state = 0; FileOutResult(CheckKey("--")); break;
    				case '=':cat(token, ch); state = 0; FileOutResult(CheckKey("-=")); break;
    				default: {
    					FileOutResult(CheckKey("-"));
    					retract(Buffer, ForwardPointer);
    					state = 0;
    					break;
    				}
    			}
    			NumOfWord[token] += 1;
    			break;
    		}
    		case 13:{
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			//判断*或者*=时 
    			if (ch == '=') {
    				cat(token, ch); state = 0; FileOutResult(CheckKey("*="));
    			}
    			else {
    				FileOutResult(CheckKey("*"));
    				retract(Buffer, ForwardPointer);
    				state = 0;
    			}
    			NumOfWord[token] += 1;
    			break;
    		}
    		case 14: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			switch (ch) {
    				case'*':state = 15; break;   //为“/* ”时 
    				case'/':state = 16; break;   //为“// ”时 
    				case'=':cat(token, ch); NumOfWord[token] += 1; state = 0; FileOutResult(CheckKey("/=")); break;  //为“/= ”时 
    				default: {
    					NumOfWord[token] += 1;
    					FileOutResult("/");
    					retract(Buffer, ForwardPointer);
    					state = 0;
    					break;
    				}
    			}
    			break;
    		}
    		case 15: {
    			//判断"*/" 
    			do {
    				ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    				if (ch == '\n') {    //遇到回车时,即换一行,行数增加一 
    					NumOfWord["enter"] += 1;
    					statement_lines++;
    					F_Out << "[Line " << statement_lines << "]:" << endl;     //输出每一行的行号 
    				}
    			} while (ch != '*' && ch != EOF);
    			//遇到文件结束符时 
    			if (ch == EOF) {
    				error();
    				break;
    			}
    			else {
    				ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    				if (ch == '/') state = 0;
    				else
    					state = 15;
    				break;
    			}
    		}
    		case 16: {
    			//判断“// ”的结束 
    			do {
    				ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			} while (ch != '\n' && ch != EOF);
    			retract(Buffer, ForwardPointer);
    			state = 0;
    			break;
    		}
    		case 17: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			//为“!= ”时 
    			if (ch == '=') {
    				cat(token, ch); state = 0; FileOutResult(CheckKey("!="));
    			}
    			//为 “!”时 
    			else {
    				FileOutResult(CheckKey("!"));
    				retract(Buffer, ForwardPointer);
    				state = 0;
    			}
    			NumOfWord[token] += 1;   //统计单词个数
    			break;
    		}
    		case 18: {
    			//遇见回车时 
    			NumOfWord["enter"] += 1;
    			++statement_lines;
    			F_Out << "[Line " << statement_lines << "]:" << endl;
    			state = 0;
    			break;
    		}
    		case 19: {
    			//遇见双引号时 
    			string str = "";
    			do {
    				ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    				str += ch;
    			} while (ch != '"' && ch != '\n' && ch != EOF);
    			if (ch == '"') {
    				str.erase(str.end() - 1);
    				FileOutResult(CheckKey("\"\""),str);
    				NumOfWord["literal"] += 1;
    			}
    			else {
    				Errorlocation.insert(statement_lines);    //记录该错误所在的行号
    				retract(Buffer, ForwardPointer);  //回退一步,进行相应处理
    			}
    			state = 0;
    			break;
    		}
    		case 20: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			//为“&& ”时 
    			if (ch == '&') {
    				cat(token, ch); state = 0; FileOutResult(CheckKey("&&"));
    			}
    			//为 “& ”时 
    			else {
    				FileOutResult(CheckKey("&"));
    				retract(Buffer, ForwardPointer);
    				state = 0;
    			}
    			NumOfWord[token] += 1;
    			break;
    		}
    		case 21: {
    			cat(token, ch);
    			ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    			//为““|| ”时 
    			if (ch == '|') {
    				cat(token, ch); state = 0; FileOutResult(CheckKey("||"));
    			}
    			//为“|”时 
    			else {
    				FileOutResult(CheckKey("|"));
    				retract(Buffer, ForwardPointer);
    				state = 0;
    			}
    			NumOfWord[token] += 1;
    			break;
    		}
    		case 22: {
    			//头文件的处理 
    			string str = "";
    			cat(token, ch);
    			NumOfWord[token] += 1;
    			FileOutResult(CheckKey(token));
    			do {
    				ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    				str += ch;
    			} while (Is_letter(ch) && ch != EOF);
    			if(ch == EOF){
    				retract(Buffer, ForwardPointer);
    				state = 0;
    				break;
    			}
    			str.erase(str.end() - 1);
    			retract(Buffer, ForwardPointer);
    			//为头文件时或者为宏定义时
    			int flag = 0;
    			if (str == "include" || str == "define") {
    				flag = 1;
    				NumOfWord[str] += 1;
    				FileOutResult(CheckKey(str));
    				//消除空格
    				do {
    					ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    				} while (ch == ' ');
    
    				//自定义文件头
    				if (str == "include" && (ch == '"' || ch == '<')) {
    					str = "";
    					do {
    						ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    						str += ch;
    					} while (ch != '\n' && ch != EOF);
    					if (ch == EOF) {
    						retract(Buffer, ForwardPointer);
    						state = 0;
    						break;
    					}
    					retract(Buffer, ForwardPointer);
    					str.erase(str.end() - 1);
    					str.erase(std::remove(str.begin(), str.end(), ' '), str.end());
    					auto p = str.find('.');
    					if (p == str.npos) {
    						flag = 0;
    					}
    					else {
    						if (p + 2 < str.size() && str[p + 1] == 'h' && (str[p + 2] == '\"' || str[p + 2] == '>')) {
    							str.erase(str.end() - 1);
    							NumOfWord["header_file"] += 1;
    							FileOutResult("header_file",str);
    						}
    						else
    							flag = 0;
    					}
    				}
    				else if (str == "define") {
    					retract(Buffer, ForwardPointer);
    					state = 0;
    					break;
    				}
    				else {
    					flag = 0;
    				}
    			}
    			//两者都不是时,即错误
    			if(flag == 0) {
    				error();
    			}
    			state = 0;
    			break;
    		}
    		case 23:{
    			//单引号的处理 
    			string str = "";
    			do {
    				ch = ExtractingWords(StartPointer, ForwardPointer, cnt, Buffer);
    				str += ch;
    			} while (ch != '\'' && ch != '\n' && ch != EOF);
    			if (ch == '\'') {
    				str.erase(str.end() - 1);
    				FileOutResult(CheckKey("''"), str);
    				NumOfWord["ch"] += 1;
    			}
    			else {
    				Errorlocation.insert(statement_lines);    //记录该错误所在的行号
    				if (ch == EOF) {
    					retract(Buffer, ForwardPointer);
    					state = 0;
    					break;
    				}
    			}
    			state = 0;
    			break;
    		}
    		case 24: {
    			//错误处理 
    			error();
    			state = 0;
    			break;
    		}
    		}
    	} while (ch != EOF);
    	fclose(stdin);//关闭文件
    
    	//输出统计信息到输出文件中
    	ShowResult(); 
    	F_Out.close();
    	cout << "Lexical Analysis Succeed!" << endl;
    	return 0;
    }
    
    char ExtractingWords(int& StartPointer, int& ForwardPointer, int& cnt, char* Buffer)
    {
    	char ch;   //存储临时读入的字符
    	//向前指针在左半区的终点时
    
    	if (ForwardPointer == Half_Buffer_len - 1) {
    		while (cnt < Buffer_len && (ch = getchar()) != EOF) {
    			Buffer[cnt++] = ch;
    		}
    		//读完文件时,一般的缓冲区没有填满时,即处于结束状态
    		if (ch == EOF) {
    			Buffer[cnt++] = EOF;
    		}
    		cnt = 0;
    		++ForwardPointer;
    	}
    	//向前指针在右半区的终点时
    	else if (ForwardPointer == Buffer_len - 1) {
    		while (cnt < Half_Buffer_len && (ch = getchar()) != EOF) {
    			Buffer[cnt++] = ch;
    		}
    		//读完文件时,一般的缓冲区没有填满时,即处于结束状态
    		if (ch == EOF) {
    			Buffer[cnt++] = EOF;
    		}
    		ForwardPointer = 0;
    	}
    	else {
    		++ForwardPointer;
    	}
    	if(Buffer[ForwardPointer] == '\n' || Buffer[ForwardPointer] == '\t')
    		char_num += 2;  //字符总数加二
    	else
    		char_num ++;   //字符总数加一
    	return Buffer[ForwardPointer];
    }
    
     
    void cat(string& token, const char& ch)
    {
    	token += ch;
    }
    
    bool Is_letter(const char& ch)
    {
    	return (isalpha(ch) || ch == '_');
    }
    
    bool Is_digit(const char& ch)
    {
    	return isdigit(ch);
    }
    
    void retract(const char* Buffer,int &ForwardPointer)
    {
    	//当目前所读的字母为回车或者制表符号的时候 ,字符数目 -2  
    	if (Buffer[ForwardPointer] == '\n' || Buffer[ForwardPointer] == '\t')
    		char_num -= 2;
    	else
    		--char_num;  //字符总数减一
    	--ForwardPointer;
    	return;
    }
    
    string CheckKey(const string & token)
    {
    	string str = "";
    	for (auto it : MaketTable) {
    		if (it.first == token)
    			return it.second;
    	}
    	return str;
    }
    
    void FileOutResult(const string &str, string attribute)  
    {
    	//输出格式按照 “<记号,属性>”输出 
    	F_Out <<"	< ' "<< str <<" '  ,  "<< attribute <<" >" << endl;
    }
    
    void error()
    {
    	Errorlocation.insert(statement_lines);    //记录该错误所在的行号
    	return;
    }
    
    void ShowResult()
    {
    	F_Out << endl << "-------以上源程序语句分析后的统计结果如下所示-------" << endl;
    	F_Out << "语句行数:" << statement_lines << endl << endl;
    	F_Out << "字符总数:" << char_num << endl << endl;
    	F_Out << "单词数目(单词,单词数量):" << endl;
    	for (auto it : NumOfWord) {
    		F_Out << "( “ "<< it.first <<" ” , " << it.second <<" ) "<< endl;
    	}
    	F_Out << endl;
    	if (Errorlocation.empty())
    		F_Out << "源程序中不存在词法错误信息" << endl;
    	else {
    		F_Out << "源程序中存在的词法错误,行号如下所示:" << endl << "Line: ";
    		for (auto it : Errorlocation)
    			F_Out << "  " << it;
    	}
    	return;
    }
    

    五、可执行程序
    见附件

    六、测试报告:

    1.输入

    #include<stdio.h> 
    #include "123.h"  
    #include "123.p"  
    #define ERROR -1
    #define ACCEPT 5
    #define START 0
    #define Q1 1
    #
    #define Q2 2
    #define Q3 3
    #define Q4 4
    main()
    {
    	ch@ar ch; //读入的字符
    	int state=START; 
    	int test1 = 1E3a;
    	int test2 = 1.23e+34;
    	int test3 = 1.23E-2A;
    	int test4 = 1.a;
    	int test5 = 1.23Ew;		 
    	while(state!=ACCEPT && state!=ERROR)
    	{
    	    scanf("%c",&ch);
    	    switch(state)
    	    {
    	       case START: 
    		  if(ch=='a') state=Q1;
    		  else if(ch=='b') state=Q2; 
    		       else state=ERROR; 
    		  break;
    	     case Q1: 
                                 if(ch=='b') state=Q3;
                                 else state=ERROR; 
                                 break;
    	
      case Q2: 
         if(ch=='a') state=Q4;
         else state=ERROR; break;
      case Q3: 
         if (ch=='b') state=Q3; 
         else if(ch=='a') state=ACCEPT; 
                else state=ERROR; break;
      case Q4: 
    
         if (ch=='a) state=Q4 + 1.34E-'123;/* Here
    	is a test point,you can see here and how output?* */
         else if(ch=='b') state=ACCEPT; 
                 else state=ERROR; 
         break;
     }
    }
    if(state==ACCEPT)
       printf("valid string");
    else
       printf("invalid string);
    	//return 0;
    	/*int a = 3;
    }
    

    2.输出
    词法分析结果如下所示:

    [Line 1]:
    	< 1 ,‘ # '  ,  - >
    	< 1 ,‘ include '  ,  - >
    	< 1 ,‘ header_file '  ,  stdio.h >
    [Line 2]:
    	< 2 ,‘ # '  ,  - >
    	< 2 ,‘ include '  ,  - >
    	< 2 ,‘ header_file '  ,  123.h >
    [Line 3]:
    	< 3 ,‘ # '  ,  - >
    	< 3 ,‘ include '  ,  - >
    [Line 4]:
    	< 4 ,‘ # '  ,  - >
    	< 4 ,‘ define '  ,  - >
    	< 4 ,‘ id '  ,  ERROR >
    	< 4 ,‘ - '  ,  - >
    	< 4 ,‘ num '  ,  1 >
    [Line 5]:
    	< 5 ,‘ # '  ,  - >
    	< 5 ,‘ define '  ,  - >
    	< 5 ,‘ id '  ,  ACCEPT >
    	< 5 ,‘ num '  ,  5 >
    [Line 6]:
    	< 6 ,‘ # '  ,  - >
    	< 6 ,‘ define '  ,  - >
    	< 6 ,‘ id '  ,  START >
    	< 6 ,‘ num '  ,  0 >
    [Line 7]:
    	< 7 ,‘ # '  ,  - >
    	< 7 ,‘ define '  ,  - >
    	< 7 ,‘ id '  ,  Q1 >
    	< 7 ,‘ num '  ,  1 >
    [Line 8]:
    	< 8 ,‘ # '  ,  - >
    [Line 9]:
    	< 9 ,‘ # '  ,  - >
    	< 9 ,‘ define '  ,  - >
    	< 9 ,‘ id '  ,  Q2 >
    	< 9 ,‘ num '  ,  2 >
    [Line 10]:
    	< 10 ,‘ # '  ,  - >
    	< 10 ,‘ define '  ,  - >
    	< 10 ,‘ id '  ,  Q3 >
    	< 10 ,‘ num '  ,  3 >
    [Line 11]:
    	< 11 ,‘ # '  ,  - >
    	< 11 ,‘ define '  ,  - >
    	< 11 ,‘ id '  ,  Q4 >
    	< 11 ,‘ num '  ,  4 >
    [Line 12]:
    	< 12 ,‘ main '  ,  - >
    	< 12 ,‘ ( '  ,  - >
    	< 12 ,‘ ) '  ,  - >
    [Line 13]:
    	< 13 ,‘ { '  ,  - >
    [Line 14]:
    	< 14 ,‘ id '  ,  ch >
    	< 14 ,‘ id '  ,  ar >
    	< 14 ,‘ id '  ,  ch >
    	< 14 ,‘ ; '  ,  - >
    [Line 15]:
    	< 15 ,‘ int '  ,  - >
    	< 15 ,‘ id '  ,  state >
    	< 15 ,‘ assign-op '  ,  - >
    	< 15 ,‘ id '  ,  START >
    	< 15 ,‘ ; '  ,  - >
    [Line 16]:
    	< 16 ,‘ int '  ,  - >
    	< 16 ,‘ id '  ,  test1 >
    	< 16 ,‘ assign-op '  ,  - >
    	< 16 ,‘ num '  ,  1E3 >
    	< 16 ,‘ id '  ,  a >
    	< 16 ,‘ ; '  ,  - >
    [Line 17]:
    	< 17 ,‘ int '  ,  - >
    	< 17 ,‘ id '  ,  test2 >
    	< 17 ,‘ assign-op '  ,  - >
    	< 17 ,‘ num '  ,  1.23e+34 >
    	< 17 ,‘ ; '  ,  - >
    [Line 18]:
    	< 18 ,‘ int '  ,  - >
    	< 18 ,‘ id '  ,  test3 >
    	< 18 ,‘ assign-op '  ,  - >
    	< 18 ,‘ num '  ,  1.23E-2 >
    	< 18 ,‘ id '  ,  A >
    	< 18 ,‘ ; '  ,  - >
    [Line 19]:
    	< 19 ,‘ int '  ,  - >
    	< 19 ,‘ id '  ,  test4 >
    	< 19 ,‘ assign-op '  ,  - >
    	< 19 ,‘ ; '  ,  - >
    [Line 20]:
    	< 20 ,‘ int '  ,  - >
    	< 20 ,‘ id '  ,  test5 >
    	< 20 ,‘ assign-op '  ,  - >
    	< 20 ,‘ id '  ,  w >
    	< 20 ,‘ ; '  ,  - >
    [Line 21]:
    	< 21 ,‘ while '  ,  - >
    	< 21 ,‘ ( '  ,  - >
    	< 21 ,‘ id '  ,  state >
    	< 21 ,‘ != '  ,  - >
    	< 21 ,‘ id '  ,  ACCEPT >
    	< 21 ,‘ && '  ,  - >
    	< 21 ,‘ id '  ,  state >
    	< 21 ,‘ != '  ,  - >
    	< 21 ,‘ id '  ,  ERROR >
    	< 21 ,‘ ) '  ,  - >
    [Line 22]:
    	< 22 ,‘ { '  ,  - >
    [Line 23]:
    	< 23 ,‘ scanf '  ,  - >
    	< 23 ,‘ ( '  ,  - >
    	< 23 ,‘ literal '  ,  %c >
    	< 23 ,‘ , '  ,  - >
    	< 23 ,‘ & '  ,  - >
    	< 23 ,‘ id '  ,  ch >
    	< 23 ,‘ ) '  ,  - >
    	< 23 ,‘ ; '  ,  - >
    [Line 24]:
    	< 24 ,‘ switch '  ,  - >
    	< 24 ,‘ ( '  ,  - >
    	< 24 ,‘ id '  ,  state >
    	< 24 ,‘ ) '  ,  - >
    [Line 25]:
    	< 25 ,‘ { '  ,  - >
    [Line 26]:
    	< 26 ,‘ case '  ,  - >
    	< 26 ,‘ id '  ,  START >
    	< 26 ,‘ : '  ,  - >
    [Line 27]:
    	< 27 ,‘ if '  ,  - >
    	< 27 ,‘ ( '  ,  - >
    	< 27 ,‘ id '  ,  ch >
    	< 27 ,‘ == '  ,  - >
    	< 27 ,‘ ch '  ,  a >
    	< 27 ,‘ ) '  ,  - >
    	< 27 ,‘ id '  ,  state >
    	< 27 ,‘ assign-op '  ,  - >
    	< 27 ,‘ id '  ,  Q1 >
    	< 27 ,‘ ; '  ,  - >
    [Line 28]:
    	< 28 ,‘ else '  ,  - >
    	< 28 ,‘ if '  ,  - >
    	< 28 ,‘ ( '  ,  - >
    	< 28 ,‘ id '  ,  ch >
    	< 28 ,‘ == '  ,  - >
    	< 28 ,‘ ch '  ,  b >
    	< 28 ,‘ ) '  ,  - >
    	< 28 ,‘ id '  ,  state >
    	< 28 ,‘ assign-op '  ,  - >
    	< 28 ,‘ id '  ,  Q2 >
    	< 28 ,‘ ; '  ,  - >
    [Line 29]:
    	< 29 ,‘ else '  ,  - >
    	< 29 ,‘ id '  ,  state >
    	< 29 ,‘ assign-op '  ,  - >
    	< 29 ,‘ id '  ,  ERROR >
    	< 29 ,‘ ; '  ,  - >
    [Line 30]:
    	< 30 ,‘ break '  ,  - >
    	< 30 ,‘ ; '  ,  - >
    [Line 31]:
    	< 31 ,‘ case '  ,  - >
    	< 31 ,‘ id '  ,  Q1 >
    	< 31 ,‘ : '  ,  - >
    [Line 32]:
    	< 32 ,‘ if '  ,  - >
    	< 32 ,‘ ( '  ,  - >
    	< 32 ,‘ id '  ,  ch >
    	< 32 ,‘ == '  ,  - >
    	< 32 ,‘ ch '  ,  b >
    	< 32 ,‘ ) '  ,  - >
    	< 32 ,‘ id '  ,  state >
    	< 32 ,‘ assign-op '  ,  - >
    	< 32 ,‘ id '  ,  Q3 >
    	< 32 ,‘ ; '  ,  - >
    [Line 33]:
    	< 33 ,‘ else '  ,  - >
    	< 33 ,‘ id '  ,  state >
    	< 33 ,‘ assign-op '  ,  - >
    	< 33 ,‘ id '  ,  ERROR >
    	< 33 ,‘ ; '  ,  - >
    [Line 34]:
    	< 34 ,‘ break '  ,  - >
    	< 34 ,‘ ; '  ,  - >
    [Line 35]:
    [Line 36]:
    	< 36 ,‘ case '  ,  - >
    	< 36 ,‘ id '  ,  Q2 >
    	< 36 ,‘ : '  ,  - >
    [Line 37]:
    	< 37 ,‘ if '  ,  - >
    	< 37 ,‘ ( '  ,  - >
    	< 37 ,‘ id '  ,  ch >
    	< 37 ,‘ == '  ,  - >
    	< 37 ,‘ ch '  ,  a >
    	< 37 ,‘ ) '  ,  - >
    	< 37 ,‘ id '  ,  state >
    	< 37 ,‘ assign-op '  ,  - >
    	< 37 ,‘ id '  ,  Q4 >
    	< 37 ,‘ ; '  ,  - >
    [Line 38]:
    	< 38 ,‘ else '  ,  - >
    	< 38 ,‘ id '  ,  state >
    	< 38 ,‘ assign-op '  ,  - >
    	< 38 ,‘ id '  ,  ERROR >
    	< 38 ,‘ ; '  ,  - >
    	< 38 ,‘ break '  ,  - >
    	< 38 ,‘ ; '  ,  - >
    [Line 39]:
    	< 39 ,‘ case '  ,  - >
    	< 39 ,‘ id '  ,  Q3 >
    	< 39 ,‘ : '  ,  - >
    [Line 40]:
    	< 40 ,‘ if '  ,  - >
    	< 40 ,‘ ( '  ,  - >
    	< 40 ,‘ id '  ,  ch >
    	< 40 ,‘ == '  ,  - >
    	< 40 ,‘ ch '  ,  b >
    	< 40 ,‘ ) '  ,  - >
    	< 40 ,‘ id '  ,  state >
    	< 40 ,‘ assign-op '  ,  - >
    	< 40 ,‘ id '  ,  Q3 >
    	< 40 ,‘ ; '  ,  - >
    [Line 41]:
    	< 41 ,‘ else '  ,  - >
    	< 41 ,‘ if '  ,  - >
    	< 41 ,‘ ( '  ,  - >
    	< 41 ,‘ id '  ,  ch >
    	< 41 ,‘ == '  ,  - >
    	< 41 ,‘ ch '  ,  a >
    	< 41 ,‘ ) '  ,  - >
    	< 41 ,‘ id '  ,  state >
    	< 41 ,‘ assign-op '  ,  - >
    	< 41 ,‘ id '  ,  ACCEPT >
    	< 41 ,‘ ; '  ,  - >
    [Line 42]:
    	< 42 ,‘ else '  ,  - >
    	< 42 ,‘ id '  ,  state >
    	< 42 ,‘ assign-op '  ,  - >
    	< 42 ,‘ id '  ,  ERROR >
    	< 42 ,‘ ; '  ,  - >
    	< 42 ,‘ break '  ,  - >
    	< 42 ,‘ ; '  ,  - >
    [Line 43]:
    	< 43 ,‘ case '  ,  - >
    	< 43 ,‘ id '  ,  Q4 >
    	< 43 ,‘ : '  ,  - >
    [Line 44]:
    [Line 45]:
    	< 45 ,‘ if '  ,  - >
    	< 45 ,‘ ( '  ,  - >
    	< 45 ,‘ id '  ,  ch >
    	< 45 ,‘ == '  ,  - >
    	< 45 ,‘ ch '  ,  a) state=Q4 + 1.34E- >
    	< 45 ,‘ num '  ,  123 >
    	< 45 ,‘ ; '  ,  - >
    [Line 46]:
    [Line 47]:
    	< 47 ,‘ else '  ,  - >
    	< 47 ,‘ if '  ,  - >
    	< 47 ,‘ ( '  ,  - >
    	< 47 ,‘ id '  ,  ch >
    	< 47 ,‘ == '  ,  - >
    	< 47 ,‘ ch '  ,  b >
    	< 47 ,‘ ) '  ,  - >
    	< 47 ,‘ id '  ,  state >
    	< 47 ,‘ assign-op '  ,  - >
    	< 47 ,‘ id '  ,  ACCEPT >
    	< 47 ,‘ ; '  ,  - >
    [Line 48]:
    	< 48 ,‘ else '  ,  - >
    	< 48 ,‘ id '  ,  state >
    	< 48 ,‘ assign-op '  ,  - >
    	< 48 ,‘ id '  ,  ERROR >
    	< 48 ,‘ ; '  ,  - >
    [Line 49]:
    	< 49 ,‘ break '  ,  - >
    	< 49 ,‘ ; '  ,  - >
    [Line 50]:
    	< 50 ,‘ } '  ,  - >
    [Line 51]:
    	< 51 ,‘ } '  ,  - >
    [Line 52]:
    	< 52 ,‘ if '  ,  - >
    	< 52 ,‘ ( '  ,  - >
    	< 52 ,‘ id '  ,  state >
    	< 52 ,‘ == '  ,  - >
    	< 52 ,‘ id '  ,  ACCEPT >
    	< 52 ,‘ ) '  ,  - >
    [Line 53]:
    	< 53 ,‘ printf '  ,  - >
    	< 53 ,‘ ( '  ,  - >
    	< 53 ,‘ literal '  ,  valid string >
    	< 53 ,‘ ) '  ,  - >
    	< 53 ,‘ ; '  ,  - >
    [Line 54]:
    	< 54 ,‘ else '  ,  - >
    [Line 55]:
    	< 55 ,‘ printf '  ,  - >
    	< 55 ,‘ ( '  ,  - >
    [Line 56]:
    [Line 57]:
    [Line 58]:
    

    -------以上源程序语句分析后的统计结果如下所示-------
    语句行数:58

    字符总数:1261

    单词数目(单词,单词数量):
    ( “ != ” , 2 )
    ( “ # ” , 11 )
    ( “ & ” , 1 )
    ( “ && ” , 1 )
    ( “ ( ” , 15 )
    ( “ ) ” , 13 )
    ( “ , ” , 1 )
    ( “ - ” , 1 )
    ( “ : ” , 5 )
    ( “ ; ” , 27 )
    ( “ == ” , 9 )
    ( “ assign-op ” , 18 )
    ( “ break ” , 5 )
    ( “ case ” , 5 )
    ( “ ch ” , 8 )
    ( “ define ” , 7 )
    ( “ else ” , 9 )
    ( “ enter ” , 57 )
    ( “ header_file ” , 2 )
    ( “ id ” , 65 )
    ( “ if ” , 9 )
    ( “ include ” , 3 )
    ( “ int ” , 6 )
    ( “ literal ” , 2 )
    ( “ main ” , 1 )
    ( “ num ” , 11 )
    ( “ printf ” , 2 )
    ( “ scanf ” , 1 )
    ( “ switch ” , 1 )
    ( “ while ” , 1 )
    ( “ { ” , 3 )
    ( “ } ” , 2 )

    源程序中存在的词法错误,行号如下所示:
    Line: 14 19 20 55 58


    3.分析说明
    1.关键词的符号与属性的对照表是从文件中进行读取的,因此在运行程序之前,需要将相应的对照表与.c文件放在同一个目录下。
    2.关键词或者自定义的标识符的输出时,关键词只会输出记号而关键词的属性就没有输出,用‘-’代替;自定义的标识符输出时,如果是字符串或者单引号字符,则会在属性的地方输出引号中的内容或者字符内容。
    3.记录字符的个数时,会将文件中的所有字符都计算在内,包括解释语句的所有内容(注意,此时如果注释是中文,那么在计算字符个数的时候,在此程序中,会将中文汉字按照一个汉字一个字符数目计算)。
    4.回车和制表符在此程序中都当作两个字符进行计数。
    5.错误处理
    (1)上述示例代码的第14行,“ch@ar”很明显,‘@’是非法字符,那么处理这个错误的时候,将‘@’直接跳过,接着处理“ar”,将“ar”也当作一个自定义标识符进行处理,记录错误的行号14。
    (2)第19,20行,指数的输入规则错误,第19行错在1.a,第20行错在指数的后面跟着字符。但是分析的时候,会将如上述第19列所示的将‘w’当作一个字符进行处理,并且写进了符号表中。记录错误的行号19,20。
    (3)第45行的注释符处理,正常理解执行即可。
    (4)第57行的注释符处理,因为找不到与第57行的注释符匹配的符号,导致直到源程序代码结束,都没有遇到“*/”,那么对该中情况的处理,将会是将“/*”之后的内容全部忽略掉,然后错误处理(即记录/*所在的行号)。记录错误的行号58(即记录最后为程序代码结束的行号)。
    (5)第55行所在的输出时,“”””英文双引号不匹配,缺少了右边的对应的双引号,导致词法分析错误,这种错误的处理,就是读到回车时或者文件结束符号的时候,才会进行新的一个字符的读取。当然,会记录以上错误所发生的行号55。


    如需下载完整文档及代码,请跳转下载链接

    展开全文
  • 你必须知道495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    2.17 C语言中有和Pascalwith等价语句吗? 2.18 既然数组名可以用作数组基地址,为什么对结构不能这样? 2.19 程序运行正确,但退出时却“coredump”(核心转储)了,怎么回事? 联合 2.20 结构和联合有...
  • C语言基础知识

    2018-07-12 11:07:27
    是对程序的说明,可出现在程序中任意合适地方。注释不可以嵌套。 【要点5】书写格式 每条语句后面必须有一个分号。一行内可写多条语句,一个语句可写在多行上。 【要点6】标识符 ………………
  •  需要说明的是,C语言规定对scanf和printf这两个函数可以省去对其头文件的包含命令。所以在本例中也可以删去第二行的包含命令#include。同样,在例1.1中使用了printf函数,也省略了包含命令。  在例题中的主函数体...
  • C语言预处理命令

    2013-01-15 09:21:00
    首先要说明的C语言的预处理命令是在去掉注释之后才进行的。有时因为注释的存在会对预处理有影响,去注释就是将注释换成空格。1.预处理指令不是C语言本身的组成部分,更不是C语言语句:他是C语言标准规定的可以出现...

    首先要说明的是C语言的预处理命令是在去掉注释之后才进行的。有时因为注释的存在会对预处理有影响,去注释就是将注释换成空格。

    1.预处理指令不是C语言本身的组成部分,更不是C语言语句:他是C语言标准规定的可以出现在C源程序的文件中的命令。这些命令必须以#开头,结尾不加分号,可以放置在源程序的任何位置,其有效范围是从现在位置开始到源程序文件末尾。

    2,预处理指令的操作对象是编译器和连接器:用来设置程序编译和链接的各种参数。

    3.C语言标准提供了多种预处理命令,包括文件包含、宏定义、条件编译。

    1.宏定义:
        1.不带参数的宏定义:#define 宏名 [空格] 字符文本
    说明:1.宏名按标识符语法取,习惯上用大写字母。2.字符文本可以为C各种符号(包括关键字)

    注意:
    1.一个宏名不要重复定义多次,否则引用的宏名是最后一次的宏定义。

    2.#undef 宏名 命令的作用是取消已有的宏定义。
    3.宏定义允许嵌套,即在宏定义的字符文本中可以引用已经定义的宏名,在宏替换时由预处理器层层替换。
    例如:
        #define WIDTH 80
        #define LENGTH (WIDTH+10)
        L=WIDTH * a
         S=LENGTH * b * WIDTH

    2.带参数的宏定义:
    #define 宏名(参数列表) 字符文本
    引用的形式:
        宏名(参数列表)


    注意:无论带参数的宏还是不带参数的宏如果想要定义多行可以用 \ 续行


    3.#和##预处理运算
    C语言标准为预处理命令定义了两个运算符:#和##,他们在预处理时被执行。
    #运算符的作用是文本参数"字符串化",即出现在宏定义的字符文本中的#把跟在后面的参数转化为一个C语言常量。

    例如:
    #define PRINT_MSG1(x) printf(#x"\n")//加点料
    PRINT_MSG1(hel loworld)//加点料,工作正常cout不可以
    简单来说,#运算符的作用就是对这个参数替换后,再加上双引号括起来,变为参数

    ##运算符的作用是将两个字符文本连接成一个字符文本,如果其中一个字符文本是宏定义的参数,连接会在参数替换后发生。
    例如:
    #define SET1(arg) A##arg=arg;
    #define SET2(x) Aarg=arg
    SET(1)//A1=1;
    SET2(1)//Aarg=1;


    4.预定义的宏
    C语言标准中预先定义了一些有用的符号常量,这些符号常量主要是编译信息,如:
    其中是两个'_',__DATE__(字符串类型,MM DD YYYY)和__TIME__(字符串常量 hh:mm:ss)用于指明程序的编译的时间,__FILE__(字符串常量,编译程序文件名)和__LINE__(int,代码的行号)用于调试目地,__STDC__(int ,ANSI C 标志 若为1表明程序兼容ANSI标准)检测系统是否支持C语言标准。

    例如:

    #include <stdio.h>
    #include <stdlib.h>

    int main(int argc,char * argv[])
    {
        printf("the programming name is: %s\n",__FILE__);
        printf("the complie date is :\t %s\t%s\n",__DATE__,__TIME__);
        /*if(__STDC__==1)
        {
            printf("C ANSI Standard");
        }*/
        printf("the line is:\t%u\n",__LINE__);
        
    }

    转载于:https://www.cnblogs.com/aswater-yuanye/archive/2013/01/15/2860596.html

    展开全文
  • C语言部分知识

    2015-07-23 21:11:07
    main函数是C语言程序的入口(开始执行的位置),{}表示main函数的起止点 2怎样理解注释增强代码的可读性和可维护性?  //、/**/对代码的解释说明 3C语言中有哪些基本的数据类型,占的字节数,以及格式化的描述形式...

    1标准输入输出头文件的意义?以及main函数的作用?

    <>系统头文件、””自定义头文件。引入系统的标准头文件,可以用其中的一些函数,如printf();

    main函数是C语言程序的入口(开始执行的位置),{}表示main函数的起止点

    2怎样理解注释增强代码的可读性和可维护性?

       //、/**/对代码的解释说明

    3C语言中有哪些基本的数据类型,占的字节数,以及格式化的描述形式?

    char 、signed char 、unsigned char 、bool     1    %c

    short 、unsigned short    2   %hd

    int 、float 、unsigned int    4      %d 、%f

    double、 long int 、unsigned long   8    %lf 、%ld

    sizeof(数据类型名)  求某种类型的字节数

    4变量的本质,变量的命名规则,以及变量初始化的方式?

    本质:内存里的存储单元。开辟空间、往空间里面写内容、从空间里面读取内容

    命名规则:每个变量必须以字母和下划线开头,由字母下划线数字组成

             大小写是两个不同的字符

             不能用C的关键字做变量名

    初始化:声明同时进行初始化、先声明然后在运行时使用赋值表达式初始化、先声明然后用户输入数值进行初始化

    5什么是常量,它的意义?

    在变量前面加上const关键字,成为常量。

    常量的值必须在创建的同时初始化,且一经初始化就不能改变

    6怎样声明一个枚举类型,如何使用,枚举如何代替宏定义?

    enum weekday {Mon, Tue, Wed,Thr, Fri, Sat, Sun } a, b, c;

    enum 关键字,weekday枚举名,a,b,c 枚举变量名

    { , ,}表示这种类型可能取的值,每个值对应一个整数,从0开始,依次加1;

    1、enum weekday

    {

    };  //没有定义变量

    enum weekday a, b, c;  //可以用这种方法定义

    2、enum weekday

    {

    }a,b,c;  //可以增加e, f, g等变量

    3、enum

    {

    }a, b, c;  //没有枚举类型名,只能有abc三个变量

    { ,}表示这种类型可能取的值,每个值对应一个整数,从0开始,依次加1;

        可以代替整型的宏定义,增强代码可维护性;

        枚举是封装好的define集合,用便于记忆的字符来代表常量,枚举类型实质是整型变量,通过枚举类型将一类有关联的标识组合起来,增加程序的可读性和可维护性

    枚举变量可以用在switch语句中作为常量使用;使用枚举变量时,应该把枚举变量的值赋值为枚举中常量集合中某个常量的值

    7定义初始化一个数组,用下标访问数组

       int a[5];

       int a[ ]={1, 2, 3, 4};

       int a[5]={1, 2, 3, 4};

    8大数分解

    万  12345/10000

    千  12345/1000%10  == 12345%10000/1000

    百  12345/100%10  == 12345%1000/100

    十  12345/10%10  == 12345%100/10

    个  12345%10

    9 怎么样理解前置(后置)自增自减?

    当需要使用自增自减的值时,考虑其是前置还是后置

    前置:++i 先进行自增自减,再使用增减后的值

    后置:i-- 先使用变量当前的值,然后再进行自增自减运算

    10怎样使用&& ||

    与、全真为真,有假则假

    或、全假为假,有真则真

    非、非真为假,非假为真

    11条件表达式

    if()

      …

    else if ()

      …

    else

      …

    12隐式和显示类型转化?

    当某一个操作符拥有不同类型的操作数时,将发生类型转换

    显式:(数据类型名) 变量名  float i = 1.23;  int j = (int) i;

         i的类型依然是float,只是把i的整数部分赋给了j

    隐式:char c = ‘a’;  int i = c;

         赋值表达式,把等号右边的类型,转型为等号左边的类型;

         在一个表达式中,默认状态下变量是从低类型向高类型转化的

    13控制流

    顺序结构:按照语句编写的顺序顺序执行

            ;是语句结束的标志;{}被用在程序块中,其右侧括号后面不加分号;任何可以放置单个语句的地方,都可以用一个复合语句来代替

    选择结构:if:条件为真时,执行语句,否则跳过不执行

            if-else:条件为真时执行if分支语句,否则执行else分支语句(嵌套)

            switch:根据条件表达式的值,执行多个动作当中的某一个动作

    switch (…)   //表达式或者变量,必须返回整数型(包括字符型)

    {

        case 1: …;break;  case:… 必须是常量表达式,且不允许重复

        case 2: …;break;

        default: …; break;

    }

    循环结构:while:首先初始化循环控制变量while(…//条件为真)  {…//进入循环体;改变循环控制变量} 

            do/while:后置测试循环,先循环一次,再测试条件  do{…循环体;修改循环控制变量}while (表达式)//控制变量不需要初始化

            for:前置测试循环,先测试条件是否满足,若满足再进入循环体执行 for(循环控制变量初始化;条件表达式,为真则执行循环体语句;修改循环控制变量)   {…循环体语句}  à首先初始化循环控制变量,然后执行条件表达式,为真则执行循环体语句,然后改变循环控制变量,再执行条件表达式,为真则执行循环体语句。。。直到条件表达式为假

    14breakcontinue return作用?

    break:结束循环,执行循环后面的语句;多层循环只跳出break所在这一层循环;跳出switch结构

    continue:跳过本次循环而执行下次循环

    return:退出该函数的执行(跳出函数)

    15函数作用

    可以多人合作开发

    单元测试,有利于早发现bug

    复用性

    16怎样封装函数,函数调用的实质;

    封装函数:main.c中需包含自定义的调用函数的头文件;调用函数头文件声明调用函数原型;调用函数.c文件定义、实现调用函数

    实质:

    17函数的值传递

    传值方式,在函数调用时,把实参值的一份拷贝赋值给形参

    在被调用函数体内,操作和修改的是形参的值,实参的值不受影响

    单向传递,从实参到形参

    18指针实质,指针访问变量,指针的类型,野指针,空指针,手动开辟内存空间

    指针也是一个变量,它的值是另外一个变量的地址,即指针是存放内存地址的变量

    指针类型与它指向的变量的类型保持一致

     char *p = &achar;  //p指针变量名;*表示p是一个指针变量;&取地址运算符,返回变量地址;char*指针变量的类型,p是一个字符型指针,char代表指针指向的变量的类型;%p打印地址,打印指针变量的值;指针是long int,8个字节

    解引用运算符,*p:放等号右边,读取p指向的变量的值;左边,给p指向的变量写入内容

    如果定义一个指针没有初始化,它存储的是垃圾地址,即为野指针

    当定义一个指针还不确定指向哪个变量,就把它置为空,空指针是被初始化为NULL的指针,里面的地址是0(不要解引用空指针,因0号地址属于系统级内存空间,不允许用户级程序访问)

    int * p = (int *) malloc(sizeof(int));

    free(p);

    19传地址,传指针,返回指向局部变量的指针(解决方案),函数返回值

    int exchange(int *a, int *b)

    {

        int temp = *a;

        *a = *b;

        *b = temp;

    }

    int main()

    {

        int aa=1,bb=2;

        指针int p = &aa, *q = &bb;

        指针exchange(p, q);

        地址exchange(&aa, &bb);

        printf(“..”);

    }

    111、定义全局变量*p,开辟堆空间,主函数回收开辟的堆上的内存空间

    #include <stdio.h>

    #include <stdlib.h>

    int *p=NULL;

    int *Test()

    {

        p=(int *)malloc(sizeof(int));

        *p=10;

        return p;

    }

    int main()

    {

        int c=*Test();

        printf("%d\n",c);

        free(p);

        return 0;

    }

    222static

    #include <stdio.h>

    int *Test()

    {

        static int temp=12;  //加static定义到静态存储区,不加则声明局部变量,调用函数结束时内存回收

        return &temp;  //不能返回一个指向局部变量的指针

    }

    int main()

    {

        int c=*Test();

        printf("%d\n",c);

        return 0;

    }

     

    20内存分配问题

    逐步分析

    全局变量:在所有函数体之外声明的变量,作用于所有源文件,全局区

    静态全局变量:不可用于其他文件

    静态局部变量

    局部变量:栈(形参放在栈上)

    堆:手动开辟的内存空间

    静态存储区:变量前加static,生命周期很长,从申请到程序退出

     

    21怎样用指针访问数组?

    数组元素在内存空间中连续分布,每个元素有相应的内存地址;数组名就是数组首地址,就是指向数组首元素的指针,即a == &a[0];数组名是个指针常量,存储的地址是不能更改的

    p = a;   或 p = &a[0];   则a[1]==*(p+1);

    22指针运算和数组?

    #include <stdio.h>

    int main()

    {

       char a[8];

       int b[8];

       float c[8];

       char *pa = a + 1;

       int *pb = b + 4;

       float *pc = c +6;

       printf("%p,%p\n",a,pa);

       printf("%p,%p\n",b,pb);

       printf("%p,%p\n",c,pc);

       printf("%ld,%ld,%ld\n",pa-a,pb-b,pc-c);    //1,4,6

       printf("%ld,%ld,%ld\n",sizeof(pa-a),sizeof(pb-b),sizeof(pc-c));    //8,8,8

       return 0;

    }

     

    23指针常量的使用

    #include <stdio.h>

    int main ()

    {

       const int a=9;//常量,定义时要初始化

       //a=9;  常量初始化后不能修改,即使赋相同的值也不行

       const int aa = 99;

       int b = 10;

       int c = 11;

       //int pp=&b;

       int * const p = &b;

       //p=pp;  指针常量初始化后不能修改,即使赋相同的值也不行

       //p=&c;  不同的值更不行

       printf("%d\n",*p);

       const int *q = &a;  //指向常量的指针,这个指针最好要指向一个常量

        q= &b;  //也可以指向变量

       printf("%d\n",*q);

       q=&aa;  //指向常量的指针,也可以指向其他常量

       printf("%d\n",*q);

       return 0;

    }

     

        int* const p = &a;    //必须在声明时初始化,且指针常量的值不能再修改,即不能存一个新的地址,不能指向别的变量,但是可以通过指针常量修改它所指向的变量的值

    24指向常量指针的使用?

       const int a = 1;

    const int *q = &a;    //指向常量的指针,这个指针指向一个常量

    q = &b;    //也可以指向变量或者其他常量

    25全局变量,函数域,块域

    标识符:变量名、函数名

    作用域:能够访问某标识符的程序段

    全局变量:在所有函数体之外声明的变量,作用于所有源文件,全局区

    局部变量

    函数域:标识符只能在它所在的函数被访问到

    函数形参:函数实现时形参的名字可以和函数原型形参名字不同;但类型要一致。函数原型的形参的作用域,只限于函数原型本身

    块域:被大括号{}包围的范围叫块;其作用域:从标识符开始到块结束,可以被识别

    当在块内部声明了一个与外部标识符同名的标识符时,外部标识符可以被临时隐藏

    就近原则:若有同名标识符,优先使用同一作用域内的标识符

    如果想访问被临时隐藏的全局变量,要使用全局域操作符::

    26链接编译理解

    预处理   编译  链接

    预处理阶段,编译器以C文件作为一个单元,首先读这个C文件,发现包含头文件,就会在所有搜索路径中寻找文件,找到之后,就会将相应头文件中再去处理宏,变量,函数声明,嵌套的头文件包含等,检测依赖关系,进行宏替换,看是否有重复定义与声明的情况发生,最后将那些文件中全部扫描进这个当前的C文件中,形成一个中间"C文件"

    编译阶段,将中间C文件的所有变量,函数分配空间,将各个函数编译成二进制码,按照特定目标文件格式生成目标文件,在这种格式的目标文件中进行各个全局变量,函数的符号描述,将这些二进制码按照一定的标准组织成一个目标文件

    连接阶段,将上一步生成的各个目标文件,根据一些参数,连接生成最终的可执行文件,主要的工作就是重定位各个目标文件的函数,变量等,相当于将个目标文件中的二进制码按一定的规范合到一个文件中

    想在多个文件中访问一个变量,就要在变量前面加上extern关键字

    27怎样使用函数指针

    函数指针的类型就是指针指向的函数的参数类型和返回值类型

    int ( *fp) (int a, intb);    //声明一个函数指针

    int func (int m, intn);    //声明一个函数

    fp = func;  或  fp = &func;

    28字符串和字符数组的区别

    字符串:用双引号包围  “abcde”

    字符数组:数组的每一个元素都是字符,字符用单引号包围

    在内存里用字符数组存储字符串,字符数组要加一个元素,以空字符\0作为结尾

    定义:字符串就是存入字符的数组,以’\0’作为结束标志,%s输出

    区别:字符串用字符数组存储,但是字符数组不需要有结束标志’\0’,字符串需要

    29怎样拷贝一个存在静态常量区的字符串

    char c[6] = “hello”;   //声明之后,首先在静态存储区的常量区开辟一块空间,写入hello,然后开辟一块连续的栈空间,把字符串拷贝一份,然后将内容写入到栈空间,c本身是个变量,所以可以通过c修改他所指向的内存的值

    可以把一个字符串赋值给一个char * 类型的指针,但不能通过指针修改这个字符串

    char *str = "I am astudent";

    //const char *str = "Iam a student";

    //把一个字符串赋给一个字符指针,相当于赋给一个指向字符常量的指针

    str = "sun";  //可以,改变地址,指向sun

    //strcpy(str,"abcde");//错误,改变值

    30使用strcpy strcmp strcatstrlen等字符串函数的操作

    strlen (length) 返回字符串的字符数(长度),不包括\0

    strcat (to, from) ,把from”…”连接到to”…”的结尾

    strcpy (to, from) ,把from”…”copy到to”…”

    strcmp (s1, s2) s1 > s2,返回正数s1 < s2,返回负数s1 = s2,返回0

    两个字符串从前到后,逐个比较每对字符的ASCII码的大小;若相同,则继续比较,直到遇到第一对不同的字符,ASCII码整数大的字符为大

    31 起别名的语法规范

    typedef  type IDENTIFIER   关键字   已有类型   类型别名,一般全大写字母

    typedef  unsigned int UN;

    用来代替自定义的枚举类型、结构体类型、系统定义的长度较长的类型

    32 声明结构体类型的变量的两种主要形式,以及初始化

    //111

    struct  //直接定义结构体变量,结构体本身没有名字

    {

        char name[15];

        int num;

        int age;

    }Astu;  //结构体变量的声明,必须紧跟在结构体定义的后面

    //222

    struct student  //结构体类型,类型名为struct student

    {

        char name[15];

        int num;

        int age;

    }Bstu;  //可以在这里声明结构体变量

    struct student Cstu;  //也可以用结构体类型名,声明一个结构体变量

    //333

    typedef struct  //给结构体类型起一个别名   STU

    {

        char name[15];

        int num;

        int age;

    }STU;  //结构体别名

    STU Dstu;  //通过别名,声明结构体变量

    >>>>>>>>>>>>>>>>>>>>><<<<<<<<<<<<<<<<<<<<<< 

    STU Dstu = {…, …, …};

    33 结构体类型的指针访问结构体类型的变量

        访问:p = &Astu;     Astu.name     p -> num    (*p).age

    34 如何计算结构体类型的变量在系统内存里占用的字节数

    结构体的值从上往下依次分配,先找到最大字节的变量,然后依次从上到下分配内存,当分配到相应类型时,图中编号一定要能整除当前类型字节数。(大小要能被每一种类型大小整除)

    char a[10];     //0—9

    int b;     //12—15

    char c;     //16

    double a;     //24—31

    double 最大,8字节,以8字节为单位画内存分配:

    0 1 2 3 4 5 6 7

    8 9 10 11 12 13 14 15

    16 17 18 19 20 21 22 23

    24 25 26 27 28 29 30 31

    <<<<<<<<<<<<<<<>>>>>>>>>>>>>>>>><<<<<<<>>>>>>>>> 

    int a;     //0—3

    fioat b;     //4—7

    char c[15];     //8—22

    0      1  2  3

    4  5 6  7

    8  9  1011

    12 13 14 15

    16 17 18 19

    20 21 22 23

    24 25 26 27

    35宏替换

    #define N 10  //预处理阶段,源代码里所有的N将被替换成10

    #define max(a,b) ((a) >(b) ? (a) : (b))  //宏替换的参数都要加上括号

    #define  exchange ( x,  y)\

    {\

    int temp = *x;\

    *x = *y;\

    *y = temp;\

    }    //替换自定义函数,除最后大括号的结束行,其余的都要加上”\”

    36条件包含

    #if  。。。  //如果为真,则包含后面内容,直到#endif、#elif、#else结束

    #ifndef XXX

    #define XXX

    ……

    #endif   //避免重复定义同一个头文件

     

     

    #ifdef XXX    //如果宏定义了XXX,执行下面语句

    ……

    #else     //否则,执行else下面语句

    ……

    #endif

    #ifndef XXX    //如果没有宏定义XXX,执行下面语句

    ……

    #else     //否则,执行else下面语句

    ……

    #endif

    展开全文
  • C语言编程要点

    2017-09-18 00:10:37
    9.8. 为什么用const说明的常量不能用来定义一个数组的初始大小? 145 9.9. 字符串和数组有什么不同? 145 第10章 位(bit)和字节(byte) 147 10.1. 用什么方法存储标志(flag)效率最高? 147 10.2. 什么是“位屏蔽(bit ...
  • 《你必须知道495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    《你必须知道495个C语言问题》以问答形式组织内容,讨论了学习或使用C语言的过程中经常遇到一些问题。书中列出了C用户经常问400多个经典问题,涵盖了初始化、数组、指针、字符串、内存分配、库函数、C预...
  • 1 C程序中必有且仅有一个main( )函数程序从main( )开始执行并且在main( )中结束 main( )函数可以放在任何位置 2 每一个说明每一个语句都必须以分号;结尾但预处理命令函数头和花括号}之后不能加分号 3 C 语言的注释...
  • 1. 阅读下面代码段,回答问题 ...sizeof(A)的结果是什么,为什么,再定义一个 int 类型的 t3, 定义的位置影响结果吗,说明理由。 typedef struct tag_unimportant { char *t2; int t1; } A; void func(A *a
  • 快速排序 C语言

    2021-04-11 22:38:04
    找到每个数字在序列中自己的位置 所需知识前景 一个序列中除了最大与最小数字,必定存在:左边的数字始终小于该数字,该数字右边的数始终大于该数字。 当一个数字左边的数是自己,右边的数字还是自己,那么则说明该...
  • 程序的注释在程序编写过程中是非常重要工作一个没有程序注释的程序就像一个没有使用说明软件 C程序注释方式如下 //注释的内容 或 /*注释的内容*/ 注释以//开头其后是注释文字可一直延续到该行行尾/*注释的...
  • 最近我们C语言的课设快开始了,开始前刚好有时间就写了一下C语言的贪吃蛇小游戏,包含了经典模式和无边界模式 ,网上查了设置颜色还有改变光标位置的函数,第一次写, 有写不好地方请多指教 代码的说明都在代码...
  • 2.17 C语言中有和Pascalwith等价语句吗? 29 2.18 既然数组名可以用作数组基地址,为什么对结构不能这样? 29 2.19 程序运行正确,但退出时却“core dump ”(核心转储)了,怎么回事? 29 联合 30 2.20...
  • 第 1 章 1. 以下叙述不正确的是 AC程序的基本组成单位是函数 B在 C程序中注释说明只能位于一条语句的... C语言规定在一个源程序中 main函数的位置 A必须在最开始 B必须在系统调用的库函数的后面 C必须在最后 D可以任
  • 函数有注释说明功能,对参数、返回值也要以注释形式说明用途;关键语句段要求有注释解释。 (3)程序层次清晰,可读性强。 5 开发环境 可以选择TC2.0、TC3.0、VC++6.0等。 MFC就先算了,我想先把黑屏程序...
  • 写的代码要有注释说明 (2.要有运行结果截图 (3.以实验报告的形式提交 ?输入:磁头所在的位置以及对块的请求序列 ?输出:对块的调度访问序列 ?算法:你自己用C语言模拟一个读盘的调度算法 实验内容与算法分析 NOOP电梯...
  • 上一篇随笔写了关于C++在注释,输入输出,局部变量说明的扩充,以及const修饰符与C中的#define的比较,也得到了几位学习C++朋友们的帮助讲解,十分感谢,我也希望欢迎有更多学习C++的朋友一起来讨论,这样大家都能...
  • 2以下叙述中不正确是 A一条 C 语句可以分写在多行中 B一条 C 语句必须包含一个分号 C单独一个分号不能构成一条 C 语句 D在 C 程序中注释说明可以位于程序任何位置 ;3下面 是合法 C 语句. A#define MY 100 Ba=...
  • //还有关于字符串的匹配问题,本程序采用BF蛮力算法来匹配字符串,也可以使用KMP算法,具体算法并未在本 //程序体现,在重要的位置处都有详细的代码注释,如有问题,请私信我,谢谢! #include&amp;amp;amp;amp;...
  • 你必须知道495个C语言问题(PDF)

    热门讨论 2009-09-15 10:25:47
    难道在C语言中一个结构不能包含指向自己指针吗? . . . . 3 1.7 怎样建立和理解非常复杂声明?例如定义一个包含N 个指向返 回指向字符指针函数指针数组? . . . . . . . . . . . . . . 3 1.8 函数只定义...
  • C语言教程(谭浩强)

    2008-12-16 10:35:00
    注释可出现在程序中任何位置注释用来向用户提示或解释程序意义。在调试程序中对暂不使用语句也可用注释符括起来,使翻译跳过不作处理,待调试结束后再去掉注释符。 1.13 Turbo C 2.0集成开发环境使用 ...

空空如也

空空如也

1 2 3 4 5
收藏数 97
精华内容 38
关键字:

c语言注释说明的位置

c语言 订阅