(void (*)())0 的含义
(void (*)())0 的含义：
1. fp是一个指针｛有*｝，她指向返回值为void｛有（void）｝类型的函数｛有（）｝：void (*fp)();
调用方式简写为：(*fp)();
2. 制作其对应的类型强制转换符：void (*)()
3. 存储位置为0 的强制转换为一个指向返回值为void类型的函数的指针：(void (*)())0
4. 用上式代替fp，从而实现调用存储位置为0的子例程：(*(void(*)())0)();
5. 利用typedef简化：typedef void (*funcptr)(); (*(funcptr)0)();
(void (*)())0 的含义：实际上就是将地址0强制转换为一个指向返回值为void类型的函数的指针。
下面将相关基础知识进行介绍，其中参考了网上一些文章，名单不再列出，谢谢各位大虾的贡献：
1、c语言的声明
2、类型转换符的制作
3、signal函数分析
4、typedef用法
5、const用法
6、typedef的好处
1 C语言的声明
声明由两部分组成：类型以及声明符：
float f,g;
float ((f));//对其求值时，((f))的类型为浮点型，可以推知,f也是浮点型
float *g(),(*h)();//g是函数，该函数的返回类型为指向浮点数的指针
//h是个指针，且是一个函数指针，该指针指向函数返回值，该返回值是一个float型
(*fp)()简写为fp()//函数调用方式，其中fp为函数指针
*((*fp)())简写为*fp()//函数返回值为某个类型的指针
、2 类型转换符制作
类型转换符制作：
1、去掉声明中的变量名、分号；
2、将剩余部分用括号"封装"起来
float (*h)(); --> (float (*)())//指向返回值为float型的函数指针的类型转换符(*0)();//返回值为void类型的函数指针
如果fp是一个指向返回值为void类型的函数的指针，那么(*fp)()的值为 void，fp的声明如下：void (*fp)();
因此可以用下式完成调用存储位置为0的子例程：void (*fp)(); (*fp)();
这种写法的代价是多声明了一个哑变量，我们常将0转型为“指向返回值为void的函数的指针”：(void (*)())0
用上式代替fp，从而得到：(*(void(*)())0)();
typedef void (*funcptr)();
将0转型为“指向返回值为void的函数的指针”-----(void (*)())0
(*(funcptr)0)();
3 signal函数
signal函数接受两个参数：信号类型的整型值、指向用户提供的信号处理函数指针
用户提供的信号处理函数返回值类型为：void
signal的返回值类型：指向调用前的用户定义信号处理函数的指针
下面分析 signal函数在signal.h中是如何声明的
1. 用户定义信号处理函数：void sigfunc(int n){/*特定信号处理部分*/}
2. sigfunc声明：void sigfunc(int);
3. 假设sfp指向sigfunc函数，sigfunc函数声明：void (*sfp)(int);
4. 假设sig为一整数，则 (*sfp)（sig）返回值为void类型
5. sfp与signal返回值类型相同，故声明signal函数：void (*signal(something))(int);
//something 为signal的参数类型
//过程分析：传递一个适当的参数调用signal；对signal的返回值解引用；传递一个参数调用解引用后
(void (*)())0
将0转型为“指向返回值为void的函数的指针”-----(void (*)())0
//得到的函数；得到返回值为void型
//signal函数返回值是一个指向返回值为void类型的函数的指针
6. signal其中参数为：int 、 void (*)(int)，故signal函数：void (*signal(int,void
(*)(int)))(int);
7. 用typedef简化： typedef void (*HANDLER)(int); HANDER signal(int,HANDER);
将0转型为“指向返回值为void的函数的指针”-----(void (*)())0
4 typedef用法
例1：
int* (*a[5])(int, char*);
typedef int* (*PF)(int, char*);//PF是一个类型别名
PF a[5];//跟int* (*a[5])(int, char*);的效果一样！
//很多初学者只知道typedef char* p char；但是对于typedef的其它用法不太了解。
//Stephen Blaha对typedef用法做过一个总结：“建立一个类型别名的方法很简单，
//在传统的变量声明表达式里用类型名替代变量名，然后把关键字 typedef加在该语句的开头”。例2：
void (*b[10])(void (*)());
typedef void (*pfv)();
typedef void (*pf_taking_pfv)(pfv);
pf_taking_pfv b[10]; //跟void (*b[10]) (void (*)());的效果一样！
例3：
double(*)()(*pa)[9];
typedef double(*PF)();const和volatile在类型声明中的位置。
5 const用法（volatile是一样的）
volatile修饰的量就是很容易变化，不稳定的量，它可能被其它线程，操作系统，硬件等等在未知的时间改变，所以它被存储在内存中，每次取用它的时候都只能在内存中去读取，它不能被编译器优化放在内部寄存器中。
const int； //int是const
const char*;//char是const
char* const;//*（指针）是const
const char* const;//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* pchar，当const在前面的时候，就是const pchar，它的真实含义是char* const，而不是const char* 。
将0转型为“指向返回值为void的函数的指针”-----(void (*)())0
6 typedef的好处
使用 typedef 来编写更美观和可读的代码。所谓美观，意指typedef 能隐藏笨拙的语法构造以及平台相关的数据类型，从而增强可移植性和以及未来的可维护性，使代码更健壮。
typedef使用最多的地方是创建易于记忆的类型名，用它来归档程序员的意图。类型出现在所声明的变量名字中，位于typedef关键字右边：
typedef int size;
注意typedef并不创建新的类型，仅仅为现有类型添加一个同义字，使用 size：
void measure(size * psz);
size array[4];
typedef 可以掩饰复合类型，如指针和数组：
char line[81]; char text[81];
定义一个typedef，每当要用到相同类型和大小的数组时，可以这样：
typedef char Line[81];
Line text, secondline;
getline(text);
同样，可以象下面这样隐藏指针语法：
typedef char * pstr;
int mystrcmp(pstr, pstr);
第一个 typedef 陷阱:
标准函数 strcmp()有两个const char *类型的参数。因此，它可能会误导人们象下面这样声明：
int mystrcmp(const pstr, const pstr);
const pstr被编译器解释为char * const（一个指向 char 的常量指针），而不是const char *（指向常量 char 的指针）。
这个问题很容易解决：
typedef const char * cpstr;
int mystrcmp(cpstr, cpstr);
typedef 行为有点像 #define 宏，用其实际类型替代同义字。不同点是typedef在编译时被解释，因此让编译器来应付超越预处理器能力的文本替换。例如：
typedef int (*PF) (const char *, const char *);
这个声明引入了 PF 类型作为函数指针的同义字，该函数有两个 const char * 类型的参数以及一个int 类型的返回值。如果要使用下列形式的函数声明，那么上述这个 typedef 是不可或缺的：
PF Register(PF pf);
Register()的参数是一个PF类型的回调函数，返回某个函数的地址，其署名与先前注册的名字相同,如果不用 typedef，如何实现这个声明的：
int (*Register (int (*pf)(const char *, const char *))) (const char *, const char *); typedef 就像 auto，extern，mutable，static，和 register 一样,是一个存储类关键字。
这并不是说typedef会真正影响对象的存储特性；它只是说在语句构成上，typedef 声明看起来象static，extern 等类型的变量声明。第二个陷阱：
typedef register int FAST_COUNTER; // 错误编译通不过
不能在声明中有多个存储类关键字,因为符号 typedef 已经占据了存储类关键字的位置。
在 typedef 声明中不能用 register（或任何其它存储类关键字）。
typedef定义机器无关的类型：
例如定义一个叫 REAL 的浮点类型，在目标机器上它可以获得最高的精度：
typedef long double REAL;
typedef double REAL;//不支持 long double 的机器上
typedef float REAL;//不支持double 的机器上
不用修改源代码，便可在每一种平台上编译这个使用 REAL 类型的应用程序。唯一要改的是 typedef 本身。
标准库的平台无关类型：size_t，ptrdiff 和 fpos_t就是很好的例子.
C语言指针
1、指针函数：表示的是函数的返回值为指针
int *max（int，int）;
2、函数的指针、函数指针：表示定义一个指针，用来存储函数的指针，或者说函数的首地址
定义：函数返回值类型 (*P)(函数形参列表);
3、数组的指针、数组的指针
一维数组的指针： int *p;
多维数组的指针： int *p[]; 还是指向数组的指针.
这里的应用最常见的是main函数的定义。
4、指针数组：表示的是这是一个数组，但是数组的元素是指针
定义：int (*p)[];
复杂的函数指针说明
以下所说的结合顺序就是由内向外一层一层剥，有助于理解。
1. int func(int);//定义一个函数,该函数返回值int,接受一个int型参数；结合顺序
为:func(int)--int func(int)
2.int *return_pointer_array_func1(int)[10];return_pointer_array_func1返回指针数组的函数,
//结合顺序
为:return_pointer_array_func1(int)--return_pointer_array_func1(int)[10]--*return_pointe r_array_func1(int)[10]--int *return_pointer_array_func1(int)[10]
3.int return_array_func1(int)[10];定义一个函数return_array_func1,该函数返回值int[10],接受一个 int型参数；
//结合顺序为return_array_func1(int)--return_array_func1(int) [10]--int
return_array_func1(int)[10]
// 4~5 两者之间差别是,前者是拥有10个整型指针为元素的数组,array1是一个数组名.(存放指针的数组)
// 后者是pointer1是一个指针,该指针指向拥有10个整型变量为元素的数组.(指向数组的指针)
4.int *array1[10];//结合顺序为 array1[10]-- *array1[10]--int *array1[10]
5.int (*pointer1)[10];//结合顺序为 *pointer1--(*pointer)[10]--int (*pointer)[10]
//pointer1=array1; 是错误的两者类型不相同.
6.int (*return_array_pointer_func(int))[10];//定义一个返回数组指针的函数
return_array_pointer_func.结合顺序为:
//return_array_pointer_func(int)--*return_array_pointer_func(int)--(*return_array_point er_func(int))[10]
//--int (*return_array_pointer_func(int))[10]
7.int (*func_pointer_array[10])(int);//定义一个返回int,接受一个int参数的函数指针数组.结合顺序为:
//func_pointer_array[10]--(*func_pointer_array[10])--(*func_pointer_array[10])(int)--in t (*func_pointer_array[10])(int)
8.int (*(*func_pointer_pointer_array)(int))[10]; //定义一个函数指针的指针的数组.结合顺序为:
//*func_pointer_pointer_array--(*func_pointer_pointer_array)
(int)--( *(*func_pointer_pointer_array) (int))
//--( *(*func_pointer_pointer_array) (int))[10]--int ( *(*func_pointer_pointer_array) (int))[10]
9.int *(*(*fun_pointer_pointer_array_pointer)(int)) [10]; //定义一个函数指针的指针数组的指针.结合顺序为:
//*fun_pointer_pointer_array_pointer--*fun_pointer_pointer_array_pointer)(int)--(*(*fun _pointer_pointer_array_pointer)(int))
//--(*(*fun_pointer_pointer_array_pointer)(int))
[10]--*(*(*fun_pointer_pointer_array_pointer)(int)) [10]
//--int *(*(*fun_pointer_pointer_array_pointer)(int)) [10]
10.float ( * ( *getvalue()) [] )(); ////定义一个函数,该函数不接受参数,返回值类型是一个指针,返回值类型是一个指针数组
// 返回值类型是一个指针数组指针,返回值类型是一个指针数组函数指针,该函数有一个float返回值,不接受参数结合顺序为:
//getvalue()--( *getvalue())--( *getvalue()) [] --( * ( *getvalue()) [] )--( * ( *getvalue()) [] )()
//--float ( * ( *getvalue()) [] )();
//定义一个函数, 该函数不接受参数,返回值类型是一个指针,返回值类型是一个指针数组,返回值类型是一个指针数组指针,返回值类型是一个指针数组函数指针,该函数有一个 float返回值,不接受
参数
11.void * ( *func_pointer1) ( char, int (*)()); //定义一个函数指针,结合顺序为:
//*func_pointer1--( *func_pointer1) ( char, int (*)())--void * ( *func_pointer1) ( char, int (*)());
12.void ** (*func_pointer2) (int &, char **(*)(char *, char **)); //定义一个指针,该指针是一个函数指针,该函数接受两个参数,
//一个参数是int &型,一个是char **(*)(char*,char**)型,返回值是void **型.结合顺序为:
//*func_pointer2--(*func_pointer2) (int &, char **(*)(char *, char **))--
//** (*func_pointer2) (int &, char **(*)(char *, char **))--void ** (*func_pointer2) (int &, char **(*)(char *, char **));
13.float ( * ( * func_array_pointer1[10]) (int &) ) [5];//定义一个数组,该数组存放指针,该数组存放函数指针,
// 函数的返回值是指向数组的指针,参数是int &.结合顺序为:
//func_array_pointer1[10]--* func_array_pointer1[10]--( * func_array_pointer1[10]) (int &)--
//( * ( * func_array_pointer1[10]) (int &) )--( * ( * func_array_pointer1[10]) (int &) ) [5]
//--float ( * ( * func_array_pointer1[10]) (int &) ) [5]
复杂的函数指针例子分析
一个最简单的函数指针定义如下：
Void (*funcPtr) (); //funcptr是一个函数指针，它指向的函数没有参数，返回值为void
非常复杂的函数指针定义：
1.Void * (* ( * fp1)(int))[10];
解析：Void * X[10];è这是一个有10个void*类型的元素的数组。
X=* ( * fp1)(int)，从而可以看出（*fp1）(int)它是一个指针，指向一个数组。这个数组有10个void指针类型的元素。
Fp1是一个函数指针，它的参数是一个int型的参数。返回值为一个指向含有10个void*元素的数组的指针。
2． Void * ( * fp1)(int)[10]；
解析：void*X[10]；èX是一个有着10个void*类型的数组
X=( * fp1)(int)；
Fp1是一个函数指针，它有一个整型参数，其返回值是一个有着10个void*类型的元素的数组。3． Void ( * fp1)(int)[10]；
解析：void X[10]èX是一个有着10个void类型的数组
X=( * fp1)(int)；
Fp1是一个函数指针，它有一个整型参数，其返回值是一个有着10个void类型的元素的数组
若是这个形式，Void ( * fp1)(int)[10]，则其返回值为一个有10个void类型的数组。
4． Float (*(*fp2)(int,int,float))(int);
解析：Float X(int)èX是一个函数，有一个整型参数，返回值是一个浮点数。
X=*(*fp2)(int,int,float)；
Fp2是一个函数指针，它有三个参数，前两个是整型，最后一个是浮点型。其返回值是一个指针，是一个指向函数的指针（函数指针）。这个函数指针所指向的函数的原型是只有一个整型参数，返回值是一个浮点数。
5． Typedef double (*(*(*fp3)())[10])();
解析：fp3是一个函数指针；它不带参数；返回值是一个指针。
X=(*(*fp3)())
Typedef double (*X[10])()
X是一个数组，他有10个元素，它的元素都是函数指针，这个函数指针所指向的函数原型是一个没有参数，返回值为double类型的函数。
综合起来就是：fp3是一个新定义的数据类型，它是一个函数指针，这个函数指针所指向的函数原型是不带参数，返回值是一个指向数组的指针。这个数组有10个元素，其元素类型是一个函数指针，这个函数指针所指向的函数原型是一个没有参数，返回值为double类型的函数。
6． Int (*(*fp4())[10])();
解析：fp4是一个函数，他没有参数，返回值是一个指针；
X= (*fp4())；
Int (*X[10])();
X是一个数组，其有10个元素，每个元素都是一个函数指针，这个函数指针所代表的函数原型是一个没有参数，返回值是整型的函数。
综合起来就是：fp4是一个函数，他没有参数，返回值时一个指向数据的指针，这个数组有10个元素，每个元素都是一个函数指针，这个函数指针所代表的函数圆型是一个没有参数，返回值是整型的函数。
typedef
一、typedef结构的问题
当用下面的代码定义一个结构时，编译器报了一个错误，为什么呢？莫非C语言不允许在结构中包含指向它自己的指针吗？请你先猜想一下，然后看下文说明：
typedef struct tagNode
{
char *pItem;
pNode pNext;
} *pNode;
答案与分析：
1、typedef的最简单使用
typedef long byte_4;
给已知数据类型long起个新名字，叫byte_4。
2、 typedef与结构结合使用
typedef struct tagMyStruct
{
int iNum;
long lLength;
} MyStruct;
这语句实际上完成两个操作：
1) 定义一个新的结构类型
struct tagMyStruct
{
int iNum;
long lLength;
};
分析：tagMyStruct称为“tag”，即“标签”，实际上是一个临时名字，struct 关键字和tagMyStruct 一起，构成了这个结构类型，不论是否有typedef，这个结构都存在。
我们可以用struct tagMyStruct varName来定义变量，但要注意，使用tagMyStruct varName 来定义变量是不对的，因为struct 和tagMyStruct合在一起才能表示一个结构类型。
2) typedef为这个新的结构起了一个名字，叫MyStruct。
typedef struct tagMyStruct MyStruct;
因此，MyStruct实际上相当于struct tagMyStruct，我们可以使用MyStruct varName来定义变量。
答案与分析
C语言当然允许在结构中包含指向它自己的指针，我们可以在建立链表等数据结构的实现上看到无数这样的例子，上述代码的根本问题在于 typedef的应用。
根据我们上面的阐述可以知道：新结构建立的过程中遇到了pNext域的声明，类型是pNode，要知道pNode表示的是类型的新名字，那么在类型本身还没有建立完成的时候，这个类型的新名字也还不存在，也就是说这个时候编译器根本不认识pNode。
解决这个问题的方法有多种：
1)、
typedef struct tagNode
{
char *pItem;
struct tagNode *pNext;
} *pNode;
2)、
typedef struct tagNode *pNode;
struct tagNode
{
char *pItem;
pNode pNext;
};
注意：在这个例子中，你用typedef给一个还未完全声明的类型起新名字。C语言编译器支持这种做法。
3)、规范做法：
struct tagNode
{
char *pItem;
struct tagNode *pNext;
};
typedef struct tagNode *pNode;
二、. typedef & #define的问题
有下面两种定义pStr数据类型的方法，两者有什么不同？哪一种更好一点？
typedef char *pStr;
#define pStr char *;
答案与分析：
通常讲，typedef要比#define要好，特别是在有指针的场合。请看例子：
typedef char *pStr1;
#define pStr2 char *;
pStr1 s1, s2;
pStr2 s3, s4;
在上述的变量定义中，s1、s2、s3都被定义为char *，而s4则定义成了char，不是我们所预期的指针变量，根本原因就在于#define只是简单的字符串替换而typedef则是为一个类型起新名字。
#define用法例子：
#define f(x) x*x
main( )
{
int a=6，b=2，c；
c=f(a) / f(b)；
printf("%d \n"，c)；
}
以下程序的输出结果是: 36。
因为如此原因，在许多C语言编程规范中提到使用#define定义时，如果定义中包含表达式，必须使用括号，则上述定义应该如下定义才对：
#define f(x) (x*x)
当然，如果你使用typedef就没有这样的问题。
typedef & #define的另一例
下面的代码中编译器会报一个错误，你知道是哪个语句错了吗？
typedef char * pStr;
char string[4] = "abc";
const char *p1 = string;
const pStr p2 = string;
p1++;
p2++;
答案与分析：
是p2++出错了。这个问题再一次提醒我们：typedef和#define不同，它不是简单的文本替换。上述代码中 const pStr p2并不等于const char * p2。const pStr p2和const long x本质上没有区别，都是对变量进行只读限制，只不过此处变量p2的数据类型是我们自己定义的而不是系统固有类型而已。因此，const pStr p2的含义是：限定数据类型为 char *的变量p2为只读，因此p2++错误。
（注：关于const的限定内容问题，在本系列第二篇有详细讲解）。
#define与typedef引申谈
1) #define宏定义有一个特别的长处：可以使用 #ifdef ,#ifndef等来进行逻辑判断，还可以使用#undef来取消定义。
2) typedef也有一个特别的长处：它符合范围规则，使用typedef定义的变量类型其作用范围限制在所定义的函数或者文件内（取决于此变量定义的位置），而宏定义则没有这种特性。
三、typedef & 复杂的变量声明
在编程实践中，尤其是看别人代码的时候，常常会遇到比较复杂的变量声明,使用typedef作简化自有其价值，比如：
下面是三个变量的声明，我想使用typdef分别给它们定义一个别名，请问该如何做？
>1：int *(*a[5])(int, char*);
>2：void (*b[10]) (void (*)());
>3. doube(*)() (*pa)[9];
答案与分析：
对复杂变量建立一个类型别名的方法很简单，你只要在传统的变量声明表达式里用类型名替代变量名，然后把关键字typedef加在该语句的开头就行了。
（注：如果你对有些变量的声明语法感到难以理解，请参阅本系列第十篇的相关内容）。
>1：int *(*a[5])(int, char*);
//pFun是我们建的一个类型别名
typedef int *(*pFun)(int, char*);
//使用定义的新类型来声明对象，等价于int* (*a[5])(int, char*);
pFun a[5];
>2：void (*b[10]) (void (*)());
//首先为上面表达式蓝色部分声明一个新类型
typedef void (*pFunParam)();
//整体声明一个新类型
typedef void (*pFun)(pFunParam);
//使用定义的新类型来声明对象，等价于void (*b[10]) (void (*)());
pFun b[10];
>3. doube(*)() (*pa)[9];
//首先为上面表达式蓝色部分声明一个新类型
typedef double(*pFun)();
//整体声明一个新类型
typedef pFun (*pFunParam)[9];
//使用定义的新类型来声明对象，等价于doube(*)() (*pa)[9];
pFunParam pa;
1.int * (* (*getvalue) (int) ) [10];
-----------------------------------
getvalue是一个函数指针，它指向的函数的形参是int，返回值是一个指向数组的指针，这个指针指向的数组是一个二维指针数组，第二维的上界为10。
2. float ( * ( *getvalue()) [] )();
-------------------------------------
getvalue是一个函数，这个函数的形参不确定，返回值是一个指向数组的指针，所指向数组的元素是函数指针，这些函数指针所指向的函数的形参不确定，返回值是float。
3. void * ( *getvalue) ( char, int (*)());
---------------------------------------------
这个最简单。getvalue是一个函数指针，形参是char和函数指针，返回值为void*。那个函数指针形参所指向的函数的形参不确定，返回值是int。
4.void ** (*getvalue) (int &, char **(*)(char *, char **));
------------------------------------------------------------
这个也简单。getvalue是一个函数指针，形参是int类型的引用和一个函数指针，返回值是指向void的二级指针。那个函数指针形参的形参是指向char的指针和指向char的二级指针，返回值是指向char的二级指针。
5.float ( * ( * e[10]) (int &) ) [5];
--------------------------------------
e是一个一维数组，元素是函数指针，这些指针所指向的函数的形参具有int类型的引用，返回值是指向数组的指针，这些指针指向一个二维float数组，第二维的上界是5。
将0转型为“指向返回值为void的函数的指针”-----(void (*)())0
引用就是某个目标变量的“别名”(alias)，对引用的操作与对变量直接操作效果完全相同。声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。 将“引用”作为函数返回值类型 格式：类型标识符&函数名（形参列表及类型说明）{ //函数体} 好处：在内存中不产生被返回值的副本 A a(){...;return *this;}//会调用拷贝构造函数和析构函数 A& a(){...;return *this;}//不会调用拷贝构造函数和析构函数 关键：当想要返回一个引用而不是一个拷贝时，要确保这个引用的有效性，比如： int & fun() { int a; a=10; return a; } 这样是不行的，因为a会在fun退出时被销毁，这时返回的a的引用是无效的。 这种情况下，如果fun的返回类型不是int & 而是int就没有问题了。 注意事项： （1）不能返回局部变量的引用。这条可以参照Effective C++的Item 31。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。 （2）不能返回函数内部new分配的内存的引用。这条可以参照Effective C++的Item 31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。（3）可以返回类成员的引用，但最好是const。这条原则可以参照Effective C++的Item 30。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。 （4）流操作符重载返回值申明为“引用”的作用：流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout << "hello" << endl; 因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回一个流对象，程序必须重新（拷贝）构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的！这无法让人接受。对于返回一个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这就是C++语言中引入引用这个概念的原因。赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。 例 #include
函数返回值 int Count() { int i,j; i=100; j=200; return i+j; } 测试函数: void Test() { int k=Count(); printf("\n k[%d]\n"); } C/C++的函数返回值一般是放在寄存器eax里的，而不是在栈里。 你的这一句int k = Count()的汇编语句就是这样： mov [esp - 4], eax //eax里是300，esp - 4是局部变量k的位置 你可以在vc里做个实验： int add(int a, int b) { __asm { mov eax,a // 把参数1存入eax add eax,b // eax += 参数2, 结果在eax里 } } int main() { printf("%d\n", add(3, 4)); return 0; } 楼主需要了解下寄存器这一概念，我就不把C/C++函数的汇编代码给发出来了。 还有在汇编层面来看，函数的返回值根本就没有定论，函数可以通过多种方式返回。保存返回值在eax里只是C/C++的一个约定而已。
返回值可以放在栈里，但你在C的语言层面上可能做不到，其实随着函数的结束，mov esp, ebp这条指令过后，函数内部的局部变量就报废了。如果你之后没改变过栈的内容，你可以用栈来存返回值，但比起用寄存器来存储，存储和读取要慢的多。 自己突发奇想在vc下试了下用栈“返回”值，写了段代码： #include
函数返回值 1.不带返回值的函数：return； 不带返回值的函数的返回类型为void，这样的函数会在函数的最后一个语句完成时隐式调用return;也可以在函数的结尾显式地调用return； 对于任意一个函数，只要执行了return语句，函数就强制结束了。 对于返回类型为void的函数，如果不显式地调用return；则只有在函数结束时才会隐式调用。可以在函数执行的某一阶段，显式地调用return；来结束函数，不再执行return语句之后的函数部分。 由于break语句只能用于循环和switch语句中，因此，想要结束if语句直接退出函数，可用return； 只有一种情况下，返回类型为void的函数可以使用return expression这一形式，那就是返回另一个返回类型同样是void的函数的调用结果。 如： void A() void B() { { .... .... .... .... return; return A(); } }//因为A返回类型为void，所以可以这样调用。 2.具有返回值的函数：return expression； 代码： int max(int x,int y) #include
c++中，引用和指针的区别 (1)引用总是指向一个对象,没有所谓的null reference .所有当有可能指向一个对象也由可能不指向对象则必须使用指针. 由于C++ 要求reference 总是指向一个对象所以reference要求有初值. String & rs = string1; 由于没有所谓的null reference 所以所以在使用前不需要进行测试其是否有值.,而使用指针则需要测试其的有效性. (2)指针可以被重新赋值而reference则总是指向最初或地的对象. (3)必须使用reference的场合. Operator[] 操作符由于该操作符很特别地必须返回[能够被当做assignment 赋值对象] 的东西,所以需要给他返回一个reference. (4)其实引用在函数的参数中使用很经常. void Get***(const int& a) //这样使用了引用有可以保证不修改被引用的值 { } 引用和指针 ★相同点： 1. 都是地址的概念； 指针指向一块内存，它的内容是所指内存的地址；引用是某块内存的别名。 ★区别： 1. 指针是一个实体，而引用仅是个别名； 2. 引用使用时无需解引用(*)，指针需要解引用； 3. 引用只能在定义时被初始化一次，之后不可变；指针可变； 引用“从一而终” ^_^ 4. 引用没有const，指针有const，const 的指针不可变； 5. 引用不能为空，指针可以为空； 6. “sizeof 引用”得到的是所指向的变量(对象)的大小，而“sizeof 指针”得到的是指针本身(所指向的变量或对象的地址)的大小； typeid(T) == typeid(T&) 恒为真，sizeof(T) == sizeof(T&) 恒为真， 但是当引用作为成员时，其占用空间与指针相同（没找到标准的规定）。
第四章类与对象习题 一.基本概念与基础知识自测题 填空题 引入类定义的关键字是（1）。类的成员函数通常指定为（2），类的数据成员通常指定为（3）。指定为（4）的类成员可以在类对象所在域中的任何位置访问它们。通常用类的（5）成员表示类的属性，用类的（6）成员表示类的操作。 答案： （1）class （2）公有的public （3）私有的private （4）公有的public （5）数据 （6）$ （7）函数 类的访问限定符包括（1）、（2）和（3）。私有数据通常由（4）函数来访问（读和写）。这些函数统称为（5）。 答案： （1）public（公有的） （2）private（私有的） （3）protected（保护的） （4）公有的成员函数 （5）类的接口 通常在逻辑上，同一类的每个对象都有（1）代码区，用以存储成员函数。而在物理上通常只有（2）代码区。只有在（3）定义，并（4）的函数和加了关键字（5）的函数例外。 答案： （1）| （2）独立的 （3）共用的 （4）在类说明中 （5）不包括循环等复杂结构 （6）inline C++中支持三种域：（1）、（2）、（3）。函数域被包括在（4）中，全局域被包括在（5）中。using指示符以关键字using开头，后面是关键字（6），最后是（7）。这样表示以后在该名字空间中所有成员都（8）。 如不使用using指示符则在使用时要加::，称为（9）运算符。 答案： （1）局部域（local scope） （2）名字空间域（namespace scope） （3）类域（class scope） （4）/ （5）局部域
（6）名字空间域 （7）namespace （8）名字空间名 （9）可以直接被使用 （10）域 引用通常用作函数的（1）和（2）。对数组只能引用（3）不能引用（4）。 答案： （1）参数 （2）返回值 （3）~ （4）数组元素 （5）数组名本身 构造函数的任务是（1）。构造函数无（2）。类中可以有（3）个构造函数，它们由（4）区分。如果类说明中没有给出构造函数，则C++编译器会（5）。拷贝构造函数的参数是（6），当程序没有给出复制构造函数时，系统会自动提供（7）支持，这样的复制构造函数中每个类成员（8）。 答案： （1）初始化数据成员 （2）函数返回类型说明 （3）多 （4）不同的参数表 （5）自动给出一个默认的构造函数 （6）同一类对象的引用 （7）： （8）默认的的复制构造函，称为默认的按成员语义支持。 （9）被依次复制 一个类有（1）个析构函数。（2）时，系统会自动调用析构函数。 答案： （1）一 （2）对象注销时 运算符重载时，其函数名由（1）构成。成员函数重载双目运算符时，左操作数是（2），右操作数是（3）。 答案： （1）关键字operator和该运算符 （2）对象 （3）… （4）该函数的参数 面向过程的程序设计中程序模型描述为（1），面向对象程序设计的程序模型可描述为（2）。 答案： （1）“程序=算法+数据结构”。其数据与数据处理是分离的。 （2）程序=（对象+对象+……+对象）+消息；对象=（算法+数据结构）。面向对象设计将数据和对数据的操作方法放在一起，形成一个相对独立的整体——对象（Object），并通过
C语言实现函数返回多值 笔者从事C语言教学多年，在教学中学生们常常会问到如何编写具有多个返回值的C语言函数。编写有多个返回值的函数是所有C语言教材里均没有提到的知识点，但在实际教学与应用的过程中我们都有可能会遇到这样的问题。有学生也尝试了不少方法:如把多个需要返回的值作相应的处理后变成一个可以用语句返回的数据，再在主调函数中拆开返回的数据使之变成几个值;或者return 把需要返回多个值的一个函数分开几个函数去实现多个值的返回。这些方法虽然最终都能实现返回要求的多个值，但从程序算法的合理性与最优化方面去考虑，显然不理想。我们知道C语言函数的返回值是通过函数中的return语句来实现的，可是每调用一次函数，return语句只能返回一个值。那么当我们希望从一个函数中返回多个值时，用什么方法去实现比较合理呢,在教学过程中，我建议学生跳出对return语句的定势思维，一步步引导学生通过几种间接方式实现多个返回值的C语言函数。以下是笔者在教学过程中引导学生采用的三种不同方法编写多个返回值的C语言函数。 2方法1:利用全局变量 分析:全局变量作为C语言的一个知识点，虽然我们都了解它的特点，但 于全局变量的作用域是从定义变量开始在实际教学过程中应用得并不是很多。由 直到程序结束，而对于编写有多个返回值的C语言函数，我们可以考虑把要返回的多个值定义成全局变量。当函数被调用时，全局变量被更改，我们再把更改后的全局变量值应用于主调函数中。函数被调用后被更改后的全局变量值即为函数的数个返回值。下面以一个实例演示该方法的应用。
实例1:编写函数求3个数中的最大值与最小值。 方法:把最大值、最小值分别定义成2个全局变量max、min，在用户自定义函数中把求出来的最大值与最小值分别赋给全局变量max、min。函数调用完毕后全局变量的max、min值即保存了函数要求返回的值。程序参考代码如下: #include "stdio.h" #include "conio.h" int max,min;/*定义两个全局变量用于保存函数返回值*/ void max_min(int a,int b,int c) /*定义求最大最小值的函数*/ {max=min=a; /*初始化最大最小值*/ if(max if(max if(min>b)min=b; if(min>c)min=c; } main() {int x,y,z; printf(" 请输入3个整数:\n"); scanf("%d,%d,%d",&x,&y,&z); max_min(x,y,z) ;/*调用求最大值与最小值的函数*/ printf("三个数中的最大值为:%d;最小值为:%d",max,min);/*输出最大值与最小值*/ getch(); } 调试结果如下: 请输入3个整数: 5,-6,2
函数的参数、返回值总结 （一）参数 ◆函数分： 有参函数：函数名（实参列表） 无参函数：函数名（） ◆有参函数调用语句中的实参应与被调函数中的形参在个数、类型、顺序上一致。 ◆参数传递时，实参向形参一一对应进行单向的值传递。值：可是数值（变量或数 组元素）或数值的地址值（指针或数组名）。 （二）返回值 函数的返回值即为函数调用后的结果，可有如下返回结果的方法： （1）通过return语句返回一个值； （2）利用地址做参数返回一个或多个值； （3）利用全局变量返回一个或多个值。 （三）例 1、170页实验内容（1）：打印由正三角和倒三角组成的图形。 有一个参数，无返回值。实参向形参传递一个数值。 #include
指向函数的指针 函数指针是指指向函数而非指向对象的指针。像其他指针一样，函数指针也指向某个特定的类型。函数类型由其返回类型以及形参表确定，而与函数名无关： bool (*pf)(const string &,const string &); 这个语句将pf声明为指向函数的指针，它所指向的函数带有两个const string &类型的形参和bool 类型的返回值。 注意：*pf两侧的括号是必需的。 1.typedef简化函数指针的定义： 函数指针类型相当地冗长。使用typedef为指针类型定义同义词，可将函数指针的使用大大简化： Typedef bool (*cmpfn)(const string &,const string &); 该定义表示cmpfn是一种指向函数的指针类型的名字。该指针类型为“指向返回bool类型并带有两个const string 引用形参的函数的指针”。在要使用这种函数指针类型时，只需直接使用cmpfcn即可，不必每次都把整个类型声明全部写出来。 2.指向函数的指针的初始化和赋值 在引用函数名但又没有调用该函数时，函数名将被自动解释为指向函数的指针。假设有函数: Bool lengthcompare(const string &,const string &); 除了用作函数调用的左操作数以外，对lengthcompare的任何使用都被解释为如下类型的指针:
bool (*)(const string &,const string &); 可使用函数名对函数指针初始化或赋值: cmpfn pf1=0; cmpfn pf2=lengthcompare; pf1=legnthcompare; pf2=pf1; 此时，直接引用函数名等效于在函数名上应用取地址操作符: cmpfcn pf1=lengthcompare; cmpfcn pf2=lengthcompare; 注意：函数指针只能通过同类型的函数或函数指针或0值常量表达式进行初始化或赋值。 将函数指针初始化为0，表示该指针不指向任何函数。 指向不两只函数类型的指针之间不存在转换： string::size_type sumLength(const string &,const string &); bool cstringCompare(char *,char *); //pointer to function returning bool taking two const string& cmpFcn pf；//error:return type differs pf=cstringCompare;//error:parameter types differ pf=lengthCompare;//ok:function and pointer types match exactly 3.通过指针调用函数 指向函数的指针可用于调用它所指向的函数。可以不需要使用解引用
一填空题（） 1、派生类的生成过程经历了三个步骤：吸收基类成员、改造基类成员、添加新成员。 2、多态分为：专用多态和通用多态。 二、选择题（10分） 1在一个函数中，要求通过函数来实现一种不太复杂的功能，并且要求加快执行速度，选用（A ）比较合适。 A 内联函数 B 重载函数 C 递归调用 D 嵌套调用 2下面对构造函数的描述不正确的是（C ） A 可以重载 B 其名字与类名相同 C 可以显式调用构造函数 D 构造函数是成员函数 E 构造函数不能是虚函数 3、判断题（正确的请写T，错误的请写F）（20分） 静态成员函数可以直接调用类中说明的非静态成员。（F） windows应用程序采用基于消息的事件驱动运行机制。（T） 4、找出程序中的错误并改正（10分） class student（） { private: public: display(){} } }； //----------------------------------------------- void g() student g() { student s; return s; } //------------------------------------------------ mian（）void main（） { student s1; s1->display(); s1.display(); } 5、读程序，在语句后的括号中填入相应的选项，并写出程序运行结果结果（8个小题）（共40分结果30分选择10分）选项：A、复制构造函数 B、构造函数 C、内联成员函数 D、对象成员 E、对象作为函数的参数 F、调用复制构造函数 G、对象调用成员函数 1、 #include
VBA 之函数返回值(可多个返回值) vba之函数返回值1.Function define_yy(ByVal names As String, ByValworkbooks As String) As String Dim str_return As String '返回值 Dim i, t As Integer ........ ........ ........ ........ ........ define_yy = str_return End Function 对于函数返回值的要点已经用粗体表示出来了.调用此函数的格式为: call modle_connection.define_yy() (这个是不需要返回值的调用方法) bb=modle_connection.define_yy(a,b) (这是需要返回值的方法) 注:modle_connection为程序块名 2.返回值为多个值,可以采用返回数组的类型 Function return_data(ByVal strSEL As String, ByRef x As
Integer) AsString() '需要有括号,代表数组Dim cn As New ADODB.Connection Dim rs As New ADODB.Recordset Dim bb(1000, 20) As String Dim i As Integer, j As Integer cn.Open strCN rs.Open strSEL, cn i = 1 Do While Not rs.EOF If x = 1 Then bb(i, 1) = rs(0) Else For j = 1 To x bb(i, j) = rs(j - 1) Next j End If i = i + 1 rs.MoveNext Loop
C语言函数说明与返回值 在学习C语言函数以前，我们需要了解什么是模块化程序设计方法。 人们在求解一个复杂问题时，通常采用的是逐步分解、分而治之的方法，也就是把一个大问题分解成若干个比较容易求解的小问题，然后分别求解。程序员在设计一个复杂的应用程序时，往往也是把整个程序划分为若干功能较为单一的程序模块，然后分别予以实现，最后再把所有的程序模块像搭积木一样装配起来，这种在程序设计中分而治之的策略，被称为模块化程序设计方法。 在C语言中，函数是程序的基本组成单位，因此可以很方便地用函数作为程序模块来实现C语言程序。 利用函数，不仅可以实现程序的模块化，程序设计得简单和直观，提高了程序的易读性和可维护性，而且还可以把程序中普通用到的一些计算或操作编成通用的函数，以供随时调用，这样可以大大地减轻程序员的代码工作量。 函数是C语言的基本构件，是所有程序活动的舞台。函数的一般形式是: type-specifier function_name(parameter list) parameter declarations { body of the function } 类型说明符定义了函数中return语句返回值的类型，该返回值可以是任何有效类型。如果没有类型说明符出现，函数返回一个整型值。参数表是一个用逗号分隔的变量表，当函数被调用时这些变量接收调用参数的值。一个函数可以没有参数，这时函数表是空的。但即使没有参数，括号仍然是必须要有的。参数说明段定义了其中参数的类型。
当一个函数没有明确说明类型时， C语言的编译程序自动将整型( i n t)作为这个函数的缺省类型，缺省类型适用于很大一部分函数。当有必要返回其它类型数据时，需要分两步处理: 首先，必须给函数以明确的类型说明符;其次，函数类型的说明必须处于对它的首次调用之前。只有这样，C编译程序才能为返回非整型的值的函数生成正确代码。 4.1.1 函数的类型说明 可将函数说明为返回任何一种合法的C语言数据类型。 类型说明符告诉编译程序它返回什么类型的数据。这个信息对于程序能否正确运行关系极大，因为不同的数据有不同的长度和内部表示。 返回非整型数据的函数被使用之前，必须把它的类型向程序的其余部分说明。若不这样做，C语言的编译程序就认为函数是返回整型数据的函数，调用点又在函数类型说明之前，编译程序就会对调用生成错误代码。为了防止上述问题的出现，必须使用一个特别的说明语句，通知编译程序这个函数返回什么值。下例示出了这种方法。 第一个函数的类型说明sum()函数返回浮点类型的数据。这个说明使编译程序能够对sum( ) 的调用产生正确代码。 函数类型说明语句的一般形式是: type_specifier function_name (; ) 即使函数使用形参，也不要将其写入说明句。若未使用类型说明语句，函数返回的数据类型可能与调用者所要求的不一致，其结果是难以预料的。如果两者同处于一个文件中，编译程序可以发现该错误并停止编译。如果不在同一个文件中，编译程序无法发现这种错误。类型检查仅在编译中进行，链接和运行时均不检查。因此，必须十分细心以确保绝不发生上
彻底搞定C指针---指向指针的指针 彻底搞定C指针---指向指针的指针一．回顾指针概念： 今天我们又要学习一个叫做指向另一指针地址的指针。让我们先回顾一下指针的概念吧！ 当我们程序如下申明变量： short int i; char a; short int * pi; 程序会在内存某地址空间上为各变量开辟空间，如下图所示。 内存地址→6 7 8 9 10 11 12 13 14 15 ------------------------------------------------------------------------------------- … | | | | | | | | | | ------------------------------------------------------------------------------------- |short int i |char a| |short int * pi| 图中所示中可看出： i 变量在内存地址5的位置，占两个字节。 a变量在内存地址7的位置，占一个字节。 pi变量在内存地址9的位置，占两个字节。(注：pi 是指针，我这里指针的宽度只有两个字节，32位系统是四个字节) 接下来如下赋值: i=50; pi=&i; 经过上在两句的赋值，变量的内存映象如下: 内存地址→6 7 8 9 10 11 12 13 14 15 -------------------------------------------------------------------------------------- … | 50 | | | 6 | | | | -------------------------------------------------------------------------------------- |short int i |char a| |short int * pi| 看到没有：短整型指针变量pi的值为6，它就是I变量的内存起始地址。所以，这时当我们对*pi进行读写操作时，其实就是对i变量的读写操作。如：*pi=5; //就是等价于I=5; 你可以回看本系列的第二篇，那里有更加详细的解说。 二．指针的地址与指向另一指针地址的指针 在上一节中，我们看到，指针变量本身与其它变量一样也是在某个内存地址中的，如pi的内存起始地址是10。同样的，我们也可能让某个指针指向这个
C++笔试题目：将”引用”作为函数返回值类型的格式、好处和需要格式：类型标识符函数名（形参列表及类型说明）｛//函数体｝ 好处：在内存中不产生被返回值的副本；（注意：正是因为这点原因，所以返回一个局部变量的引用是不可取的因为随着该局部变量生存期的结束，相应的引用也会失效产生runtimeerror! 注意事项： （1）不能返回局部变量的引用。这条可以参照EffectiveC++[l]的Item31。主要原因是局部变量会在函 返回后被销毁，因此被返回的引用就成为了”无所指”的引用，程序会进入未知状态。 （2 ）不能返回函数内部ne w分配的内存的引用。这条可以参照Effect i veC++[l]的I tem31。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由n ew分配）就无法释放，造成memoryl eak。 （3）可以返回类成员的引用，但最好是const。这条原则可以参照Eff ect iveC++[l]的I tem30。主要原因是当对
象的属性是与某种业务规则(busines sru le)相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。 如果其它对象可以获得该属性的非常量引用(或指针)，那么对该属性的单纯赋值就会破坏业务规则的完整性。 (4)流操作符重载返回值申明为“引用”的作用： 流操作符〉，这两个操作符常常希望被连续使用，例如: cout对于返回一个流指针则不能连续使用这个操作符象流操作符一样，是可以连续使用的，例如：x=j=10;或者(x=10)=100 :赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。 例3 ^include in tp ut (intn); in tvals [10]: i nter ror=-l; voi dmain() { put (0)=10 ://以put (0)函数值作为左值，等价于V als[0]二10 ; put (9) =20;//以put (9)函数值作为左值，等价于va ls[9]=20;
VBA之函数返回值 1.返回一个值 Function define_yy(ByVal names As String, ByVal workbooks As String) As String Dim str_return As String '返回值 Dim i, t As Integer ........ ........ ........ ........ ........ define_yy = str_return End Function 对于函数返回值的要点已经用粗体表示出来了.调用此函数的格式为: call modle_connection.define_yy() (这个是不需要返回值的调用方法) bb=modle_connection.define_yy(a,b) (这是需要返回值的方法) 注:modle_connection为程序块名 2.返回值为多个值,可以采用返回数组的类型 Function return_data(ByVal strSEL As String, ByRef x As Integer) As String() '需要有括号,代表数组 Dim cn As New ADODB.Connection Dim rs As New ADODB.Recordset Dim bb(1000, 20) As String Dim i As Integer, j As Integer cn.Open strCN rs.Open strSEL, cn i = 1 Do While Not rs.EOF If x = 1 Then bb(i, 1) = rs(0) Else For j = 1 To x bb(i, j) = rs(j - 1) Next j End If i = i + 1 rs.MoveNext Loop x = i - 1 return_data = bb() 'BB()本身也需要定义为数组
指向对象的常指针 将指针变量声明为const型，这样指针值始终保持为其初值，不能改变。 如： Time t1(10,12,15),t2; //定义对象 Time * const ptr1; //const位置在指针变量名前面，规定ptr1的值是常值 ptr1=&t1; //ptr1指向对象t1，此后不能再改变指向 ptr1=&t2; //错误，ptr1不能改变指向 定义指向对象的常指针的一般形式为： 类名* const 指针变量名; 也可以在定义指针变量时使之初始化，如将上面第2, 3行合并为： Time * const ptr1=&t1; //指定ptr1指向t1 请注意，指向对象的常指针变量的值不能改变，即始终指向同一个对象，但可以改变其所指向对象(如t1)的值。 指向常对象的指针变量 下面定义了一个指向常变量的指针变量ptr： const char *ptr; 注意const的位置在最左侧，它与类型名char紧连，表示指针变量ptr指向的char变量是常变量，不能通过ptr来改变其值的。 定义指向常变量的指针变量的一般形式为： const 类型名*指针变量名; 几点说明： 1) 如果一个变量已被声明为常变量，只能用指向常变量的指针变量指向它，而不能用一般的(指向非const型变量的)指针变量去指向它。如： const char c[] ="boy"; //定义const 型的char 数组 const char * pi; //定义pi为指向const型的char变量的指针变量 pi =c; //合法，pi指向常变量(char数组的首元素） char *p2=c; //不合法，p2不是指向常变量的指针变量 2) 指向常变量的指针变量除了可以指向常变量外，还可以指向未被声明为const的变量。此时不能通过此指针变量改变该变量的值。如： char cl ='a'; //定义字符变量cl，它并未声明为const const char *p; //定义了一个指向常变量的指针变量p p = &cl; //使p指向字符变量cl *p = 'b'; //非法，不能通过p改变变量cl的值 cl = 'b'; //合法，没有通过p访问cl，cl不是常变量 3) 如果函数的形参是指向非const型变量的指针，实参只能用指向非const变量的指针，
C语言函数练习题 一、选择题 1. 一个完整的C源程序是【】。 A）要由一个主函数或一个以上的非主函数构成 B）由一个且仅由一个主函数和零个以上的非主函数构成 C）要由一个主函数和一个以上的非主函数构成 D）由一个且只有一个主函数或多个非主函数构成 2. 以下关于函数的叙述中正确的是【】。 A）C语言程序将从源程序中第一个函数开始执行 B）可以在程序中由用户指定任意一个函数作为主函数，程序将从此开始执行 C）C语言规定必须用main作为主函数名，程序将从此开始执行，在此结束 D）main可作为用户标识符，用以定义任意一个函数 3. 以下关于函数的叙述中不正确的是【】。 A）C程序是函数的集合，包括标准库函数和用户自定义函数 B）在C语言程序中，被调用的函数必须在main函数中定义 C）在C语言程序中，函数的定义不能嵌套 D）在C语言程序中，函数的调用可以嵌套 4. 在一个C程序中,【】。 A）main函数必须出现在所有函数之前 B）main函数可以在任何地方出现 C）main函数必须出现在所有函数之后 D）main函数必须出现在固定位置 5. 若在C语言中未说明函数的类型，则系统默认该函数的数据类型是【】 A）float B）long C）int D）double 6. 以下关于函数叙述中，错误的是【】。 A）函数未被调用时，系统将不为形参分配内存单元 B）实参与形参的个数应相等，且实参与形参的类型必须对应一致 C）当形参是变量时，实参可以是常量、变量或表达式 D）形参可以是常量、变量或表达式 7. C程序中各函数之间可以通过多种方式传递数据，下列不能用于实现数据传递的方式是 【】。 A）参数的形实结合 B）函数返回值 C）全局变量 D）同名的局部变量 8. 若函数调用时参数为基本数据类型的变量，以下叙述正确的是【】。 A）实参与其对应的形参共占存储单元 B）只有当实参与其对应的形参同名时才共占存储单元 C）实参与对应的形参分别占用不同的存储单元 D）实参将数据传递给形参后，立即释放原先占用的存储单元
如何透彻理解C语言中指针的概念 强大的指针功能是C语言区别于众多高级语言的一个重要特征。C语言指针的功能强大，使用灵活多变，可以有效地表示复杂的数据结构、动态分配内存、高效地使用数组和字符串、使得调用函数时得到多个返回值。而它的应用远不限于此。初学者对于指针的概念总是感到无所适从，有时觉得“自己懂了，为什么编译器就是不懂呢”，常有茫然和无助的感觉。 学好指针的关键在于深入了解内存地址的空间可以理解为一个一维线性空间，内存的编址和寻址方法，以及指针在使用上的一些规定。事实上，指针就是方便我们对内存地址直接进行操作的，是为程序员服务的，我们只要抓住指针想要帮助我们解决什么问题这个核心，就可以轻松地理解它的工作原理。 什么是指针，指针有什么作用 指针就是指向一个特定内存地址的一个变量。简化了的内存空间模型是按照从0到某一个数（比如1048575=1M-1）的一维线性空间，其中的每一个数对应一个存储单元，即1个字节。指针有两个属性：指向性和偏移性。指向性指的是指针一定要有一个确定的指向，偏移性则是体现指针重要应用的方面，即指针可以按程序员的要求向前或向后偏移。 指针的应用往往与数组联系在一起，为了方便说明问题，不妨从数组开始解释指针的偏移。数组就是许多的变量，它的一个重要特征就是在内存空间中连续地存放，而且是按下标顺序存放。比如我们定义一个有100个变量的一维整型数组，它一定从内存的某一个存储单元开始按数组下标顺序存放，连续占用100*4=400字节。当我们定义一个数组时，系统就会自动为它分配一个指针，这个指针指向数组的首地址。（在本文剩余部分的论述中，不加区分地使用“指向数组的首地址”与“指向数组的第一个元素”这两种说法，事实上这两种说法也是一致的。） 为了让系统了解每一次指针偏移的单位，也为了方便程序员进行指针偏移（让程序员记住一个整形变量占用4字节，一个字符型变量占用1字节……等等是很麻烦的），不用每次去计算要偏移多少个字节，C语言引入了指针的基类型的概念。基类型的作用就是让系统了解某个指针每次偏移的字节数。比如，对于一个字符型指针，它每次偏移（比如ptr=ptr+1）所起到的作用就是让指针偏移1字节；而对于一个整型指针，它每次偏移就应该是4字节。这样操作数组时就带来了方便。比如对于一个指向某个整型数组起始存储单元（称为首地址）的指针ptr，ptr=ptr+1就表示将该指针指向这个数组的下一个元素的存储单元，即向后移动4字节，而不仅仅是移动一个存储单元（即移动1字节）。 &()、*()、和[ ]运算符的意义 在本文中，将&()、*()和[ ]都看成是运算符。这样可以方便理解这三个概念。简单地说，&()将某个标识符（比如变量）转化为其在内存空间中的地址，而*()是产生一个对应于某个地址的标识符，[ ]就更复杂一点，ptr[i]表示
事件处理函数中返回值 事件处理函数返回值其实指当事件发生时，浏览器会执行默认的操作，而当事件处理函数会返回一个结果，而当这个结果为true时，浏览器会继续执行默认操作，否则会停止执行。如果还是不懂的话，我们看一下下面这个实例： 当点击超链接标签时，如果check()的值为true，那么浏览器会跳转到abc.html页面中去，如果check()的值为false,点击超链接标签就不会跳转 这里return其实是对事件对象中的returnValue属性值的设置，而该属性就决定了该事件操作是否继续操作，当retrunValue为true时则继续操作，为false时则中断操作。 然而直接执行函数check，不使用return返回将不会对eturnvalue进行设置所以会默认地继续执行操作，比如如下实例 上面的实例就是不管check()的结果是true还是fasle，浏览器都会跳转到abc.html 页面中去。所以必须使用return返回。 事件处理函数返回值在表单中也存在这种情况，如下图
判断用户名是否为空，如果为空就不提交表单，否则就提交表单...跟上面理解是一样的。 讲到这里有很多同学在这里还能理解，但是呢，换个地方，换个事件绑定方式就不能理解了。 比如：在DOM对象上绑定事件： 很多人不能理解的是：在html元素上绑定事件时，return用了两次，才能阻止表单的提交，为什么在DOM对象上绑定事件时只用了一次return就能阻止表单提交，这里我们就要看看为什么了。 我们看看直接打印btn.onclick的结果，发现我们在html元素上绑定的事件处理函数fn是出现在DOM对象上事件处理函数的里面。 所以onclick=”return fn()”等价于 btn.onclick=function(){ return fn() }，而fn()的结果true/false就决定表单是否提交。 总结：事件函数返回值； 如果返回true或者不返回，浏览器执行默认操作； 如果返回false，阻止浏览器默认操作。