编译原理实验语法分析器

已于 2022-07-05 22:04:49 修改
阅读量480 收藏 8
点赞数 6
文章标签： c++ c语言
于 2022-05-12 20:52:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_64446869/article/details/124739602
版权 
#include <iostream>
#include <stdlib.h>
#include <stdio.h>
#include<string.h>
#include<fstream>
#include<map>
using namespace std;
const int N=10010;
string words[N];
string vlaue[N];
int wordsnums=0;
string KEYWORD[19]={"const","if","else","void","return","while","then","for","do",      //关键字
                    "int","char","double","float","case","cin","cout","main","scanf","printf"};
char OPERATOR[8]={'+','-','*','/','>','<','=','!'};     //运算符
string OPERRATOR1[11]={"+","-","*","/",">","<","=","<=",">=","==","!="};
char FILTER[4]={' ','\t','\r','\n'};                    //过滤符
      //过滤字符值
 

/**判断是否为关键字**/
bool IsKeyword(string word){
    for(int i=0;i<19;i++){
        if(KEYWORD[i]==word){
            return true;
        }
    }
    return false;
}

 
/**判断是否为运算符**/
bool IsOperator(char ch){
    for(int i=0;i<8;i++){
        if(OPERATOR[i]==ch){
            return true;
        }
    }
    return false;
}
/**判断是否为过滤符**/
bool IsFilter(char ch){
    for(int i=0;i<4;i++){
        if(FILTER[i]==ch){
            return true;
        }
    }
    return false;
}
/**判断是否为大写字母**/
bool IsUpLetter(char ch){
    if(ch>='A' && ch<='Z') return true;
    return false;
}
/**判断是否为小写字母**/
bool IsLowLetter(char ch){
    if(ch>='a' && ch<='z') return true;
    return false;
}
/**判断是否为数字**/
bool IsDigit(char ch){
    if(ch>='0' && ch<='9') return true;
    return false;
}
/**返回每个字的值**/
template <class T>
int value(T *a,int n,T str){
	for(int i=0;i<n;i++){
		if(a[i]==str) return i;
	}
	return -1;
}
int value1(string str1,string a[])
{
	for(int i=0;i<11;i++)
	{
		if(a[i]==str1) return i;
		
	}
	return true;
}
/**词法分析**/
void analyse(FILE * fpin){
    char ch=' ';
    string arr="";
    while((ch=fgetc(fpin))!=EOF){
        arr="";
        if(IsFilter(ch)){}              //判断是否为过滤符
        else if(IsLowLetter(ch)){       //判断是否为关键字
            while(IsLowLetter(ch)||IsDigit(ch)||IsUpLetter(ch)||ch=='_'){
				arr += ch;
				ch=fgetc(fpin);
            }
			//fseek(fpin,-1L,SEEK_CUR);
			if(IsKeyword(arr)){
				int flag;
				flag=value(KEYWORD,19,arr);
				switch(flag)
				{
					case 0: words[wordsnums]="CONSTTK";break;
					case 1: words[wordsnums]="IFTK";break;
					case 2: words[wordsnums]="ELSETK";break;
					case 3: words[wordsnums]="VOIDTK";break;
					case 4: words[wordsnums]="RETURNTK";break;
					case 5: words[wordsnums]="WHILETK";break;
					case 6: words[wordsnums]="THENTK";break;
					case 7: words[wordsnums]="FORTK";break;
					case 8: words[wordsnums]="DOTK";break;
					case 9: words[wordsnums]="INTTK";break;
					case 10: words[wordsnums]="CHARTK";break;
					case 11:words[wordsnums]="DOUBLETK";break;
					case 12: words[wordsnums]="FLOATTK";break;
					case 13: words[wordsnums]="CASETK";break;
					case 14: words[wordsnums]="CINTK";break;
					case 15: words[wordsnums]="COUTTK";break;
					case 16: words[wordsnums]="MAINTK";break;
					case 17: words[wordsnums]="SCANFTK";break;
					case 18:words[wordsnums]="PRINTFTK";break;
				}
				fseek(fpin,-1L,SEEK_CUR);
				
			}
			else
            {
                
                words[wordsnums]="IDENFR";
                fseek(fpin,-1L,SEEK_CUR);
            }
            vlaue[wordsnums]=arr;
            wordsnums++;
        }
        else if(IsDigit(ch)){           //判断是否为数字
            while(IsDigit(ch)||(ch=='.'&&IsDigit(fgetc(fpin)))){
                arr += ch;
                ch=fgetc(fpin);
            }
            fseek(fpin,-1L,SEEK_CUR);
            words[wordsnums]="INTCON";
            vlaue[wordsnums]=arr;
            wordsnums++;
            
			
			 
        }
        else if(IsUpLetter(ch)||IsLowLetter(ch)||ch=='_'){
            while(IsUpLetter(ch)||IsLowLetter(ch)||ch=='_'||IsDigit(ch)){
                arr += ch;
                ch=fgetc(fpin);
            }
            fseek(fpin,-1L,SEEK_CUR);
            words[wordsnums]="IDENFR";
            vlaue[wordsnums]=arr;
            wordsnums++;
        }
        
		
		else if(IsOperator(ch))
			{
				do
				{
					arr+=ch;
					ch=fgetc(fpin);
				}while(IsOperator(ch)&&ch!='+');
				int flag1;
			    flag1=value1(arr,OPERRATOR1);
		 	    
			    switch(flag1)
			   {
				case 0: words[wordsnums]="PLUS";break;
				case 1: words[wordsnums]="MINU";break;
				case 2: words[wordsnums]="MULT";break;
				case 3: words[wordsnums]="DIV";break;
				case 4: words[wordsnums]="GRE";break;
				case 5: words[wordsnums]="LSS";break;
				case 6: words[wordsnums]="ASSIGN";break;
				case 7: words[wordsnums]="LEQ";break;
				case 8: words[wordsnums]="GEQ";break;
				case 9: words[wordsnums]="EQL";break;
				case 10: words[wordsnums]="NEQ";}
				fseek(fpin,-1L,SEEK_CUR);
				vlaue[wordsnums]=arr;
				wordsnums++;
			}
		else if(ch=='"')
		{
			ch=fgetc(fpin);
			string str2;
			while(ch!='"')
			{
				str2+=ch;
				ch=fgetc(fpin);
			}
			words[wordsnums]="STRCON";
			vlaue[wordsnums]=str2;
			wordsnums++;
		}
		else if(ch==39)
		{
			ch=fgetc(fpin);
			string str3;
			while(ch!=39)
			{
				str3+=ch;
				ch=fgetc(fpin);
			}
			words[wordsnums]="CHARCON";
			vlaue[wordsnums]=str3;
			wordsnums++;
			
		
		}
					
		
			
			
			
			
		else {
			switch(ch){
			case ';': 
			          words[wordsnums]="SEMICN";
			          vlaue[wordsnums]=ch;
			          wordsnums++;
			          break;
            case ',': 
			          words[wordsnums]="COMMA";
			          vlaue[wordsnums]=ch;
			          wordsnums++;
			          break;
            case '(': 
			          words[wordsnums]="LPARENT";
			          vlaue[wordsnums]=ch;
			          wordsnums++;
			          break;
            case ')': 
			          words[wordsnums]="RPARENT";
			          vlaue[wordsnums]=ch;
			          wordsnums++;
			          break;
            case '[': 
			          words[wordsnums]="LBRACK";
			          vlaue[wordsnums]=ch;
			          wordsnums++;
			          break;
            case ']': 
			          words[wordsnums]="RBRACK";
			          vlaue[wordsnums]=ch;
			          wordsnums++;
			          break;
            case '{': 
			          words[wordsnums]="LBRACE";
			          vlaue[wordsnums]=ch;
			          wordsnums++;
			          break;
            case '}': 
			          words[wordsnums]="RBRACE";
			          vlaue[wordsnums]=ch;
			          wordsnums++;
			          break;
            default :{}}
            }
        
        
    }
 
}
int q;
map <string,int>Choose;
void digui0();		//＜字符串＞
void digui1();		//＜程序＞
void digui2();		//＜常量说明＞
void dugui3();		//＜常量定义＞
void digui4();		//＜无符号整数＞	
void digui5();		//＜整数＞
void digui6();		//＜声明头部＞
void digui7();		//＜变量说明＞
void digui8();		//＜变量定义＞
void digui9();		//＜有返回值函数定义＞
void digui10();		//＜无返回值函数定义＞
void digui11();		//＜复合语句＞
void digui12();		//＜参数表＞
void digui13();		//＜主函数＞
void digui14();		//＜表达式＞
void digui15();		//＜项＞
void digui16();		//＜因子＞
void digui17();		//＜语句＞
void digui18();		//＜赋值语句＞
void digui19();		//＜条件语句＞
void digui20();		//＜条件＞
void digui21();		//＜循环语句＞
void digui22();		//＜步长＞
void digui234();	//＜有无返回值函数调用语句＞
void digui25();		//＜值参数表＞ 
void digui26();     //＜语句列＞
void digui27();     //＜读语句＞
void digui28();     //＜写语句＞
void digui29();		//＜返回语句＞
fstream fout("output.txt",ios::out);
void string_analyse()
{
	q=0;
	digui1();
	return;
}
void output(string str)
{
	if(words[q]==str)
	{
		fout<<words[q]<<" "<<vlaue[q]<<endl;
		q++;
	}
	else cout<<"error"<<endl;
}
void digui0()
{
	output("STRCON");
	fout<<"<字符串>"<<endl;
}
void digui1()
{
	//［＜常量说明＞］［＜变量说明＞］{＜有返回值函数定义＞|＜无返回值函数定义＞}＜主函数＞
	//常量说明：
	if(words[q]=="CONSTTK") digui2();
	//变量说明: 
	if((words[q]=="INTTK"||words[q]=="CHARTK")&&words[q+1]=="IDENFR"&&words[q+2]!="LPARENT")
	{
		digui7();
	} 
	//有无返回值函数定义
	while((words[q]=="VOIDTK"||words[q]=="CHARTK"||words[q]=="INTTK")&&words[q+1]=="IDENFR"&&words[q+2]=="LPARENT")
	{
		if(words[q]=="CHARTK"||words[q]=="INTTK") digui9();
		else digui10();
	}
	//主函数
	if((words[q]=="VOIDTK"||words[q]=="INTTK")&&words[q+1]=="MAINTK") 
	{
		digui13();
	}
	if(q==wordsnums)
	{
		fout<<"<程序>"<<endl;
		return;
	}
	else
	{
		cout<<"qerror"<<endl;
	}
}
void digui3(); //距离太远重新声明 
void digui2() //常量说明
{
	//const＜常量定义＞;{ const＜常量定义＞;}
	do
	{
		output("CONSTTK");
		digui3();
		output("SEMICN");	
	}while(words[q]=="CONSTTK");
	fout<<"<常量说明>"<<endl;
} 
void digui3() //常量定义 
{
    //int＜标识符＞＝＜整数＞{,＜标识符＞＝＜整数＞}
    //char＜标识符＞＝＜字符＞{,＜标识符＞＝＜字符＞}
	if(words[q]=="INTTK")
	{
		output("INTTK");output("IDENFR");output("ASSIGN");
		digui5();//整数 
		while(words[q]=="COMMA")
		{
			output("COMMA");
			output("IDENFR");
			output("ASSIGN");
			digui5();
		}
	}
	if(words[q]=="CHARTK")
	{
		output("CHARTK");output("IDENFR");output("ASSIGN");output("CHARCON");
		while(words[q]=="COMMA")
		{
			output("COMMA");output("IDENFR");output("ASSIGN");output("CHARCON"); 
		}
		
	}
	fout<<"<常量定义>"<<endl;
	
		
}
void digui4()
{
	//＜非零数字＞｛＜数字＞｝| 0
	output("INTCON");
	fout<<"<无符号整数>"<<endl;
	
}
void digui5()
{
	//［＋｜－］＜无符号整数＞
	if(words[q]=="PLUS") output("PLUS"); 
	else if(words[q]=="MINU") output("MINU");
	digui4();
	fout<<"<整数>"<<endl;
}
void digui6()
{
	//int＜标识符＞ |char＜标识符＞
	if(words[q]=="INTTK") output("INTTK");
	else if(words[q]=="CHARTK") output("CHARTK");
	output("IDENFR");
	fout<<"<声明头部>"<<endl;
}
void digui7()
{
	//＜变量定义＞;{＜变量定义＞;}
	do
	{
		digui8();
		output("SEMICN");
	}while((words[q]=="INTTK"||words[q]=="CHARTK")&&words[q+1]=="IDENFR"&&words[q+2]!="LPARENT");
	fout<<"<变量说明>"<<endl;
}
void digui8()
{
	//＜类型标识符＞(＜标识符＞|＜标识符＞'['＜无符号整数＞']'){,(＜标识符＞|＜标识符＞'['＜无符号整数＞']' )} 
	//||＜无符号整数＞表示数组元素的个数，其值需大于0
	//＜类型标识符＞      ::=  int | char
	if(words[q]=="INTTK") output("INTTK");
	else if(words[q]=="CHARTK") output("CHARTK");
	output("IDENFR");
	if(words[q]=="LBRACK")  
	{
		output("LBRACK");
		digui4();
		output("RBRACK");
	}
	while(words[q]=="COMMA")
	{
		output("COMMA");
		output("IDENFR");
		if(words[q]=="LBRACK")
		{
			output("LBRACK");
			digui4();
			output("RBRACK");
		}		
	}
	fout<<"<变量定义>"<<endl;
}
void digui9()
{
	//＜声明头部＞'('＜参数表＞')' '{'＜复合语句＞'}'
	digui6();
	output("LPARENT");
	digui12();
	output("RPARENT");
	output("LBRACE");
	digui11();
	output("RBRACE");
	fout<<"<有返回值函数定义>"<<endl;
	
}
void digui10()
{
	//＜无返回值函数定义＞  ::= void＜标识符＞'('＜参数表＞')''{'＜复合语句＞'}'
	output("VOIDTK");
	Choose[vlaue[q]]=1;
	output("IDENFR");
	output("LPARENT");
	digui12();
	output("RPARENT");
	output("LBRACE");
	digui11();
	output("RBRACE");
	fout<<"<无返回值函数定义>"<<endl;
	
}
void digui11()
{
	//［＜常量说明＞］［＜变量说明＞］＜语句列＞
	if(words[q]=="CONSTTK") digui2();
	if((words[q]=="INTTK"||words[q]=="CHARTK")&&words[q+1]=="IDENFR"&&words[q+2]!="LPARENT")
	{
		digui7();
	}
	digui26();
	fout<<"<复合语句>"<<endl;
}
void digui12()
{
	//＜类型标识符＞＜标识符＞{,＜类型标识符＞＜标识符＞}| ＜空＞
	if(words[q]!="RPARENT")
	{
		if(words[q]=="INTTK") output("INTTK");
		else if(words[q]=="CHARTK") output("CHARTK");
		output("IDENFR");
		while(words[q]=="COMMA")
		{
			output("COMMA");
			if(words[q]=="INTTK") output("INTTK");
		    else if(words[q]=="CHARTK") output("CHARTK");
		    output("IDENFR");
		}
	}
	fout<<"<参数表>"<<endl;

}
void digui13()
{
	//＜主函数＞    ::= void main‘(’‘)’ ‘{’＜复合语句＞‘}’
	output("VOIDTK");output("MAINTK");output("LPARENT");output("RPARENT");
	output("LBRACE");
	digui11();
	output("RBRACE");
	fout<<"<主函数>"<<endl;
	
}
void digui14()
{
	//＜表达式＞    ::= ［＋｜－］＜项＞{＜加法运算符＞＜项＞}   //[+|-]只作用于第一个<项>
	if(words[q]=="PLUS") output("PLUS");
	else if(words[q]=="MINU") output("MINU");
	digui15();
	while(words[q]=="PLUS"||words[q]=="MINU")
	{
		if(words[q]=="PLUS") output("PLUS");
	    else if(words[q]=="MINU") output("MINU");
	    digui15();
	}
	fout<<"<表达式>"<<endl;
}
void digui15()
{
	//＜项＞     ::= ＜因子＞{＜乘法运算符＞＜因子＞}
	digui16();
	while(words[q]=="MULT"||words[q]=="DIV")
	{
		if(words[q]=="MULT") output("MULT");
		else if(words[q]=="DIV") output("DIV");
		digui16();
	} 
	fout<<"<项>"<<endl;
}
void digui16()
{
	//＜因子＞    ::= ＜标识符＞｜＜标识符＞'['＜表达式＞']'
	//|'('＜表达式＞')'｜＜整数＞|＜字符＞｜＜有返回值函数调用语句＞
	if(words[q]=="IDENFR")
	{
		if(words[q+1]=="LBRACK")
		{
			output("IDENFR");
			output("LBRACK");
			digui14();
			output("RBRACK");
		}
		else if(words[q+1]=="LPARENT") digui234();
		else output("IDENFR");
	}
	else if(words[q]=="LPARENT") {output("LPARENT");digui14();output("RPARENT");}
	else if(words[q]=="INTCON"||words[q]=="PLUS"||words[q]=="MINU") digui5();
	else if(words[q]=="CHARCON") output("CHARCON");
	fout<<"<因子>"<<endl;
}
void digui17()
{
	//＜语句＞    ::= ＜条件语句＞｜＜循环语句＞| '{'＜语句列＞'}'| ＜有返回值函数调用语句＞; 
	// |＜无返回值函数调用语句＞;｜＜赋值语句＞;｜＜读语句＞;｜＜写语句＞;｜＜空＞;|＜返回语句＞;
	if(words[q]=="IFTK") digui19();
	else if(words[q]=="WHILETK"||words[q]=="DOTK"||words[q]=="FORTK") digui21();
	else if(words[q]=="LBRACE")
	{
		output("LBRACE");
		digui26();
		output("RBRACE");
	}
	else if(words[q]=="IDENFR")
	{
		if(words[q+1]=="LPARENT") {digui234();output("SEMICN");}//有无返回值函数调用语句 
		else{
			digui18();
			output("SEMICN"); //赋值语句 
		}
	}
	else if(words[q]=="SCANFTK")
	{
		digui27();output("SEMICN");
	}
	else if(words[q]=="PRINTFTK")
	{
		digui28();output("SEMICN");
	}
	else if(words[q]=="SEMICN") output("SEMICN");
	else if(words[q]=="RETURNTK")
	{
		digui29();output("SEMICN");
	}
	fout<<"<语句>"<<endl;
	
}
void digui18()
{
	//＜赋值语句＞   ::=  ＜标识符＞＝＜表达式＞|＜标识符＞'['＜表达式＞']'=＜表达式＞
	output("IDENFR");
	if(words[q]=="LBRACK")
	{
		output("LBRACK");
		digui14();
		output("RBRACK");
	}
	output("ASSIGN");
	digui14();
	fout<<"<赋值语句>"<<endl;

}
void digui19()
{
	//＜条件语句＞  ::= if '('＜条件＞')'＜语句＞［else＜语句＞］
	output("IFTK");
	output("LPARENT");
	digui20();
	output("RPARENT");
	digui17();
	if(words[q]=="ELSETK")
	{	
	  output("ELSETK");
	  digui17();}
	fout<<"<条件语句>"<<endl;
}
void digui20()
{
	// ＜表达式＞＜关系运算符＞＜表达式＞ (整型表达式之间才能进行关系运算)
	//＜表达式＞    (表达式为整型，其值为0条件为假，值不为0时条件为真)
	digui14();
	if(words[q]=="LSS"||words[q]=="LEQ"||words[q]=="GRE"||words[q]=="GEQ"
	||words[q]=="EQL"||words[q]=="NEQ")
	{
		output(words[q]);
		digui14();
	}
	fout<<"<条件>"<<endl;
}
void digui21()
{
	//＜循环语句＞   ::=  while '('＜条件＞')'＜语句＞
	//| do＜语句＞while '('＜条件＞')' 
	//|for'('＜标识符＞＝＜表达式＞;＜条件＞;＜标识符＞＝＜标识符＞(+|-)＜步长＞')'＜语句＞
	if(words[q]=="WHILETK")
	{
		output("WHILETK");
		output("LPARENT");
		digui20();
		output("RPARENT");
		digui17();
	}
	else if(words[q]=="DOTK")
	{
		output("DOTK");
		digui17();
		output("WHILETK");
		output("LPARENT");
		digui20();
		output("RPARENT");
	}
	else if(words[q]=="FORTK")
	{
		output("FORTK");output("LPARENT");output("IDENFR");output("ASSIGN");digui14();output("SEMICN");
		digui20();output("SEMICN");
		output("IDENFR");output("ASSIGN");output("IDENFR");
		if(words[q]=="PLUS") output("PLUS");
		else if(words[q]=="MINU") output("MINU");
		digui22();
		output("RPARENT");
		digui17();
		
	}
	fout<<"<循环语句>"<<endl;
}
void digui22()
{
	//＜步长＞::= ＜无符号整数＞  
	digui4();
	fout<<"<步长>"<<endl;
}
void digui234()
{
	//＜标识符＞'('＜值参数表＞')'
	int chooseresult=Choose[vlaue[q]];
	output("IDENFR");
	output("LPARENT");
	digui25();
	output("RPARENT");
	if(chooseresult==1) fout<<"<无返回值函数调用语句>"<<endl;
	else fout<<"<有返回值函数调用语句>"<<endl;
}
void digui25()
{
	//＜值参数表＞   ::= ＜表达式＞{,＜表达式＞}｜＜空＞
	if(words[q]!="RPARENT")
	{
	
	    digui14();
	    while(words[q]=="COMMA")
	  {
		 output("COMMA");
		 digui14();
	  }
    }
    fout<<"<值参数表>"<<endl;

}
void digui26()
{
	//｛＜语句＞｝
	while(words[q]!="RBRACE")
	{
		digui17();
	}
	fout<<"<语句列>"<<endl;

}
void digui27()
{
	//＜读语句＞    ::=  scanf '('＜标识符＞{,＜标识符＞}')'
	output("SCANFTK");
	output("LPARENT");
	output("IDENFR");
	while(words[q]=="COMMA")
	{
		output("COMMA");
		output("IDENFR");
	}
	output("RPARENT");
	fout<<"<读语句>"<<endl;
}
void digui28()
{
	//＜写语句＞    ::= printf '(' ＜字符串＞,＜表达式＞ ')'
	//| printf '('＜字符串＞ ')'| printf '('＜表达式＞')'
	output("PRINTFTK");
	output("LPARENT");
	if(words[q]=="STRCON") digui0();
	else digui14();
	if(words[q]=="COMMA") {output("COMMA");digui14();}
	output("RPARENT");
	fout<<"<写语句>"<<endl;
}
void digui29()
{
	//＜返回语句＞   ::=  return['('＜表达式＞')']   
	output("RETURNTK");
	if(words[q]=="LPARENT")
	{
		output("LPARENT");
		digui14();
		output("RPARENT");
	}
	fout<<"<返回语句>"<<endl;
}

