通俗易懂的C语言指针（详解）

1.语言中变量的实质

        
理解内存实质，如下图：

        如图所示，内存只不过是一个存放数据的空间，就好像我们看电影时的电影院中的座位一样。每个座位都要编号，我们的内存要存放各种各样的数据，当然我们要知道我们的这些数据存放在什么位置吧！所以内存也要象座位一样进行编号了，这就是我们所说的内存编址。座位可以是按一个座位一个号码的从一号开始编号，内存则是按一个字节一个字节进行编址， 如上图所示。每个字节都有个编号，我们称之为内存地址。

我们继续看看以下的 C、C++语言变量申明：

int i;
char a;

每次我们要使用某变量时都要事先这样申明它，它其实是内存中申请了一个名为 i 的整
型变量宽 度的空间（DOS 下的 16 位编程中其宽度为二个字节），和一个名为 a 的字符型变量宽度的空间（占一个字 节）。

        那我们又如何来理解变量是如何存在的呢。当我们如下申明变量时：

int i;
char a;

内存中的映象可能如下图：

内存地址→

图中可看出，i 在内存起始地址为 6 上申请了 两个字节的空间（我这里假设了 int 的宽度为
16 位，不同系统中 int 的宽度是可能不一样的），并命名为 i. a 在内存地址为 8 上申请了一字节的空间，并命名为 a。这样我们就有两个不同类型的变量了。

2.赋值给变量

再看下面赋值：

int i = 30
char a = 't'

你当然知道个两个语句是将 30 存入 i 变量的内存空间中，将‘t’字符存入 a 变量的内存空
间中。我们可以这样的形象理解：

扫描二维码关注公众号，回复： 12617596 查看本文章

内存地址→

变量的地址

好了，接下来我们来看看&i 是什么意思？是取 i 变量所在的地址编号嘛！我们可 以这样读它：返回 i 变量的地址编号。你记住了吗？我要在屏幕上显示变量的地址值的话，可以写如下代码：

int main()
{
    
    
int i=39;
printf(“%d\n”,i); //i的值30
printf(“%d\n”, &i); //i的内存地址，每次都可能不一样
} 

3.指针是什么

        想说弄懂你不容易啊！我们许多初学指针的人都要这样的感慨。我常常在思索它，为什么呢？其实生活中处处都有指针。我们也处处在使用它。有了它我们的生活才更加方便了。没有指针，那生活才不方便。不信？你看下面的例子。

        这是一个生活中的例子：比如说你要 我借给你一本书，我到了你宿舍，但是你人不在宿舍，于是我把书放在你的 2 层 3 号的书架上，并写了一 张纸条放在你的桌上。纸条上写着：你要的书在第 2 层 3 号的书架上。当你回来时，看到这张纸条。你就 知道了我借与你的书放在哪了。你想想看，这张纸条的作用，纸条本身不是书，它上面也没有放着书。 那么你又如何知道书的位置呢？因为纸条上写着书的位置嘛！其实这张纸条就是一个指针了。它上面的 内容不是书本身，而是书的地址，你通过纸条这个指针找到了我借给你的本书。那么我们 C，C++ 中的指针又是什么呢？请继续跟我来吧，看下面看一个申明一整型指针

变量的语句如下：

int* pi

pi 是一个指针，当然我们知道啦，但是这样说，你就以为 pi 一定是个多么特别的东西了。
其 实，它也只过是一个变量而已。与上一篇中说的变量并没有实质的区别。不信你看下面
图。

内存 地址→

（说明：这里我假设了指针只占 2 个字节宽度，实际上在 32 位系统中，指针的宽度 是 4
个字节宽的，即 32 位。）

由图示中可以看出，我们使用 int *Pi 申明指针变量； 其实是在内存的某处 申明一个一定宽度的内存空间，并把它命名为 Pi.你能在图中看出 pi 与前面的 i，a 变量有什么本质区别 吗，没有，当然没有！pi 也只不过是一个变量而已嘛！那么它又为什么会被称为指针？关键是我们要让 这个变量所存储的内容是什么。现在我要让 pi 成为真正有意义上的指针。请接着看下面语句：

pi = &i;

你应该知道 &i 是什么意思吧！再次提醒你啦：这是返回 i 变量的地址编 号。整句的意思
就是把 i 地址的编号赋值给 pi，也就是你在 pi 上写上 i 的地址编号。结果如下图所示：

        你看，执行完 pi=&i；后，在图示中的系统中，pi 的值是 6.这 个 6 就是 i 变量的地址编号，这样 pi 就指向了变量 i 了。你看，pi 与那张纸条有什么区别？pi 不就是那张纸条嘛！上面写着 i 的地址，而 i 就是那个本书。你现在看懂了吗？因此，我们就把 pi 称为指针。所以你要 记住，指针变量所存的内容就是内存的地址编号！好了，现在我们就可以通过这个指针 pi 来访问到 i 这个 变量了，不是吗？。看下面语句：

