C语言编程是什么
C语言编程，顾名思义，就是用C语言来进行计算机编程工作。C语言是国际上广泛流行的,很有发展前途的计算机高级语言.它适合作为系统描述语言,即可用来编写系统软件,也可用来编写应用软件.
C语言编程
C语言编程，顾名思义，就是用C语言来进行计算机编程工作。C语言是国际上广泛流行的,很有发展前途的计算机高级语言.它适合作为系统描述语言,即可用来编写系统软件,也可用来编写应用软件.
中文名
C语言编程
原型
ALGOL 60
特点
结构化设计
语言类型
高级语言
定义
C语言是一种计算机程序设计语言。它既有高级语言的特点，又具有汇编语言的特点。它可以作为系统设计语言，编写工作系统应用程序，也可以作为应用程序设计语言，编写不依赖计算机硬件的应用程序。因此，它的应用范围广泛。主要有以下特点：
C语言在很多方面都可以用，不仅仅是在软件开发上，各类科研都是需要用到C语言的。具体应用比如我是学硬件的，单片机以及嵌入式系统都可以用C来开发。
C 语言发展如此迅速, 而且成为最受欢迎的语言之一, 主要因为它具有强大的功能。许多著名的系统软件, 如DBASE Ⅲ PLUS、DBASE Ⅳ 都是由C 语言编写的。用C 语言加上一些汇编语言子程序, 就更能显示C 语言的优势了, 象PC- DOS 、WORDSTAR等就是用这种方法编写的。归纳起来C 语言具有下列特点:1. C是中级语言它把高级语言的基本结构和语句与低级语言的实用性结合起来。C 语言可以象汇编语言一样对位、字节和地址进行操作, 而这三者是计算机最基本的工作单元。
2. C是结构式语言结构式语言的显著特点是代码及数据的分隔化, 即程序的各个部分除了必要的信息交流外彼此独立。这种结构化方式可使程序层次清晰, 便于使用、维护以及调试。C 语言是以函数形式提供给用户的, 这些函数可方便的调用, 并具有多种循环、条件语句控制程序流向, 从而使程序完全结构化。
3. C语言功能齐全C 语言具有各种各样的数据类型, 并引入了指针概念, 可使程序效率更高。另外C 语言也具有强大的图形功能, 支持多种显示器和驱动器。而且计算功能、逻辑判断功能也比较强大, 可以实现决策目的编游戏，编3D游戏，做数据库，做联众世界，做聊天室，做PHOTOSHOP做FLASH，做3DMAX。
4. C语言适用范围大C语言还有一个突出的优点就是适合于多种操作系统, 如DOS、UNIX,也适用于多种机型。
C语言对操作系统和系统使用程序以及需要对硬件进行操作的场合，用C语言明显优于其它解释型高级语言，有一些大型应用软件也是用C语言编写的。
C语言具有绘图能力强，可移植性，并具备很强的数据处理能力，因此适于编写系统软件，三维，二维图形和动画。它是数值计算的高级语言。
常用的C语言IDE（集成开发环境）有Microsoft Visual C++，Borland C++，Watcom C++ ,Borland C++ ，Borland C++ Builder,Borland C++ 3.1 for DOS,Watcom C++ 11.0 for DOS,GNU DJGPP C++ ，Lccwin32C Compiler 3.1,Microsoft C,High C,Turbo C,Dev-C++,C-Free，win-tc等等......
C语言编程？
10个C语言新手编程时常犯的错误及解决方式
C语言的最大特点是：功能强、使用方便灵活。C编译的程序对语法检查并不象其它高级语言那么严格，这就给编程人员留下“灵活的余地”，但还是由于这个灵活给程序的调试带来了许多不便，尤其对初学C语言的人来说，经常会出一些连自己都不知道错在哪里的错误。看着有错的程序，不知该如何改起，小编通过对C的学习，积累了一些C编程时常犯的错误，写给各位学员以供参考。
1、将字符常量与字符串常量混淆。
char c;
c="a";
在这里就混淆了字符常量与字符串常量，字符常量是由一对单引号括起来的单个字符，字符串常量是一对双引号括起来的字符序列。C规定以“\”作字符串结束标志，它是由系统自动加上的，所以字符串“a”实际上包含两个字符：‘a'和‘\0'，而把它赋给一个字符变量是不行的。
2、输入数据时，企图规定精度。
scanf("%7.2f",a);
这样做是不合法的，输入数据时不能规定精度。
3、输入字符的格式与要求不一致。
在用“%c”格式输入字符时，“空格字符”和“转义字符”都作为有效字符输入。
scanf("%c%c%c",c1,c2,c3);
如输入a b c
字符“a”送给c1，字符“ ”送给c2，字符“b”送给c3，因为%c只要求读入一个字符，后面不需要用空格作为两个字符的间隔。
4、输入输出的数据类型与所用格式说明符不一致。
例如，a已定义为整型，b定义为实型
a=3;b=4.5;
printf("%f%d\n",a,b);
编译时不给出出错信息，但运行结果将与原意不符。这种错误尤其需要注意。
5.switch语句中漏写break语句。
例如：根据考试成绩的等级打印出百分制数段。
switch(grade)
{
case 'A':printf("85~100\n");
case 'B':printf("70~84\n");
case 'C':printf("60~69\n");
case 'D':printf("60\n");
default:printf("error\n");
}
由于漏写了break语句，case只起标号的作用，而不起判断作用。因此，当grade值为A时，printf函数在执行完第一个语句后接着执行第二、三、四、五个printf函数语句。正确写法应在每个分支后再加上“break;”。例如
case 'A':printf("85~100\n");break;
6、定义数组时误用变量。
int n;
scanf("%d",n);
int a[n];
数组名后用方括号括起来的是常量表达式，可以包括常量和符号常量。即C不允许对数组的大小作动态定义。
7、在不应加地址运算符的位置加了地址运算符。
scanf("%s",str);
C语言编译系统对数组名的处理是：数组名代表该数组的起始地址，且scanf函数中的输入项是字符数组名，不必要再加地址符。应改为：
c语言编程怎样入门
一、工欲善其事，必先利其器
这里介绍几个学习C语言必备的装置和书籍：
A）开发环境
例如turbo C 2.0,这个曾经占据了DOS时代开发程序的大半个江山。但是现在windows时代，用turbo C有感觉不方面，编辑程序起来很吃力，并且拖放，更没有函数变量自动感应功能，查询参考资料也不方便。建议使用Visual C++,这个平台虽然体积大，但是一旦安装好了，用起来很方便。
B）一本学习教程
现在C语言教材多如牛毛，推荐大家使用《C语言程序设计》第二版。此书很适合初学者，并且内容也很精到。
C）利用辅助学习软件
毕竟现在是Windows时代了，学习软件多如牛毛，这里向大家推荐一个“集成学习环境(C语言)”，里边的知识点总结和例程讲解都非常好，有好几千题的题库测试环境，包括一个windows下的trubo C，初学者甚至不用装其它的编译器，就可以练习编程了。还有一个“C语言学习系统”软件，不过感觉只是一个题库系统，如果你觉得题做的不够，不妨也可以试试。
二、葵花宝典
学习计算机语言最好的方法是什么？答曰：读程序。
没错，读程序是学习C语言入门最快，也是最好的方法。我们大家都应该有个体验——在最初学习windows系统操作或Microsoft words如果操作的过程中，刚开始总是正儿八经地买来教材，结果读来读去却云里雾里，而当我们将教材丢在一边，拿起鼠标反复地试，几个小时就搞定。包括学习J#,C#等其他语言，在今天的Windows时代，也不再提倡抱着书本逐行啃，而是学习它们的例程。
当然，对于没有学过任何计算机语言的初学者，多少要先阅读教程，认真体会所有概念，然后不放过这一章中提到的所有例程，仔细研读，直到每一行都理解了，再找几个编程题目，最好是和例程类似的或一样的，自己试图写出这段已经读懂的程序。如果写不出来，回过头来再继续研究例程，想想自己为什么写不出来，然后再去写这段程序，反反复复，直到你手到擒来为止。
三、登峰造极
写程序的最高境界其实就是掌握各种解决问题的手段（数据结构）和解决问题的方法（算法）。
是不是写出底层程序就是程序设计高手呢？非也，写底层程序，无非是掌握了硬件的结构，况且硬件和硬件还不一样，要给一个芯片写驱动程序，无非就是掌握这块芯片的各种寄存器及其组合，然后写值读值，仅此而已。这不过是熟悉一些I/O函数罢了。那么怎样才算精通程序设计呢？怎样才能精通程序设计呢？举个例子：
你面前有10个人，找出一个叫“张三”的人，你该怎么办？第一种方法：直接对这10个人问：“谁叫张三”。第2种方法：你挨个去问“你是不是张三？”，直到问到的这个人就是张三。第三种方法：你去问一个人“你认不认识张三，指给我看”。不要小看这个问题，你说当然会选第一种方法，那么恭喜你答对了，因为这个方法最快，效率最高，但是在程序设计中找到解决问题的最优方法和你用的手段却是考验一个程序员程序设计水平的重要标志，而且是不容易达到的。刚才这个问题类似于数据结构和算法中的：Map数据结构，穷举查找和折半查找。所以掌握好数据结构和一些常用算法，是登峰造极的必然之路。
用c语言编程
您若要C++程序就看我这个
#include
iostream
using
namespace
std;
int
main()
{
int
numbers[10];
int
i;
cout"请输入10个整数"endl;
for(i=0;
i10;
i++)
{
cinnumbers[i];
}
int
maxnum
=
numbers[0];
for(i=1;
i10;
i++)
{
if(maxnum
=
numbers[i])
{
maxnum
=
numbers[i];
}
}
int
sum
=
0;
for(i=0;
i10;
i++)
{
sum
+=
numbers[i];
}
float
average
=
sum/10.0f;
cout"10个整数当中最大的是"maxnumendl;
cout"10个整数的平均数是"averageendl;
return
0;
}
谢谢采纳！
C语言编程。
第一题：
#include
stdio.h
#include
math.h
#include
stdlib.h
#define
ESSP
0.00000001
int
main()
{
//定义a,b,c和两个根，以及delta（数学中希腊字母）
double
a,b,c,delta,root1,root2;
//输入
printf("Please
input
a:");
scanf("%lf",a);
printf("Please
input
b:");
scanf("%lf",b);
printf("Please
input
c:");
scanf("%lf",c);
//套用求根公式并且计算得到结果
delta=b*b-4*a*c;
if(delta-ESSP)
{
printf("This
equation
has
no
real
root.");
}
else
if(deltaESSP)
{
root1=(-b+sqrt(delta))/(2*a);
root2=(-b-sqrt(delta))/(2*a);
printf("This
eqution
has
two
unequalize
roots:x1=%lf,x2=%lf\n",root1,root2);
}
else
{
root1=-b/(2*a);
printf("This
eqution
has
two
equalize
roots:%lf",root1);
}
system("pause");
return
0;
}
第二题：
#include
stdio.h
#include
math.h
#include
stdlib.h
#define
ESSP
0.00000001
int
Fun(int
x)
{
switch(x)
{
case
1:
case
2:
case
3:
case
4:return
x;
break;
case
5:
case
6:
case
7:
case
8:
case
9:
case
10:
case
11:
case
12:
case
13:
case
14:
case
15:return
x+6;
default:return
x-6;
}
}
int
main()
{
printf("Fun(4)
=
%d",Fun(4));
system("pause");
return
0;
}
c语言编程
//计划做的脚本引擎的一部分
//参考的 C++编程艺术
//总地来说会有一些难度
//我的是C++应该会给你一些启发
//TypeDef.h
#include "windows.h"
#ifndef B_TYPE_DEF_H
#define B_TYPE_DEF_H
const int MAX_T_LEN = 128;//可以分析的最大符号长度(同时决定了一个字符变量的最大长度为128字节)
const int MAX_ID_LEN = 31;//允许的最大的标识长度(一个标识符是指一个变量名或函数名)
const int MAX_BUF_LEN = 1024;//解释缓冲区1024字节
const int NUM_PARAMS = 32;//最大参数数目
const int MAX_DIM_NUM = 65536//数组最大维数
//需要分析的所有东西
enum Token_Item { UNDEF=1, //未定义
E_TEMP,//当模板使用
E_CHAR,//char关键字
E_INT,//int关键字
E_FLOAT,//float关键字
E_SWITCH,//switch关键字
E_CASE,//case关键字
E_IF,//if关键字
E_ELSE,//else关键字
E_FOR,//for关键字
E_DO,//do关键字
E_WHILE,//while关键字
E_BREAK,//break关键字
E_RETURN,//return关键字
E_COUT,//cout关键字
E_CIN,//cin关键字
LBLOCK, //{
RBLOCK,//}
DOU,//,
EOS,//;
MAO,//:
SFEN,//'已舍弃,不含'分析
LT,//
LE,//=
GT,//
GE,//=
EQ,//==
NE,//!=
FF,//.
LK,//(
NOT,//!
INC,//++
DEC,//--
ADD,//+
SUB,//-
RK,//)
LZK,//[
RZK,//]
LS,//
RS,//
ASS,//=
AND,//
OR,//||
MUL,//*
DIV,///
MOD,//%
POW,//^
NUMBER, //数字
IDENTIFIER,//标识
STRING,//字符串
END//文件结束
};//需要分析的全部符号
enum Token_Type{
UNK,//未知类型
KEY,//关键字
FJF,//分界符
CMP,//比较运算符
OPE,//运算符
NUM,//数字
IDE,//标识符
STR,//字符串
NON,//结束符号
UDF//未定义
};
typedef struct Token_Table{//符号表
char name[MAX_T_LEN];
Token_Item token;
Token_Type type;
} TOKEN_TABLE,*PTOKEN_TABLE;
enum error_msg //错误类型
{ SYNTAX=1000, NO_EXP, NOT_VAR, DUP_VAR, DUP_FUNC,
SEMI_EXPECTED, UNBAL_BRACES, FUNC_UNDEF,
TYPE_EXPECTED, RET_NOCALL, PAREN_EXPECTED,
WHILE_EXPECTED, QUOTE_EXPECTED, DIV_BY_ZERO,
BRACE_EXPECTED, COLON_EXPECTED,FAIL_OPEN,ERROR_SIZE,
NO_MAIN,ERROR_ASSIGN,ERROR_RZK,ERROR_DIM};
class InterpExc { //错误类
error_msg err;
public:
InterpExc(error_msg e) { err = e; }
error_msg get_err() { return err; }
};
enum Vars{类型
V_Int,
V_Float,
V_String,
V_pInt,
V_pFloat,
V_pString,
V_Udef
};
#endif
#ifndef V_NULL
#define V_NULL (-1)
#endif
//Cfenxi.h
#include "TypeDef.h"
#include iostream
#include vector
#include stack
#include algorithm
#include string
using namespace std;
//Fenxi类说明
//curr_pt始终指向将要分析的地址
//prev_pt为前一个分析的地址
//可以使用函数GotoPt来改变当前分析地址
//分析结果放在变量stoken,item,type
//在Cfenxi.cpp中定义了一个文件级变量TOKEN_TABLE tokentable[];
//在使用的时候必须声明这个变量
#ifndef B_CFENXI_H
#define B_CFENXI_H
class Fenxi{
public:
char stoken[MAX_T_LEN+1];//分析出来的符号名
char buff[MAX_BUF_LEN+1];//缓冲区
Token_Item item;//分析出来的具体符号
Token_Type type;//符号大类
long curr_pt;//当前分析点
long prev_pt;//前一个分析点
char pFileName[256];//脚本文件名
PTOKEN_TABLE pTokenTable;//符号表
public:
Fenxi(){};
~Fenxi(){};
void Create(char*,PTOKEN_TABLE,int);//创建分析对象
void GetToken();//分析一步
void GotoPt(long);//跳分析点
void PutBack();//回退一个分析点
private:
int nTableItem;//分析表中的分析数目
long iFileLength;//脚本文件长度
int iBlock;//当前所在区块
int iYouBiao;//当前游标
char cbuff;//当前所指向的字符
char cbuff1;//超前搜索的字符
void MoveNext();//向下移动
void MovePrev();//向前移动
void LoadBlock();//装入一个块
long GetPt(int i,int n){return (long)(i*MAX_BUF_LEN+n);};//计算位置
bool KeyLookUp(char*,Token_Item );//查找是不是关键词
bool isdelim(char);
};
//解释类
class var_value{
public:
char string_value[MAX_T_LEN+1];
int int_value;
float float_value;
Vars v_type;
public:
var_value()
{
int_value=0;
float_value=0;
string_value[0]=0;
v_type=Udef;
}
var_value(const var_value);
set_type(Vars type){v_type=type;}
~var_value(){}
friend bool operator == (const var_value _X, const var_value _Y);
friend bool operator (const var_value _X, const var_value _Y);
};
class temp_var_value{
public:
char string_value[MAX_T_LEN+1];
int int_value;
float float_value;
int p_int;
int p_float;
int p_string;
vectorint dim;
Vars v_type;
public:
temp_var_value()
{
int_value=0;
float_value=0;
string_value[0]=0;
p_int=p_float=p_string=V_NULL;
v_type=Udef;
};
temp_var_value(const temp_var_value);
temp_set_type(Vars type){v_type=type;}
~temp_var_value(){}
friend bool operator == (const temp_var_value _X, const temp_var_value _Y);
friend bool operator (const temp_var_value _X, const temp_var_value _Y);
};
struct var_type { //变量类型
char var_name[MAX_ID_LEN+1]; // 变量名
Vars v_type;//数据类型
vectorvar_value value; //变量值
vectorint v_dim;//变量维数
int v_max;//变量的最大数目
};
struct func_type {
char func_name[MAX_ID_LEN+1]; //函数名
Vars ret_type; //返回值类型
long loc; // 函数入口点,函数的入口点是指分析点指向函数括号后第一个字符
};
class Script{
public:
Fenxi theFx;//词法分析对象,负责对脚本文件的操作
char FileName[256];//脚本文件名
var_value ret_value;//返回值
bool breakfound;//中断
public:
Script(){};
~Script(){};
void Create(char*,PTOKEN_TABLE,int);//创建脚本对象
void ExecuteScript();//开始解释脚本
private:
void PreScan();//预扫描
void decl_global();//声明全局变量
long find_func(char*);//返回函数的入口点
void ItemToVar(Token_Item,Vars);//根据一个项,得到相当的变量类型
void CallFun();//执行一个函数
void get_args();//得到函数的形式参数名
void Interp();//具体解释
private:
void eval_exp (var_value value);
void eval_exp0(var_value value);
void eval_exp1(var_value value);
void eval_exp2(var_value value);
void eval_exp3(var_value value);
void eval_exp4(var_value value);
void eval_exp5(var_value value);
void eval_exp6(var_value value);
void eval_exp7(var_value value);
void eval_exp8(var_value value);
bool is_var(char *s);
// 变量名,变量的维数,变量的值,变量的类型
void assign_var(char *var_name,int idx, var_value value);
void find_var_value(char *var_name,int idx,var_value value);
int find_idx(vectorint,vectorint);// 计算[][]
void find_vector(vectorint );//读取[]
int cal_idx(vectorint);
Vars is_var_type;//使用is_var的时候如果返回值是真那么这个变量存储了变量类型
public:
//每执行一个函数的时候就把进入前的局部变量数目
//放到函数结点栈,函数执行完的时候就根据栈里的
//数据改变局部函数表里的变量,从而实现变量的灵活使用
//同理块结点栈的原理也一样
//变量表
vectorvar_type global_vars; //全局变量表
vectorvar_type local_var_stack; //局部变量表(函数参数作为局部变量处理)
vectorfunc_type func_table; //函数表
stackint func_call_stack;//函数结点栈
stackint nest_scope_stack;//块结点栈
};
#endif
//Fenxi.cpp
#include "CFenxi.h"
#include cstring
#include cctype
#include fstream
#include cstdio
#include cmath
using namespace std;
///////////////////////////////////////////////////////////////////////
/////////////////////////词法分析类的函数定义//////////////////////////
///////////////////////////////////////////////////////////////////////
extern TOKEN_TABLE tokentable[]={
"char",E_CHAR,KEY,
"int",E_INT,KEY,
"float",E_FLOAT,KEY,
"switch",E_SWITCH,KEY,
"case",E_CASE,KEY,
"if",E_IF,KEY,
"else",E_ELSE,KEY,
"for",E_FOR,KEY,
"do",E_DO,KEY,
"while",E_WHILE,KEY,
"break",E_BREAK,KEY,
"return",E_RETURN,KEY,
"cout",E_COUT,KEY,
"cin",E_CIN,KEY,
"{",LBLOCK,FJF,
"}",RBLOCK,FJF,
",",DOU,FJF,
";",EOS,FJF,
"",LT,CMP,
"=",LE,CMP,
"",GT,CMP,
"=",GE,CMP,
"==",EQ,CMP,
"!=",NE,CMP,
".",FF,OPE,
"(",LK,OPE,
")",RK,OPE,
"[",LZK,OPE,
"]",RZK,OPE,
"++",INC,OPE,
"--",DEC,OPE,
"",LS,OPE,
"",RS,OPE,
"=",ASS,OPE,
"!",NOT,OPE,
"",AND,OPE,
"||",OR,OPE,
"+",ADD,OPE,
"-",SUB,OPE,
"*",MUL,OPE,
"/",DIV,OPE,
"%",MOD,OPE,
"^",POW,OPE,
};
var_value::var_value(const var_value p)
{
int_value=p.int_value;
float_value=p.float_value;
strcpy(string_value,p.string_value);
v_type=p.v_type;
}
bool operator == (const var_value _X, const var_value _Y)
{
if (_X.v_type != _Y.v_type)
{
return false;
}
else
{
switch (_X.v_type)
{
case V_Float:
return (abs(_X.float_value - _Y.float_value) 0.0001);
break;
case V_Int:
return (_X.int_value == _Y.int_value);
break;
case V_Int:
return !(strcmp(_X.string_value, _Y.string_value));
break;
default:
return false;
}
}
}
bool operator (const var_value _X, const var_value _Y)
{
if (_X.v_type != _Y.v_type)
{
return false;
}
else
{
switch (_X.v_type)
{
case V_Float:
return (_X.float_value _Y.float_value);
break;
case V_Int:
return (_X.int_value _Y.int_value);
break;
case V_Int:
return !(strcmp(_X.string_value, _Y.string_value));
break;
default:
return false;
}
}
temp_var_value::temp_var_value(const temp_var_value p)
{
int_value=p.int_value;
float_value=p.float_value;
strcpy(string_value,p.string_value);
p_int=p.p_int;
p_float=p.p_float;
p_string=p.p_string;
v_type=p.v_type;
}
void Fenxi::Create(char* p,PTOKEN_TABLE ptt,int n)
{
strcpy(pFileName,p);
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(0,ios::end);
iFileLength=fin.tellg();
fin.close();
if(iFileLength==0)
throw InterpExc(ERROR_SIZE);
iBlock=0;
LoadBlock();
MoveNext();//指向第一个字符
iYouBiao=0;//置游标于文件头
curr_pt=0;
prev_pt=0;
cbuff=buff[0];//当前应该分析字符
cbuff1=buff[1];//超前搜索字符
pTokenTable=ptt;
nTableItem=n;//分析表设置
}
void Fenxi::MoveNext()
{
if(iYouBiao==MAX_BUF_LEN-1)//如果当前游标在缓冲区尾
{
iBlock++;
LoadBlock();
cbuff=buff[0];
cbuff1=buff[1];//超前搜索
}
else
{
iYouBiao++;
cbuff=buff[iYouBiao];
if(iYouBiao==MAX_BUF_LEN-1)//超前搜索
{
char temp[2];
temp[1]=0;
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(MAX_BUF_LEN*(iBlock+1));
fin.read(temp,1);
int i=fin.gcount();
temp[i]=0;
fin.close();
cbuff1=temp[0];
}
else
cbuff1=buff[iYouBiao+1];
}
curr_pt=GetPt(iBlock,iYouBiao);
}
void Fenxi::MovePrev()
{
if(iYouBiao==0)//如果当前游标在缓冲区头
{
cbuff1=cbuff;//超前搜索
iBlock--;
LoadBlock();
iYouBiao=MAX_BUF_LEN-1;
cbuff=buff[iYouBiao];
}
else
{
cbuff1=cbuff;//超前搜索
iYouBiao--;
cbuff=buff[iYouBiao];
}
curr_pt=GetPt(iBlock,iYouBiao);
}
void Fenxi::PutBack()
{
GotoPt(prev_pt);
}
void Fenxi::LoadBlock()//装入一个块
{
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(MAX_BUF_LEN*iBlock);
fin.read(buff,MAX_BUF_LEN);
int i=fin.gcount();
buff[i]=0;
iYouBiao=0;
fin.close();
}
void Fenxi::GotoPt(long pt)
{
if(pt/MAX_BUF_LEN==curr_pt/MAX_BUF_LEN)//如果是在同一个块内的话
{
curr_pt=pt;
iYouBiao=curr_pt-iBlock*MAX_BUF_LEN;
cbuff=buff[iYouBiao];
}
else//否则要重新装入内存
{
curr_pt=pt;
iBlock=curr_pt/MAX_BUF_LEN;
LoadBlock();
iYouBiao=curr_pt-iBlock*MAX_BUF_LEN;
cbuff=buff[iYouBiao];
}
if(iYouBiao==MAX_BUF_LEN-1)//超前搜索
{
char temp[2];
temp[1]=0;
ifstream fin(pFileName,ios::in|ios::binary);
fin.seekg(MAX_BUF_LEN*(iBlock+1));
fin.read(temp,1);
int i=fin.gcount();
temp[i]=0;
fin.close();
cbuff1=temp[0];
}
else
cbuff1=buff[iYouBiao+1];
}
void Fenxi::GetToken()
{
prev_pt=curr_pt;//保存前一个的位置
char *temp; //利用一个指针向字符里写内容
item=UNDEF;type=UDF;
temp = stoken;
*temp = '\0';
// 如果当前字符是空格且未到文件末
while(isspace(cbuff) cbuff) MoveNext();
// 跳过行
while(cbuff == '\r') {
MoveNext();
MoveNext();
while(isspace(cbuff) cbuff) MoveNext();
}
// 是否结尾
if(cbuff == '\0') {
*stoken = '\0';
item = END;
type=NON;
return ;
}
// 检查{}标识符
if(strchr("{}", cbuff)) {
stoken[0]=cbuff;
stoken[1]='\0';
type=FJF;
if(cbuff=='{')
item=LBLOCK;
else
item=RBLOCK;
MoveNext();//指向下一个字符
return ;
}
// 检查注释信息
if(cbuff == '/')
if(cbuff1 == '*') { // /*注释符
MoveNext();
MoveNext();
do { // 找到结尾
while(cbuff != '*') MoveNext();
MoveNext();
} while (cbuff != '/');
MoveNext();
GetToken();
return;
} else if(cbuff1 == '/') { // is a // CMPment
MoveNext();
MoveNext();
// Find end of CMPment.
while(cbuff != '\r' cbuff != '\0') MoveNext();
if(cbuff == '\r') {MoveNext();MoveNext();}
GetToken();
return;
}
// 检查双操作符
if(strchr("!=+-|", cbuff)) {
switch(cbuff) {
case '|':
if(cbuff1 == '|') {
MoveNext();MoveNext();
*temp = '|';
temp++;
*temp = '|';
temp++;
*temp = '\0';
item=OR;
type=OPE;
}
break;
case '':
if(cbuff1 == '') {
MoveNext();MoveNext();
*temp = '';
temp++;
*temp = '';
temp++;
*temp = '\0';
item=AND;
type=OPE;
}
break;
case '=':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '=';
temp++;
*temp = '=';
temp++;
*temp = '\0';
item=EQ;
type=CMP;
}
break;
case '!':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '!';
temp++;
*temp = '=';
temp++;
*temp = '\0';
item=NE;
type=CMP;
}
break;
case '':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '';
temp++;
*temp = '=';
item=LE;
type=CMP;
}
else if(cbuff1 == '') {
MoveNext();MoveNext();
*temp = '';
temp++;
*temp = '';
item=LS;
type=OPE;
}
else {
MoveNext();
*temp = '';
item=LT;
type=CMP;
}
temp++;
*temp = '\0';
break;
case '':
if(cbuff1 == '=') {
MoveNext();MoveNext();
*temp = '';
temp++;
*temp = '=';
item=GE;
type=CMP;
} else if(cbuff1 == '') {
MoveNext();MoveNext();
*temp = '';
temp++;
*temp = '';
item=RS;
type=OPE;
}
else {
MoveNext();
*temp = '';
item=GT;
type=CMP;
}
temp++;
*temp = '\0';
break;
case '+':
if(cbuff1 == '+') {
MoveNext();MoveNext();
*temp = '+';
temp++;
*temp = '+';
temp++;
*temp = '\0';
item=INC;
type=OPE;
}
break;
case '-':
if(cbuff1 == '-') {
MoveNext();MoveNext();
*temp = '-';
temp++;
*temp = '-';
temp++;
*temp = '\0';
item=DEC;
type=OPE;
}
break;
}
if(*stoken) return;
}
// 其它运算符号
if(strchr("+-*^/=().[]|!%", cbuff)) {
type=OPE;
switch(cbuff){
case '+':
item=ADD;break;
case '-':
item=SUB;break;
case '*':
item=MUL;break;
case '/':
item=DIV;break;
case '=':
item=ASS;break;
case '(':
item=LK;break;
case ')':
item=RK;break;
case '[':
item=LZK;break;
case ']':
item=RZK;break;
case '.':
item=FF;break;
case '|':
item=UNDEF;type=UDF;break;
case '!':
item=NOT;break;
case '%':
item=MOD;break;
}
*temp = cbuff;
MoveNext();
temp++;
*temp = '\0';
return ;
}
// 分界符号
if(strchr(";,#:", cbuff)) {
type=FJF;
switch(cbuff){
case ';':
item=EOS;break;
case ',':
item=DOU;break;
case ':':
item=MAO;break;
}
*temp = cbuff;
MoveNext();
temp++;
*temp = '\0';
return ;
}
// 读取一个字符串
if(cbuff == '"') {
MoveNext();
while(cbuff != '"' cbuff != '\r' cbuff) {
// Check for \n escape sequence.
if(cbuff == '\\') {
if(cbuff1 == 'n') {
MoveNext();
*temp++ = '\n';
}
}
else if((temp - stoken) MAX_T_LEN)
*temp++ = cbuff;
MoveNext();
}
if(cbuff == '\r' || cbuff == 0)
throw InterpExc(SYNTAX);
MoveNext(); *temp = '\0';
item=STRING;
type=STR;
return ;
}
// 读取一个数字
if(isdigit(cbuff)) {
while((cbuff='0'cbuff='9')||(cbuff=='.')) {
if((temp - stoken) MAX_T_LEN)
*temp++ = cbuff;
MoveNext();
}
*temp = '\0';
item=NUMBER;
type=NUM;
return ;
}
// Read identifier or keyword.
if(isalpha(cbuff)) {
while(!isdelim(cbuff)) {
if((temp - stoken) MAX_T_LEN)
*temp++ = cbuff;
MoveNext();
}
item=E_TEMP;
}
*temp = '\0';
// Determine if token is a keyword or identifier.
if(item == E_TEMP) { // convert to internal form
if(KeyLookUp(stoken,item)) type=KEY; // is a keyword
else {type = IDE;item=IDENTIFIER;}
}
if(type==UDF)
throw InterpExc(SYNTAX);
}
bool Fenxi::KeyLookUp(char *s,Token_Item it){
int i;
// char *p;
// 转为小写字母
// p = s;
// while(*p) { *p = tolower(*p); p++; }
for(i=0; inTableItem; i++) {
if((tokentable[i].type==KEY)!strcmp(tokentable[i].name, s))
{
it=tokentable[i].token;
return true;
}
}
return false;
}
// 符号检查
bool Fenxi::isdelim(char c)
{
if(strchr(" !:;,+-/*^=().|[]\"%", c) || c == 9 ||
c == '\r' || c == 0) return true;
return false;
}