“哦o”通过精心收集，向本站投稿了8篇C++ 函数指针的详解，下面是小编给大家带来关于C++ 函数指针的详解，一起来看看吧，希望对您有所帮助。
篇1：C++函数指针详解
学习c++的过程中，指针是难点，熟悉了指针之后，还有一个让人很 的难点，那就是函数指针了，本博文详细介绍一下常见的各种 的函数指针。
至于指针的详细学习，推荐这篇博文C++指针详解
与数据一样，函数也有地址，函数的地址就是内存中存放函数语言代码的起始地址。函数指针就是指向这个地址。函数指针所指向的类型，就是函数本身。我们知道，指针所指向类型代表了指针所指向的内存区域的大小。所以函数指针所指向的类型，就是函数在内存中所占据内存的大小。知道了函数的起始地址和大小，所以函数指针可以很轻易的代替函数完成函数调用。
一、最简单的函数指针
变量都包括声明和赋值，指针不例外，函数指针也不例外。我们来看一个简单的函数：
void add(int a, int b){
cout << a + b << endl;
}
一个简单的加法计算并输出到命令行的函数。
那么如何通过函数指针来调用它呢？
1、声明：
void (*p1)(int a, int b);
函数指针的声明很简单，基本就是通过一个指针把函数名替换。指针p1的类型为void (*) (int a,int b)，表明指针是一个指向某个函数的指针，指针指向的类型为void (int a,int b)
2、赋值：
p1 = add;
3、也可以直接定义：
void (*p1)(int a, int b) = add;
注意，函数void add(int a,int b)的函数名add就是函数的地址。将地址add赋值给指针p1，那么就可以通过函数指针p1直接调用函数了。
4、调用：
(*p1)(1, 2);
p1(1, 2);
注意！出于历史原因以上2种方式都是可以调用函数的。
二、包含多个函数指针的数组
有时候有这种情况，有一个数组，数组中的每个元素都是一个函数指针，该怎么定义这个数组呢？
1、解释*p[n]和(*p)[n]
我们知道，[]运算符的优先级要高于*，所以，p[3]表示含有3个元素的数组，而*p[3] 前面的 “ * ” 指明了数组中元素的类型，即*p[3]表示一个指向3个指针的数组，
p[3]表示含有3个元素的数组，那么(*p)[3]就是用 *p 替换了 p，很容易想到，(*p)[3] 表示指向一个包含3个元素的数组的指针。
2、声明：
void (*p2[2])(int a, int b);
数组名为p2，数组大小为2，数组中元素类型为void (*)(int a, int b)，表明元素是一个指向某个函数的指针，指针指向的类型为void () (int a,int b)。
3、赋值：
p2[1] = add;
理解上跟上面是一样的。
4、调用：
p2[1](2,3);
(*p2[1])(3,4);
同样是2种方式都可以。
三、指向“包含多个函数指针的数组“的指针
这个标题好像有点拗口。简而言之，这个指针指向上文中的 “包含多个函数指针的数组” 。其实很简单，说白了，就是把上文中的p2用一个指针来代替。
1、声明：
void (*(*p3)[2])(int a, int b);
可以看到，无非就是把p2用*p3代替。
2、赋值，注意，既然是指针，使用前必须初始化：
p3 = &p2;
(*p3)[1] = add;
注意！既然实质上就是把p2用*p3代替，c++11可以很简单的这样直接定义：auto p3 = &p2; 代替了void (*(*p3)[2])(int a, int b)= &p2;
3、调用：
(*p3)[1](1, 2);
((*p3)[1])(1, 2);
篇2：C++ 函数指针的详解
1.函数指针
（1）一般来说函数通常包括一系列指令，通过编译后，在内存中占据了一块存储空间，
它有一个起始地址，这个起始（入口）地址就称为函数的指针。
（2）主函数在调用子函数时，就是让程序转移到函数的入口地址开始执行。
（3）我们可以定义一个指针变量用来指向函数，然后通过使用该指针变量调用此函数。
指向函数的指针：就是能够存放某个函数入口地址的指针变量。
总结了一下，函数指针有两个用途：一个是调用函数，另一个是做函数的参数
函数指针定义的一般形式：
数据类型 (*指针变量名)(参数表)；
例如：
int (*p)(); // p为指向返回值为整型数据的函数的指针
float (*q)(float,int); // q为指向返回值为浮点型数据的函数的指针
2.函数指针调用函数的步骤
（1）函数指针变量先要指向函数
定义了指向函数的指针变量，就可以在指针变量与特定函数之间建立关联，让指针变量指向特定函数。
要注意一下：
(1)指针变量只能指向定义时所指定的一类函数，
(2)一个指针变量可以先后指向多个不同的函数。
具体代码：
#include
int arr_add(int (*arr)[4], int n, int m )
void main()
{
int a[3][4] = {1,3,5,7,9,11,13,15,17,19,21,23};
int *p, total1, total2;
int (*pt)(int (*arr)[4], int n, int m );
pt=arr_add;
total1 = arr_add( a,3,4 );
total2 = (*pt)( a,3,4 );
printf( “total1 = %d, total2 = %dn”, total1,total2 );
}
int arr_add(int (*arr)[4], int n, int m )
{
int i, j, sum=0;
for(i=0;i
for( j = 0; j< m; j++ )
sum += arr[i][j];
return (sum);
}
篇3：函数指针
在前面的章节中已经介绍了函数的传指针参数调用，返回指针，根据数组名和指针的等价性，函数的参数也可以是数组，在这些基本概念的基础上，本节讨论指向函数的指针以及带参主函数的相关内容，
指向函数的指针
函数是一组代码的封装体，这组代码在内存中占有一片存储空间，该空间的起始地址存放在以函数名为名的单元的，换言之，函数名就是指向函数的常指针，这有点类似于数组名是指向数组内存空间的常指针。
(1)函数指针的声明和初始化
（2）函数指针使用举例
typedef
为了避免读者对typedef的用法产生误解，前面一直没有介绍typedef的相关内容，介绍完函数指针，来看看typedef的相关内容。
typedef用来给一个已经存在的类型声明一个别名，举一个最简单的例子:
typedef int* int_p; //不要忘记分号
typedef为int* 引入了一个新的助记符int_p，可以在程序中使用int_p声明指向int型变量的指针，如：
int_p pA,pB;
上述代码声明了两个int型指针变量pA和pB，应当注意：typedef不同于编译预处理命令＃define，这种不同主要体现在两个方面：
（1）#define是预处理指令，在编译预处理时进行简单的替换，不做正确性检查，不管含义，只是简单的替换，如：
#define PI 3.14
（2）＃define结构可以抽象为：
＃define A B
通过函数指针将函数作为另一个函数的参数
函数指针的一个功用是把函数地址作为参数传送，以提高函数的通用性和灵活性，如代码7‑10 ：
函数指针数组
指向函数的指针还可以组成指针数组，称为函数指针数组，
函数指针数组的使用范例见代码：
(详细内容请参照本书)
返回函数指针的函数
和普通指针一样，函数指针也可以作为另一个函数的返回值，如代码7‑12：
篇4：学通C语言：函数型指针
C程序中的函数也都是存放在代码区内的，它们同样也是有地址的，那么如何取得函数的地址呢？在前面也说过函数定义的时候实际上是定义了一个函数变量，那么是否可以将函数变量赋值给其他变量呢？回答这些问题需要涉及另外一个概念：函数型指针。按照已有的指针的知识，顾名思义，函数型指针就是指向函数的指针。如果有一个函数声明为：
int func(const int a, const int b);
那么，此时声明的函数变量add的地址即为这个函数的地址，同时，add的值保存为这个函数的地址，这个特性与数组相似：数组变量与数组变量的地址均为数组的起始地址。而在这个函数声明中，函数类型为int (const int a, const int b)。使用该函数类型来定义一个函数型指针，其方式如下：
int (* fp)(const int a, const int b); /* 其中，参数列表的参数名a和b可省 */
上述语句将变量func定义为指向类型为int (const int a, const int b)的指针操作符和变量名两侧的小括号不可省，否则其含义大不相同。例如：
int * fp(const int a, const int b);
此时，指针操作符与数据类型int结合为int型指针类型，该语句只是声明了一个fp函数，而非定义一个函数指针。为该函数型指针赋值的方式如下：
fp = func;
被赋值的函数变量的类型必须与fp的类型完全一致，包括其返回类型和每一个形参的类型。否则程序将报错。
注意：函数型指针变量赋值时，左值与右值的类型必须完全一致。
使用函数型指针变量调用函数的方法与使用函数变量类似，得到函数地址后再带上参数列表即可。可以使用下面两种方式来调用函数：
fp(5, 6);
或
(*fp)(5, 6);
由于fp被赋值为函数变量func的地址，而func的值又等于其地址，所以*fp可以得到func函数的地址。因此，在调用方式上，可以粗略地将两者视为一致（实际上其后台的处理略有不同）。范例14-7演示了如何使用函数型指针来调用函数。
【范例14-7】使用函数型指针来调用函数，实现方法如示例代码14-7所示。
示例代码14-7
01 #include
02
03 int add(const int a, const int b) { /* 定义add函数 */
04 return a + b;
05 }
06
07 int main(void) {
08 int (*fp) (const int a, const int b); /* 定义函数指针 */
09
10 fp = add; /* 将其赋值为add */
11 printf(“3 + 4 = %d”, fp(3, 4)); /* 使用fp计算+ 4的值 */
12 printf(“3 + 4 = %d”, (*fp)(3, 4)); /* 使用*fp计算+ 4的值 */
13
14 printf(“%p”, add); /* 输出add的值 */
15 printf(“%p”, &add); /* 输出add的地址 */
16 printf(“%p”, fp); /* 输出fp的值 */
17 printf(“%p”, *fp); /* 输出fp指向的值 */
18
19 return 0;
20 }
【运行结果】程序运行后，
【代码解析】本程序定义了一个函数指针，并将其赋值为相应类型的函数变量add。
第11～12行分别使用fp和*fp的方式调用函数，从图14-12的第1～2行中可以看到它们的调用结果是一样的。
第14～17行输出了add的值和地址、fp的值和指向的值，从图14-12的第3～6行中可以看到它们的调用结果都是一样的。
篇5：（C语言）字符串比较函数，指针数组与数组指针
问题描述：
写一个函数，用于比较两个字符串的比较（string_compare）.
程序分析：
（1）主要思想：传入两个字符串后，比较这两个字符串中的每个元素，如果第一次比较就不相等，就不要让它进入到下面的比较中，这样一来，将它返回一个相减的值（即：两数组中开始不相等的那两个元素相减，返回值（int类型），是ASCII码值相减）。进入比较的过程中时，相等就返回0；其他情况都返回那个相减的值。
（2）主要方式：定义指针数组，并对其初始化。然后照上面的思想，进行代码的实现。
代码如下：
/***指针数组（1）int *a[10] 是一个指针数组--->是一个数组（每个数组中的元素都是int*类型）（2）int (*a)[10] 是一个数组指针--->指向一个数组（十个int类型的数组） 注意：*，[]，的优先级依次递增。下面使用了指针数组的例子，至于数组指针。。**/#include
篇6：c语言指针
一、数组的指针、指针数组以及指向指针的指针
考虑数组的指针的时候我们要同时考虑类型和维数这两个属性，换一句话，就是说一个数组排除在其中存储的数值，那么可以用类型和维数来位置表示他的种类。
A）一维数组
在c和c++中数组的指针就是数组的起始地址（也就第一个元素的地址），而且标准文档规定数组名代表数组的地址（这是地址数值层面的数组表示）。例如：
int a[10]; int *p;p=&a[0]//和p=a是等价的：
因为a是数组名，所以他是该数组的地址，同时因为第一个元素为a[0]，那么&a[0]也代表了该数组的地址。但是我们是不是就说一个数组名和该数组的第一个元素的&运算是一回事呢？在一维的时候当时是的，但是在高维的时候，我们要考虑到维数给数组带来的影响。
a[10]是一个数组，a是数组名，它是一个包含10个int类型的数组类型，不是一般的指针变量噢！（虽然标准文档规定在c++中从int[]到int*直接转换是可以的，在使用的时候似乎在函数的参数为指针的时候，我们将该数组名赋值没有任何异样），a代表数组的首地址，在数字层面和a[10]的地址一样。这样我们就可以使用指针变量以及a来操作这个数组了。
所以我们要注意以下问题：
（1） p[i]和a[i]都是代表该数组的第i+1个元素；
（2） p+i和a+i代表了第i+1个元素的地址，所以我们也可以使用 *（p+I）和*（a+I）来引用对象元素；
（3）p+1不是对于指针数量上加一，而是表示从当前的位置跳过当前指针指向类型长度的空间，对于win32的int为4byte；
B)多维数组
对于二维数组a[4][6];由于数组名代表数组的起始地址，所以a（第一层）和第一个元素a[0][0]地址的数字是相同的，但是意义却是不同的。对于该数组我们可以理解为：a的一维数组（第一层），它有四个元素a[0]、a[1]、a[2]、a[3]（第二层），而每个元素又含有6个元素a[0][0],a[0][1],a[0][2],a[0][3],a[0][4]，a[0][5]（第三层）,…到此我们终于访问到了每个元素了，这个过程我们经历了：a->a[0]->a[0][0]；
整体来讲：a是一个4行5列的二维数组，a表示它指向的数组的首地址（第一个元素地址&a[0]）,同时a[0]指向一行，它是这个行的名字（和该行的第一个元素的首地址相同（第一个元素为地址&a[0][0]））。所以从数字角度说：a、a[0]、&a[0][0]是相同的，但是他们所处的层次是不同的。
既然a代表二维数组，那么a+i就表示它的第i+1个元素*（a+i）的地址，而在二维数组中
*（a+i）又指向一个数组，*（a+i）+j表示这个数组的第j+1个元素的地址，所以要访问这个元素可以使用 *（*（a+i）+j）（也就是a[i][j]）。
他们的示意图为（虚线代表不是实际存在的）：
对照这个图，如下的一些说法都是正确的（对于a[4][6]）：
a是一个数组类型，*a指向一个数组；
a+i指向一个数组；
a、*a和&a[0][0]数值相同；
a[i]+j和*（a+i）+j是同一个概念；
总结一下就是：我们对于二维指针a，他指向数组a[0，1，2，3]，使用*，可以使他降级到第二层次，这样*a就指向了第一个真正的数组。对于其他的情况我们也可以采用相同的方式，对于其他维数和类型的数组我们可以采用相类似的思想，
说到指向数组的指针，我们还可以声明一个指针变量让它指向一个数组。例如：
int （*p）[5]；这时p就是一个指针，要指向一个含有5个int类型元素的数组，指向其他的就会出现问题。
这个时候我们可以使用上面的什么东西来初始化呢？
我们可以使用*a,*(a+1)，a[2]等。
原因很简单：我们在一个二维的数组中，那么表达方式有上面的相互类似的意义呢？只有 *a,*(a+1)，a[2]等，
C)指针数组
一个指针数组是指一个数组中的每个元素都是一个指针，例如：
int *p[10];//而不能是int (*p)[10]或者
char *p[10];此时p是一个指针（数值上和&p[0]一样）；
在前面有int t[10]；
int * pt=t;//使用pt指向t那么这里我们用什么指向int *t[10]中的t呢？我们要使用一个指针的指针：
int **pt=t;这是因为：在int *t[10]中，每个元素是指针，那么同时t又指向这个数组，数组上和&t[0]相同，也就是指向t[0]，指向一个指针变量，可以说是一个指针的指针了，所以自然要用
int **pt;D)指针的指针
一个指针变量内部可以存储一个值，这个值是另外一个对象的地址，所以我们说一个指针变量可以指向一个普通变量，同样这个指针变量也有一个地址，也就是说有一个东西可以指向这个指针变量，然后再通过这个指针变量指向这个对象。那么如何来指向这个指针变量呢？由于指针变量本身已经是一个指针了（右值），那么我们这里就不能用一般的指针了，需要在指针上体现出来这些特点，我们需要定义指针的指针（二重指针）。
int *p1=&i; int**p2=&p1；综合以上的所有点，下面是我们常常看到一些匹配（也是经常出错的地方）：
int a[3],b[2][3],c,*d[3]; void fun1(int *p)； void fun2(int (*p)[3]); void fun3(int **p); void fun4(int p[3]); void fun5(int p[]); void fun6(int p[2][3]); void fun7(int (&p)[3]);函数 不会产生编译时刻的可能值（但逻辑上不一定都对）
函数
不会产生编译时刻的可能值（但逻辑上不一定都对）
fun1
a, &a[i], *b ,b[i],&b[i][j] ,&c ,d[i]
fun2
b，b+i，
fun3
d
fun4
a, &a[i], *b ,b[i],&b[i][j] ,&c ,d[i]
fun5
a, &a[i], *b ,b[i],&b[i][j] ,&c ,d[i]
fun6
b
篇7：C语言指针
指针变量是包含内存地址的变量，它指向内存中的一块区域，通过指针的值，可以间接访问到相应的内存单元的数据，并做相应的修改，
1、指针的定义和简单使用
定义一个指针变量和定义一般的变量类似，只需在变量名前面加一个“*”。对一个指针变量赋值可以用取地址符&来获取到一个变量的地址，如果要获得指针指向的内存区域的数据，用解参考运算符*(也称为间接运算符，它返回其操作数指向的对象的值)。指针的值为NULL(NULL是stdio.h中定义的符号变量，实际上是0)说明其不指向任何的内存单元，0是唯一直接可以赋值给指针变量的整数值。实际上，*和&是互补的，当两个运算符连续应用于一个指针变量时，无论顺序如何，运算结果相同。同时可以用printf中的格式化字符串%p来输出指针变量的值，下面是一个简单的程序。
[cpp]
#include
int main
{
int a;
a=9;
//定义并初始化一个指针，命名就可以看出
int *aPtr=NULL;
//将指针指向变量a
aPtr=&a;
printf(“The address of a is %p”
“nThe value of aPtr is %p”,&a,aPtr);
printf(“nnThe value of a is %d”
“nThe value of *aPtr is %d”,a,*aPtr);
printf(“nnShowing that * and & are complements of ”
“each othern&*aPtr = %p”
“n*&aPtr = %pn”,&*aPtr,*&aPtr);
return 0;
}
2、用指针做函数的参数
2.1 通过指针实现的引用传递
程序设计语言的参数传递方式，大致分两种：值传递和引用传递。C语言中没有引用传递，但是C语言通过指针间接实现了引用传递。通过用指针变量作为函数的参数，可以传递变量的地址(只需要在变量前面加上&运算符就可以)，这样，用该地址就可以访问到主调函数中的该变量的内存地址，并可以进行相应的修改。这样，在函数执行完毕之后，修改仍然可以得到保留。
2.2 const
const限定符可以告诉编译器特定的变量的值是不能被修改的。如果想确保函数不会修改传递进来的参数值，应该将参数声明为const。这样对于C语言中用指针实现的引用传递，有四种情况：指向非常量数据的非常量指针(int *aPtr)，指向非常量数据的常量指针(int *const aPtr)，指向常量数据的非常量指针(const int *aPtr)和指向常量数据的常量指针(const int * const aPtr)。简单的说，就是指针变量自身和指针指向的变量都有可能是const，这样就产生了四种情况，这四种情况提供了四种不同的访问权限，下面分别解释。
指向非常量数据的非常量指针(int *aPtr)：指针的值本身和指针指向变量的值都可以在函数中被修改。
指向非常量数据的常量指针(int *const aPtr)：指针的值不能被修改，但是指针指向的变量的值可以被修改。
指向常量数据的非常量指针(const int *aPtr)：指针指向的值不能被修改，但是指针本身的值可以被修改。
指向常量数据的常量指针(const int * const aPtr)：指针本身和指针指向变量的值都不能被修改。
3、sizeof和指针运算
3.1 sizeof
sizeof是C语言中特殊的一元运算符，可以应用在变量名称、数据类型和常量之前，它在程序编译期间以字节为单位来确定数组或其他数据类型的大小。当应用于数组时，sizeof返回数组中的字节总数。如float a[20]，sizeof(a)的值应该是4*20，80。当然，如果想获得数组的大小可以采用sizeof(a)/sizeof(float)。
3.2 指针运算
实际上，指针变量可以进行的算术操作是有限的：递增，递减，将指针和整数相加，从指针中减去一个整数或者一个指针减去另一个指针，
需要注意的是，对于指针的算术运算，其单位长度并不是一般意义上的1，而是sizeof(TYPE)。这样，如果float a[14]; float *aPtr=a;(或者int *aPtr=&a[0]); aPtr++;这样aPtr应该指向的是数组a的第二个元素，也就是a[1]，这里的单位长度就是sizeof(float)。同样地，如果aPtr=aPtr+5;，这样aPtr又指向了数组a的第6个元素。如果aPtr-a，这样可以得到两个指针之间的元素间隔个数。应该是6。
进行指针运算要注意：
(1)如果将一个指针的值赋给另外一个指针，那么这两个指针的类型必须相同，否则应该用类型转换运算符进行类型转换。但是，有一个例外就是指向void类型的指针，它是通用指针，可以代表任何指针类型。因此，所有指针类型都可以赋值给void指针，而void指针也可以赋值给任何类型的指针，而不需要任何类型转换运算符。但是，void指针不能解参考，编译器知道指向int类型的指针引用的是32位计算机上的4个字节内存，但指向void的指针仅包含未知数据类型的内存位置，也就是说，编译器不知道指针所引用的字节数。编译器必须知道数据类型，才能确定所引用的字节数。
(2)除非两个指针变量都指向的是一个数组中的元素，否则对它们相减的结果没有任何意义，因为我们不能假设两个变量在内存中是连续的。
4、指针和数组
4.1 数组和指针的共性
实际上，数组名称的本质是一个常量指针。因此，int a[6]; int *aPtr;定义一个数组和指针之后，通过a[3]，*(a+3)和*(aPtr+3)都可以访问到数组的第四个元素的值。但是区别在于，aPtr=aPtr+3;这样aPtr就指向了a数组的第四个元素，但是，不能a=a+3;，因为a是一个数组名，它是一个常量指针它的值不能被修改，更加具体地说，它应该是一个指向非常量数据的常量指针。
4.2 指针数组
数组元素也可以是指针类型，指针数组常见的用途就是构成由字符串组成的数组，简单地说就是字符串数组，数组中的每一个元素都是字符串。下面是一个例子，const限定符说明不能修改每个元素指针所指向的字符串。
[cpp]
#include
int main()
{
const char *suit[4]={“Hearts”,“Diamonds”,“Clubs”,“Spades”};
int i;
for(i=0;i<4;i++)
printf(“sizeof pointer to ”%s“ :%dn”,suit[i],sizeof(suit[i]));
printf(“nsizeof suit:%dn”,sizeof(suit));
return 0;
}
运行结果如下：
从这个例子中，可以看出const char *suit[4]={“Hearts”,“Diamonds”,“Clubs”,“Spades”};定义了一个指针数组，但是，其中的每个元素只是一个指针，而不是数组名(如果是数组名的话，sizeof的结果不应该都是4)。这样定义字符串数组可以节省空间。
5、函数指针
和数组名实际上就是数组第一个元素在内存中的地址类似，函数迷你实际上就是执行函数任务的代码在内存中的起始地址。函数指针包含函数在内存中的地址，可以传递给函数、从函数返回、存储在数组中或者是赋值给其它的函数指针，下面是两个函数指针的例子。
(1) 用函数指针实现升序/降序排序
[cpp]
#include
#define SIZE 10
int ascending(int a,int b)
{
return a>b;
}
int descending(int a,int b)
{
return a
}
void swap(int *aPtr,int *bPtr)
{
int temp=*aPtr;
*aPtr=*bPtr;
*bPtr=temp;
}
篇8：十七、指针函数和函数指针
一、指针函数
当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中，
格式：
类型说明符 * 函数名(参数)
当然了，由于返回的是一个地址，所以类型说明符一般都是int。
例如：int *GetDate();
int * aaa(int,int);
函数返回的是一个地址值，经常使用在返回数组的某一元素地址上。
int * GetDate(int wk,int dy);
main()
{
int wk,dy;
do
{
printf(Enter week(1-5)day(1-7)n);
scanf(%d%d,&wk,&dy);
}
while(wk<1||wk>5||dy<1||dy>7);
printf(%dn,*GetDate(wk,dy));
}
int * GetDate(int wk,int dy)
{
static int calendar[5][7]=
{
{1,2,3,4,5,6,7},
{8,9,10,11,12,13,14},
{15,16,17,18,19,20,21},
{22,23,24,25,26,27,28},
{29,30,31,-1}
};
return &calendar[wk-1][dy-1];
}
程序应该是很好理解的，子函数返回的是数组某元素的地址。输出的是这个地址里的值。
二、函数指针
指向函数的指针包含了函数的地址，可以通过它来调用函数。声明格式如下：
类型说明符 (*函数名)(参数)
其实这里不能称为函数名，应该叫做指针的变量名。这个特殊的指针指向一个返回整型值的函数。指针的声明笔削和它指向函数的声明保持一致。
指针名和指针运算符外面的括号改变了默认的运算符优先级。如果没有圆括号，就变成了一个返回整型指针的函数的原型声明。
例如：
void (*fptr)();
把函数的地址赋值给函数指针，可以采用下面两种形式：
fptr=&Function;
fptr=Function;
取地址运算符&不是必需的，因为单单一个函数标识符就标号表示了它的地址，如果是函数调用，还必须包含一个圆括号括起来的参数表。
可以采用如下两种方式来通过指针调用函数：
x=(*fptr)();
x=fptr();
第二种格式看上去和函数调用无异。但是有些程序员倾向于使用第一种格式，因为它明确指出是通过指针而非函数名来调用函数的。下面举一个例子：
void (*funcp)();
void FileFunc(),EditFunc();
main()
{
funcp=FileFunc;
(*funcp)();
funcp=EditFunc;
(*funcp)();
}
void FileFunc()
{
printf(FileFuncn);
}
void EditFunc()
{
printf(EditFuncn);
}
程序输出为：
FileFunc
EditFunc
三、指针的指针
指针的指针看上去有些令人费解，
它们的声明有两个星号。例如：
char ** cp;
如果有三个星号，那就是指针的指针的指针，四个星号就是指针的指针的指针的指针，依次类推。当你熟悉了简单的例子以后，就可以应付复杂的情况了。当然，实际程序中，一般也只用到二级指针，三个星号不常见，更别说四个星号了。
指针的指针需要用到指针的地址。
char c='A';
char *p=&c;
char **cp=&p;
通过指针的指针，不仅可以访问它指向的指针，还可以访问它指向的指针所指向的数据。下面就是几个这样的例子：
char *p1=*cp;
char c1=**cp;
你可能想知道这样的结构有什么用。利用指针的指针可以允许被调用函数修改局部指针变量和处理指针数组。
void FindCredit(int **);
main()
{
int vals[]={7,6,5,-4,3,2,1,0};
int *fp=vals;
FindCredit(&fp);
printf(%dn,*fp);
}
void FindCredit(int ** fpp)
{
while(**fpp!=0)
if(**fpp<0) break;
else (*fpp)++;
}
首先用一个数组的地址初始化指针fp，然后把该指针的地址作为实参传递给函数FindCredit()。FindCredit()函数通过表达式**fpp间接地得到数组中的数据。为遍历数组以找到一个负值，FindCredit()函数进行自增运算的对象是调用者的指向数组的指针，而不是它自己的指向调用者指针的指针。语句(*fpp)++就是对形参指针指向的指针进行自增运算的。但是因为*运算符高于++运算符，所以圆括号在这里是必须的，如果没有圆括号，那么++运算符将作用于二重指针fpp上。
四、指向指针数组的指针
指针的指针另一用法旧处理指针数组。有些程序员喜欢用指针数组来代替多维数组，一个常见的用法就是处理字符串。
char *Names[]=
{
Bill,
Sam,
Jim,
Paul,
Charles,
0
};
main()
{
char **nm=Names;
while(*nm!=0) printf(%sn,*nm++);
}
先用字符型指针数组Names的地址来初始化指针nm。每次printf()的调用都首先传递指针nm指向的字符型指针，然后对nm进行自增运算使其指向数组的下一个元素(还是指针)。注意完成上述认为的语法为*nm++，它首先取得指针指向的内容，然后使指针自增。
注意数组中的最后一个元素被初始化为0，while循环以次来判断是否到了数组末尾。具有零值的指针常常被用做循环数组的终止符。程序员称零值指针为空指针(NULL)。采用空指针作为终止符，在树种增删元素时，就不必改动遍历数组的代码，因为此时数组仍然以空指针作为结束。
![[湘潭会计网]湖南省湘潭初级职称准考证考前15天内打印](https://www.youxiufanwen.cn/uploads/202509/14/5e6c3fb615f11344.webp)
