现在的位置: 首页 > 综合 > 正文

C之诡谲

2013年10月08日 ⁄ 综合 ⁄ 共 11944字 ⁄ 字号 评论关闭

指针,数组,类型的识别,参数可变的函数。 
一.指针

 


它的本质是地址的类型。在许多语言中根本就没有这个概念。但是它却正是C灵活,高效, 
在面向过程的时代所向披靡的原因所在。因为C的内存模型基本上对应了现在von Neumann 
(冯·诺伊曼)计算机的机器模型,很好的达到了对机器的映射。不过有些人似乎永远也 
不能理解指针【注1】。 
注1:Joel Spolsky就是这样认为的,他认为对指针的理解是一种aptitude,不是通过训练 
就可以达到的。
指针可以指向值、数组、函数,当然它也可以作为值使用。 
看下面的几个例子: 

int* p;//p是一个指针,指向一个整数 
int** p;//p是一个指针,它指向第二个指针,然后指向一个整数 
int (*pa)[3];//pa是一个指针,指向一个拥有3个整数的数组 
int (*pf)();//pf是一个指向函数的指针,这个函数返回一个整数 
后面第四节我会详细讲解标识符(identifier)类型的识别。 

1.指针本身的类型是什么?
 
先看下面的例子:int a;//a的类型是什么? 
对,把a去掉就可以了。因此上面的4个声明语句中的指针本身的类型为: 
int*  
int** 
int (*)[3] 
int (*)() 

它们都是复合类型,也就是类型与类型结合而成的类型。意义分别如下: 
point to int(指向一个整数的指针) 
pointer to pointer to int(指向一个指向整数的指针的指针) 
pointer to array of 3 ints(指向一个拥有三个整数的数组的指针) 
pointer to function of parameter is void and return value is int (指向一个函数 
的指针,这个函数参数为空,返回值为整数) 

2.指针所指物的类型是什么? 

很简单,指针本身的类型去掉 “*”号就可以了,分别如下: 
int 
int* 
int ()[3] 
int ()() 
3和4有点怪,不是吗?请擦亮你的眼睛,在那个用来把“*”号包住的“()”是多余的,所以: 
int ()[3]就是int [3](一个拥有三个整数的数组) 
int ()()就是int ()(一个函数,参数为空,返回值为整数)【注2】 
注2:一个小小的提醒,第二个“()”是一个运算符,名字叫函数调用运算符(function  
call operator)。 

3.指针的算术运算。 

请再次记住:指针不是一个简单的类型,它是一个和指针所指物的类型复合的类型。因此 
,它的算术运算与之(指针所指物的类型)密切相关。 
int a[8]; 
int* p = a; 
int* q = p + 3; 
p++; 
指针的加减并不是指针本身的二进制表示加减,要记住,指针是一个元素的地址,它每加 
一次,就指向下一个元素。所以: 
int* q = p + 3;//q指向从p开始的第三个整数。 
p++;//p指向下一个整数。 
double* pd; 
……//某些计算之后 
double* pother = pd – 2;//pother指向从pd倒数第二个double数。 

4.指针本身的大小。 

