void类型。这既是程序良好可读性的需要,也
是编程规范性的要求。另外,加上
void类型声明后,也可以发挥代码的“自注释”作用。所
谓的代码的“自注释”即代码能自己注释自己。
【规则
1…34】如果函数无参数;那么应声明其参数为
void
在
C++语言中声明一个这样的函数:
intfunction(void)
{
return
1;
}
则进行下面的调用是不合法的:function(2);
因为在
C++中,函数参数为
void的意思是这个函数不接受任何参数。
但是在
TurboC
2。0中编译:
#include〃stdio。h〃
fun()
{
return
1;
}
main()
{
printf(〃%d〃;fun(2));
getchar();
}
编译正确且输出
1,这说明,在
C语言中,可以给无参数的函数传送任意类型的参数,
但是在
C++编译器中编译同样的代码则会出错。在
C++中,不能向无参数的函数传送任何
参数,出错提示“'fun':
function
doesnottake1parameters”。
所以,无论在
C还是
C++中,若函数不接受任何参数,一定要指明参数为
void。
1。10。3,void指针
【规则
1…35】千万小心又小心使用
void指针类型。
按照
ANSI(AmericanNationalStandardsInstitute)标准,不能对
void指针进行算法操作,
即下列操作都是不合法的:
void
*
pvoid;
pvoid++;//ANSI:错误
pvoid+=1;//ANSI:错误
ANSI标准之所以这样认定,是因为它坚持:进行算法操作的指针必须是确定知道其指
向数据类型大小的。也就是说必须知道内存目的地址的确切值。
例如:
int*pint;
pint++;//ANSI:正确
但是大名鼎鼎的
GNU(GNU's
NotUnix的递归缩写)则不这么认定,它指定
void
*的算法
操作与
char
*一致。因此下列语句在
GNU编译器中皆正确:
pvoid++;//GNU:正确
pvoid+=1;//GNU:正确
在实际的程序设计中,为符合
ANSI标准,并提高程序的可移植性,我们可以这样编写
实现同样功能的代码:
void
*
pvoid;
(char
*)pvoid++;//ANSI:正确;GNU:正确
(char
*)pvoid
+=
1;//ANSI:错误;GNU:正确
GNU和
ANSI还有一些区别,总体而言,GNU较
ANSI更“开放”,提供了对更多语法
的支持。但是我们在真实设计时,还是应该尽可能地符合
ANSI标准。
【规则
1…36】如果函数的参数可以是任意类型指针,那么应声明其参数为
void
*。
典型的如内存操作函数
memcpy和
memset的函数原型分别为:
void
*
memcpy(void
*dest;constvoid
*src;size_tlen);
void
*
memset(
void
*
buffer;intc;size_tnum
);
这样,任何类型的指针都可以传入
memcpy和
memset中,这也真实地体现了内存操作
函数的意义,因为它操作的对象仅仅是一片内存,而不论这片内存是什么类型。如果
memcpy
和
memset的参数类型不是
void
*,而是
char
*,那才叫真的奇怪了!这样的
memcpy和
memset
明显不是一个“纯粹的,脱离低级趣味的”函数!
下面的代码执行正确:
例子:memset接受任意类型指针
intIntArray_a'100';
memset(IntArray_a;0;100*sizeof(int));//将
IntArray_a清
0
例子:memcpy接受任意类型指针
intdestIntArray_a'100';srcintarray_a'100';
//将
srcintarray_a拷贝给
destIntArray_a
memcpy
(destIntArray_a;srcintarray_a;100*sizeof(int)
);
有趣的是,memcpy和
memset函数返回的也是
void
*类型,标准库函数的编写者都不是一
般人。
1。10。4,void不能代表一个真实的变量
【规则
1…37】
void不能代表一个真实的变量。
因为定义变量时必须分配内存空间,定义
void类型变量,编译器到底分配多大的内存呢。
下面代码都企图让
void代表一个真实的变量,因此都是错误的代码:
voida;//错误
function(void
a);//错误
void体现了一种抽象,这个世界上的变量都是
“有类型”的,譬如一个人不是男人就是女
人(人妖不算)。
void的出现只是为了一种抽象的需要,如果你正确地理解了面向对象中
“抽象基类”的概
念,也很容易理解
void数据类型。正如不能给抽象基类定义一个实例,我们也不能定义一
个
void(让我们类比的称
void为“抽象数据类型”)变量。
void简单吧?到底是“色”还是“空”呢?
1。10,return关键字
return用来终止一个函数并返回其后面跟着的值。
return(Val);//此括号可以省略。但一般不省略,尤其在返回一个表达式的值时。
return可以返回些什么东西呢?看下面例子:
char
*Func(void)
{
char
str'30';
…
returnstr;
}
str属于局部变量,位于栈内存中,在
Func结束的时候被释放,所以返回
str将导致错误。
【规则
1…38】return语句不可返回指向“栈内存”的“指针”,因为该内存在函数体结束时
被自动销毁。
留个问题:
return;
这个语句有问题吗?如果没有问题,那返回的是什么?
1。11,const关键字也许该被替换为
readolny
const是
constant的缩写,是恒定不变的意思,也翻译为常量、常数等。很不幸,正是
因为这一点,很多人都认为被
const修饰的值是常量。这是不精确的,精确的说应该是只读
的变量,其值在编译时不能被使用,因为编译器在编译时不知道其存储的内容。或许当初
这个关键字应该被替换为
readonly。那么这个关键字有什么用处和意义呢?
const推出的初始目的,正是为了取代预编译指令,消除它的缺点,同时继承它的优点。
我们看看它与
define宏的区别。(很多人误以为
define是关键字,在这里我提醒你再回到本
章前面看看
32个关键字里是否有
define)。
1。11。1,const修饰的只读变量
定义
const只读变量,具有不可变性。
例如:
constintMax=100;
intArray'Max';
这里请在
VisualC++6。0里分别创建。c文件和。cpp文件测试一下。你会发现在
。c文件中,
编译器会提示出错,而在
。cpp文件中则顺利运行。为什么呢?我们知道定义一个数组必须指
定其元素的个数。这也从侧面证实在
C语言中,
const修饰的
Max仍然是变量,只不过是只
读属性罢了;而在
C++里,扩展了
const的含义,这里就不讨论了。
注意:const修饰的只读变量必须在定义的同时初始化,想想为什么?
留一个问题:case语句后面是否可以是
const修饰的只读变量呢?请动手测试一下。
1。11。2,节省空间,避免不必要的内存分配,同时提高效率
编译器通常不为普通
const只读变量分配存储空间,而是将它们保存在符号表中,这使
得它成为一个编译期间的值,没有了存储与读内存的操作,使得它的效率也很高。
例如:
#defineM3
//宏常量
constintN=5;
//此时并未将
N放入内存中
。。。。。。
inti=N;
//此时为
N分配内存,以后不再分配!
intI=M;
//预编译期间进行宏替换,分配内存
intj=N;
//没有内存分配
intJ=M;
//再进行宏替换,又一次分配内存!
const定义的只读变量从汇编的角度来看,只是给出了对应的内存地址,而不是象#define
一样给出的是立即数,所以,const定义的只读变量在程序运行过程中只有一份拷贝(因为
它是全局的只读变量,存放在静态区),而#define定义的宏常量在内存中有若干个拷贝。
#define宏是在预编译阶段进行替换,而
const修饰的只读变量是在编译的时候确定其值。
#define宏没有类型,而
const修饰的只读变量具有特定的类型。
1。11。3,修饰一般变量
一般常量是指简单类型的只读变量。这种只读变量在定义时,修饰符
const可以用在类
型说明符前,也可以用在类型说明符后。例如:
int
const
i=2;或
const
int
i=2;
1。11。4,修饰数组
定义或说明一个只读数组可采用如下格式:
intconsta'5'={1;2;3;4;5};或
constinta'5'={1;2;3;4;5};
1。11。5,修饰指针
constint*p;
//p可变,p指向的对象不可变
intconst*p;
//p可变,p指向的对象不可变
int*constp;
//p不可变,p指向的对象可变
constint*constp;//指针
p和
p指向的对象都不可变
在平时的授课中发现学生很难记住这几种情况。这里给出一个记忆和理解的方法:
先忽略类型名(编译器解析的时候也是忽略类型名),我们看
const离哪个近。“近水楼
台先得月”,离谁近就修饰谁。
constint
*p;
//const修饰*p;p是指针,*p是指针指向的对象,不可变
intconst*p;
//const修饰*p;p是指针,*p是指针指向的对象,不可变
int*constp;
//const修饰
p,p不可变,p指向的对象可变
constint
*const
p;//前一个
const修饰*p;后一个
const修饰
p,指针
p和
p指向的对象
都不可变
1。11。6,修饰函数的参数
const修饰符也可以修饰函数的参数,当不希望这个参数值被函数体内意外改变时使
用。例如:
void
Fun(constinti);
告诉编译器
i在函数体中的不能改变,从而防止了使用者的一些无意的或错误的修改。
1。11。7,修饰函数的返回值
const修饰符也可以修饰函数的返回值,返回值不可被改变。例如:
constintFun(void);
在另一连接文件中引用
const只读变量:
externconstinti;
//正确的声明
externconstintj=10;//错误!只读变量的值不能改变。
注意这里是声明不是定义,关于声明和定义的区别,请看本章开始处。
讲了这么多讲完了吗?远没有。在
C++里,对
const做了进一步的扩展,还有很多知识未能
讲完。有兴趣的话,不妨查找相关资料研究研究。
1。12,最易变的关键字volatile
volatile是易变的、不稳定的意思。很多人根本就没见过这个关键字,不知道它的存在。
也有很多程序员知道它的存在,但从来没用过它。我对它有种“杨家有女初长成;养在深闺
人未识”的感觉。
volatile关键字和
const一样是一种类型修饰符,用它修饰的变量表示可以被某些编译器
未知的因素更改,比如操作系统、硬件或者其它线程等。遇到这个关键字声明的变量,编
译器对访问该变量的代码就不再进行优化,从而可以提供对特殊地址的稳定访问。
先看看下面的例子:
inti=10;
intj
=
i;//(1)语句
intk
=
i;//(2)语句
这时候编译器对代码进行优化,因为在(1)、(2)两条语句中,i没有被用作左值。这时候
编译器认为
i的值没有发生改变,所以在(
1)语句时从内存中取出
i的值赋给
j之后,这个
值并没有被丢掉,而是在(
2)语句时继续用这个值给
k赋值。编译器不会生成出汇编代码
重新从内存里取
i的值,这样提高了效率。但要注意:(1)、(2)语句之间
i没有被用作左
值才行。
再看另一个例子:
volatile
inti=10;
intj
=
i;//(3)语句
intk
=
i;//(4)语句
volatile关键字告诉编译器
i是随时可能发生变化的,每次使用它的时候必须从内存中取出
i
的值,因而编译器生成的汇编代码会重新从
i的地址处读取数据放在
k中。
这样看来,如果
i是一个寄存器变量或者表示一个端口数据或者是多个线程的共享数
据,就容易出错,所以说
volatile可以保证对特殊地址的稳定访问。
但是注意:在
VC++6。0中,一般
Debug模式没有进行代码优化,所以这个关键字的作
用有可能看不出来。你可以同时生成
Debug版和
Release版的程序做个测试。
留一个问题:constvolatileinti=10;这行代码有没有问题?如果没有,那
i到底是什么
属性?
1。13,最会带帽子的关键字extern
extern,外面的、外来的意思。那它有什么作用呢?举个例子:假设你在大街上看到
一个黑皮肤绿眼睛红头发的美女(外星人?)或者帅哥。你的第一反应就是这人不是国产
的。extern就相当于他们的这些区别于中国人的特性。extern可以置于变量或者函数前,以
标示变量或者函数的定义在别的文件中,下面的代码用到的这些变量或函数是外来的,不
是本文件定义的,提示编译器遇到此变量和函数时在其他模块中寻找其定义。就好比在本
文件中给这些外来的变量或函数带了顶帽子,告诉本文件中所有代码,这些家伙不是土著。
那你想想
extern修饰的变量或函数是定义还是声明?
看列子:
A。c文件中定义:
B。c文件中用
extern修饰:
inti
=
10;
externinti;//写成
i=
10;行吗?
voidfun(void)
externvoid
fun(void);//两个
void可否省略?
{
//code
}
C。h文件中定义:
D。c文件中用
extern修饰:
int
j
=1;
externdoubl