第7讲 返回指针值的函数-指针数组-指向指针的指针

指针函数和指针形参详解
指针函数（pointer function）是一个返回指针的函数，它的返
回值是一个指向特定类型数据的指针。

这意味着指针函数返回的是一
个地址，可以用于访问指定类型的数据。

指针函数的定义形式类似于普通函数的定义，只不过返回类型是
指针类型。

例如，如果要定义一个指针函数来返回整数数组的首地址，可以使用如下的语法：
```c
int* function_name(parameters){
// 函数体
return pointer_to_array;
}
```
在函数体内部，可以通过运算或者其他方式获得一个指向指定类型数
据的指针，并将它返回。

指针形参（pointer parameter）是一个函数参数，其类型为指针。

指针形参允许函数访问和修改指针所指向的数据。

指针形参的定义形式与其他形参类似，只不过类型是指针类型。

例如，如果要将一个整型指针作为参数传递给函数，可以使用如下的
语法：
```c
void function_name(int* pointer_name){
// 函数体
// 通过指针访问或修改数据
}
```
在函数体内部，可以通过指针形参访问或修改指针指向的数据。

可以使用*操作符来获取指针所指向的值，使用赋值运算符来修改指针所指向的值。

指针函数和指针形参在C语言中可以用于处理复杂数据结构、动态内存分配等问题。

它们可以提供灵活的数据访问和操作方式，让程序员能够更加高效地处理数据。

函数指针的用法函数指针是一种指向函数的指针变量，它可以用来间接调用函数。

在C语言中，函数指针通常用于回调函数、动态函数调用等领域。

以下是函数指针的用法：1. 声明函数指针函数指针的声明格式为：返回类型 (*指针变量名)(参数类型列表)。

例如，int (*p)(int, int) 表示 p 是一个指向返回类型为 int，参数类型为 int, int 的函数指针。

2. 定义函数指针定义函数指针时，需要将其指向具体的函数。

例如：int add(int a, int b) {return a + b;}int (*p)(int, int) = add;上述代码定义了一个指针变量 p，它指向函数 add。

这样，我们就可以通过 p 间接调用 add 函数，例如 p(1, 2)。

3. 函数指针作为参数函数指针还可以作为函数的参数。

这种用法通常用于回调函数。

例如：void forEach(int* arr, int length, int (*callback)(int)) {for (int i = 0; i < length; i++) {arr[i] = callback(arr[i]);}}上述代码定义了一个函数 forEach，它接受一个 int 类型的数组和一个函数指针 callback，用于对数组中的每个元素进行操作。

其中，callback 函数的返回值是 int。

这样，我们就可以通过forEach 函数调用不同的 callback 函数，实现不同的操作。

4. 函数指针数组函数指针还可以放在数组中，形成函数指针数组。

例如：int add(int a, int b) {return a + b;}int sub(int a, int b) {return a - b;}int (*funcs[2])(int, int) = {add, sub};上述代码定义了一个名为 funcs 的函数指针数组，它包含两个元素，分别指向 add 函数和 sub 函数。

指针函数的定义及用法指针函数是C语言中非常重要的概念之一、了解指针函数的定义及使用方法，对于理解C语言的高级特性和编程技巧非常有帮助。

本文将详细介绍指针函数的概念、定义、使用方法及示例。

一、指针函数的概念：指针函数是指返回值类型为指针类型（即地址类型）的函数。

它可以在函数内部动态地分配内存空间，并通过返回指针来传递该内存空间的地址。

与普通函数不同的是，指针函数的返回值是一个地址，而不是一个具体的数值或变量。

二、指针函数的定义：指针函数可以被定义为任何类型的数据的指针。