在一个现代典型的32位机器上【注3】,机器的内存模型大概是这样的,想象一下,内存空 
间就像一个连续的房间群。每一个房间的大小是一个字节(一般是二进制8位)。有些东西 
大小是一个字节(比如char),一个房间就把它给安置了;但有些东西大小是几个字节( 
比如double就是8个字节,int就是4个字节,我说的是典型的32位),所以它就需要几个房 
间才能安置。 
注3:什么叫32位?就是机器CPU一次处理的数据宽度是32位,机器的寄存器容量是32位, 
机器的数据,内存地址总线是32位。当然还有一些细节,但大致就是这样。16位,64位, 
128位可以以此类推。 
这些房间都应该有编号(也就是地址),32位的机器内存地址空间当然也是32位,所以房 
间的每一个编号都用32位的二进制数来编码【注4】。请记住指针也可以作为值使用,作为 
值的时候,它也必须被安置在房间中(存储在内存中),那么指向一个值的指针需要一个 
地址大小来存储,即32位,4个字节,4个房间来存储。 
注4:在我们平常用到的32位机器上,绝少有将32位真实内存地址空间全用完的(232 =  
4G),即使是服务器也不例外。现代的操作系统一般会实现32位的虚拟地址空间,这样可 
以方便运用程序的编制。关于虚拟地址(线性地址)和真实地址的区别以及实现,可以参 
考《Linux源代码情景分析》的第二章存储管理,在互联网上关于这个主题的文章汗牛充栋 
,你也可以google一下。 
但请注意,在C++中指向对象成员的指针(pointer to member data or member function 
)的大小不一定是4个字节。为此我专门编制了一些程序,发现在我的两个编译器(VC7.1 
.3088和Dev-C++4.9.7.0)上,指向对象成员的指针的大小没有定值,但都是4的倍数。不 
同的编译器还有不同的值。对于一般的普通类(class),指向对象成员的指针大小一般为 
4,但在引入多重虚拟继承以及虚拟函数的时候,指向对象成员的指针会增大,不论是指向 
成员数据,还是成员函数。【注5】。 
注5:在Andrei Alexandrescu的《Modern C++ Design》的5.13节Page124中提到,成员函 
数指针实际上是带标记的(tagged)unions,它们可以对付多重虚拟继承以及虚拟函数, 
书上说成员函数指针大小是16,但我的实践告诉我这个结果不对,而且具体编译器实现也 
不同。一直很想看看GCC的源代码,但由于旁骛太多,而且心不静,本身难度也比较高(这 
个倒是不害怕^_^),只有留待以后了。 
还有一点,对一个类的static member来说,指向它的指针只是普通的函数指针,不是poi 
nter to class member,所以它的大小是4。 

5.指针运算符&和* 

它们是一对相反的操作,&取得一个东西的地址(也就是指针),*得到一个地址里放的东 
西。这个东西可以是值(对象)、函数、数组、类成员(class member)。 

其实很简单,房间里面居住着一个人,

&操作只能针对人,取得房间号码; 
*操作只能针对房间,取得房间里的人。 

参照指针本身的类型以及指针所指物的类型很好理解。 
小结:其实你只要真正理解了1,2,就相当于掌握了指针的牛鼻子。后面的就不难了,指 
针的各种变化和C语言中其它普通类型的变化都差不多(比如各种转型)。

 
二.数组。 
在C语言中,对于数组你只需要理解三件事。 

1.C语言中有且只有一维数组。 

所谓的n维数组只是一个称呼,一种方便的记法,都是使用一维数组来仿真的。 
C语言中数组的元素可以是任何类型的东西,特别的是数组作为元素也可以。所以int a[3 
][4][5]就应该这样理解:a是一个拥有3个元素的数组,其中每个元素是一个拥有4个元素 
的数组,进一步其中每个元素是拥有5个整数元素的数组。 
是不是很简单!数组a的内存模型你应该很容易就想出来了,不是吗?:)

 
2.数组的元素个数,必须作为整数常量在编译阶段就求出来。
 

int i; 
int a[i];//不合法,编译不会通过。 
也许有人会奇怪char str[] = “test”;没有指定元素个数为什么也能通过,因为编译器 
可以根据后面的初始化字符串在编译阶段求出来, 
不信你试试这个:int a[]; 
编译器无法推断,所以会判错说“array size missing in a”之类的信息。不过在最新的 
C99标准中实现了变长数组【注6】 
注6:如果你是一个好奇心很强烈的人,就像我一样,那么可以查看C99标准6.7.5.2。 

3.对于数组,可以获得数组第一个(即下标为0)元素的地址(也就是指针),从数组名 
获得。

 
比如int a[5]; int* p = a;这里p就得到了数组元素a[0]的地址。 
其余对于数组的各种操作,其实都是对于指针的相应操作。比如a[3]其实就是*(a+3)的简 
单写法,由于*(a+3)==*(3+a),所以在某些程序的代码中你会看到类似3[a]的这种奇怪表 
达式,现在你知道了,它就是a[3]的别名。还有一种奇怪的表达式类似a[-1],现在你也明 
白了,它就是*(a-1)【