printf（“%d”，*pi）；

        那么*pi 什么意 思呢？你只要这样读它：pi 内容所指的地址的内容（嘻嘻，看上去好像在绕口令了），就 pi 这张“ 纸条”上所写的位置上的那本 “书”——i .你看，Pi 内容是 6，也就是说 pi 指向内存编号为 6 的地址。*pi 嘛！就是它所指地址的内容，即地址编号 6 上的内容了。当然就是 30 的值 了。所以这条语句会在屏幕上显示 30.也就是说 printf（“%d”，*pi）；语句等价于 printf （ “%d”， i ）

        到此为止，你掌握了类似&i ， *pi 写法的含义和相关操作吗。总的一句话 ，我们的
纸条就是我们的指针，同样我们的 pi 也就是我们的纸条！

4.数组元素

看下面代码：

int i,a[]={
    
    3,4,5,6,7,3,7,4,4,6};
for (i=0;i<=9;i++)
{
    
    
	printf ( “%d”, a[i] );
} 

很显然，它是显示 a 数组的各元素值。我们还可以这样访问元素，如下:

int i,a[]={
    
    3,4,5,6,7,3,7,4,4,6};
for (i=0;i<=9;i++)
{
    
    
printf ( “%d”,*(a+i) );
} 

它们的结果是一样的。

通过指针访问数组元素：

int i,*pa,a[]={
    
    3,4,5,6,7,3,7,4,4,6};
pa =a ;//请注意数组名 a 直接赋值给指针 pa
for (i=0;i<=9;i++)
{
    
    
	printf ( “%d”, pa[i] );
}

很显然，它也是显示 a 数组的各元素值。另外与数组名一样也可如下：

int i,*pa,a[]={
    
    3,4,5,6,7,3,7,4,4,6};
pa =a;
for (i=0;i<=9;i++)
{
    
    
	printf ( “%d”, *(pa+i) );
}

        看 pa=a 即数组名赋值给指针，以及通过数组名、指针对元素的访问形式看，它们并没有什么区别，从 这里可以看出数组名其实也就是指针。难道它们没有任何区别？有，请继续。

5.数组名与指针变量的区别

请看下面的代码：

int i,*pa,a[]={
    
    3,4,5,6,7,3,7,4,4,6};
pa =a;
for (i=0;i<=9;i++)
{
    
    
	printf ( “%d”, *pa );
	pa++ ; //注意这里，指针值被修改
}

        可以看出，这段代码也是将数组各元素值输出。不过，你把{}中的 pa 改成 a 试试。你会发现程序编译出错，不能成功。

        看来指针和数组名还是不同的。其实上面的指针是指针变量，而数组名只是一个指针 常量。这个代码与上面的代码不同的是，指针 pa 在整个循环中，其值是不断递增的，即指针值被修改了 。数组名是指针常量，其值是不能修改的，因此不能类似这样操作：a++.前面 4，5 节中 pa[i]，*（pa+i ）处，指针 pa 的值是使终没有改变。所以变量指针 pa 与数组名 a 可以互换。

6.申明指针常量

再请看下面的代码：

int i, a[]={
    
    3,4,5,6,7,3,7,4,4,6};
int * const pa=a;//注意 const 的位置：不是 const int * pa，
for (i=0;i<=9;i++)
{
    
    
	printf ( “%d”, *pa );
	pa++ ; //注意这里，指针值被修改
}

        这时候的代码能成功编译吗？不能。因为 pa 指针被定义为常量指针了。这时与数组名 a 已经没有不同 。这更说明了数组名就是常量指针。

但是：

int * const a={
    
    3，4，5，6，7，3，7，4，4，6}；//不行
int a[]={
    
    3，4，5，6，7，3，7，4，4，6}；//可以，所以初始化数组时必定要这样。

1 int i 说起

你知道我们申明一个变量时象这样 int i ；这个 i 是可能在它处重新变赋值的。 如下：

int i=0；
//…
i=20；//这里重新赋值了

        不过有一天程序可能需要这样一个变量（暂且称它变量），在申明时就赋一个初始值。之后我的程序在其它任何处都 不会再去重新对它赋值。那我又应该怎么办呢？用 const .

