复杂的函数指针例子分析.doc
指针函数 和 指针形参详解
指针函数和指针形参详解
指针函数（pointer function）是一个返回指针的函数，它的返
回值是一个指向特定类型数据的指针。
这意味着指针函数返回的是一
个地址，可以用于访问指定类型的数据。
指针函数的定义形式类似于普通函数的定义，只不过返回类型是
指针类型。
例如，如果要定义一个指针函数来返回整数数组的首地址，可以使用如下的语法：
```c
int* function_name(parameters){
// 函数体
return pointer_to_array;
}
```
在函数体内部，可以通过运算或者其他方式获得一个指向指定类型数
据的指针，并将它返回。
指针形参（pointer parameter）是一个函数参数，其类型为指针。
指针形参允许函数访问和修改指针所指向的数据。
指针形参的定义形式与其他形参类似，只不过类型是指针类型。
例如，如果要将一个整型指针作为参数传递给函数，可以使用如下的
语法：
```c
void function_name(int* pointer_name){
// 函数体
// 通过指针访问或修改数据
}
```
在函数体内部，可以通过指针形参访问或修改指针指向的数据。
可以使用*操作符来获取指针所指向的值，使用赋值运算符来修改指针所指向的值。
指针函数和指针形参在C语言中可以用于处理复杂数据结构、动态内存分配等问题。
它们可以提供灵活的数据访问和操作方式，让程序员能够更加高效地处理数据。
第8章 指针及其应用
【说明】 ①、直接拿 a 当指针用，a 指向数组的开始元素，a+i 是指向数组的第 i 个元素的指针。 ②、指针变量 pa 是变量，可以变的。但数组 a 是静态的变量名，不可变，只能当做常 量指针使用。例如：p=p+2;是合法的，a=a+2;是非法的。 ③、 最早在使用标准输入 scanf 时就使用了指针技术， 读入一个变量时要加取地址运算 符’&’传递给 scanf 一个指针。对于数组，可以直接用数组名当指针。
4、多重指针
既然指针是指向其他类型的，指针本身也是一种类型。 C++允许递归地指针指向指针的指针——多重指针。 【例 4】双重指针运用举例。 #include<cstdio> using namespace std; int a=10; int *p; int **pp; //定义双重指针 int main() { p=&a; //将 p 指向 a pp=&p; //将 pp 指向 p printf("%d=%d=%d\n",a,*p,**pp); //**pp 通过 2 次间接访问了 a 的变量的值 10 return 0; } 输出： 10=10=10 【说明】 多重指针除了可以多次“间接”访问数据，OI 上主要的应用是动态的多维数组，这个 强大的功能将在后面专门介绍。
第八章
指针及其应用
指针是 C++语言中广泛使用的一种数据类型，运用指针编程是 C++语言最主要风格之 一。利用指针变量可以表示各种数据结构，能很方便地使用数组和字符串，并能像汇编语言 一样处理内存地址，从而编出精炼而高效的程序，指针极大地丰富了 C++语言的功能。学习 指针是学习 C++语言最重要的一环，能否正确理解和使用指针是我们是否掌握 C++语言的一 个标志。 同时， 指针也是 C++语言中最为困难的一部分， 在学习中除了要正确理解基本概念， 还必须要多编程、多上机调试，只要做到这些，指针也是不难掌握的。
指针函数传参
指针函数传参（原创实用版）目录1.指针函数的定义2.指针函数的参数传递方式3.指针函数的传参实例4.指针函数传参的优缺点5.总结正文一、指针函数的定义指针函数是一种将函数的指针作为参数传递给另一个函数的函数类型。
它允许函数在执行过程中修改另一个函数的行为，从而实现更灵活、高效的编程方式。
二、指针函数的参数传递方式指针函数的参数传递方式主要有两种：值传递和指针传递。
1.值传递：将函数的返回值作为一个值传递给另一个函数。
这种方式相对简单，但无法实现函数的行为修改。
2.指针传递：将函数的指针作为一个参数传递给另一个函数。
这种方式允许函数在执行过程中修改另一个函数的行为，实现更复杂的功能。
三、指针函数的传参实例以下是一个指针函数传参的实例：```c#include <stdio.h>void swap(int *a, int *b) {int temp = *a;*a = *b;*b = temp;}int main() {int x = 1, y = 2;swap(&x, &y);printf("%d %d", x, y); // 输出 2 1return 0;}```在这个例子中，我们定义了一个名为 swap 的函数，它接受两个整型指针作为参数。
在函数内部，我们通过指针访问的方法实现了两个整数的交换。
四、指针函数传参的优缺点指针函数传参的优点：1.灵活性：指针函数可以根据传入的指针实现不同的功能，更加灵活。
2.效率：指针函数可以直接通过指针访问内存，速度更快。
3.可扩展性：指针函数可以方便地实现函数链、回调等功能，提高代码的可扩展性。
指针函数传参的缺点：1.复杂性：指针函数的传参方式较为复杂，需要掌握一定的指针知识。
2.可读性：指针函数的代码可读性较差，可能影响代码的维护。
3.潜在风险：指针函数传参容易引发内存泄漏、野指针等问题，需要谨慎使用。
五、总结指针函数传参是一种强大的编程方式，可以实现更复杂、高效的功能。
举例说明返回指针的函数
举例说明返回指针的函数返回指针的函数是指函数返回一个指向某个数据类型的指针。
通过返回指针，可以将函数内部的计算结果传递给调用函数，实现数据的共享和传递。
下面将列举10个示例来说明返回指针的函数。
1. 函数名称：findMax函数功能：找到数组中的最大值并返回指向该最大值的指针示例代码：```int* findMax(int arr[], int size) {int maxIndex = 0;for (int i = 1; i < size; i++) {if (arr[i] > arr[maxIndex]) {maxIndex = i;}}return &arr[maxIndex];}```2. 函数名称：createArray函数功能：动态创建一个指定大小的数组，并返回指向该数组的指针```int* createArray(int size) {int* arr = new int[size];return arr;}```3. 函数名称：copyString函数功能：拷贝一个字符串，并返回指向拷贝后字符串的指针示例代码：```char* copyString(const char* str) {int length = strlen(str);char* copy = new char[length + 1];strcpy(copy, str);return copy;}```4. 函数名称：findElement函数功能：在数组中查找指定元素的索引，并返回指向该索引的指针```int* findElement(int arr[], int size, int target) {for (int i = 0; i < size; i++) {if (arr[i] == target) {return &arr[i];}}return nullptr;}```5. 函数名称：reverseArray函数功能：逆转数组中的元素，并返回指向逆转后数组的指针示例代码：```int* reverseArray(int arr[], int size) {int* reverse = new int[size];for (int i = 0; i < size; i++) {reverse[i] = arr[size - i - 1];}return reverse;}```6. 函数名称：allocateMemory函数功能：动态分配指定大小的内存，并返回指向该内存的指针示例代码：```void* allocateMemory(int size) {void* memory = malloc(size);return memory;}```7. 函数名称：findSubstring函数功能：在字符串中查找子串的位置，并返回指向该位置的指针示例代码：```const char* findSubstring(const char* str, const char* sub) {const char* position = strstr(str, sub);return position;}```8. 函数名称：findPrimeNumbers函数功能：在指定范围内查找素数，并返回指向素数数组的指针示例代码：```bool isPrime(int num) {if (num < 2) {return false;}for (int i = 2; i * i <= num; i++) {if (num % i == 0) {return false;}}return true;}int* findPrimeNumbers(int start, int end, int& count) { int* primes = new int[end - start + 1];count = 0;for (int i = start; i <= end; i++) {if (isPrime(i)) {primes[count++] = i;}}return primes;}```9. 函数名称：findMaxElement函数功能：找到二维数组中的最大元素，并返回指向该元素的指针示例代码：```int* findMaxElement(int** matrix, int rows, int cols) {int* maxElement = matrix[0];for (int i = 0; i < rows; i++) {for (int j = 0; j < cols; j++) {if (matrix[i][j] > *maxElement) {maxElement = &matrix[i][j];}}}return maxElement;}```10. 函数名称：findCommonElements函数功能：找到两个数组中的相同元素，并返回指向相同元素数组的指针示例代码：```int* findCommonElements(int arr1[], int size1, int arr2[], int size2, int& count) {int* commonElements = new int[size1];count = 0;for (int i = 0; i < size1; i++) {for (int j = 0; j < size2; j++) {if (arr1[i] == arr2[j]) {commonElements[count++] = arr1[i];break;}}}return commonElements;}。
指针函数的使用方法
指针函数的使用方法
指针函数是指返回值为指针的函数。
它们通常用于动态分配内存、返回数组或结构等复杂对象。
以下是指针函数的使用方法：
1. 定义指针函数的语法如下：
返回类型*函数名(参数列表)
{
函数体
}
例:
int* getPointer(int num) {
int* ptr = new int(num);
return ptr;
}
2. 在函数体内部，可以使用new运算符动态分配内存，并将其地址返回给调用者。
注意确保在适当的时间释放这段内存，以避免内存泄漏。
3. 调用指针函数时，可以将返回的指针保存在同类型的指针变量中，然后使用指针变量来访问指向的数据。
例:
int* ptr = getPointer(10);
cout << *ptr << endl; 输出10
4. 可以在任何需要指针的地方使用指针函数的返回值。
例如，可以将指针传递给其他函数，并将其用于动态分配内存或修改指向的数据。
例:
void modifyPointer(int* ptr) {
*ptr = 20;
}
modifyPointer(ptr);
cout << *ptr << endl; 输出20
需要注意的是，在使用指针函数时，应确保返回的指针不会在其所指对象被销毁后继续被使用。
可以通过适当释放内存或通过其他方式来确保这一点。
指针经验总结(经典 非常详细 精品)
(3)int**ptr;//指针的类型是int**
(4)int(*ptr)[3];//指针的类型是int(*)[3]
(5)int*(*ptr)[4];//指针的类型是int*(*)[4]
怎么样？找出指针的类型的方法是不是很简单？
b.指针所指向的类型
当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了
例二：
char a[20];
int *ptr=(int *)a; //强制类型转换并不会改变a的类型,只改变ptr由它的值开始的所指向的
//内存区的的长度(sizeof(int)).
ptr++;
在上例中，指针ptr的类型是int*,它指向的类型是int，它被初始化
为指向整型变量a。接下来的第3句中，指针ptr被加了1，编译器是这样
下面让我们先从简单的类型开始慢慢分析吧:
int p; //这是一个普通的整型变量
int *p; //首先从P处开始,先与*结合,所以说明P是一个指针,然后再与int结合,说明指针所指向的内容的类型为int型.所以P是一个返回整型数据的指针
int p[3]; //首先从P处开始,先与[]结合,说明P是一个数组,然后与int结合,说明数组里的元素是整型的,所以P是一个由整型数据组成的数组
int *p[3]; //首先从P处开始,先与[]结合,因为其优先级比*高,所以P是一个数组,然后再与*结合,说明数组里的元素是指针类型,然后再与int结合,说明指针所指向的内容的类型是整型的,所以P是一个由指向整型数据的指针所组成的数组.
int (*p)[3]; //首先从P处开始,先与*结合,说明P是一个指针
函数指针类型定义
函数指针类型定义函数指针是指向函数的指针变量，它可以指向具体的函数实现，并且可以作为参数传递给其他函数。
函数指针类型定义是指定函数指针类型的格式化规则，使用函数指针类型可以减少代码重复、提高程序可读性和可维护性。
在C语言中，函数指针类型定义的定义形式为：返回值类型 (*函数指针变量名)(参数列表)。
其中，返回值类型是指函数返回值的类型，函数指针变量名是该函数指针变量的名称，参数列表是指函数的参数类型和个数。
函数指针类型定义的作用非常广泛，最常见的应用是在回调函数中使用。
回调函数是指程序在某个事件发生时自动调用的函数，它可以用函数指针类型定义来指定回调函数的格式和参数。
例如，注册键盘事件函数时，可以使用函数指针类型定义将键盘事件处理函数注册到回调函数中，当键盘事件发生时，回调函数会自动调用相应的键盘事件处理函数。
另外，函数指针类型定义还可以用来实现函数指针数组。
函数指针数组是一个数组，每个元素都是一个函数指针，可以执行不同的函数实现。
例如，在编写图像处理程序时，可以定义一个函数指针类型定义，将图像处理函数注册到函数指针数组中，然后通过数组索引调用相应的图像处理函数，实现多种图像处理效果。
在使用函数指针类型定义时，需要特别注意指针变量的类型和参数类型的匹配。
如果类型不匹配，程序运行时会出现未定义的行为，导致程序崩溃或产生无法预测的结果。
因此，在定义函数指针类型时，建议使用typedef关键字，将函数指针类型定义为一个新的类型名称，以便于后续使用，并避免类型匹配错误。
总之，函数指针类型定义是一个重要的概念，它可以提高代码的可读性和可维护性，使代码更加模块化和可复用。
掌握函数指针类型定义的使用技巧，可以让程序员更加高效地编写程序，实现更多复杂的功能。
函数指针与指针函数
指针变量可以指向变量地址、数组、字符串、 指针变量可以指向变量地址、数组、字符串、动 态分配地址，同时也可指向函数， 态分配地址，同时也可指向函数，每一个函数在编译 系统会分配给该函数一个人口地址， 时，系统会分配给该函数一个人口地址，函数名表示 这个人口地址，那么， 这个人口地址，那么，指向函数的指针变量称之函数 指针变量. 指针变量
[例7．23]下列程序的可执行文件名为test．exe。 23]下列程序的可执行文件名为test exe。 test． argc， main(int argc，char *argv[]) { int i; printf(“argc＝ argc)； printf(“argc＝％d＼n”，argc)； for(i＝ i<argc； for(i＝1；i<argc；i++) printf(” argv[i])； printf(”％s＼n”，argv[i])； } 在操作系统提示符下，输入如下命令行： 在操作系统提示符下，输入如下命令行：
│2x - 1.76 │ fun1(x)=───────── (x-0.3)(10.5 -x) (x-
Cos(x-1.3) Cos(x-
例如：fun1( 例如：fun1( 1.66 ) = -0.806 ****************************************************** *******************/
*********************************************************/
fun( char str1[], char str2[]) { /*================================================*/ int i,j,k,len,len1; char ch; i<len len=strlen(str1); strcpy(str2,""); k=0; for (i=0;i<len-1;i++) { ch=str1[i]; ; if (ch>='A' && ch<='Z') ch=ch+32 else if ( ch>='a' && ch<='z' ) ch=ch-32; str2[k]=ch; k++; } str2[k]='\0'; /*-------------------------------------------------------*/ }
最复杂的函数
最复杂的函数本函数影响由fd参数引用的一个打开的文件。
第三个参数总是一个指针，但指针的类型依赖于request参数。
#include<unistd.h>int ioctl( int fd, int request, .../* void *arg */ );返回：成功-1：出错我们可以把和网络相关的请求划分为6类：套接口操作文件操作接口操作ARP高速缓存操作路由表操作流系统下表列出了网络相关ioctl请求的request参数以及arg地址必须指向的数据类型：类别Request说明数据类型套接口SIOCATMARK SIOCSPGRP SIOCGPGRP是否位于带外标记设置套接口的进程ID或进程组ID获取套接口的进程ID或进程组IDintintint文件FIONBIN FIOASYNCFIONREAD FIOSETOWN FIOGETOWN设置/清除非阻塞I/O标志设置/清除信号驱动异步I/O标志获取接收缓存区中的字节数设置文件的进程ID或进程组ID获取文件的进程ID或进程组IDintintintintint接口SIOCGIFCONF SIOCSIFADDR SIOCGIFADDR SIOCSIFFLAGSSIOCGIFFLAGS SIOCSIFDSTADDR SIOCGIFDSTADDR SIOCGIFBRDADDR SIOCSIFBRDADDR SIOCGIFNETMASK SIOCSIFNETMASK SIOCGIFMETRIC SIOCSIFMETRIC SIOCGIFMTU SIOCxxx获取所有接口的清单设置接口地址获取接口地址设置接口标志获取接口标志设置点到点地址获取点到点地址获取广播地址设置广播地址获取子网掩码设置子网掩码获取接口的测度设置接口的测度获取接口MTU（还有很多取决于系统的实现）struct ifconfstruct ifreqstruct ifreqstruct ifreqstruct ifreqstruct ifreqstruct ifreqstruct ifreqstruct ifreqstruct ifreqstruct ifreqstruct ifreqstruct ifreqstruct ifreq ARPSIOCSARP SIOCGARP SIOCDARP创建/修改ARP表项获取ARP表项删除ARP表项struct arpreq struct arpreqstruct arpreq路由SIOCADDRT SIOCDELRT增加路径删除路径struct rtentrystruct rtentry流I_xxx。
理解复杂的C C++声明
void * (*a[5])(char * const, char * const);
“右左法则”[重要！！！]
The right-left rule: Start reading the declaration from the innermost parentheses, go right, and then go left. When you encounter parentheses, the direction should be reversed. Once everything in the parentheses has been parsed, jump out of it. Continue till the whole declaration has been parsed.
上的误区，比如：
int* p,q;
第一眼看去，好像是p和q都是int*类型的，但事实上，只有p是一个指针，而q是一个最简单的int型变量。
我们还是继续我们前面的话题，再来看一个指针的指针的例子：
char **argv;
理论上，对于指针的级数没有限制，你可以定义一个浮点类型变量的指针的指针的指针的指针...
更喜欢第一种声明方式，因为它更突出了const修饰符的作用。
当const与指针一起使用时，容易让人感到迷惑。例如，我们来看一下下面的p和q的声明：
const int *p;
int const *q;
他们当中哪一个代表const int类型的指针（const直接修饰int），哪一个代表int类型的const指针（const直接修饰指针）？实际上，p和q都
typedef给你一种方式来克服“*只适合于变量而不适合于类型”的弊端。你可以如下使用typedef：
c++指针例题及解析
c++指针例题及解析下面是一个简单的 C++ 指针例题及解析：题目：#include <iostream>int main() {int x = 5;int y = 10;int* ptrX = &x;int* ptrY = &y;std::cout << "Value of x: " << x << std::endl;std::cout << "Address of x: " << &x << std::endl;std::cout << "Value pointed by ptrX: " << *ptrX << std::endl;std::cout << "\nValue of y: " << y << std::endl;std::cout << "Address of y: " << &y << std::endl;std::cout << "Value pointed by ptrY: " << *ptrY << std::endl;return 0;}解析：这个例子演示了基本的指针概念。
让我们逐步解析：int x = 5;：声明一个整数变量 x 并初始化为 5。
int y = 10;：声明另一个整数变量 y 并初始化为 10。
int* ptrX = &x;：声明一个整型指针 ptrX，指向 x 的地址。
int* ptrY = &y;：声明另一个整型指针 ptrY，指向 y 的地址。
std::cout << "Value of x: " << x << std::endl;：输出 x 的值。
关于指针的使用示例
关于指针的使⽤⽰例指针（指针与数组，指针与字符串，指针数组）掌握指针、地址和数组间的关系；掌握通过指针操作数组元素的⽅法；掌握数组名作为函数参数的编程⽅法；掌握指针、地址和字符串间的关系；掌握通过指针操作字符串的⽅法。
什么是指针？下⾯通过3个例⼦感受和理解⼀下。
例⼦1：//下⾯是⼀个关于指针的例⼦，请通过该例⼦了解指针的作⽤、指针所代表的地址、指针⾃⼰的地址等概念。
#include <stdio.h>void main(){int *p,q;q=98;printf("\n变量q被初始化赋值后其值为：%d ，其内存地址为：%d \n",q,&q); // &为取地址符printf("\n在未指向任何变量时候，指针p⾃⼰的值为：%d \n",p);p=&q; //现在让指针p指向变量q，此后p的值代表变量q的地址, *p代表q的值。
printf("\n在指向变量q后，指针p⾃⼰的值为:%d\n",p);printf("\n指针p所指向的内存变量(实际上就是q)的值为：%d \n",*p);printf("\n我们通过上⾯的输出应该可以看出：");printf("指针p的值和它所指向的变量p的地址应该是相同的 \n");printf("并且*p的值应该就是变量q的值。
\n\n");}例⼦2：#include "stdio.h"void swap(int p1,int p2) //没学指针前的两个数交换值{int temp;temp = p1;p1 = p2;p2 = temp;}int main(){int x = 99,y = 66;printf("交换前：%d %d\n",x,y); swap(x,y);printf("交换后：%d %d\n",x,y);}例⼦3：#include "stdio.h"void swap(int *p1,int *p2){int temp;temp = *p1;*p1 = *p2;*p2 = temp;}int main(){int x = 99,y = 66;printf("交换前：%d %d\n",x,y); swap(&x,&y);printf("交换后：%d %d\n",x,y);}编程⽰例和提⽰（1）利⽤指针作为参数，返回值#include <stdio.h>void change(int *p){*p=9;}void main(void){int a=5;change(&a);printf("a=%d\n",a);}讲解：在上述程序中，输出a=9。
15 指针高级应用
例如： int a[3][5]; a[0]、a[1]和a[2]分别是包含五个元素的一维数组名， 分别代表a数组元素的起始地址(即a[0]是第0行元素的 首地址， a[1]是第1行元素的首地址）。 a[i]和*(a+i)（无条件等价）都是第i行第0列元素的地址， 那么a[i]+j、*(a+i)+j、&a[0][0]+5*i+j都是第i行第j列元素 的地址。
8
数组作参数传递
一维数组元素作参数传递时，按值传递 整个数组(数组名)当参数传递时，按地址传递， 有以下三种等价的写法：
void TestArray(char ary[ ]); void TestArray(char ary[ LEN]); void TestArray(char *ary);
9
数组作为返回值
按地址传递
指针可以作为参数 把实参的地址传给形参 允许函数访问内存位置 被调函数能够修改主调程序的参数的值 定义 getstr(char *ptr_str, int *ptr_int); 使用 getstr(pstr, &var);
7
按地址传递示例
#include <stdio.h> void swap(int *x, int *y); void main() { int a, b; a = 10; b = 20; swap(&a, &b); printf(“a=%d,b=%d” ,a,b); } void swap(int *x, int *y) { int temp; temp = *x; *x = *y; *y = temp; }
结构体内函数指针
结构体内函数指针结构体内函数指针的定义结构体是一种用户自定义的数据类型，可以包含若干个不同类型的变量，通过结构体可以将这些变量组织在一起，形成一个整体。
结构体内函数指针就是将函数指针作为结构体的成员之一，在结构体中声明和定义一个函数指针变量。
结构体内函数指针的定义方式如下：```typedef struct {int (*func)(int);} FuncPtrStruct;```在这个定义中，我们定义了一个结构体FuncPtrStruct，它有一个成员变量func，它的类型是一个函数指针，该函数指针指向一个返回类型为int，参数为int类型的函数。
结构体内函数指针的使用结构体内的函数指针可以通过结构体变量来访问和调用，可以通过函数指针来调用相应的函数。
下面我们来看一个例子：```#include <stdio.h>int add(int a, int b) {return a + b;}int sub(int a, int b) {return a - b;}typedef struct {int (*func)(int, int);} FuncPtrStruct;int main() {FuncPtrStruct funcPtr;funcPtr.func = add;printf("Add function result: %d\n", funcPtr.func(3, 5));funcPtr.func = sub;printf("Subtract function result: %d\n", funcPtr.func(3, 5));return 0;}```在这个例子中，我们首先定义了两个函数add和sub，然后定义了一个结构体FuncPtrStruct，它包含一个函数指针成员变量func。
接着在主函数中，我们定义了一个FuncPtrStruct类型的变量funcPtr，然后分别将add和sub函数的地址赋值给funcPtr.func，最后通过funcPtr.func来调用相应的函数。
深入解析C语言中函数指针的定义与使用
深⼊解析C语⾔中函数指针的定义与使⽤1.函数指针的定义函数是由执⾏语句组成的指令序列或者代码，这些代码的有序集合根据其⼤⼩被分配到⼀定的内存空间中，这⼀⽚内存空间的起始地址就成为函数的地址，不同的函数有不同的函数地址，编译器通过函数名来索引函数的⼊⼝地址，为了⽅便操作类型属性相同的函数，c/c++引⼊了函数指针，函数指针就是指向代码⼊⼝地址的指针，是指向函数的指针变量。
因⽽“函数指针”本⾝⾸先应该是指针变量，只不过该指针变量指向函数。
这正如⽤指针变量可指向整形变量、字符型、数组⼀样，这⾥是指向函数。
C在编译时，每⼀个函数都有⼀个⼊⼝地址，该⼊⼝地址就是函数指针所指向的地址。
有了指向函数的指针变量后，可⽤该指针变量调⽤函数，就如同⽤指针变量可引⽤其他类型变量⼀样，在这些概念上是⼀致的。
函数指针有两个⽤途：调⽤函数和做函数的参数。
函数指针的声明⽅法为：数据类型标志符 (指针变量名) (形参列表);“函数类型”说明函数的返回类型，由于“()”的优先级⾼于“*”,所以指针变量名外的括号必不可少，后⾯的“形参列表”表⽰指针变量指向的函数所带的参数列表。
例如： int function(int x，int y); /* 声明⼀个函数 */ int (*f) (int x，int y); /* 声明⼀个函数指针 */ f=function; /* 将function函数的⾸地址赋给指针f */ 赋值时函数function不带括号，也不带参数，由于function代表函数的⾸地址，因此经过赋值以后，指针f就指向函数function(int x，int y);的代码的⾸地址。
2.函数指针使⽤的例⼦ 知道了如何定义⼀个函数指针，但如何来使⽤它呢？先看如下例⼦：#include <stdio.h>#include <string.h>char * fun(char * p1,char * p2){ int i = 0; i = strcmp(p1,p2); if (0 == i) { return p1; } else { return p2; }}int main(){ char * (*pf)(char * p1,char * p2); pf = &fun; (*pf) ("aa","bb"); return 0;} 我们使⽤指针的时候，需要通过钥匙（“*”）来取其指向的内存⾥⾯的值，函数指针使⽤也如此。
学生成绩分析——指针作为函数的参数_C语言程序设计基础_[共2页]
![学生成绩分析——指针作为函数的参数_C语言程序设计基础_[共2页]](https://img.taocdn.com/s3/m/5a1adb0626fff705cd170a0a.png)
115 C
Visual Basic
VC++
Java
7.6 指针与函数
7.6.1 学生成绩分析——指针作为函数的参数
1．案例描述
（1）提出问题
经常要对某班学生考试成绩进行分析。
如针对某门课程的考试结果，计算该班的平均成绩，统计最高分和最低分。
可以编写函数来完成该功能，输入值是这个班的学生人数和每个人这门课的考试成绩，输出值是平均成绩、最高分和最低分。
使用这个函数对不同班级、不同课程的成绩进行分析。
但是，存在一个问题，即函数只能有一个返回值，我们想要平均成绩、最高分和最低分3个返回值，那该怎样实现呢？
（2）程序运行结果
程序运行结果如图
7-17所示。
图7-1７ 执行结果
（3）涉及知识点
指针变量作为函数参数。
2．指针作为函数的参数
函数的参数不仅可以是整型、实型、字符型等数据，还可以是指针类型。
它的作用是将一个变量的地址传送到另一个函数中。
【例7.14】 交换两个整数的值后输出。
用指针类型的数据作函数参数进行处理。
swap(int *p1, int *p2){
int temp;
temp = *p1; *p1 = *p2; *p2=temp;
}
main( ){
int a = 10, b = 20;
printf("%d,%d\n", a, b);
swap(&a, &b);
printf("%d,%d\n", a, b);
}
运行结果为：
10,20。
指针函数的定义
1.指针函数的定义顾名思义，指针函数即返回指针的函数。
其一般定义形式如下：类型名*函数名(函数参数表列);其中，后缀运算符括号“()”表示这是一个函数，其前缀运算符星号“*”表示此函数为指针型函数，其函数值为指针，即它带回来的值的类型为指针，当调用这个函数后，将得到一个“指向返回值为…的指针（地址），“类型名”表示函数返回的指针指向的类型”。
“(函数参数表列)”中的括号为函数调用运算符，在调用语句中，即使函数不带参数，其参数表的一对括号也不能省略。
其示例如下：int *pfun(int, int);由于“*”的优先级低于“()”的优先级，因而pfun首先和后面的“()”结合，也就意味着，pfun是一个函数。
即：int *(pfun(int, int));接着再和前面的“*”结合，说明这个函数的返回值是一个指针。
由于前面还有一个int，也就是说，pfun是一个返回值为整型指针的函数。
我们不妨来再看一看，指针函数与函数指针有什么区别？int (*pfun)(int, int);通过括号强行将pfun首先与“*”结合，也就意味着，pfun是一个指针，接着与后面的“()”结合，说明该指针指向的是一个函数，然后再与前面的int 结合，也就是说，该函数的返回值是int。
由此可见，pfun是一个指向返回值为int的函数的指针。
虽然它们只有一个括号的差别，但是表示的意义却截然不同。
函数指针的本身是一个指针，指针指向的是一个函数。
指针函数的本身是一个函数，其函数的返回值是一个指针。
2.用函数指针作为函数的返回值在上面提到的指针函数里面，有这样一类函数，它们也返回指针型数据（地址），但是这个指针不是指向int、char之类的基本类型，而是指向函数。
对于初学者，别说写出这样的函数声明，就是看到这样的写法也是一头雾水。
比如,下面的语句：int (*ff(int))(int *, int);我们用上面介绍的方法分析一下，ff首先与后面的“()”结合，即：int (*(ff(int)))(int *, int); // 用括号将ff(int)再括起来也就意味着，ff是一个函数。
什么是函数指针(理解及使用)
什么是函数指针（理解及使用）函数指针是指向函数的指针变量，它可以存储函数的地址，通过函数指针可以访问和调用函数。
在理解和使用函数指针时，主要包括函数指针的定义，函数指针的使用以及函数指针的应用。
一、函数指针的定义函数指针的声明一般形式为：返回值类型(*指针变量名)(参数列表)，其中指针变量名可以根据需要自行命名，参数列表是指函数的参数类型列表。
以下是一个简单的函数指针定义的示例：```int (*funcPtr)(int, int); // 定义一个返回值为int类型，接受两个int类型参数的函数指针```二、函数指针的使用函数指针的使用主要包括函数指针的赋值和函数指针的调用。
1.函数指针的赋值函数指针的赋值可以将一个函数的地址赋给函数指针变量，使其指向该函数。
以下是一个函数指针的赋值示例：```int add(int a, int b) { // 定义一个函数add，计算两个数的和return a + b;int (*funcPtr)(int, int) = add; // 将add函数的地址赋给funcPtr指针变量```2.函数指针的调用函数指针的调用可以通过函数指针来调用对应的函数。
以下是一个函数指针的调用示例：```int result = (*funcPtr)(3, 4); // 通过funcPtr指针变量调用add函数，传入参数3和4```三、函数指针的应用1.回调函数函数指针可以作为参数传递给另一个函数，用于回调函数的实现。
回调函数是指当一些事件发生时，调用另一个函数进行处理的函数。
以下是一个回调函数的示例：```void printNumber(int num) { // 定义一个打印数字的函数printf("Number: %d\n", num);void forEach(int arr[], int length, void (*funcPtr)(int)) { // 定义一个遍历数组的函数，接受一个函数指针作为回调函数for (int i = 0; i < length; i++)(*funcPtr)(arr[i]);}int maiint arr[] = {1, 2, 3, 4, 5};int length = sizeof(arr) / sizeof(arr[0]);forEach(arr, length, printNumber); // 调用forEach函数，并将printNumber函数的地址传入作为回调函数return 0;```通过以上示例，forEach函数通过函数指针调用printNumber函数，实现了遍历数组并打印数字的功能。
不能用解析法表示的函数例子
不能用解析法表示的函数例子
1. 狄利克雷函数呀，这可真是个特别的存在呢！想象一下，在数轴上，它的值一会儿是 1，一会儿又是 0，毫无规律可言，根本没办法用一个式子来表示它，就像天气一会儿晴一会儿雨，让人捉摸不透！
2. 还有那个科赫雪花曲线对应的函数，那复杂的形状，弯弯绕绕的，怎么可能用解析法来表达呢！这就好比你要给一个极其复杂的拼图找一个简单的描述公式，根本不可能嘛！
3. 像那个康托尔集对应的函数，那简直是让人头疼呀！一堆密密麻麻的点，混乱得很，想要用解析法来抓住它，那可真是痴心妄想！就像在一堆乱麻中找线头一样困难。
4. 魏尔斯特拉斯函数也不行哟！它那无穷无尽的锯齿，要想用解析法来表现它，岂不是异想天开！就如同让你用一句话来形容一幅无比复杂的抽象画。
5. 还有那个布朗运动对应的函数，那随机的跳动，没有一点规律可循呀，怎么能用解析法来描述呢！这就好像试图给一只调皮猫咪的行动轨迹写出一个解析式。
6. 门格尔海绵对应的函数，哇，那可是超级复杂呢！层层叠叠的结构，让人眼花缭乱，想用解析法，那是绝对不可能哒！简直就像是要把一座复杂的城堡用一个公式来概括。
7. 最后说说那个奇怪的希尔伯特曲线对应的函数，那扭曲缠绕的样子，想用解析法简直是天方夜谭啦！就好像让你去给一团纠结在一起的绳子找一个简单明白的表达式一样。
结论：这些函数呀，真的是很特别，没法用解析法来表示它们呢，是不是很神奇呀！。
指针的问题讨论
指针表达式。
一个表达式的最后结果如果是一个指针，那么这个表达式就叫指针表达式。
下面是一些指针表达式的例子：例六：int a,b;int array[10];int *pa;pa=&a;//&a是一个指针表达式。
int **ptr=&pa;//&p a也是一个指针表达式。
*ptr=&b;//*ptr和&b都是指针表达式。
pa=array;pa++;//这也是指针表达式。
例七：char *arr[20];char **p arr=arr;//如果把arr看作指针的话，arr也是指针表达式char *str;str=*parr;//*parr是指针表达式str=*(parr+1);//*(parr+1)是指针表达式str=*(parr+2);//*(parr+2)是指针表达式由于指针表达式的结果是一个指针，所以指针表达式也具有指针所具有的四个要素：指针的类型，指针所指向的类型，指针指向的内存区，指针自身占据的内存。
好了，当一个指针表达式的结果指针已经明确地具有了指针自身占据的内存的话，这个指针表达式就是一个左值，否则就不是一个左值。
在例七中，&a不是一个左值，因为它还没有占据明确的内存。
*ptr是一个左值，因为*ptr这个指针已经占据了内存，其实*ptr就是指针pa，既然pa已经在内存中有了自己的位置，那么*ptr当然也有了自己的位置。
第五章。
数组和指针的关系如果对声明数组的语句不太明白的话，请参阅我前段时间贴出的文?lt;<如何理解c和c++的复杂类型声明>>。
数组的数组名其实可以看作一个指针。
看下例：例八：int array[10]={0,1,2,3,4,5,6,7,8,9},value;......value=array[0];//也可写成：value=*array;value=array[3];//也可写成：value=*(array+3);value=array[4];//也可写成：value=*(array+4);上例中，一般而言数组名array代表数组本身，类型是int [10]，但如果把array看做指针的话，它指向数组的第0个单元，类型是int *，所指向的类型是数组单元的类型即int。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
复杂的函数指针例子分析2008-01-26 11:38:22
分类:
一个最简单的函数指针定义如下：
Void (*funcPtr) (); //funcptr是一个函数指针，它指向的函数没有参数，返回值为void 非常复杂的函数指针定义：
1.Void*(*(*fpl)(int))[10];
解析：Void * 这是一个有10个void*类型的元素的数组。
x=* ( * fpl)(int),从而可以看出(*fpl) (int)它是一个指
针，指向一个数组。
这个数组有10个void指针类型的元素。
Fpl是一个函数指针，它的参数是一个int型的参数。
返回值为一个指向含有1。
个void*元素的数组的指针。
2.Void*( *fpl)(int)[10]；
解析：void*X[10]；今X是一个有着[。
个void*类型的数组
x=( * fpl)(int)；
Fpl是一个函数指针，它有一个整型参数，其返回值是一个有着1()个void* 类型的元素的数组。
若是这个形式Ve i d-*-—和•块40], 则状返物=-令指向含有个v&d 类型的数组的指针U
3.Void(*fpl)(int)[10]；
解析:void X[10]->X是一个有着1()个void类型的数组
x=( * fpl)(int)；
Fpl是一个函数指针，它有一个整型参数，其返回值是一个有着10个void 类型的元素的数组
若是这个形式，Void ( * fpl)(int)[10],则其返回值为一个有1()个void类型的数组。
4・Float (*(*fp2)(int,int,float))(int);
解析：Float X(int)今X是一个函数，有,个整型参数，返回值是一个浮点数。
x=*(*fp2)(int,int,float)；
Fp2是一个函数指针，它有三个参数，前两个是整型，最后一个是浮点型。
其返回值是一个指针，是一个指向函数的指针(函数指针)o这个函数指针所指向的函数的原型是只有一个整型参数，返叫值是一个浮点数。
5.Typedef double (*(*(*fp3)())[10])()；
解析：fp3是一个函数指针；它不带参数；返回值是一个指针。
x=(*(*fp3)())
Typedef double (*X[10])()
X是一个数组，他有1()个元素，它的元素都是函数指针，这个函数指针所
指向的幽数原型是一个没有参数，返回值为double类型的函数。
综合起来就是：fp3是一个新定义的数据类型，它是一个函数指针，这个函数指针所指向的函数原型是不带参数，返回值是一个指向数组的指针。
这
个数组有10个元素，其元素类型是一个函数指针，这个函数指针所指向的函数原型是一个没有参数，返回值为double类型的函数。
6.Int(*(*fp4())[10])();
解析：fp4是一个函数，他没有参数，返回值是一个指针；
X= (*fp4())；
Int(*X[10])();
X是一个数组，其有1()个元素，每个元素都是一个函数指针，这个函数指针所代表的函数原型是一个没有参数，返回值是整型的函数。
综合起来就是:fp4是一个函数，他没有参数，返回值时一个指向数据的指针，这个数组有10个元素，每个元素都是一个函数指针，这个函数指针所代表的函数圆型是一个没有参数，返回值是整型的函数。
char* const* (*ss[23][200])(void (*)(int h, void (*)(void)))
void*(*(*fp1)(int))[10];
看了以后，我怀着“明知山有虎，偏向虎山行”的心理，决定写•下我|'|己关于复杂指针的理解方法。
我的这个方法是按照语法，•层一层进行分析来理解复杂指针的，完全是自己的方法，不- 定适合其他人，不过写出来也给大家一个参考。
首先拿简单-的那个例子来介绍,下我的“层次理解法”：(this name is made up by myself:P) void *(*(*fp1)(int))[1O];
⑴ 从外层看：void* (*(*fp1)(int)) [10];这个等价于：void* A[10];所以整
个声明就是个10个元素的数组，这个数组的每个元素是一个指向void的指针(或者说成：每个元素是一个void* )；
(2)再往里看:(* (*fp1)(int) ) ==> * (*fp1) (int)这就是•个函数指针，所指向函数需要一个int型的参数，并且返同值是一个指针；下•步就是确定返PI值指针的类型了；⑶ 结合(1),就知道，fp1返同值指针指向的就是(1)里所声明的那个类型。
所以，整理-下语言，就是：fp1是•个函数指针，指向的函数有•个int型参数，并返同 -个指针；返Pl的这个指针指向的是•个含有10个元素的数组，这个数组的每个元素是- 个void*,
现在看-下那个比较BT的例子：
char* const* (*ss[23][200])(void (*)(int h, void (*)(void)));
(1)最外麋』char* const * (*ss[23][200]) _ ( void (*) ( int h, void (*)(void)));这个相当于：T*
(A) (B);也就是•个函数指针，所指向的函数的参
数是B,返回值是T的指针；
⑵ •个•个来看，先看T, char* const是char型的指针常量；]
(3)再看A：(* ss[23][200] ) (B),这个相当于：(* F ) (B)，也就是一个函数指针;
(3.1) A的里面ss[23][200]是•个二维数组声明,这个数组的类型是什么呢?结合⑶就知
道了：这个数组的每个元素就是(3)中分析得到的——函数指针；整理•下就是：ss[23][200]
的每个元素都是一个函数指针；
(4)再看B： ( void (*)( int h, void(*)(void)))这个又是一•个函数指针，相
当于：void (*F) (P);它指向的函数参数是P,返同值是void；
(4.1) B这个函数指针指向的函数需要2个参数：第•个参数是int型，第二个参数是：void (*)(void),即：第二个参数又是-个函数指针(这个指针很好分析，就不写了)；
(5) 结合(3)和(4)就知道(*ss[23][200]) (B)这个数组函数指针所指向的函数的参数也是一个函数指针；
(6) 又结合(2)知道(5)的函数指针返同值类型。
所以，整理•下，得到：ss是-个23X200的二维数组，每个元素是-个函数指针(a)；它指向的函数的返Pl值是•个指针，这个返同值指针的类型是char型的指针常量；函数(a)的参数只有一个，是个函数指针(b)：(b)指向的函数返"I值是void型，参数有两个，第-个是int型变鬲，第二个乂是•个函数指针(c), (c)的返|可值是void,参数也是void。