注7】。

 
注7:你肯定是一个很负责任的人,而且也知道自己到底在干什么。你难道不是吗?:)所 
以你一定也知道,做一件事是要付出成本的,当然也应该获得多于成本的回报。 
我很喜欢经济学,经济学的一个基础就是做什么事情都是要花成本的,即使你什么事情也 
不做。时间成本,金钱成本,机会成本,健康成本……可以这样说,经济学的根本目的就 
是用最小的成本获得最大的回报。 
所以我们在自己的程序中最好避免这种邪恶的写法,不要让自己一时的智力过剩带来以后 
自己和他人长时间的痛苦。用韦小宝的一句话来说:“赔本的生意老子是不干的!” 
但是对邪恶的了解是非常必要的,这样当我们真正遇到邪恶的时候,可以免受它对心灵的 
困扰! 
对于指向同一个数组不同元素的指针
,它们可以做减法,比如int* p = q+i;p-q的结果就 
是这两个指针之间的元素个数。i可以是负数。但是请记住:对指向不同的数组元素的指针 
,这样的做法是无用而且邪恶的! 


对于所谓的n维数组,比如int a[2][3];你可以得到数组第一个元素的地址a和它的大小。 
*(a+0)(也即a[0]或者*a)就是第一个元素,它又是一个数组int[3],继续取得它的第一 
个元素,*(*(a+0)+0)(也即a[0][0]或者*(*a)),也即第一个整数(第一行第一列的第一 
个整数)。

如果采用这种表达式,就非常的笨拙,所以a[0][0]记法上的简便就非常的有用 
了!简单明了! 
对于数组,你只能取用在数组有效范围内的元素和元素地址,不过最后一个元素的下一个 
元素的地址是个例外。它可以被用来方便数组的各种计算,特别是比较运算。但显然,它 
所指向的内容是不能拿来使用和改变的! 
关于数组本身大概就这么多,下面简要说一下数组和指针的关系。它们的关系非常暧昧, 
有时候可以交替使用。 

比如 int main(int args, char* argv[])中,其实参数列表中的char* argv[]就是char* 
* argv的另一种写法。因为在C语言中,一个数组是不能作为函数引数(argument)【注8 
】直接传递的。因为那样非常的损失效率,而这点违背了C语言设计时的基本理念——作为 
一门高效的系统设计语言。 

注8:这里我没有使用函数实参这个大陆术语,而是运用了台湾术语,它们都是argument这 
个英文术语的翻译,但在很多地方中文的实参用的并不恰当,非常的勉强,而引数表示被 
引用的数,很形象,也很好理解。很快你就可以像我一样适应引数而不是实参。 
dereferance,也就是*运算符操作。我也用的是提领,而不是解引用。 
我认为你一定智勇双全:既有宽容的智慧,也有面对新事物的勇气!你不愿意承认吗?: 
) 
所以在函数参数列表(parameter list)中的数组形式的参数声明,只是为了方便程序员 
的阅读!比如上面的char* argv[]就可以很容易的想到是对一个char*字符串数组进行操作 
,其实质是传递的char*字符串数组的首元素的地址(指针)。

其它的元素当然可以由这个 
指针的加法间接提领(dereferance)【参考注8】得到!从而也就间接得到了整个数组。 


但是数组和指针还是有区别的,
比如在一个文件中有下面的定义: 
char myname[] = “wuaihua”; 
而在另一个文件中有下列声明: 
extern char* myname; 
它们互相是并不认识的,尽管你的本义是这样希望的。 

它们对内存空间的使用方式不同【注9】。 
对于char myname[] = “wuaihua”如下 
myname 

 u 
 a 
 i 
 h 
 u 
 a 
 /0 
  
对于char* myname;如下表 
myname 
  
  
/|/ 

 u 
 a 
 i 
 h 
 u 
 a 
 /0 
  
注9:可以参考Andrew Konig的《C陷阱与缺陷》4.5节。 
改变的方法就是使它们一致就可以了。 
char myname[] = “wuaihua”; 
extern char myname[]; 
或者 
char* myname = “wuaihua”;//C++中最好换成const char* myname = “wuaihua”。 
extern char* myname; 


三.类型的识别。
 

基本类型的识别非常简单: 
int a;//a的类型是a 
char* p;//p的类型是char* 
…… 
那么请你看看下面几个: 
int* (*a[5])(int, char*);                //#1 
void (*b[10]) (void (*)());             //#2 
doube(*)() (*pa)[9];                  //#3 

如果你是第一次看到这种类型声明的时候,我想肯定跟我的感觉一样,就如晴天霹雳,五 
雷轰顶,头昏目眩,一头张牙舞爪的狰狞怪兽扑面而来。 
不要紧(Take it easy)!我们慢慢来收拾这几个面目可憎的纸老虎! 

 

1.C语言中函数声明和数组声明。 

