1. 自学c语言 零基础 看什么书 该怎么学
现在，市面上的
C语言书籍多的数不过来，但是很多不适合你这种初学者使用，作为一名老程序员，我给你推荐几本我看过认为还不错的书：
1)
《C语言小白变怪兽》：既适合对计算机一窍不通的小白，也适合有编程基础的读者，还可以用来进阶。同时，最重要的是，这本书的作者还在不断地更新这本书，我认为最大的特点是通俗易懂，深入浅出，只要认真看，就一定能看懂，我认为这是C语言入门的首选教材，吐血推荐，经典中的经典！！！
2)
《啊哈C语言》：适合对计算机一窍不通的纯小白，有编程基础的读者请忽略。这本书语言幽默，生动形象，通俗易懂，给人耳目一新的感觉，但是这本书非常浅显，并不深入，所以适合纯小白入门，找到门以后也就扔了。这本书着重于语言艺术，针对纯小白下足了功夫，小学生坐在马桶上都能学会编程。说实话，我非常欣赏作者的创意和用心，国内像这样写书的少之又少，入门的书就应该是这个样子。
上边这两本书是我推荐给你用于C语言入门的，我不建议你使用谭浩强的《C语言程序设计》这本书入门，虽然这本书的知名度很高，因为很多大学把它作为C语言的授课教材，然而，这本书被吐槽最多，不但代码不标准，而且有很多错误，据说可以找出几十个错误，这样很容易误导你这种小白。
等你有一定的C语言基础了，可以看下面的这几本书，进一步提升你的编程水平：
1)
《C
Primer
Plus》：畅销
30
余年的C语言入门经典书籍，至今无人能撼动它的地位，它是最符合C语言标准的书籍，作为一名C语言程序员，不收藏一本都觉得自己很水。
2)
《C程序设计语言，The
C
Programming
Language》：C语言创始人丹尼斯·里奇（Dennis
MacAlistair
Ritchie）的着作，和《C
Primer
Plus》并驾齐驱，很难分出伯仲，这两本书都是一样的优秀，都是C语言程序员必须收藏的。
3)
《C专家编程》：适合已经具备C语言基础、想进阶的读者。这貌似是一本吐槽C语言的书，基本上介绍了大多数C语言的坑，有不少精髓，在C语言界久负盛名，进阶时一定要看。
4)
《C陷阱与缺陷》：和《C专家编程》类似，也是给C语言挑刺的，阐述了很多容易让人误解的语法细节，重在帮助C程序员绕过编程过程中的陷阱和障碍。
5)
《程序员的自我修养
--
链接、装载与库》：这真是一本深入骨髓的书，让你彻底明白程序的编译、链接、装载和运行的全过程，你会从此上天，拉开和别人的差距，看任何问题都有了深度和高度。重点推荐！
所有的这些书我都有电子版，需要可以找我要！
2. 学习Ｃ语言有什么书适合新手看
学习C语言不是一朝一夕的事情，但也不需要花费十年时间才能精通。如何以最小的代价学习并精通C语言是本文的主题。请注意，即使是“最小的代价”，也绝不是什么捷径，而是以最短的时间取得最多的收获，同时也意味着你需要经历艰苦的过程。
一、要读就读好书，否则不如不读
所有初学者面临的第一个问题便是：如何选择教材。好的开始是成功的一半，选择一本优秀的教材是事半功倍的关键因素。不幸的是，学校通常会帮你指定一本很差劲的C语言课本；而幸运的是，你还可以再次选择。
大名鼎鼎的谭浩强教授出了一本《C语言程序设计》，据说发行量有超过400万，据我所知，很多学校都会推荐这本书作为C语言课本。虽然本人的名字（谭浩宇）跟教授仅仅一字之差，但我是无比坚定地黑他这本书的。这本书不是写给计算机专业的学生的，而是给那些需要考计算机等级考试的其它专业学生看的。这本书的主要缺点是：例子程序非常不专业，不能教给你程序设计应该掌握的思考方式；程序风格相当地不好，会让你养成乱写代码的恶习；错误太多，曾经有人指出过这本书的上百个错误，其中不乏关键的概念性错误。好了，这本书我也不想说太多了，有兴趣大家可以网络一下：）
Kernighan和 Ritchie的《The C Programming Language》（中译名《C程序设计语言》）堪称经典中的经典，不过旧版的很多内容都已过时，和现在的标准C语言相去甚远，大家一定要看最新的版本，否则不如不看。另外，即使是最经典最权威的书，也没有办法面面俱到，所以手边常备一本《C语言参考手册》是十分必要的。《C语言参考手册》就是《C Reference Manual》，是C语言标准的详细描述，包括绝大多数C标准库函数的细节，算得上是最好的标准C语言的工具书。顺便提一句，最新的《C程序设计语言》是根据C89标准修订的，而《C语言参考手册》描述的是C99标准，二者可能会有些出入，建议按照C99标准学习。还有一本《C和指针》，写得也是相当地不错，英文名是《Pointers on C》，特别地强调指针的重要性，算是本书的一个特点吧。不过这本书并不十分适合初学者，如果你曾经学过C语言，有那么一些C语言的基础但又不是很扎实，那么你可以尝试一下这本书。我相信，只要你理解了指针，C语言便不再神秘。
如果你已经啃完了一本C语言教材，想要更进一步，那么有两本书你一定要看。首先是《C Traps and Pitfalls》（中译名《C陷井与缺陷》），很薄的一本小册子，内容非常非常地有趣。要注意一点，这本书是二十多年前写成的，里面提到的很多C语言的缺陷都已被改进，不过能够了解一些历史也不是什么坏事。然后你可以挑战一下《Expert C Programming》（中译名《C专家编程》），书如其名，这本书颇具难度，一旦你仔细读完并能透彻理解，你便可以放心大胆地在简历上写“精通C语言”了。
切记一个原则，不要读自己目前还看不懂的书，那是浪费生命。如果你看不懂，那你一定是缺失了某些必需基础知识。此时，你要仔细分析自己需要补充哪些内容，然后再去书店寻找讲述的这些内容的书籍。把基础知识补充完毕再回头来学习，才会真正的事半功倍。
二、Unix/Linux还是Windows，这是个很大的问题
不同的编程环境会造就出不同思维的程序员。Windows的程序员大多依赖集成开发环境，比如Visual Studio，而Unix程序员更加钟爱Makefile与控制台。显而易见，集成开发环境更容易上手，在Windows上学习C语言，只需要会按几个基本的Visutal C++工具栏按钮就可以开始写Hello, World!了，而在Unix下，你需要一些控制台操作的基本知识。有人也许认为Unix的环境更简洁，但习惯的力量是很大的，大家都很熟悉 Windows的基本操作，而为了学习C语言去专门装一个Unix系统，似乎有点不划算。
对于一个只懂得Windows基本操作、连 DOS是什么都不知道的新手而言，尽快做一些有趣而有意义的事情才是最重要的。用C语言写一个小程序远比学习ls、cat等命令有趣，况且我们要专注于C 语言本身，就不得不暂时忽略一些东西，比如编译链接的过程、Makefile的写法等等等等。
所以我建议初学者应该以Visual C++ 6.0（不是VisualC++ .NET）或者Dev C++作为主要的学习环境，而且千万不要在IDE的使用技巧上过多纠缠，因为今后你一定要转向Unix环境的。Visual C++ 6.0使用很方便，调试也很直观，但其默认的编译器对C标准的支持并不好，而Dev C++使用gcc编译器，对C99的标准都支持良好。使用顺带提一下，很多大学的C语言课程还在使用Turbo C 2.0作为实验环境，这是相当不可取的，原因其一是TC 2.0对C标准几乎没有支持，其二是TC 2.0编译得到的程序是16位的，这对今后理解32位的程序会造成极大的困扰（当然,用djgpp之类的东西可以使TC 2.0编译出32位程序，不过那过于复杂了）。
等你学完一本C语言的教材，你一定要转向Unix平台继续学习，几乎所有的C语言高级教程都是基于Unix平台的（比如《C专家编程》）。转变的过程是痛苦的，你需要面对的是各种纷繁复杂的命令，完全不同于Windows平台的思考方式，但是这种痛苦是值得的。Unix与C是共生的，Unix的思考方式和习惯更加符合C语言的思考方式和习惯。在Unix下，你可以找到无数优秀的源代码供你尽情阅读，你可以方便地查看某个库函数的联机手册，还可以看到最优秀的代码风格（说到代码风格，我会专门写一篇文章详细叙述）。
归结起来就是一句话：初学C语言，建议使用Windows系统和集成开发环境，在准备向“高手”方向努力时，请先转向Unix平台。
三、万事俱备，你就是东风
书已选定，环境配置完成，正所谓万事俱备，只欠你自己的努力了。请从书的前言开始，仔细地阅读手头的教材，很多人看书喜欢直接从第一章开始看，这是错误的做法。前言是作者对整本书的大体介绍，作者一般会告诉你需要什么基础才能够顺利阅读本书，这可以帮助你检验自己的基础知识是否已经具备。看完前言，还要浏览一下目录，了解一下书的整体结构，顺便给自己安排一下学习计划。
学习C语言，必需注意每一个细节，书上的例子代码一定要自己亲自敲一遍，编译执行输出都跟书上说的一致才能算是学完了一个例子，如果不一致，就要仔细找原因。出了书本上有的例子，自己还要“创造”一些例子，比如学习运算符优先级的时候，可以写几个相同的表达式，在不同的位置加上括号，看看有哪些不同的行为，比如*p++和(*p)++，又比如a = b == c、(a = b) == c和a = (b == c)等等。自己抄的书上的例子以及改造之后的例子，还有自己“创造”的例子，都应该仔细地归类保存，并且要在源代码中写上简短的注释，阐述这个例子的意图。
例子之后就是习题了，我建议初学者把所有的习题都独立做一遍，然后对照答案的代码，看看自己的代码有那些不足，再试着修改自己的代码。很多人不重视习题，这是极大的错误，因为作者通常会在习题中说明一些重要的道理，而不是单纯地检验前面的知识。
也许你认为这样学习太慢，其实不然。学得细致就不用走回头路，等你学到后面才发现自己前面没搞清楚，那才是真的得不偿失。一般说来，整本书读完，你应该完成数千行乃至上万行的代码，无论是原封不动照抄书上的，还是自己心血来潮写就的，都是今后继续学习的一笔财富。以我自己举例，阅读《Windows核心编程》时（我只阅读了3/4的内容），除了抄书上的代码，还自己写了很多例子，一共有5574行（用unix下的wc工具统计），时隔多日，我早已记不清 Windows的系统编程了，但只要花几分钟翻出以前的代码看看，便会重新了然于胸。所谓好记性不如烂笔头，就是这个道理。
仔细读书、认真抄写源代码、独立完成习题外加更进一步的实验，最后将所有的代码留下，成为自己的经验和财富，绝对的辛苦，也绝对的事半功倍。当然，这种方式只适合学习需要精通的技术，如果不是学习C语言，你还要具体情况具体分析。
写到最后，还有非常非常重要的一点没有提及──代码风格，从最开始学习就必须强迫自己模仿最优秀的代码风格。因为代码风格太重要内容也太多，我会用专门的一篇文章来详细讨论，请大家关注《程序员之路──关于代码风格》。
3. 什么事C语言
C语言是一种编程语言，通俗地讲就是把你的想法通过计算机表现出来，人有人的语言，同样，机器也有机器语言，而这些个语言就是类似一种翻译工具，把人的命令传达给计算机。最早的编程语言就是对计算机语言直接进行翻译，是一对一的，更靠近机器一方，但机器的识别度高，还有一种语言叫VB，这种语言就是更靠近人，可以直接指令，都是英语单词组成的，但其机器识别度较低。。。而介于这两种之间的就是C语言，如果有兴趣建议你先去看看VB，积累编程思想。。。再慢慢深入，编程不只是记住代码那么简单。。。它是一门艺术
4. c语言算法经典入门书籍推荐！！！！！！！！！！！1最好是国外的书！
《算法导论》原书名——《Introction to Algorithms》，是一本十分经典的计算机算法书籍，与高德纳（Donald E.Knuth）的《计算机程序设计艺术》（《The Art Of Computer Programming》）相媲美。 《算法导论》由Thomas H.Cormen、Charles E.Leiserson、Ronald L.Rivest、Clifford Stein四人合作编着（其中Clifford Stein是第二版开始参与的合着者）。本书的最大特点就是将严谨性和全面性融入在了一起。
http://ke..com/link?url=-
大学教的数据结构和算法基本上面都有，我就作为参考书
5. 谁能告诉我什么叫C语言具体点，谢谢啦
首先：C语言是C语言 是面向过程的语言；而C++是面向对象的语言，两者不同，但是C++是从C演变过来的，所以有了C的基础对C++会有帮助。
首先:C语言入门相对比较简单,但如果想成为一个优秀的C程序员,需要很艰苦的训练,多读代码,多练习,多上机操作,多思考,学习是一件辛苦的事情,要放弃很多东西,要坚持下来才可以,可以说C语言是基础,将来想学其他的C++,JAVA等,如果有C的基础,还是比较好入门的.
C语言的用处比较广泛,可以说任何精通计算机的人都掌握C语言了,我是本科计算机专业的,C被作为许多课程的先行课,没有了C语言基础,就不能学习数据结构,操作系统,编译原理,计算机网络等核心课程,所以说,想学习计算机的话无论想在哪个方向发展(软件,硬件,网络,应用,开发,设计等方向)都必须掌握C语言.
关于C语言的教材:我向你推荐几本:
最经典的:《C程序设计语言》第2版，机械工业出版社
这个是C语言的设计者和UNIX系统的设计者合作编写的最经典的C语言教材，原书名叫《The C Programming Language》当然，这本书不太适合0起点的人，看这本书之前最好把《C程序设计》（谭浩强，清华大学）看了，老谭的书销量突破700万册了，虽然比较旧了，也不太符合新标准（现在出第3版了，也还是）但是，入门还是不错的选择。
另外还有必看的是《C Primer Plus》这个是一个美国人写的，人民邮电出版社出了中文版了，第5版，比较厚，砖头书，60元。但是非常适合初学的人，非常详细。
还有《从问题到程序——程序设计与C语言引论》机械工业出版社，这本书也很不错。
看完这些，就可以看算法的书了，比如数据结构什么的，这方面的书很多。如果想在程序界发展，那么有部重量级的着作不得不看《The Art of computer programming》一共三卷，有翻译版《计算机程序设计的艺术》这三卷书非常深，比较难，盖茨说，谁如果把这上面的习题都做对了，直接可以到微软上班了。
另外学习C语言要养成良好的程序风格，这点一定要注意练习！
6. 我想学c语言有什么书好推荐的
入门：刚开始入门的话，可以先看《C Primer Plus中文版》（如果你英语好，可以看英文版《C Primer Plus 》），书后的题目推荐做一下。 很多人对谭浩强的《C语言程序设计》褒贬不一，我觉得这本书内容相对上面那本要少，看完后基本会写小程序，也可以用来入门。上面那本确实是入门经典。
进阶：《C专家编程 》，《C陷阱与缺陷》 ，《C和指针》，进阶就看这三本书。《你必须知道的495个C语言问题》也可以看一下。
再深入的话，就是 《C语言参考手册》，《C标准库》，《 C语言接口与实现 》（必看），《C语言的科学和艺术》，《C程序设计语言》 （圣经）这几本书了。
7. 怎么才能学会c语言
我一直这么回答。
我认为，学好编程有四个方面：语言、算法和数据结构、系统调用和设计。
语言。我可以告诉你C语言有两大主题你要好好学，一个是内存管理，一个是指针！这个世界上90%以上的C/C++出的严重性错误全是和这两个有关。不要看谭浩强的那本书，那本是本烂书。推荐这本书给你《C程序设计语言（第2版·新版）》
算法和数据结构。我认为，用C语言实现算法和数据结构莫过于最爽的事情。推荐你看这本书——算法:C语言实现(第1～4部分)基础知识、数据结构、排序及搜索(原书第3版)，还有那本经典的《算法导论》
系统设计。关于设计方面，我全力推荐《Unix编程艺术》，看完以后，你就明白什么是真正的编程文化了。然后，当你看到Windows的Fans的某些言论时，你就知道什么叫一笑了之了。
8. C语言编程，输入2个实数，求它们的平均值。
#include<stdio.h>
intmain()
{
doublea,b,avg;
scanf("%lf%lf",&a,&b);
avg=(a+b)/2;
printf("avg=%lf ",avg);
return0;
}
9. 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;
vector<int> 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;//数据类型
vector<var_value> value; //变量值
vector<int> 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(vector<int>,vector<int>);// 计算[][]
void find_vector(vector<int> &);//读取[]
int cal_idx(vector<int>);
Vars is_var_type;//使用is_var的时候如果返回值是真那么这个变量存储了变量类型
public:
//每执行一个函数的时候就把进入前的局部变量数目
//放到函数结点栈,函数执行完的时候就根据栈里的
//数据改变局部函数表里的变量,从而实现变量的灵活使用
//同理块结点栈的原理也一样
//变量表
vector<var_type> global_vars; //全局变量表
vector<var_type> local_var_stack; //局部变量表(函数参数作为局部变量处理)
vector<func_type> func_table; //函数表
stack<int> func_call_stack;//函数结点栈
stack<int> 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; i<nTableItem; 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;
}