指针变量作函数参数 - 典型实例 - 错误案例分析

[编程]C语⾔结构体指针作为函数参数结构体指针作为函数参数：结构体变量名代表的是整个集合本⾝，作为函数参数时传递的整个集合，也就是所有成员，⽽不是像数组⼀样被编译器转换成⼀个指针。

如果结构体成员较多，尤其是成员为数组时，传送的时间和空间开销会很⼤，影响程序的运⾏效率。

所以最好的办法就是使⽤结构体指针，这时由实参传向形参的只是⼀个地址，⾮常快速。

#include<stdio.h>struct stu{char *name;int score;} stus[]={{"zhangsan1",65},{"zhangsan2",98}};void averge(struct stu *,int);int main(){int len=sizeof(stus)/sizeof(struct stu);printf("start...\n");//数组名可以认为是⼀个指针averge(stus,len);}void averge(struct stu *stus,int len){char *name;int score;int sum=0;for(int i=0;i<len;i++){name=stus[i].name;//第⼀种形式score=(*(stus+i)).score;//第⼆种形式sum+=score;printf("%s...%d \n",name,score);}printf("平均分：%d...\n",sum/len);}。

指针函数传参（原创实用版）目录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.潜在风险：指针函数传参容易引发内存泄漏、野指针等问题，需要谨慎使用。

五、总结指针函数传参是一种强大的编程方式，可以实现更复杂、高效的功能。

指针参数传递、引⽤的陷阱最近想熟悉⼀下基本的数据结构和算法，于是写了⼀个⼆叉树程序，功能很简单，只有⼆叉树的建⽴和遍历。

在这个过程中，却发现了⼀些平时没有注意到的细节问题，写出来作为总结和⼤家分享。

待讨论和遇到的细节问题如下：（1）常见的定式思维：指针作为参数传递，是否就不需要再赋值，因为指针指向的值会同步更改，但是，你有考虑过，如果指针变量本⾝的值被更改了呢？怎么办？（2）⽐较不常⽤的⽤法，针对指针变量的引⽤，你⽤过吗？前提：（1）笔者考虑到⾃⼰⼀直混淆使⽤C和C++，于是，打算这个简单的算法程序采⽤纯C来写，因此使⽤的是C编译器。

（2）关于C和C++的⼀些区别，笔者打算另外写⼀些系列⽂章来总结分析。

（3）另外，因为是练习写的程序，暂时还没有添加内存释放的⽅法。

程序的头部定义以及通⽤的⽅法：#include <stdio.h>#include <malloc.h>#define TRUE 1#define FALSE -1typedef char ElemType;typedef int BOOL;typedef struct _BinaryTreeNode{ElemType elem;struct _BinaryTreeNode* left;struct _BinaryTreeNode* right;}BinareTreeNode, *BiTree;void PrintNode(ElemType elem){printf("%c ", elem);}void PreOrderTraverse(BinareTreeNode* pNode, void(* Visit)(ElemType elem)){if (NULL != pNode){Visit(pNode->elem);PreOrderTraverse(pNode->left, PrintNode);PreOrderTraverse(pNode->right, PrintNode);}}笔者最初写的程序如下：void PreOrderCreateBinaryTree(BinareTreeNode* pNode){ElemType elem;scanf("%c", &elem);if ('#' == elem){pNode = NULL;}else{pNode = (BinareTreeNode*)malloc(sizeof(BinareTreeNode));pNode->elem = elem;PreOrderCreateBinaryTree(pNode->left);PreOrderCreateBinaryTree(pNode->right);}}int main(){BinareTreeNode* pHeadNode = NULL;PreOrderCreateBinaryTree(pHeadNode);PreOrderTraverse(pHeadNode, PrintNode);return 0;}你能看出来问题在哪⾥吗？先思考，不要急着往后看。

指针传入函数一、概述在C语言中，指针是一种非常重要的数据类型。

指针变量存储了一个内存地址，通过指针变量我们可以直接访问并修改内存中的数据。

在函数调用过程中，我们可以将指针作为参数传入函数中，这就是指针传入函数。