//**************
const int ic =20；
//…

ic=40；//这样是不可以的，编译时是无法通过，因为我们不能对 const 修饰的 ic 重新赋值
的。

//这样我们的程序就会更早更容易发现问题了。

        有了 const 修饰的 ic 我们不称它为变量，而称符号常量，代表着 20 这 个数。这就是const 的作用。ic 是不能在它处重新赋新值了。

        认识了 const 作用之后，另外，我们还要知道格式的写法。有两种：const int ic=20；与 int const ic=20；。它们是完全相同的。这一 点我们是要清楚。总之，你务必要记住 cconst与 int 哪个写前都不影响语义。

        有了这个概念后，我们来看这两个家伙：const int * pi 与 intconst * pi

        按你的逻辑看，它们的语义有不同吗？呵呵，你只要 记住一点，int 与 const 哪个放前哪个放后都是一样的，就好比 const int ic；与 int const ic；一样 。也就是说，它们是相同的。好了，我们现在已经搞定一个“双包胎”的问题。那么 int * const pi 与前两个式子又有什么不同呢？我下面就来具体分析它们的格式与语义吧！

2 const int * pi 的语义

我先来说说 const int * pi 是什么作用 （当然 int const * pi 也是一样 的，前面我们说过，它
们实际是一样的）。看下面的例子：

//*************代码开始 ***************
int i1=30;
int i2=40;
const int * pi=&i1;
pi=&i2; //4.注意这里，pi 可以在任意时候重新赋值一个新内存地址
i2=80; //5.想想看：这里能用*pi=80;来代替吗？当然不能
printf( “%d”, *pi ) ; //6. 输出是 80
//*************代码结束***************

语义分析：

        看出来了 没有啊，pi 的值是可以被修改的。即它可以重新指向另一个地址的，但是，不能通过pi 来修改 i2 的值。 这个规则符合我们前面所讲的逻辑吗？当然符合了！首先 const 修饰的是整个pi（注意，我 写的是pi 而不是 pi）。所以pi 是常量，是不能被赋值的（虽然 pi 所指的 i2 是变量，不是常量）。

        其次，pi 前并没有用 const 修饰，所以 pi 是指针变量，能被赋值重新指向另一内存地址的。你可 能会疑问：那我又如何用 const 来修饰 pi 呢？其实，你注意到 int * const pi 中 const 的位置就大概可 以明白了。请记住，通过格式看语义。哈哈，你可能已经看出了规律吧？那下面的一节也就没必要看下 去了。不过我还得继续我的战斗！

3 再看 int * const pi

        确实，int * const pi 与前面 的 int const * pi 会很容易给混淆的。注意：前面一句的 const 是写在 pi 前和号后的，而不是写在pi 前的。很显然，它是修饰限定 pi 的。

我先让你看例子：

//*************代码开始 ***************
int i1=30;
int i2=40;
int * const pi=&i1;
//pi=&i2; 4.注意这里，pi 不能再这样重新赋值了，即不能再指向另一个新地址。
 //所以我已经注释了它。
i1=80; //5.想想看：这里能用*pi=80;来代替吗？可以，这 里可以通过*pi 修改 i1 的值。
 //请自行与前面一个例子比较。
printf( “% d”, *pi ) ; //6.输出是 80
//***************代码结束 *********************

语义分析：

        看了这段代码，你明白了什么？有没有发现 pi 值是不能重新赋值修改了。它只能永远指向初始化时的内存地址了。相反，这次你可以通过*pi 来修改 i1 的值了。与前一个例子对照一下吧！看以下的两点分析

1. pi 因为有了 const 的修饰，所以只 是一个指针常量：也就是说 pi 值是不可修改的（即pi 不可以重新指向 i2 这个变量了）（看第 4 行）。
2. 整个*pi 的前面没有 const 的修饰。也就是说，*pi 是变量而不是常量，所以我们可以通过 *pi 来修改它所指内存 i1 的值（看 5 行的注释）

总之一句话，这次的 pi 是一个指向 int 变量类型数 据的指针常量。

最后总结两句：

1. 如果 const 修饰在pi 前则不能改的是pi（即不能 类似这样：*pi=50；赋值）而不是指
   pi.
2. 如果 const 是直接写在 pi 前则 pi 不能改（即不能类似 这样：pi=&i；赋值）。
   请你务必先记住这两点，相信你一定不会再被它们给搞糊了。现在 再看这两个申明语
   句 int const *pi 和 int * const pi 时，呵呵，你会头昏脑胀还是很轻松惬意？它们各 自申明的
   pi 分别能修改什么，不能修改什么？