例如，int *func(表示一个返回整型指针的函数。

在函数内部，我们可以使用malloc函数来动态分配内存，并将结果指针返回给调用者。

三、指针函数的使用方法：1.定义指针函数：首先需要确定指针函数要返回的数据类型，然后在函数声明中使用*符号来表示返回一个指针。

例如，int *func(表示返回一个整型指针的函数。

2. 在函数内部创建动态内存空间：使用malloc函数来为指针函数分配内存，确保返回的指针指向有效的内存空间。

例如，int *p = (int *)malloc(sizeof(int))可以创建一个整型指针p，并分配一个整型变量的内存空间。

3.返回指针：将创建的内存空间的指针返回给调用者。

例如，return p;表示将指针p返回给调用者。

4.使用指针函数：调用指针函数的方式与普通函数相同。

例如，int *ptr = func(表示调用func函数，并将返回的指针赋值给指针变量ptr。

四、指针函数的示例：下面是一个简单的示例，演示了如何使用指针函数。

```#include <stdio.h>#include <stdlib.h>int *createArray(int size)int *arr = (int *)malloc(sizeof(int) * size); // 动态分配内存int i;for (i = 0; i < size; i++)arr[i] = i; // 初始化数组元素}return arr; // 返回数组首地址void printArray(int *arr, int size)int i;for (i = 0; i < size; i++)printf("%d ", arr[i]); // 打印数组元素}int maiint *arr = createArray(5); // 调用指针函数创建数组printArray(arr, 5); // 打印数组free(arr); // 释放内存return 0;```在上面的示例中，createArray函数动态分配了一个包含5个整型元素的数组，并返回数组的首地址。

函数指针和指针函数用法和区别函数指针和指针函数（pointerfunction）是C语言编程中常用的技术，在一些高级编程技术（例如设计模式）中也有广泛的应用。

它们的概念比较复杂，有时候会让初学者有点晕头，但是一旦理解了它们的用法和区别，大家就会发现它们对于结构化编程的设计有着重要的意义。

本文尝试以最简单的方式阐述函数指针和指针函数的用法和区别。

首先，在我们讨论函数指针和指针函数之前，我们最好以一个函数为例来介绍它们：void foo (int a, int b){int c = a + b;printf(%dc);}foo函数接收两个整数参数a和b，并将它们相加后输出结果。

接下来我们来看看函数指针是什么：函数指针（function pointer）是一种指向函数的指针，它可以把函数的地址保存在指针变量中，这样你就可以通过指针调用函数。

句话说，它实际上指向一个函数，通过调用它，你可以调用函数。

函数指针的声明可以形式如下：void (*fooPtr)(int, int);其中，fooPtr是函数指针变量，函数指针变量fooPtr可以指向函数foo()。

函数指针可以赋值，例如：fooPtr=foo;此外，你可以使用函数指针调用函数，例如：(*fooPtr)(1,2);这里，可以说fooPtr指向函数foo(),并且调用函数foo()。

现在，让我们来看看指针函数是什么：指针函数（pointer function）是一种特殊的函数，其返回值类型是指针，即它是一种不接受参数并返回指针的函数。

指针函数的声明可以形式如下：int *fooPtr(void);其中，fooPtr()是指针函数，它返回一个int类型的指针。

指针函数可以调用，例如：int *p = fooPtr();这里，fooPtr()调用了指针函数，并将返回的指针赋值给*p。

了解了函数指针和指针函数的基本概念及其用法后，那么函数指针和指针函数有什么区别？函数指针和指针函数的主要区别在于，函数指针可以指向任何函数，而指针函数必须返回指针类型的变量，并且不接受任何参数。

c语言函数返回指针数组C语言是一种非常强大和灵活的编程语言，它提供了多种数据类型和函数操作，以便开发人员能够实现各种复杂的任务。

在C语言中，函数可以返回各种类型的数据，包括指针，这使得我们能够使用返回的指针进行更多的操作和处理。

函数返回指针数组是C语言中一个非常有用的概念。

通过返回指针数组，我们可以动态地分配内存并返回一个指向该数组的指针，从而使得数据的操作更加灵活。

下面我们将深入探讨函数返回指针数组的用法和指导意义。

首先，函数返回指针数组可以用于返回多个值。

在一些情况下，我们需要在函数中计算多个值并将其返回给调用者。

使用指针数组可以很方便地解决这个问题。

通过定义一个指针数组，我们可以在函数中为每个返回值分配内存，并将其保存在数组中，然后返回指向数组的指针。

这样，调用者就可以通过解引用该指针来获得函数返回的多个值。

其次，函数返回指针数组还可以用于动态内存分配。

在某些情况下，我们不知道需要分配多少内存来存储数据。

通过返回指针数组，我们可以在运行时动态地分配所需的内存，并通过指针数组将其返回。

这使得程序的内存管理更加高效和灵活。

另外，函数返回指针数组还能提供更好的代码重用性和模块化。

通过将一些通用的功能封装在函数中，并返回指针数组，我们可以将这个函数作为一个模块在多个程序中进行复用。

这样，我们可以减少代码的重复编写，并提高代码的可维护性和可扩展性。

在实际应用中，函数返回指针数组的使用有很多场景。

比如在图像处理中，我们可以编写一个函数来读取图像文件，并返回一个指针数组，其中每个指针指向一幅图像的像素数据。

通过这个函数，我们可以在程序中只调用一次，并将返回的指针数组传递给其他函数进行图像处理操作，这样可以节省内存和提高运行效率。

此外，函数返回指针数组还可以用于处理多个文本字符串。

通过定义一个指针数组，我们可以在函数中为每个字符串分配内存，并将其保存在数组中。

这样，在程序中我们可以通过解引用指针数组来获取每个字符串，并进行进一步的处理，比如字符串拼接、比较和排序等。

定义函数指针数组函数指针数组是一个包含函数指针的数组，每个元素都指向一个特定类型的函数。

在C语言中，函数指针可以用来实现回调函数、动态函数调用和函数指针表等功能。

函数指针数组的定义格式如下：```返回值类型 (*函数指针数组名[数组长度])(参数列表);```其中，返回值类型是函数指针指向的函数的返回值类型，函数指针数组名是数组的名称，数组长度是函数指针数组中元素的个数，参数列表是函数指针指向的函数的参数列表。

函数指针数组的元素可以指向不同类型的函数，但是它们的返回值类型和参数列表必须与函数指针数组的定义一致。

函数指针数组的使用方法如下：1. 定义函数指针数组```cint (*funcPtrArray[3])(int, int);```2. 将函数指针赋值给函数指针数组的元素```cfuncPtrArray[0] = add;funcPtrArray[1] = subtract;funcPtrArray[2] = multiply;```3. 通过函数指针数组调用函数```cint result1 = funcPtrArray[0](5, 3);int result2 = funcPtrArray[1](5, 3);int result3 = funcPtrArray[2](5, 3);```函数指针数组可以用于实现回调函数。

回调函数是一种通过函数指针传递给其他函数的函数，它在其他函数内部被调用，以完成特定的任务。

通过函数指针数组，我们可以将多个不同的回调函数传递给同一个函数，以实现不同的功能。

函数指针数组还可以用于实现动态函数调用。

动态函数调用是指在程序运行过程中根据不同的条件选择调用不同的函数。

通过函数指针数组，我们可以根据条件选择不同的函数指针，并通过该函数指针调用相应的函数。

函数指针数组还可以用于实现函数指针表。

函数指针表是一个包含多个函数指针的数据结构，它可以按照特定的顺序存储函数指针，并通过索引值来访问相应的函数指针。

指针函数的使用方法
指针函数是指返回值为指针的函数。

它们通常用于动态分配内存、返回数组或结构等复杂对象。

以下是指针函数的使用方法：
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
需要注意的是，在使用指针函数时，应确保返回的指针不会在其所指对象被销毁后继续被使用。

可以通过适当释放内存或通过其他方式来确保这一点。

理解C语⾔（⼀）数组、函数与指针1 指针⼀般地，计算机内存的每个位置都由⼀个地址标识，在C语⾔中我们⽤指针表⽰内存地址。

指针变量的值实际上就是内存地址，⽽指针变量所指向的内容则是该内存地址存储的内容，这是通过解引⽤指针获得。

声明⼀个指针变量并不会⾃动分配任何内存。

在对指针进⾏间接访问前，指针必须初始化: 要么指向它现有的内存，要么给它分配动态内存。

对未初始化的指针变量执⾏解引⽤操作是⾮法的，⽽且这种错误常常难以检测，其结果往往是⼀个不相关的值被修改，并且这种错误很难调试，因⽽我们需要明确强调: 未初始化的指针是⽆效的，直到该指针赋值后，才可使⽤它。

　int *a;*a=12; //只是声明了变量a,但从未对它初始化，因⽽我们没办法预测值12将存储在什么地⽅int *d=0; //这是可以的，0可以视作为零值int b=12;int *c=&b;另外C标准定义了NULL指针，它作为⼀个特殊的指针常量，表⽰不指向任何位置，因⽽对⼀个NULL指针进⾏解引⽤操作同样也是⾮法的。

因⽽在对指针进⾏解引⽤操作的所有情形前，如常规赋值、指针作为函数的参数，⾸先必须检查指针的合法性- ⾮NULL指针。

解引⽤NULL指针操作的后果因编译器⽽异，两个常见的后果分别是返回置0的值及终⽌程序。

总结下来，不论你的机器对解引⽤NULL指针这种⾏为作何反应，对所有的指针变量进⾏显式的初始化是种好做法。

如果知道指针被初始化为什么地址，就该把它初始化为该地址，否则初始化为NULL在所有指针解引⽤操作前都要对其进⾏合法性检查，判断是否为NULL指针，这是⼀种良好安全的编程风格1.1 指针运算基础在指针值上可以进⾏有限的算术运算和关系运算。

合法的运算具体包括以下⼏种: 指针与整数的加减(包括指针的⾃增和⾃减)、同类型指针间的⽐较、同类型的指针相减。

例如⼀个指针加上或减去⼀个整型值，⽐较两指针是否相等或不相等，但是这两种运算只有作⽤于同⼀个数组中才可以预测。

c返回数组的函数C语言是一种非常流行的编程语言，它被广泛应用于各种领域，包括嵌入式系统、操作系统、网络编程等。

在C语言中，数组是一种非常重要的数据结构，它可以用来存储一组相同类型的数据。

在本文中，我们将讨论如何使用C语言返回数组的函数。

在C语言中，函数是一种非常重要的概念。

函数可以用来封装一段代码，使其可以被多次调用。

在C语言中，函数可以返回各种类型的值，包括整数、浮点数、字符等。

但是，如果我们想要返回一个数组，该怎么办呢？在C语言中，返回数组的函数可以使用两种方式：指针和数组。

下面我们将分别介绍这两种方式。

使用指针返回数组在C语言中，指针是一种非常重要的概念。

指针可以用来存储变量的地址，使得我们可以通过指针来访问变量。

在使用指针返回数组时，我们可以定义一个指向数组的指针，并将其作为函数的返回值。

下面是一个使用指针返回数组的例子：```c#include <stdio.h>int* getArray() {static int arr[5] = {1, 2, 3, 4, 5};return arr;}int main() {int* arr = getArray();for (int i = 0; i < 5; i++) {printf("%d ", arr[i]);}return 0;}```在上面的例子中，我们定义了一个名为getArray的函数，该函数返回一个指向静态数组的指针。

在主函数中，我们调用getArray函数，并将其返回值赋值给一个指针变量arr。

然后，我们使用for循环遍历数组，并打印每个元素的值。

使用数组返回数组除了使用指针返回数组外，我们还可以使用数组来返回数组。

在C 语言中，数组可以作为函数的参数和返回值。

当我们使用数组作为函数的返回值时，我们需要在函数定义中指定数组的类型和大小。

下面是一个使用数组返回数组的例子：```c#include <stdio.h>int* getArray() {static int arr[5] = {1, 2, 3, 4, 5};return arr;}int main() {int arr[5];arr = getArray();for (int i = 0; i < 5; i++) {printf("%d ", arr[i]);}return 0;}```在上面的例子中，我们定义了一个名为getArray的函数，该函数返回一个静态数组。

数组指针的定义数组指针是一种特殊的指针类型，它可以指向数组的首地址。

在程序设计中，数组指针常常被用于处理数组的操作。

本文将从数组指针的定义、用途、操作等方面进行阐述，以帮助读者更好地理解和应用数组指针。

一、数组指针的定义数组指针是指向数组的指针变量，它可以存储数组的首地址。

在C 语言中，数组名就是一个指向数组首元素的指针，因此可以将数组名赋值给指针变量，这样指针变量就指向了数组的首地址。

例如，int arr[5]; int *p = arr; 这里，p就是一个指向arr数组的指针变量。

二、数组指针的用途数组指针在程序设计中有着广泛的应用，它可以用来实现数组的传递、访问和操作。

首先，数组指针可以作为函数参数，在函数中通过指针对数组进行修改，实现数组的传递和操作。

其次，数组指针还可以通过指针运算来访问数组的元素，例如通过*(p+i)的方式来访问数组的第i个元素。

此外，数组指针还可以用于动态内存分配和多维数组的处理等方面。

三、数组指针的操作使用数组指针时，可以通过指针运算来遍历数组的元素。

例如，可以使用指针变量p来遍历数组arr的所有元素，通过不断递增指针的值来访问数组的每个元素。

同时，可以使用指针变量p来修改数组的元素值，通过*p = value的方式来改变数组的元素值。

此外，还可以通过指针的比较来判断数组的边界，避免越界访问。

四、数组指针的注意事项在使用数组指针时，需要注意一些细节。

首先，数组指针的类型必须与指向的数组类型一致，否则会导致类型不匹配的错误。

其次，需要注意数组指针的初始化和赋值，确保指针变量指向有效的数组地址。

此外，还需要注意指针的引用和解引用的方式，以及指针的空指针判断和释放等问题。

五、总结数组指针是一种重要的指针类型，它可以用于实现数组的传递、访问和操作。

通过数组指针，我们可以方便地对数组进行遍历、修改和处理。

在程序设计中，熟练掌握数组指针的使用方法对于提高代码的效率和可读性非常重要。

函数指针类型定义函数指针是指向函数的指针变量，它可以指向具体的函数实现，并且可以作为参数传递给其他函数。

函数指针类型定义是指定函数指针类型的格式化规则，使用函数指针类型可以减少代码重复、提高程序可读性和可维护性。

在C语言中，函数指针类型定义的定义形式为：返回值类型 (*函数指针变量名)(参数列表)。

其中，返回值类型是指函数返回值的类型，函数指针变量名是该函数指针变量的名称，参数列表是指函数的参数类型和个数。

函数指针类型定义的作用非常广泛，最常见的应用是在回调函数中使用。

回调函数是指程序在某个事件发生时自动调用的函数，它可以用函数指针类型定义来指定回调函数的格式和参数。

例如，注册键盘事件函数时，可以使用函数指针类型定义将键盘事件处理函数注册到回调函数中，当键盘事件发生时，回调函数会自动调用相应的键盘事件处理函数。

另外，函数指针类型定义还可以用来实现函数指针数组。

函数指针数组是一个数组，每个元素都是一个函数指针，可以执行不同的函数实现。

例如，在编写图像处理程序时，可以定义一个函数指针类型定义，将图像处理函数注册到函数指针数组中，然后通过数组索引调用相应的图像处理函数，实现多种图像处理效果。

在使用函数指针类型定义时，需要特别注意指针变量的类型和参数类型的匹配。

如果类型不匹配，程序运行时会出现未定义的行为，导致程序崩溃或产生无法预测的结果。

因此，在定义函数指针类型时，建议使用typedef关键字，将函数指针类型定义为一个新的类型名称，以便于后续使用，并避免类型匹配错误。

总之，函数指针类型定义是一个重要的概念，它可以提高代码的可读性和可维护性，使代码更加模块化和可复用。

掌握函数指针类型定义的使用技巧，可以让程序员更加高效地编写程序，实现更多复杂的功能。

函数返回值为指针函数是编程中非常常见的一个概念，它可以将一系列的操作封装起来，以便在需要的时候调用。

函数可以有参数和返回值，而本文的重点是函数返回值为指针。

指针是一种特殊的数据类型，它存储的是一个变量的内存地址。

通过指针，我们可以间接地访问和修改该地址对应的变量的值。

函数返回值为指针意味着函数的返回值是一个指针类型的变量。

为什么需要函数返回值为指针呢？这是因为有些时候我们需要在函数内部创建一些动态分配的内存空间，并在函数外部使用这些内存空间。

如果不使用指针来返回函数内部创建的内存空间的地址，那么在函数返回后这些内存空间就会被释放，无法再被外部使用。

使用函数返回值为指针的函数的一个常见例子是动态数组的创建。

动态数组是指在程序运行时根据需要动态地创建的数组，它的大小可以在运行时确定。

在C语言中，我们可以使用指针来实现动态数组。

函数返回一个指针，指向动态分配的内存空间，这个内存空间可以用来存储数组的元素。

下面是一个简单的例子，演示了如何使用函数返回值为指针来创建动态数组：```c#include <stdio.h>#include <stdlib.h>int* createDynamicArray(int size) {int* arr = (int*)malloc(size * sizeof(int)); return arr;}int main() {int size = 5;int* arr = createDynamicArray(size);for (int i = 0; i < size; i++) {arr[i] = i;}for (int i = 0; i < size; i++) {printf("%d ", arr[i]);}free(arr);return 0;}```在上面的例子中，函数`createDynamicArray`接受一个参数`size`，表示动态数组的大小。

c语言函数指针数组在C语言中，函数指针数组是指一个数组中存放多个函数指针的集合。

通过函数指针数组，我们可以在程序运行过程中动态地选择不同的函数进行调用。

函数指针数组的定义格式如下：```返回类型(*函数指针数组名[大小])(参数列表);```其中，返回类型是指函数返回值的类型，函数指针数组名是数组的名称，大小表示函数指针数组中元素的数量，参数列表表示函数的参数类型。

下面我们通过一个示例来说明函数指针数组的用法。

假设我们有一个需求，需要根据用户输入的命令来执行对应的函数。

我们可以先定义一个包含不同函数指针的函数指针数组，然后根据用户输入的命令在数组中查找对应的函数指针，最后调用该函数指针。

首先，我们定义几个需要执行的函数：```cint add(int a, int b)return a + b;int subtract(int a, int b)return a - b;int multiply(int a, int b)return a * b;int divide(int a, int b)return a / b;```然后，我们定义一个函数指针数组，将上述函数指针存入数组中：```cint (*operation[4])(int, int) = {add, subtract, multiply, divide};```接下来，我们编写一个函数来根据用户输入的命令执行相应的函数：```cvoid executeOperation(int operationIndex, int a, int b)if (operationIndex >= 0 && operationIndex < 4)int result = operation[operationIndex](a, b);printf("Result: %d\n", result);} elseprintf("Invalid operation index\n");}```最后，在主函数中获取用户输入的命令，并根据命令调用对应的函数：```cint maiint operationIndex, a, b;printf("Enter operation index (0 for add, 1 for subtract, 2 for multiply, 3 for divide): ");scanf("%d", &operationIndex);printf("Enter two numbers: ");scanf("%d %d", &a, &b);executeOperation(operationIndex, a, b);return 0;```通过以上代码，我们可以根据用户输入的命令选择对应的函数进行调用，并返回相应的结果。

一、指针数组及指向一维数组的指针（数组指针）讲解1、数组指针（也称行指针）定义 int (*p)[n];()优先级高，首先说明p是一个指针，指向一个整型的一维数组，这个一维数组的长度是n，也可以说是p的步长。

也就是说执行p+1时，p要跨过n个整型数据的长度。

如要将二维数组赋给一指针，应这样赋值：int a[3][4];int (*p)[4];//该语句是定义一个数组指针，指向含4个元素的一维数组。

p=a;//将该二维数组的首地址赋给p，也就是a[0]或&a[0][0] p++;//该语句执行过后，也就是p=p+1;p跨过行a[0][]指向了行a[1][]所以数组指针也称指向一维数组的指针，亦称行指针。

2、指针数组定义 int *p[n];[]优先级高，先与p结合成为一个数组，再由int *说明这是一个整型指针数组，它有n个指针类型的数组元素。

这样赋值是错误的：p=a；只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。

但可以这样 *p=a; 这里*p表示指针数组第一个元素的值，a的首地址的值。

如要将二维数组赋给一指针数组:int *p[3];int a[3][4];for(i=0;i<3;i++)p[i]=a[i];这里int *p[3] 表示一个一维数组内存放着三个指针变量，分别是p[0]、p[1]、p[2]所以要分别赋值。

这样两者的区别就豁然开朗了，数组指针只是一个指针变量，似乎是C语言里专门用来指向二维数组的，它占有内存中一个指针的存储空间。

指针数组是多个指针变量，以数组形式存在内存当中，占有多个指针的存储空间。

还需要说明的一点就是，同时用来指向二维数组时，其引用和用数组名引用都是一样的。

比如要表示数组中i行j列一个元素：*(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]优先级：()>[]>*例1、下列给定程序中，函数fun()的功能是：从N个字符串中找出最长的那个串，并将其地址作为函数值返回。

C语言指针函数和函数指针详解C语言指针函数和函数指针详解往往，我们一提到指针函数和函数指针的时候，就有很多人弄不懂。

以下是店铺为大家带来的C语言指针函数和函数指针详解，希望能帮助到大家！一、指针函数当一个函数声明其返回值为一个指针时，实际上就是返回一个地址给调用函数，以用于需要指针或地址的表达式中。

格式：类型说明符 * 函数名(参数)当然了，由于返回的是一个地址，所以类型说明符一般都是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) ");scanf("%d%d",&wk,&dy);}while(wk<1||wk>5||dy<1||dy>7);printf("%d ",*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];}程序应该是很好理解的，子函数返回的是数组某元素的地址。

输出的是这个地址里的值。

二、函数指针指向函数的指针包含了函数的地址，可以通过它来调用函数。

声明格式如下：类型说明符 (*函数名)(参数)其实这里不能称为函数名，应该叫做指针的变量名。

这个特殊的指针指向一个返回整型值的函数。

指针的声明笔削和它指向函数的声明保持一致。

函数指针作为返回值在C语言中，函数指针是一种非常强大且常用的概念。

它允许我们将函数作为参数传递给其他函数，但你可能不知道的是，函数指针也可以作为函数的返回值。

本文将介绍函数指针作为返回值的用法和优势。

一、函数指针简介函数指针是指向函数的指针变量，它可以用于存储函数的地址。

通过函数指针，我们可以以变量的形式调用函数，这在某些场景下非常有用。

二、函数指针作为返回值在C语言中，函数可以返回各种类型的值，如整数、浮点数、结构体等。

但你可能不知道，函数还可以返回函数指针。

1. 返回具体函数的指针可以将函数指针作为返回值的函数称为高阶函数。

它们可以根据不同的条件返回不同的函数指针，实现动态选择函数的功能。

示例代码：```c#include <stdio.h>int add(int a, int b) {return a + b;}int sub(int a, int b) {return a - b;}int (*getCalculator(char op))(int, int) { if (op == '+') {return add;} else if (op == '-') {return sub;} else {return NULL;}}int main() {int a = 10;int b = 5;char operator = '+';int (*calculator)(int, int) = getCalculator(operator);if (calculator != NULL) {int result = calculator(a, b);printf("Result: %d\n", result);} else {printf("Invalid operator\n");}return 0;}```上述代码中，getCalculator函数根据传入的操作符返回对应的函数指针，然后在main函数中通过函数指针调用具体函数。

举例说明返回指针的函数返回指针的函数是指函数返回一个指向某个数据类型的指针。

通过返回指针，可以将函数内部的计算结果传递给调用函数，实现数据的共享和传递。

下面将列举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;}。

返回结构体指针类型的函数返回结构体指针类型的函数是一种常见的函数类型，它可以返回一个指向结构体的指针，这个指针可以用来访问结构体中的成员变量。

在C语言中，结构体是一种自定义的数据类型，它可以包含多个不同类型的成员变量，这些成员变量可以被访问和修改。

通过返回结构体指针类型的函数，我们可以方便地访问和修改结构体中的成员变量，从而实现更加灵活的编程。

在C语言中，结构体指针类型的函数通常有以下几种用途：1. 创建结构体对象通过返回结构体指针类型的函数，我们可以方便地创建一个新的结构体对象。

例如，我们可以定义一个名为“create_student”的函数，它返回一个指向“student”结构体的指针。

在这个函数中，我们可以使用“malloc”函数动态分配内存，然后将结构体指针返回给调用者。

这样，调用者就可以使用这个指针来访问和修改结构体中的成员变量。

2. 访问结构体成员变量通过返回结构体指针类型的函数，我们可以方便地访问结构体中的成员变量。

例如，我们可以定义一个名为“get_student_name”的函数，它接受一个指向“student”结构体的指针作为参数，并返回一个指向结构体中“name”成员变量的指针。

在这个函数中，我们可以使用“->”运算符来访问结构体中的成员变量，然后将指向成员变量的指针返回给调用者。

这样，调用者就可以使用这个指针来访问和修改成员变量。

3. 修改结构体成员变量通过返回结构体指针类型的函数，我们可以方便地修改结构体中的成员变量。

例如，我们可以定义一个名为“set_student_name”的函数，它接受一个指向“student”结构体的指针和一个字符串作为参数，并将字符串赋值给结构体中的“name”成员变量。

在这个函数中，我们可以使用“->”运算符来访问结构体中的成员变量，然后将字符串赋值给成员变量。

这样，调用者就可以使用这个函数来修改结构体中的成员变量。

返回结构体指针类型的函数是一种非常有用的函数类型，它可以方便地访问和修改结构体中的成员变量，从而实现更加灵活的编程。