函数声明一般是这样int fun(int,double);
对应函数指针(pointer to function)的声明 
是这样: 
int (*pf)(int,double),你必须习惯。可以这样使用: 
pf = &fun;//赋值(assignment)操作 
(*pf)(5, 8.9);//函数调用操作

 

也请注意,C语言本身提供了一种简写方式如下:

 
pf = fun;// 赋值(assignment)操作 
pf(5, 8.9);// 函数调用操作 

不过我本人不是很喜欢这种简写,它对初学者带来了比较多的迷惑。

 
数组声明一般是这样int a[5];对于数组指针(pointer to array)的声明是这样: 

int (*pa)[5]; 你也必须习惯。可以这样使用: 
pa = &a;// 赋值(assignment)操作 
int i = (*pa)[2]//将a[2]赋值给i;

 
  
2.有了上面的基础,我们就可以对付开头的三只纸老虎了!:) 
这个时候你需要复习一下各种运算符的优先顺序和结合顺序了,顺便找本书看看就够了。 

#1:int* (*a[5])(int, char*); 

首先看到标识符名a,“[]”优先级大于“*”,a与“[5]”先结合。所以a是一个数组,这 
个数组有5个元素,每一个元素都是一个指针,指针指向“(int, char*)”,对,指向一个 
函数,函数参数是“int, char*”,返回值是“int*”。

完毕,我们干掉了第一个纸老虎 
。:) 
#2:void (*b[10]) (void (*)()); 

b是一个数组,这个数组有10个元素,每一个元素都是一个指针,指针指向一个函数,函数 
参数是“void (*)()”【注10】,返回值是“void”。完毕! 
注10:这个参数又是一个指针,指向一个函数,函数参数为空,返回值是“void”。

 

#3. doube(*)() (*pa)[9];
  
pa是一个指针,指针指向一个数组,这个数组有9个元素,每一个元素都是“doube(*)()” 

 

 

【也即一个指针,指向一个函数,函数参数为空,返回值是“double”】。 
现在是不是觉得要认识它们是易如反掌,工欲善其事,必先利其器!我们对这种表达方式 
熟悉之后,就可以用“typedef”来简化这种类型声明。

 

 
#1:int* (*a[5])(int, char*); 
typedef int* (*PF)(int, char*);//PF是一个类型别名【注11】。 
PF a[5];//跟int* (*a[5])(int, char*);的效果一样! 
注11:很多初学者只知道typedef char* pchar;但是对于typedef的其它用法不太了解。 
Stephen Blaha对typedef用法做过一个总结:“建立一个类型别名的方法很简单,在传统 
的变量声明表达式里用类型名替代变量名,然后把关键字typedef加在该语句的开头”

。可 
以参看《程序员》杂志2001.3期《C++高手技巧20招》。  

#2:void (*b[10]) (void (*)()); 
typedef void (*pfv)(); 
typedef void (*pf_taking_pfv)(pfv); 
pf_taking_pfv b[10]; //跟void (*b[10]) (void (*)());的效果一样! 
#3. doube(*)() (*pa)[9];   
typedef double(*PF)(); 
typedef PF (*PA)[9]; 
PA pa; //跟doube(*)() (*pa)[9];的效果一样! 
  
3.const和volatile在类型声明中的位置 
在这里我只说const,volatile是一样的【注12】! 
注12:顾名思义,volatile修饰的量就是很容易变化,不稳定的量,它可能被其它线程, 
操作系统,硬件等等在未知的时间改变,所以它被存储在内存中,每次取用它的时候都只 
能在内存中去读取,它不能被编译器优化放在内部寄存器中。 


类型声明中const用来修饰一个常量,我们一般这样使用:const在前面 
const int;//int是const 
const char*;//char是const 
char* const;//*(指针)是const 
const char* const;//char和*都是const 


对初学者,const char*;和 char* const;是容易混淆的。这需要时间的历练让你习惯它。 

上面的声明有一个对等的写法:const在后面 
int const;//int是const 
char const*;//char是const 
char* const;//*(指针)是const 
char const* const;//char和*都是const 


第一次你可能不会习惯,但新事物如果是好的,我们为什么要拒绝它呢?:)

const在后面 有两个好处: 
A.              const所修饰的类型是正好在它前面的那一个。如果这个好处还不能让 
你动心的话,那请看下一个! 
B.               我们很多时候会用到typedef的类型别名定义。比如typedef char* p 
char,如果用const来修饰的话,当const在前面的时候,就是const pchar,你会以为它就 
是const char* ,但是你错了,它的真实含义是char * const 。是不是让你大吃一惊!但如果你采用const在后面的写法,意义就怎么也不会变,不信你试试! 