3. 补充三种情况。
   这里， 我再补充以下三种情况。其实只要上面的语义搞清楚了，这三种情况也就已经被包
   含了。不过作为三种 具体的形式，我还是简单提一下吧！

情况一：int * pi 指针指向 const int i 常量的情况

//**********begin*****************
const int i1=40;
int *pi;
pi=&i1; //这样可以吗？不行，VC 下是编译错。
 //const int 类型的 i1 的地址 是不能赋值给指向 int 类型地址的指针 pi 的。否则
pi 岂不是能修改 i1 的值了吗！
pi=(int* ) &i1; // 这样可以吗？强制类型转换可是 C 所支持的。
 //ＶＣ下编译通过，但是仍 不能通过*pi=80 来修改 i1 的值。去试试吧！看看具体的怎
样。

情况二：const int * pi 指针指向 const int i1 的 情况

const int i1=40;
const int * pi;
pi=&i1;//两个类型相同，可以这样赋值。很显然，i1 的值无论是通过 pi 还是 i1 都不能修 改
的。

情况三：用 const int * const pi 申明 的指针

int i
const int * const pi=&i;//你能想象 pi 能够作什么操作吗？pi 值不能改，也不能通过 pi 修改 i
的值。因为不管是*pi 还 是 pi 都是 const 的。

三道考题
开讲之前，我先请你做三道题目。

1.考题一：程序代码如下：

void Exchg1(int x, int y)
{
    
    
	int tmp;
	tmp=x;
	x=y;
	y=tmp;
	printf (“x=%d,y=%d\n”,x,y)
}
void main()
{
    
    
	int a=4,b=6;
	Exchg1 (a,b) ;
	printf(“a=%d,b=%d\n”,a,b)
}

输出的结果 ：
x=， y=
a=， b=
问下划线的部分应是什么，请完成。

2.考题二：代码如下。

Exchg2(int *px, int *py)
{
    
    
	int tmp=*px;
	*px=*py;
	*py=tmp;
	print(“*px=%d,*py=%d\n”,*px,*py);
}
main()
{
    
    
	int a=4;
	int b=6;
	Exchg2( &a,&b);
	Print (“a=%d,b=%d\n”, a, b);
}

输出的结果为：
*px=， *py=
a=， b=
问下划线的部分应是什么，请完成。

3.考题三：

Exchg2(int &x, int &y)
{
    
    
	int tmp=x;
	x=y;
	y=tmp;
	print(“x=%d,y=%d\n”,x,y);
}
main()
{
    
    
	int a=4;
	int b=6;
	Exchg2(a,b);
	Print(“a=%d,b=%d\n”, a, b);
}

输出的结果：
x=， y=
a=， b=
问下划线的部分输出的应是什么， 请完成。

        我们都知道：C 语言中函数参数的传递有：值传递，地址传递，引用传递这三种形式。题一为值 传递，题二为地址传递，题三为引用传递。不过，正是这几种参数传递的形式，曾把我给搞得晕头转向 。我相信也有很多人与我有同感吧？

下面请让我逐个地谈谈这三种传递形式。

7、函数参数传递方式

之一：值传递

1.值传递的一个错误认识

先看题一中 Exchg1 函数的定义：

void Exchg1(int x, int y) //定义中的 x,y 变量被称为 Exchg1 函数的形式参数
{
    
    
int tmp;
tmp=x;
x=y;
y=tmp;
printf(“x=%d,y=% d\n”,x,y)
}

问：你认为这个函数是在做什么呀？
答：好像是对参数 x，y 的值对调吧？

请往下看，我想利用这个函数来完成对 a，b 两个变量值的对调，程序如下：

void main()
{
    
    
int a=4,b=6;
Exchg1 (a,b) //a,b 变量为 Exchg1 函数的实际参数。
/ printf(“a=%d,b=%d\n”,a,b)
}

我问：Exchg1 （）里头的 printf（“x=%d，y=%d\n”，x，y）语句会输出什么啊？

我再问：Exchg1 （）后的 printf（“a=%d，b=%d\n”，a，b）语句输出的是什么 ？

程序输出的结果是：

x=6 ， y=4
a=4 ， b=6 //为什么不是 a=6，b=4 呢？

        奇怪，明明我把 a，b 分别代入了 x，y 中，并在函数里完成了两个变量值的交换，为什么 a，b 变量 值还是没有交换（仍然是 a4，b6，而不是 a6，b4）？如果你也会有这个疑问，那是因为你跟本 就不知实参 a，b 与形参 x，y 的关系了。