二、指针传入函数的基本语法指针传入函数的基本语法如下：void functionName(datatype *ptr){// 函数体}其中，datatype是指针所指向的数据类型，ptr是指针变量名。

在函数体中，我们可以通过这个指针变量访问和修改相应地址上的数据。

三、指针传入函数的作用指针传入函数可以实现以下几个作用：1.通过传递指针参数，可以使函数修改主调函数中的变量值。

因为指针传递的是变量的地址，所以在函数内部可以通过指针间接修改变量的值，这是指针传入函数的最基本的作用之一。

2.传递指针参数可以减少内存的占用。

如果要传递的数据较大，传递整个数据会占用较多的内存空间。

而传递指针参数时，只需要传递一个地址，因此可以减少内存的占用。

3.指针传入函数可以实现多个返回值。

在函数中，我们可以通过指针传递多个指针参数，在函数中修改这些指针所指向的变量，从而实现多个返回值的效果。

4.指针传入函数可以提高程序的执行效率。

由于指针传递的是地址，在函数中直接对地址进行操作，可以减少了数据的复制和传输过程，从而提高了程序的执行效率。

四、指针传入函数的实例及讲解1. 通过指针传入函数实现变量值的修改#include <stdio.h>void changeValue(int *ptr){*ptr = 100;}int main(){int num = 10;printf("Before function call: %d\n", num);changeValue(&num);printf("After function call: %d\n", num);return 0;}2. 通过指针传入函数实现多个返回值#include <stdio.h>void modifyTwoNumbers(int *a, int *b){*a = *a + *b;*b = *a - *b;*a = *a - *b;}int main(){int num1 = 10;int num2 = 20;printf("Before function call: num1 = %d, num2 = %d\n", num1, num2); modifyTwoNumbers(&num1, &num2);printf("After function call: num1 = %d, num2 = %d\n", num1, num2);return 0;}五、注意事项在使用指针传入函数时，需要注意以下几点：1.在函数调用时，需要传递指针变量的地址。

函数指针作为函数参数函数指针是指向函数的指针变量，它的类型由指向函数的返回值类型和参数类型决定。

通过使用函数指针作为函数参数，我们可以将一个函数作为另一个函数的参数传入，然后在需要的时候通过函数指针来调用这个函数。

使用函数指针作为函数参数主要有以下几个优点：1.增加代码的复用性：通过使用函数指针，我们可以将一些特定的行为从一个函数中提取出来，封装成一个新的函数，并将其作为参数传入其他函数中。

这样一来，我们可以在不同的上下文中多次使用同一个函数指针，从而提高代码的复用性。

2.增加函数的灵活性：使用函数指针作为参数，可以在运行时根据需要动态地改变函数的行为。

通过传入不同的函数指针，我们可以让同一个函数在不同的情况下执行不同的行为，从而增加函数的灵活性。

3.实现回调函数：回调函数是指当一些事件发生时，执行特定的函数，用于实现事件驱动的编程。

通过使用函数指针作为回调函数的参数，我们可以将一些函数注册为回调函数，当事件发生时，系统会自动调用该函数，从而实现回调的功能。

下面以一个简单的例子来说明函数指针作为函数参数的用法。

假设我们有一个函数`run`，它接受一个函数指针和一个整数作为参数，然后将该整数作为参数传递给函数指针指向的函数，最后执行函数指针指向的函数。

具体代码如下：```c#include <stdio.h>void add_one(int num)printf("The result is %d\n", num + 1);void square(int num)printf("The result is %d\n", num * num);void run(void (*func)(int), int num)func(num);int mainint num = 5;run(add_one, num); // 输出：The result is 6run(square, num); // 输出：The result is 25return 0;```在上述代码中，我们定义了两个函数`add_one`和`square`，分别用于对一个整数进行加一和平方运算。

函数形参中的指针变量在C语言中，函数形参可以是指针变量，这意味着我们可以将指针作为参数传递给函数。

这种方式有很多用途和优势，可以有效地在函数间传递数据，并且能够对函数外部的变量进行修改。

本文将详细介绍函数形参使用指针变量的定义、用途和工作方式。

1. 函数定义指针变量是一种特殊的变量，它存储的是内存地址，可以指向其他变量或者函数。

在函数定义中，我们可以使用指针变量作为形参的类型。

函数将通过引用传递方式来使用指针变量，并且可以在函数内部对该指针变量所指向的数据进行修改。

函数定义时使用指针作为形参的一般形式如下：返回类型函数名(类型* 形参名) {// 函数体}其中，类型*表示指针类型，形参名为形参的名称。

2. 用途使用指针变量作为函数形参具有以下几个主要的用途：2.1 传递大型数据结构指针作为函数参数可以有效地传递大型数据结构，如数组和结构体。

通过传递指针，可以避免在函数调用时进行数据的复制，提高了程序的性能和效率。

同时，在函数内部可以直接访问指针所指向的数据，进行读写操作。

void processArray(int* arr, int size) {// 处理数组}int main() {int arr[5] = {1, 2, 3, 4, 5};processArray(arr, 5);return 0;}2.2 修改函数外部的变量在C语言中，函数默认是通过值传递的，即函数内部对形参进行修改不会影响到函数外部的变量。

但是，通过使用指针变量作为函数形参，可以实现对函数外部变量的修改。

这是因为函数内部可以直接操作指针所指向的内存地址，修改其中的数据。

void increment(int* num) {(*num)++;}int main() {int num = 10;increment(&num);printf("num = %d\n", num); // 输出 num = 11return 0;}2.3 动态内存管理在C语言中，我们可以使用动态内存分配函数（如malloc()）来分配内存，但是在使用完毕后需要手动释放内存（使用free()函数）。

C语言中指针变量作为函数参数详解在C语言中，指针变量作为函数参数是一种非常常见的用法。

通过指针变量作为参数，可以实现对函数外部变量的改变和共享，以及提高程序的运行效率。

一、指针变量作为函数参数的概念在C语言中，函数参数可以是各种类型的数据，包括基本类型（如int、float等）、数组和结构体等等。

而指针变量作为函数参数，是指在函数声明和调用过程中，使用指针类型的参数，将指针所指向的数据传递给函数，从而实现对这些数据的操作和使用。

二、指针变量作为函数参数的作用1.通过函数参数传递指针变量，可以实现对函数外部变量的改变。

在C语言中，函数参数传递是按值传递的，即传递的是变量的副本，而非变量本身。

但是，如果传递的是指针变量，函数可以通过该指针访问和修改变量的值，从而改变函数外部变量的值。

2.使用指针变量作为函数参数，可以实现对函数外部变量的共享。

如果需要在函数中对一些变量进行频繁的读写操作，通过传递指针变量，可以避免对变量的频繁拷贝，提高程序的运行效率。

3. 指针变量作为函数参数，可以实现对动态内存的管理。

在程序中，通过动态内存分配函数（如malloc、calloc等），可以申请一块连续的内存空间，可以通过指针变量将这块内存传递给其他函数进行操作。

三、指针变量作为函数参数的使用方法1.对于基本类型的指针变量，可以使用以下方式进行声明和传递：- 在函数声明中，将形参声明为指针类型。

例如：`void myFunc(int *ptr);`- 在函数定义和调用过程中，使用实参的地址作为参数。

例如：`int val = 10; myFunc(&val);`- 在函数内部，通过指针变量访问和修改实参的值。

例如：`*ptr = 20;`2.对于数组类型的指针变量，可以使用以下方式进行声明和传递：- 在函数声明中，将形参声明为数组指针类型。

例如：`voidmyFunc(int arr[]);`- 在函数定义和调用过程中，使用数组的名称作为参数。

C语言中指针变量作为函数参数详解C语言中指针变量作为函数参数详解在C语言中，函数的参数不仅可以是整数、小数、字符等具体的数据，还可以是指向它们的指针。

用指针变量作函数参数可以将函数外部的地址传递到函数内部，使得在函数内部可以操作函数外部的数据，并且这些数据不会随着函数的结束而被销毁。

像数组、字符串、动态分配的内存等都是一系列数据的集合，没有办法通过一个参数全部传入函数内部，只能传递它们的指针，在函数内部通过指针来影响这些数据集合。

有的时候，对于整数、小数、字符等基本类型数据的操作也必须要借助指针，一个典型的例子就是交换两个变量的值。

有些初学者可能会使用下面的方法来交换两个变量的值：#includevoid swap(int a, int b){ int temp; //临时变量 temp = a; a = b; b = temp;}int main(){ int a = 66, b = 99; swap(a, b); printf("a = %d, b = %dn", a, b); return 0;}运行结果：a = 66,b = 99从结果可以看出，a、b 的值并没有发生改变，交换失败。

这是因为 swap() 函数内部的 a、b 和 main() 函数内部的 a、b 是不同的变量，占用不同的内存，它们除了名字一样，没有其他任何关系，swap() 交换的是它内部 a、b 的值，不会影响它外部（main() 内部）a、b 的值。

改用指针变量作参数后就很容易解决上面的问题：#includevoid swap(int *p1, int *p2){ int temp; //临时变量temp = *p1; *p1 = *p2; *p2 = temp;}int main(){ int a = 66, b = 99; swap(&a, &b); printf("a = %d, b = %dn", a, b); return 0;} 运行结果：a = 99,b = 66调用 swap() 函数时，将变量 a、b 的地址分别赋值给 p1、p2，这样 *p1、*p2 代表的就是变量 a、b 本身，交换 *p1、*p2 的值也就是交换 a、b 的值。

字符串指针作为函数参数字符串指针作为函数参数，是C语言中非常基础的内容，也是让许多初学者颇感困惑的问题之一。

本文将就字符串指针作为函数参数这个主题，分步骤阐述其原理和使用方法，并提供一些经验技巧，希望对读者有所帮助。

一、什么是字符串指针在C语言中，字符串实际上就是一个字符数组。

当我们使用字符串变量时，其实是在使用一个指向这个字符串字符数组的指针。

例如，下面的代码定义了一个字符串变量str，其实就是一个指向字符数组的指针：char str[] = "hello world";可以写成：char *str = "hello world";这两种写法的效果是相同的，都是定义了一个字符串指针str，该指针指向一个字符数组，数组里的内容是字符串“hello world”。

二、字符串指针作为函数参数的原理我们知道，在函数调用时，形参和实参的值是通过栈来传递的，如果形参的类型是指针，实参将会传递该指针指向的地址。

在C语言中，字符串指针作为函数参数时，由于字符串实际上是一个字符数组，所以该指针指向的是该数组的首地址。

在函数中对该指针进行操作时，实际上是在对该字符数组进行操作。

因此，在函数内部修改字符串指针指向的数组时，会影响到主函数中字符串所对应的数组。

三、如何使用字符串指针作为函数参数下面，我们通过一个示例来演示如何使用字符串指针作为函数参数。

假设我们要定义一个函数，求出字符串中字符的个数。

代码如下：#include <stdio.h>int char_count(char *str) {int count = 0;while(*str++ != '\0') {count++;}return count;}int main() {char str[] = "hello world";int count = char_count(str);printf("The length of \"%s\" is %d", str, count);return 0;}上述代码中，我们定义了一个名为char_count的函数，该函数的形参是一个char类型的指针str，实现了对字符串长度的计算。

结构体指针作为函数参数一、什么是结构体指针？在C语言中，结构体是一种用户自定义的数据类型，可以用来存储不同类型的数据。

结构体变量可以包含多个数据，这些数据被称为成员。

例如，定义一个包含姓名、年龄、电话号码的结构体变量：```struct Person{char name[20];int age;char phone[20];};```结构体指针是指向结构体的指针变量，也就是说，它存储的是结构体变量的地址。

例如，在上面的结构体类型定义后，我们可以这样定义一个结构体指针变量：```struct Person *p;```二、为什么要使用结构体指针作为函数参数？在编程中，经常需要将结构体类型作为函数的参数传递。

当结构体变量较大或结构体个数较多时，传递结构体变量本身会增加时间和空间的开销。

因此，使用结构体指针作为函数参数可以大大减少开销。

另外，使用结构体指针作为函数参数还可以方便地对结构体的成员进行修改，因为函数可以通过指针直接访问结构体成员。

三、如何使用结构体指针作为函数参数？1.将结构体指针作为形参传递结构体指针作为形参的函数定义格式如下：```void func(struct Person *p);```在函数内部，可以通过使用指针运算符“->”来访问结构体的成员。

例如，访问姓名和年龄：```void func(struct Person *p){printf("姓名：%s，年龄：%d\n", p->name, p->age);}```在调用函数时，需要将结构体变量的地址传递给函数。

例如，假设有如下结构体变量：```struct Person wang = {"王强",28,"138****8888"};```则可以通过下面的方式调用函数：```func(&wang);```2.将结构体指针数组作为形参传递结构体指针数组作为形参的函数定义格式如下：```void func(struct Person *p[], int len);```在函数内部，可以通过循环依次访问每个结构体指针，并通过“->”运算符访问结构体成员。

指针数组做函数参数
指针数组，即一个数组中存放了多个指针，每个指针指向不同的变量或数组。

在函数参数中，指针数组可以传递多个指针，方便地进行一些操作。

例如，我们可以定义一个int类型的指针数组，用于存储多个整数：
int *arr[5];
其中，arr是一个指针数组，包含5个指针，每个指针指向一个int类型的变量。

在函数参数中使用指针数组，可以通过以下几种方式：
1.使用指针数组作为函数参数
void func(int *arr[]) {
// do something
}
2.使用指针数组的首地址作为函数参数
void func(int **arr) {
// do something
}
3.使用数组名作为函数参数
void func(int arr[][5]) {
// do something
}
这些方式在使用时需要注意指针的类型和指针数组的长度。

在函数中可以通过指针数组来访问数组中的元素，从而进行一些操作。

指针数组作为函数参数的优点在于可以方便地传递多个指针，同时也可以动态地修改数组中的元素。

但同时也需要注意指针的类型和指针数组的长度，以确保程序的正确性。

总之，指针数组作为函数参数具有很大的灵活性和实用性，在C/C++程序设计中应用广泛。

c语言结构体指针作为函数参数一、概述在C语言中，结构体是一种非常有用的数据类型。

结构体可以包含多个不同类型的变量，这些变量可以按照自己的需求进行组合。

而结构体指针则是指向结构体的指针变量，它可以更加方便地操作结构体中的成员变量。

在函数中使用结构体指针作为参数，可以使得函数能够直接修改结构体中的成员变量，从而实现更加灵活和高效的操作。

二、定义结构体在使用结构体指针作为函数参数之前，首先需要定义一个包含多个成员变量的结构体。

例如：```struct Student {char name[20];int age;float score;};```这个结构体包含了三个成员变量：姓名、年龄和分数。

三、传递结构体指针作为参数在函数中使用结构体指针作为参数时，需要注意以下几点：1. 函数声明时需要将参数声明为一个指向该结构体类型的指针。

例如：```void printStudent(struct Student *s);```这个函数接受一个指向Student类型的指针作为参数。

2. 在调用函数时需要传递一个该类型的指针作为实参。

例如：```struct Student stu = {"Tom", 18, 90.5};printStudent(&stu);```这里将stu的地址传递给了printStudent函数。

3. 在函数内部可以通过指针访问结构体中的成员变量。

例如：```void printStudent(struct Student *s) {printf("Name: %s\n", s->name);printf("Age: %d\n", s->age);printf("Score: %.2f\n", s->score);}```这个函数使用指针访问了结构体中的三个成员变量，并将它们打印出来。

使用指针作为函数参数,写一交换两个数的函数的算法使用指针作为函数参数可以实现在函数内部交换两个数的值。

以下是一个使用指针交换两个整数的函数的算法：```c++void swap(int* a, int* b) {int temp = *a;*a = *b;*b = temp;}```在此算法中，函数 `swap` 接受两个指向整数的指针作为参数。

通过使用解引用操作符 `*`，可以在函数内部访问指针指向的值。

首先，将指针 `a` 所指向的值存储在临时变量 `temp` 中，然后将指针 `b` 所指向的值赋给指针 `a` 所指向的位置，最后将临时变量`temp` 的值赋给指针 `b` 所指向的位置。

这样就完成了两个数的交换。

以下是一个示例程序，演示了如何调用 `swap` 函数并输出结果：```c++#include <iostream>void swap(int* a, int* b) {int temp = *a;*a = *b;*b = temp;}int main() {int x = 5;int y = 10;std::cout << 'Before swap: x = ' << x << ', y = ' << y << std::endl;swap(&x, &y);std::cout << 'After swap: x = ' << x << ', y = ' << y << std::endl;return 0;}```输出结果应为：```Before swap: x = 5, y = 10After swap: x = 10, y = 5```在调用 `swap` 函数时，传递 `x` 和 `y` 的地址作为参数，这样函数内部就可以通过指针来访问并修改它们的值。

指针作函数参数指针作为函数参数是C语言中非常重要的一个概念，它可以用于实现函数之间的数据传递与共享。

本文将对指针作为函数参数的概念、使用方法以及相关注意事项进行详细介绍。

在C语言中，指针是一种变量类型，它存储了一个内存地址的值。

通过指针，我们可以访问或修改一些内存地址中存储的值。

当指针作为函数参数时，实际上传递的是指针所指向的内存地址而不是它所存储的值。

指针作为函数参数的最大优势之一是可以实现对函数外部数据的修改。

当我们将一个变量的指针作为函数参数传递给一个函数时，该函数可以通过对指针进行操作来修改这个变量的值。

这种更改是直接反映到函数外部的，因为传递的实际上是变量在内存中的地址。

另一个使用指针作为函数参数的常见情况是在函数中动态分配内存。

通过传递指向指针的指针，函数可以分配并返回动态分配的内存，并确保在函数调用结束后内存不会丢失。

这种方法在动态数据结构中特别有用，例如链表、树等。

为了更好地理解指针作为函数参数的使用方法，我们将通过一个简单的示例来说明。

假设我们要编写一个函数，用于将两个整数相加并将结果存储在第三个参数所指向的内存空间中。

```c// 定义函数，其中x和y是要相加的两个数，result是存储结果的指针void add(int x, int y, int* result)*result = x + y;int maiint a = 5, b = 3, c;//调用函数，并将c的指针传递给函数add(a, b, &c);//输出计算结果printf("%d + %d = %d\n", a, b, c);return 0;```在上述示例中，我们通过传递指向c的指针来将结果返回给调用函数。

通过在函数中对指针进行解引用，我们可以将计算结果存储在c所指向的内存地址中。

这样，在函数调用结束后，我们可以直接访问并打印出结果。

当使用指针作为函数参数时，需要注意一些重要的事项。

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。

函数指针作为模板参数在C++语言中，函数指针是一种非常有用的数据类型，它可以赋值给函数指针变量，并且可以作为函数的参数和返回值。

而在模板编程中，我们可以使用函数指针作为模板参数，以实现更加灵活的代码设计和实现。

本文将介绍函数指针作为模板参数的用途、实现方法以及优缺点。

一、函数指针作为模板参数的用途在模板编程中，我们经常需要对某些类型进行一定的操作。

例如，对于一个容器类，我们可能需要对它进行排序、查找、插入、删除等操作。

这些操作往往需要一个比较器函数，以便确定操作的顺序和结果。

如果我们使用模板来实现这些操作，则每次实例化模板时，都需要指定一个比较器函数。

如果使用函数指针作为模板参数，则可以将比较器函数作为一个参数传入，从而实现更加灵活的代码设计和实现。

二、函数指针作为模板参数的实现方法在C++中，函数指针可以使用typedef关键字来定义，例如：typedef int (*CompareFunc)(const T&, const T&);上面的语句定义了一个函数指针类型CompareFunc，其返回值为int，参数类型为T&。

在模板中使用函数指针作为参数时，可以将其作为一个模板参数传入，例如：template<class T, class CompareFunc>class MyList{private:T* data;int size;public:void sort(CompareFunc cmpFunc);};上面的代码定义了一个模板类MyList，其中第二个模板参数为CompareFunc，即比较器函数的类型。

在sort函数中，可以使用这个比较器函数来对MyList中的数据进行排序操作。

也可以将函数指针包装为一个函数对象，以便在模板中进行更加灵活的使用。

例如：class IntCompare{public:int operator()(const int &a, const int &b) const{return a > b;}};上面的代码定义了一个函数对象IntCompare，实现了一个比较两个整型数大小的操作。