不过,在真实项目中的命名一致性更重要。你应该在两种情况下都能适应,并能自如的转 
换,公司习惯,商业利润不论在什么时候都应该优先考虑!不过在开始一个新项目的时候 
,你可以考虑优先使用const在后面的习惯用法。 
  
四.参数可变的函数 
C语言中有一种很奇怪的参数“…”,它主要用在引数(argument)个数不定的函数中,最 
常见的就是printf函数。 
printf(“Enjoy yourself everyday!/n”); 
printf(“The value is %d!/n”, value); 
…… 
你想过它是怎么实现的吗? 

1.      printf为什么叫printf? 
不管是看什么,我总是一个喜欢刨根问底的人,对事物的源有一种特殊的癖好,一段典故 
,一个成语,一句行话,我最喜欢的就是找到它的来历,和当时的意境,一个外文翻译过 
来的术语,最低要求我会尽力去找到它原本的外文术语。特别是一个字的命名来历,我一 
向是非常在意的,中国有句古话:“名不正,则言不顺。”printf中的f就是format的意思 
,即按格式打印【注13】。 
注13:其实还有很多函数,很多变量,很多命名在各种语言中都是非常讲究的,你如果细 
心观察追溯,一定有很多乐趣和满足,比如哈希表为什么叫hashtable而不叫hashlist?在 
C++的SGI STL实现中有一个专门用于递增的函数iota(不是itoa),为什么叫这个奇怪的 
名字,你想过吗?看文章我不喜欢意犹未尽,己所不欲,勿施于人,所以我把这两个答案 
告诉你: 
(1)table与list做为表讲的区别: 
table: 
-------|--------------------|------- 
 item1 |    kadkglasgaldfgl | jkdsfh 
-------|--------------------|------- 
 item2 |    kjdszhahlka     | xcvz 
-------|--------------------|------- 
list: 
**** 
*** 
******* 
***** 
That's the difference! 
如果你还是不明白,可以去看一下hash是如何实现的! 
(2)The name iota is taken from the programming language APL. 
而APL语言主要是做数学计算的,在数学中有很多公式会借用希腊字母, 
希腊字母表中有这样一个字母,大写为Ι,小写为ι, 
它的英文拼写正好是iota,这个字母在θ(theta)和κ(kappa)之间! 
你可以看看http://www.wikipedia.org/wiki/APL_programming_language
 
下面有一段是这样的: 
APL is renowned for using a set of non-ASCII symbols that are an extension of  
traditional arithmetic and algebraic notation. These cryptic symbols, some hav 
e joked, make it possible to construct an entire air traffic control system in 
 two lines of code. Because of its condensed nature and non-standard character 
s, APL has sometimes been termed a "write-only language", and reading an APL p 
rogram can feel like decoding an alien tongue. Because of the unusual characte 
r-set, many programmers used special APL keyboards in the production of APL co 
de. Nowadays there are various ways to write APL code using only ASCII charact 
ers. 
在C++中有函数重载(overload)可以用来区别不同函数参数的调用,但它还是不能表示任 
意数量的函数参数。 
在标准C语言中定义了一个头文件<stdarg.h>专门用来对付可变参数列表,它包含了一组宏 
,和一个va_list的typedef声明。一个典型实现如下【注14】: 
typedef char* va_list; 
#define va_start(list) list = (char*)&va_alist 
#define va_end(list) 
#define va_arg(list, mode)/ 
    ((mode*) (list += sizeof(mode)))[-1] 


注14:你可以查看C99标准7.15节获得详细而权威的说明。也可以参考Andrew Konig的《C 
陷阱与缺陷》的附录A。 
ANSI C还提供了vprintf函数,它和对应的printf函数行为方式上完全相同,只不过用va_ 
list替换了格式字符串后的参数序列。至于它是如何实现的,你在认真读完《The C Prog 
ramming Language》后,我相信你一定可以do it yourself! 
使用这些工具,我们就可以实现自己的可变参数函数,比如实现一个系统化的错误处理函 
数error。它和printf函数的使用差不多。只不过将stream重新定向到stderr。在这里我借 
鉴了《C陷阱与缺陷》的附录A的例子。 
实现如下: 
#include <stdio.h> 
#include <stdarg.h> 
void error(char* format, …) 

      va_list ap; 
      va_start(ap, format); 
      fprintf(stderr, “error: “); 
      vfprintf(stderr, format, ap); 
      va_end(ap); 
      fprintf(stderr, “/n”); 
      exit(1); 