2.一个预备的常识

为了说明这个问题，我先给出 一个代码：

int a=4；
int x；
x=a；
x=x+3；

        看好了没，现在我问 你：最终 a 值是多少，x 值是多少？

        （怎么搞的，给我这个小儿科的问题。还不简单，不就是 a==4 x ==7 嘛！）
在这个代码中，你要明白一个东西：虽然 a 值赋给了 x，但是 a 变量并不是 x 变量哦 。我们对 x 任何的修改，都不会改变 a 变量。呵呵！虽然简单，并且一看就理所当然，不过可是一个很重 要的认识喔。

3.理解值传递的形式

看调用 Exch1 函数的代码：

main()
{
    
    
int a=4,b=6;
Exchg1(a,b) //这里调用了 Exchg1 函数
printf(“a=% d,b=%d”,a,b)
}
Exchg1(a,b)时所完成的操作代码如下所示。
int x=a;//←
int y=b;//←注意这里，头两行是调用函数时的隐含操作
int tmp;
tmp=x;
x=y;
y=tmp;

        请注意在调用执行 Exchg1 函数的操作中我人为地加上 了头两句：

int x=a;
int y=b;

        这是调用函数时的两个隐含动作。它确实存在， 现在我只不过把它显式地写了出来而已。问题一下就清晰起来啦。（看到这里，现在你认为函数里面交 换操作的是 a，b 变量或者只是 x，y 变量呢？）

        原来 ，其实函数在调用时是隐含地把实参 a，b 的 值分别赋值给了 x，y，之后在你写的Exchg1 函数体内再也没有对 a，b 进行任何的操作了。交换的只是 x， y 变量。并不是 a，b.当然 a，b 的值没有改变啦！函数只是把 a，b 的值通过赋值传递给了 x，y，函数里头 操作的只是 x，y 的值并不是 a，b 的值。这就是所谓的参数的值传递了。
        哈哈，终于明白了，正是 因为它隐含了那两个的赋值操作，才让我们产生了前述的迷惑（以为 a，b 已经代替了 x，y，对 x，y 的操 作就是对 a，b 的操作了，这是一个错误的观点啊！）。
        指向另一指针的指针

8、双针概念：

        早在本系列第二篇中我就对指针的实质进行了阐述 。今天我们又要学习一个叫做指向另一指针地址的指针。让我们先回顾一下指针的概念吧！
当我 们程序如下申明变量：

short int i；
char a；
short int * pi；

程序会 在内存某地址空间上为各变量开辟空间，如下图所示。

内存地址→

图中所示中可看出：

• i 变量在内存地址 6 的位置，占两个字节。
• a 变量在内存 地址 8 的位置，占一个字节。
• pi 变量在内存地址 10的位置，占两个字节。（注：pi 是指针，我这 里指针的宽度只有两个字节，32 位系统是四个字节）

接下来如下赋值：

i=50；
pi=&i；

经过上在两句的赋值，变量的内存映象如下：

内存地址→

        看到没有：短整型指针变量 pi 的值为 6，它就是 I 变量的内 存起始地址。所以，这时当我们对*pi 进行读写操作时，其实就是对 i 变量的读写操作。
如：

*pi=5； //就是等价于 I=5；

你可以回看本系列的第二篇，那里有更加详细的解说。

二、指针的地址与指向另一指针地址的指针

        在上一节中，我们看到，指针变量本身与其 它变量一样也是在某个内存地址中的，如 pi 的内存起始地址是 10.同样的，我们也可能让某个指针指向这 个地址。

看下面代码：

short int * * ppi； //这是一个指向指针的指针，注意 有两个*号
ppi=π

        第一句：short int * * ppi；——申明了一个指针变量 ppi，这个 ppi 是用来存储（或称指向）一个 short int * 类型指针变量的地址。

        第二句： &pi 那就是取 pi 的地址，ppi=π就是把 pi 的地址赋给了 ppi.即将地址值 10 赋值给ppi.如下图：

内存地址→

        从图中看出，指针变 量 ppi 的内容就是指针变量 pi 的起始地址。于是……

• ppi 的值是多少呢？ ——10.
• *ppi 的值是多少呢？——6，即 pi 的值。
• **ppi 的值是多少 呢？——50，即 I 的值，也是*pi 的值。

三、一个应用实例

1. 设计一个函数：void find1（char array[]， char search， char * pi）
   要求：这个函数参数中的数组 array 是以 0 值为结束的字符串，要求在字符 串 array 中查找
   字符是参数 search 里的字符。如果找到，函数通过第三个参数（pa）返回值为 array 字符 串
   中第一个找到的字符的地址。如果没找到，则为 pa 为 0.