int main()
{
    FILE *fpin=fopen("testfile.txt","r");
    if(NULL==fpin) cout<<"false"<<endl;
    analyse(fpin);
    string_analyse();
    fclose(fpin);
    
    return 0;
}

smallrookie123
关注
  • 6
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
大学编译原理实验语法分析器.java
07-19
a) 启动程序后，先输出作者姓名、班级、学号（可用汉语、英语或拼音）...b) 请求输入测试程序名，键入程序名后自动开始编译。 c) 输出四元式中间代码（样式见样板输出3和4）。 d) 能发现程序的语法错误并输出出错信息。
fseek 指令
李江龙的博客
06-04 1706
fseek 时流位置指针的重定位指令。 目的是对“指向当前流读写位置的指针”进行偏移设置。 如： File *pInFile 指针，指向一个流，这个指针除了包含了流的起始位置、大小，还包含了一个指向当前读写位置的指针，fseek指令就是为了移动这个指针而设计的。 fseek（pInFile，driftSize，SEEK_CUR）；意思就是将pInFile的当前读写位置（SEEK_CUR）偏移driftSize个位置，使其指向SEEK_CUR + driftSize 。 这样当使用fread（*，s
C语言——文件操作函数 fseek、ftell、rewind详解
weixin_69283129的博客
08-04 1万+
C语言中关于文件操作三个函数 fseek、ftell、rewind的作用与实践用途介绍
c语言指针移动函数,fseek c语言指针移动函数
weixin_28873927的博客
05-19 1653
转自：http://hi.baidu.com/wengjiang000/item/867ead5da7d95c10abf6d736通常文件打开后,读写位置按先后顺序.但有时你想变动读写位置,例如重新从某处起,再读一次.int fseek(FILE *stream, long offset, int fromwhere);fseek 用于二进制方式打开的文件,移动文件读写指针位置.fseek(in,...
c语言从excal读取字符串,C语言操作EXCEL文件(读写)
weixin_31659795的博客
05-17 909
C语言操作EXCEL文件(读写)本文主要介绍通过纯C语言进行EXCEL的读写操作：(修改时间2018.08.28，如果运行结果均是0，请看文章最后一节)C语言读操作C语言写操作在之前需要使用C语言读取Excel文件内容的功能，查阅了很多资料，大部分是通过ODBC或者过OLE/COM对Excel表格的读取操作，这变要求在工程中添加类，如CApplicaton及其头文件等，这包括Excel接口、导入类...
【C 语言】文件操作 ( fseek 函数 )
热门推荐
让 学习 成为一种 习惯 ( 韩曙亮 の 技术博客 )
11-16 3万+
一、fseek 函数、 二、fseek 函数代码示例
编译原理实验词法分析器
01-02
编译原理实验词法分析器 本实验的目的是设计和实现一个词法分析器，以加深对词法分析过程的理解，并掌握词法分析方法。实验中，我们将使用 C 语言实现一个简单的词法分析器，能够识别和分析 C 语言源程序中的单词...
编译原理词法分析与语法分析实验报告
06-05
编译原理词法分析与语法分析实验报告 一、词法分析 词法分析是编译过程的第一阶段，它的主要任务是将源程序分割成单词序列。...我们的实验结果证明了我们的词法分析器和语法分析器可以正确地识别单词序列和语法结构。
南邮编译原理实验2 语法分析程序的设计 LL(1)
01-16
该源码提供了以下功能：求First集和Follow集，展示出LL(1)分析表，对用户输入的字符串，系统展示出分析过程并给出分析结论。 文法存于txt文件中，一行一句规则，建议以E::=AB|a的形式存储。
fseek( fp, SEEK_SET, SEEK_END )；的作用？以及如何获取一个文件的大小？
qq_50635297的博客
03-10 6475
fseek( fp, SEEK_SET, SEEK_END );的作用？以及如何获取一个文件的大小？fseek函数的作用是设置文件指针的位置，通过offset和whence参数的组合，可以实现对文件指针的灵活定位。在本代码中，通过将whence设置为SEEK_END，将offset设置为0，实现了将文件指针指向文件末尾的目的，从而可以通过ftell函数获取文件大小。
c语言fseek函数的总结
大猪的博客
08-21 1万+
头文件：#include 函数原型：int fseek(FILE *stream, long offset, int fromwhere); 参数：     stream：指向打开的文件指针。     offset：以基准点为起始点的偏移量。     fromwhere：基准点。 返回值：成功，返回0；失败返回-1。 其中基准点包括这三个枚举：     SEEK_SET：文件头。
Java读取文本文件
lxyoucan的博客
09-29 367
/** * 读取文本内容 * @param filePath 文件路径 * @return */ public static String readFileText(String filePath) { File file = new File(filePath); BufferedReader reader = null; StringBuffer sb = new StringBuffer(); .
fseek函数的用法linux,C 库函数 - fseek()函数
weixin_39588265的博客
05-09 2825
首先查看一下linux用户使用手册函数名：fseek头文件：#include功能：把与stream 有关的读写文件位置指针放到一个指定位置。参数：FILE *stream ：使用fopen打开的文件指针streamlong offset ： 偏移位置(以字节为单位)int whence ：基准位置，它一般指定为下列常量之一：起始点对应的数字代表的文件位置SEEK_SET0文件开头SEEK_CUR1...
C 文件 fseek() 函数
最新发布
Tom_Jerry__的博客
11-26 2210
fseek()函数用于将文件指针设置为指定的偏移量。它用于将数据写入文件中所需的位置。
fseek函数使用
weixin_30608503的博客
11-20 202
fseek函数（转） int fseek(FILE *stream, long offset, int fromwhere);fseek 用于二进制方式打开的文件,移动文件读写指针位置. fseek(in,-1L,1); -- 文件流in, 零点为当前指针位置,SEEK_CUR 就是 1, -1L -- 文件指针回退1个字节int fseek( FILE *stream, lon...
文件IO【1】
m0_63121505的博客
05-26 112
1>文件描述符是一个非负整数，使用open打开一个文件后，就会返回该文件的描述符，在之后想要操作文件，只需要通过该文件描述符即可。基于系统调用的方式，只要调用文件IO的接口，程序就会从用户空间向内核空间进行一次交互，效率相比于标准IO较低，原因是没有缓存区。使用变量拷贝文件描述符，其实只是拷贝变量的值，并没有产生新的文件描述符，只是在程序中多了一个变量，记录该文件描述符。O_CREAT:如果文件不存在，创建一个文件，如果加了该选项，第三个参数一定要加。4>一个程序中文件描述符的最大承载量默认为1024。
32.0、C语言——文件操作 (3)
m0_52433668的博客
09-24 1689
那这里需要注意的是，如果在 ftell ( fp ) 之前用了 fgetc ( fp ) ，那么 fgetc() 去读了一次之后文件指针会往后移动一位，那么这时候如果用 ftell(fp) 算出的结果就是 1 了；2. fseek()函数，传入 -> 第一个参数 pf ，第二个参数向后偏移 2 个字符，第三个参数文件指针的位置从 SEEK_CUR(也就是文件的起始位置)开始；我们将 TEST.txt 文本文件置为空后，打开该文件，然后读取，得到的返回值是 -1，所以 EOF 的值为 -1。
fseek() 移动文件指针
fba529635的专栏
08-09 1410
<br />      以下是对文本文件操作的例子：<br /> <br />int fseek(FILE* stream, long offset, int origin),<br />参数：<br />stream: Pointer to FILE structure.<br />offset:   Number of bytes from origin.<br />origin:   Initial position: SEEK_CUR: Current position of file pointe
语法分析器实验报告.doc
07-16
编译原理语法分析器实验报告

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值