你还可以自己实现printf: 
#include <stdarg.h> 
int printf(char* format, …) 

      va_list ap; 
      va_start(ap, format); 
      int n = vprintf(format, ap); 
      va_end(ap); 
      return n; 

我还专门找到了VC7.1的头文件<stdarg.h>看了一下,发现各个宏的具体实现还是有区别的 
,跟很多预处理(preprocessor)相关。其中va_list就不一定是char*的别名。 
typedef struct { 
        char *a0;       /* pointer to first homed integer argument */ 
        int offset;     /* byte offset of next parameter */ 
} va_list; 
其它的定义类似。 
  
经常在Windows进行系统编程的人一定知道函数调用有好几种不同的形式,比如__stdcall 
,__pascal,__cdecl。在Windows下_stdcall,__pascal是一样的,所以我只说一下__st 
dcall和__cdecl的区别。 
(1)__stdcall表示调用端负责被调用函数引数的压栈和出栈。函数参数个数一定的函数 
都是这种调用形式。 
例如:int fun(char c, double d),我们在main函数中调用它,这个函数就只管本身函数 
体的运行,参数怎么来的,怎么去的,它一概不管。自然有main负责。不过,不同的编译 
器的实现可能将参数从右向左压栈,也可能从左向右压栈,这个顺序我们是不能加于利用 


的【注15】。 
注15:你可以在Herb Sutter的《More Exceptional C++》中的条款20:An Unmanaged Po 
inter Problem, Part 1:Parameter Evaluation找到相关的细节论述。 
(2)__cdecl表示被调用函数自身负责函数引数的压栈和出栈。参数参数可变的函数采用 
的是这种调用形式。 
为什么这种函数要采用不同于前面的调用形式呢?那是因为__stdcall调用形式对它没有作 
用,调用端根本就无法知道被调用函数的引数个数,它怎么可能正确工作?所以这种调用 
方式是必须的,不过由于参数参数可变的函数本身不多,所以用的地方比较少。 
对于这两种方式,你可以编制一些简单的程序,如何反汇编,在汇编代码下面你就可以看 
到实际的区别,很好理解的! 
重载函数有很多匹配(match)规则调用。参数为“…”的函数是匹配最低的,这一点在A 
ndrei Alexandrescu的惊才绝艳之作《Modern C++ Design》中就有用到,参看Page34-35 
,2.7“编译期间侦测可转换性和继承性”。 
  
后记: 
C语言的细节肯定不会只有这么多,但是这几个出现的比较频繁,而且在C语言中也是很重 
要的几个语言特征。如果把这几个细节彻底弄清楚了,C语言本身的神秘就不会太多了。 
C语言本身就像一把异常锋利的剪刀,你可以用它做出非常精致优雅的艺术品,也可以剪出 
一些乱七八糟的废纸片。能够将一件武器用到出神入化那是需要时间的,需要多长时间? 
不多,请你拿出一万个小时来,英国Exter大学心理学教授麦克.侯威专门研究神童和天才 
,他的结论很有意思:“一般人以为天才是自然而生、流畅而不受阻的闪亮才华,其实, 
天才也必须耗费至少十年光阴来学习他们的特殊技能,绝无例外。要成为专家,需要拥有 
顽固的个性和坚持的能力……每一行的专业人士,都投注大量心血,培养自己的专业才能 
。”【注16】 
注16:台湾女作家、电视节目主持人吴淡如《拿出一万个小时来》。《读者》2003.1期。 
“不用太努力,只要持续下去。想拥有一辈子的专长或兴趣,就像一个人跑马拉松赛一样 
,最重要的是跑完,而不是前头跑得有多快。” 
推荐两本书: 
K&R的《The C Programming language》,Second Edition。 
Andrew Konig的《C陷阱与缺陷》。本文从中引用了好几个例子,一本高段程序员的经验之 
谈。 
但是对纯粹的初学者不太合适,如果你有一点程序设计的基础知识,花一个月的时间好好 
看看这两本书,C语言本身就不用再花更多的精力了。 
吴桐写于2003.5.26 

抱歉!评论已关闭.