设计：依题意，实现代码如下

void find1(char [] array, char search, char * pa)
{
    
    
	int i;
	for (i=0;*(array+i)!=0;i++)
	{
    
    
		if (*(array+i)==search)
		{
    
    
			pa=array+i
			break;
		}
		else if (*(array+i)==0)
		{
    
    
			pa=0;
			break;
		}
	}
}

你觉得这个函数能实现所要求的功能吗？

调试：

我下面调用这个函数 试试。

void main()
{
    
    
	char str[]={
    
    “afsdfsdfdf\0”}; //待 查找的字符串
	char a=’d’; //设置要查找的字符
	char * p=0; //如果 查找到后指针 p 将指向字符串中查找到的第一个字符的地址。
	find1(str,a,p); //调用函数以实 现所要操作。
	if (0==p )
	{
    
     
		printf (“没找到！\n”);//1.如果没找到则 输出此句
	}
	else
	{
    
    
		printf(“找到了，p=%d”,p); //如果找到则 输出此句
	}
}

分析：

上面代码，你认为会是输出什么呢？

运行试试。
唉！怎么输出的是：没有找到！
而不是：找到了，……。
明明 a 值为‘d’，而 str 字符串的第四个字符是‘d’，应该找得到呀！

再看函数定义处：void find1（char [] array， char search， char * pa）

看调用处：find1（ str，a，p）；

        依我在第五篇的分析方法，函数调用时会对每一个参数进行一个隐含的赋值操作 。

整个调用如下：

array=str;
search=a;
pa=p; //请注意：以 上三句是调用时隐含的动作。
int i;
for (i=0;*(array+i)!=0;i++)
{
    
    
	if (* (array+i)==search)
	{
    
    
		pa=array+i
		break;
	}
	else if (*(array+i)==0)
	{
    
    
		pa=0;
		break;
	}
}

        哦！参数 pa 与参数 search 的传递并没 有什么不同，都是值传递嘛（小语：地址传递其实就是地址值传递嘛）！所以对形参变量 pa 值（当然值 是一个地址值）的修改并不会改变实参变量 p 值，因此 p 的值并没有改变（即 p 的指向并没有被改变）。（如果还有疑问，再看一看《第五篇：函数参数的传递》了。）

修正：

void find2(char [] array, char search, char ** ppa)
{
    
    
	int i;
	for (i=0;*(array+i)!=0;i++) 
	{
    
    
		if (*(array+i)==search)
		{
    
    
			*ppa=array+i
			break;
		}
		else if (*(array+i)==0)
		{
    
    
			*ppa=0;
			break;
		}
	}
}

主函数的调用处改如下：

find2（str，a， &p）； //调用函数以实现所要操作。

再分析：

这样调用函数时的整个操作变成如 下：

array=str;
search=a;
ppa=&p; //请注意：以上三句是调用 时隐含的动作。
int i;
for (i=0;*(array+i)!=0;i++)
{
    
    
	if (*(array+i) ==search)
	{
    
    
		*ppa=array+i
		break;
	}
	else if (*(array+i)==0)
	{
    
    
		*ppa=0;
		break;
	}
}

看明白了吗？

ppa 指向指针 p 的地址 。
对*ppa 的修改就是对 p 值的修改。

你自行去调试。
经过修改后的程序就可以完 成所要的功能了。
看懂了这个例子，也就达到了本篇所要求的目的。

9.函数名与函数指针

一 数调用

一个通常的函数调用的例子：

//自行包含 头文件
void MyFun(int x); //此处的申明也可写成：void MyFun( int );
int main(int argc, char* argv[])
{
    
    
MyFun(10); //这里是调用 MyFun(10);函数
return 0;
}
void MyFun(int x) //这里定义一个 MyFun 函数
{
    
    
printf (“%dn”,x);
}

        这个 MyFun 函数是一个无返回值的函数，它并不完成什 么事情。这种调用函数的格式你应该是很熟悉的吧！看主函数中调用 MyFun 函数的书写格式：

MyFun（10）；

        我们一开始只是从功能上或者说从数学意义上理解 MyFun 这个函数，知道 MyFun 函数名代表的是一个功能（或是说一段代码）。
直到——学习到函数指 针概念时。我才不得不在思考：函数名到底又是什么东西呢？
（不要以为这是没有什么意义的事 噢！呵呵，继续往下看你就知道了。）

二 函数指针变量的申明

        就象某一数据变量的内存 地址可以存储在相应的指针变量中一样，函数的首地址也以存储在某个函数指针变量里的。这样，我就 可以通过这个函数指针变量来调用所指向的函数了。

        在 C 系列语言中，任何一个变量，总是要先 申明，之后才能使用的。那么，函数指针变量也应该要先申明吧？那又是如何来申明呢？以上面的例子 为例，我来申明一个可以指向MyFun 函数的函数指针变量 FunP.下面就是申明 FunP 变量的方法：

void （*FunP）（int） ； //也可写成 void （*FunP）（int x）；

        你看，整个函 数指针变量的申明格式如同函数 MyFun 的申明处一样，只不过——我们把MyFun 改成（*FunP） 而已，这样就有了一个能指向 MyFun 函数的指针 FunP 了。（当然，这个 FunP 指针变量也可以指向所有其它 具有相同参数及返回值的函数了。）

三 通过函数指针变量调用函数

有了 FunP 指针变量后 ，我们就可以对它赋值指向 MyFun，然后通过 FunP 来调用 MyFun函数了。看我如何通过 FunP 指针变量来调 用 MyFun 函数的：

//自行包含头文件
void MyFun(int x); //这个申明也可写 成：void MyFun( int );
void (*FunP)(int ); //也可申明成 void(*FunP)(int x)，但习惯 上一般不这样。
int main(int argc, char* argv[])
{
    
    
MyFun(10); //这是 直接调用 MyFun 函数
FunP=&MyFun; //将 MyFun 函数的地址赋给 FunP 变量
(*FunP)(20); //这是通过函数指针变量 FunP 来调用 MyFun 函数的。
}
void MyFun(int x) //这里 定义一个 MyFun 函数
{
    
    
printf(“%dn”,x);
}

请看黑体字部 分的代码及注释。

运行看看。嗯，不错，程序运行得很好。

哦，我的感觉是：MyFun 与 FunP 的类型关系类似于 int 与 int *的关系。函数 MyFun 好像
是一个如 int 的变量（或常量），而 FunP 则像 一个如 int *一样的指针变量。

int i，*pi；
pi=&i； //与 FunP=&MyFun 比较

（你的感觉呢？）
呵呵，其实不然——

四 调用函数的其它书 写格式

函数指针也可如下使用，来完成同样的事情：

//自行包含头文件
void MyFun(int x);
void (*FunP)(int ); //申明一个用以指向同样参数，返回值函数 的指针变量。
int main(int argc, char* argv[])
{
    
    
MyFun(10); //这里是 调用 MyFun(10);函数
FunP=MyFun; //将 MyFun 函数的地址赋给 FunP 变量
FunP(20); //这是通过函数指针变量来调用 MyFun 函数的。
return 0;
}
void MyFun(int x) // 这里定义一个 MyFun 函数
{
    
    
printf(“%dn”,x);
}

我改了黑 体字部分（请自行与之前的代码比较一下）。
运行试试，啊！一样地成功。
咦？

FunP=MyFun；

        可以这样将 MyFun 值同赋值给 FunP，难道 MyFun 与 FunP 是同一数据类型（即 如同的 int与 int 的关系），而不是如同 int 与 int*的关系了？（有没有一点点的糊涂了？）看 来与之前的代码有点矛盾了，是吧！所以我说嘛！请容许我暂不给你解释，继续看以下几种情况 （这些可都是可以正确运行的代码哟！）：

代码之三：

int main(int argc, char* argv[])
{
    
    
MyFun(10); //这里是调用 MyFun(10);函数
FunP=&MyFun; //将 MyFun 函数的地址赋给 FunP 变量
FunP(20); //这是通过函数指 针变量来调用 MyFun 函数的。
return 0;
}

代码之四：

int main(int argc, char* argv[])
{
    
    
MyFun(10); //这里是调用 MyFun(10);函数
FunP=MyFun; //将 MyFun 函数的地址赋给 FunP 变量
(*FunP)(20); //这是通过函数指针 变量来调用 MyFun 函数的。
return 0;
}

真的是可以这样的噢！
（哇 ！真是要晕倒了！）
还有呐！看——

int main(int argc, char* argv[])
{
    
    
（*MyFun）(10); //看，函数名 MyFun 也可以有这样的调用格式
return 0;
}

你也许第一次见到吧：函数名调用也可以是这样写的啊！（只不过 我们平常没有这样书写罢了。）
那么，这些又说明了什么呢？

呵呵！依据以往的知识和 经验来推理本篇的“新发现”，我想就连“福尔摩斯”也必定会由此分析并推断 出以下的结论：

1. 其实，MyFun 的函数名与 FunP 函数指针都是一样的，即都是函数指针。MyFun 函数名
   是一个函数指针常量，而 FunP 是一个函数数指针变量，这是它们的关系。
2. 但函数名调 用如果都得如（*MyFun）（10）；这样，那书写与读起来都是不方便和不习
   惯的。所以 C 语言的设计者们 才会设计成又可允许 MyFun（10）；这种形式地调用（这样
   方便多了并与数学中的函数形式一样，不是吗 ？）。
3. 为统一起见，FunP 函数指针变量也可以 FunP（10）的形式来调用。
4. 赋值时 ，即可 FunP=&MyFun 形式，也可 FunP=MyFun.
   上述代码的写法，随便你爱怎么着！
   请 这样理解吧！这可是有助于你对函数指针的应用喽！
   最后——
   补充说明一点 ：在函数的申明处：

void MyFun（int ）； //不能写成 void （*MyFun）（int ）。
void （*FunP）（int ）； //不能写成 void FunP（int ）。

（请看注释）这一点 是要注意的。

五 定义某一函数的指针类型：

就像自定义数据类型一样，我们也可以先定 义一个函数指针类型，然后再用这个类型
来申明函数指针变量。

我先给你一个自定义数据类型的 例子。

typedef int* PINT; //为 int* 类型定义了一个 PINT 的别名
int main()
{
    
    
int x;
PINT px=&x; //与 int * px=&x;是等价的。PINT 类型其 实就是 int * 类型
*px=10; //px 就是 int*类型的变量
return 0;
}

        根据注释，应该不难看懂吧！（虽然你可能很少这样定义使用，但以后学习 Win32 编程时会经常见到的。 ）下面我们来看一下函数指针类型的定义及使用：（请与上对照！）

//自行包含 头文件
void MyFun(int x); //此处的申明也可写成：void MyFun( int );
typedef void (*FunType)(int ); //这样只是定义一个函数指针类型
FunType FunP; //然后 用 FunType 类型来申明全局 FunP 变量
int main(int argc, char* argv[])
{
    
    
//FunType FunP; //函数指针变量当然也是可以是局部的 ，那就请在这里申明了。
MyFun(10);
FunP=&MyFun;
(*FunP)(20);
return 0;
}
void MyFun(int x)
{
    
    
printf(“%dn”,x);
}

看黑体部分：

        首先，在 void （ * FunType)(int )； 前加了一个 typedef . 这样只是定义一个名为 FunType函数指针类型，而不是一 个 FunType 变量。

        然后，FunType FunP； 这句就如 PINT px 一样地申明一个 FunP 变量。

        其它相同。整个程序完成了相同的事。

这样做法的好处是：

        有了 FunType 类型后 ，我们就可以同样地、很方便地用 FunType 类型来申明多个同类型的函数指针变量了。如下：

FunType FunP2；
FunType FunP3；
//……

六 函数指针作为某个函数的参数

        既然函数指针变量是一个变量，当然也可以作为某个函数的参数来使用的。所以 ，你还应知道函数指针是如何作为某个函数的参数来传递使用的。

给你一个实例：

要求 ：我要设计一个 CallMyFun 函数，这个函数可以通过参数中的函数指针值不同来分别
调用 MyFun1、MyFun2 、MyFun3 这三个函数（注：这三个函数的定义格式应相同）。

实现：代码如下：

//自行包含头文件
void MyFun1(int x);
void MyFun2(int x);
void MyFun3(int x);
typedef void (*FunType)(int ); //②. 定义一个函数指针类型 FunType,与①函 数类型一至
void CallMyFun(FunType fp,int x);
int main(int argc, char* argv[])
{
    
    
	CallMyFun(MyFun1,10); //⑤. 通过 CallMyFun 函数分别调用三个不同的函数
	CallMyFun(MyFun2,20);
	CallMyFun(MyFun3,30);
}
void CallMyFun(FunType fp,int x) //③. 参数 fp 的类型是 FunType。
{
    
    
	fp(x);//④. 通过 fp 的指针执行传递进来的 函数，注意 fp 所指的函数是有一个参数的
}
void MyFun1(int x) // ①. 这是个有一个参数 的函数，以下两个函数也相同
{
    
    
	printf(“函数 MyFun1 中输出：%dn”,x);
}
void MyFun2(int x)
{
    
    
	printf(“函数 MyFun2 中输出：%dn”,x);
}
void MyFun3(int x)
{
    
    
	printf(“函数 MyFun3 中输出：%dn”,x);
}