目录

• 1.指针概念回顾
• 2.字符指针
• 3.数组指针和指针数组
• 3.1数组指针的含义
• 3.2&数组名vs数组名
• 3.3数组指针
• 4.数组传参和指针传参
• 4.1一维数组传参
• 4.2二维数组传参
• 4.3一级指针传参
• 4.4二级指针传参
• 5.函数指针
• 6.函数指针数组
• 7.指向函数指针数组的指针
• 8.回调函数
• 总结

1.指针概念回顾

指针的基本概念：

指针是一个变量，用来存放地址，地址唯一标识一块内存空间。指针的大小是固定的4/8个字节（32位平台/64位平台）。指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限。不能对没有初始化的指针或者是空指针进行间接访问

2.字符指针

指针类型为 char* 的指针就是字符指针

字符指针指向的对象的类型为字符型

一般使用方法：

    char ch = 'a';
	char* p = &ch; //取ch的地址放到指针变量p中

另外一种常见使用方法：

char* p2 = "bcdef"; 

对于第二种使用方法我们需要注意的是

p2实际存放的只是字符串首字符的地址，即p2存放的是字符b的地址。

我们来看一道经典的面试题：

#include <stdio.h>
int main()
{
	char str1[] = "hello yang.";
	char str2[] = "hello yang.";
	char* str3 = "hello yang.";
	char* str4 = "hello yang.";
	if (str1 == str2)
		printf("str1 and str2 are same\n");
	else
		printf("str1 and str2 are not same\n");

	if (str3 == str4)
		printf("str3 and str4 are same\n");
	else
		printf("str3 and str4 are not same\n");
	return 0;
}

str3和str4指向的都是字符串H的地址

当指针指向同一个字符串的时候，它们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块。

因此它的答案为

3.数组指针和指针数组

指针数组是一个存放指针的数组

例如

int* arr1[10]; //整形指针的数组
char *arr2[4]; //一级字符指针的数组
char **arr3[5]; //二级字符指针的数组

3.1数组指针的含义

数组指针是指针？还是数组？

答案是：指针。

int *p1[10];
int (*p2)[10];
//p1, p2分别是什么？

这里就不得不谈论到优先级了，优先级从大到小的顺序为： “（ ）” > “[ ]” > “ * ”

首先看int *p1[10]; , 由于[ ]的优先级大于*，因此p1先与“[” 结合，故而p1首先它是一个数组，它是一个存放了10个指针变量的数组。

再来看int (*p2)[10];, 由于（）的优先级大于 [ ], 先看（）里的，p2与 * 结合，故而篇是一个指针，它指向了一个存放了10个整型的数组

3.2&数组名vs数组名

对于下面这个代码

#include <stdio.h>
int main()
{
    int arr[5] = {0};
    printf("%p\n", arr);
    printf("%p\n", &arr);
    return 0;
}

arr 和 &arr 有什么区别呢？

其运行结果如下：

如果你认为它们代表的含义是正确的，不妨试着运行下面这个代码

#include <stdio.h>
int main()
{
	int arr[5] = { 0 };
	printf("arr = %p\n", arr);
	printf("&arr= %p\n", &arr);
	printf("arr+1 = %p\n", arr + 1);
	printf("&arr+1= %p\n", &arr + 1);
	return 0;
}

我的编译器下运行结果如下：

如果 arr 和 &arr 代表的含义一样，那么后面两个的结果应该也是一致的，但是却不一样。

实际上： &arr 表示的是整个数组的地址，而不是数组首元素的地址。

数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40

3.3数组指针

数组指针就是一个指向数组的指针，意味着，这个指针内存放的是数组的地址

#include <stdio.h>
int main()
{
    int arr[10] = {1,2,3,4,5,6,7,8,9,0};
    int (*p)[10] = &arr;//把数组arr的地址赋值给数组指针变量p
    return 0; 
}

我们来使用下指向一维数组的数组指针

//使用函数打印数组内的内容
# include <stdio.h>
void print_arr(int(*p)[10], int sz) //传过来的是数组的地址，用指针来接收
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", (*p)[i]); //先解引用找到数组
	}
}
int main(void)
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	int sz = sizeof(arr) / sizeof(arr[0]); //求出数组的元素个数
	print_arr(&arr, sz);
	return 0;
}

4.数组传参和指针传参

在写代码的过程中，为了更好地利用模块化的特点，我们会使用大量的函数。但是在将一个功能封装成函数的过程中，我们就不可避免的会传过去数组和指针，那么函数是如何接受的呢？

4.1一维数组传参

以下是常见的一维数组传参

#include <stdio.h>
void test(int arr[]) //直接用数组接收，空间大小可以省略
{}
void test(int arr[10]) //直接用数组接收，空间大小可以指明
{}
void test(int *arr) //接收数组首元素的地址
{}
void test2(int *arr[20]) //直接用数组接收
{}
void test2(int **arr) //传过来一级指针的地址，使用二级指针接收
{}
int main()
{
 int arr[10] = {0};
 int *arr2[20] = {0}; //存放了20个int*的数组
 test(arr); //传过去的是首元素的地址
 test2(arr2);
}

4.2二维数组传参

当我们在谈论二维数组首元素的时候指的是第一行！
数组名是首元素的地址，在二维数组中指的是第一行的地址

void test(int arr[3][5])//直接用二维数组接收
{}
void test(int arr[][])//错误的接收！列不能省略
{}
void test(int arr[][5])//行是可以省略的，但是列一定不能省略
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int *arr)//错误接收！传过来的是第一行一维数组的地址
{}
void test(int* arr[5])//错误接收！这是一个存放int*类型的数组，而数组内的元素是int
{}

//由于二维数组的首元素是第一行，每一行是一个一维数组
//因此可以写成指向一维数组的指针
void test(int (*arr)[5])
{}
void test(int **arr) //错误！
{}
int main()
{
 int arr[3][5] = {0};
 test(arr);
}

4.3一级指针传参

#include <stdio.h>
void print(int *p, int sz) {
 int i = 0;
 for(i=0; i<sz; i++)
 {
 printf("%d\n", *(p+i));
 }
}
int main()
{
 int arr[10] = {1,2,3,4,5,6,7,8,9};
 int *p = arr;
 int sz = sizeof(arr)/sizeof(arr[0]);
 //一级指针p，传给函数
 print(p, sz);
 return 0; }

4.4二级指针传参

#include <stdio.h>
void test(int** ptr)
{
	printf("num = %d\n", **ptr);
}
int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	test(pp);
	test(&p);
	return 0;
}

5.函数指针

在之前的学习当中不会每天使用函数指针，但是请不要忘记它的存在。
什么是函数指针？顾名思义，函数指针就是指向一个函数的指针。既然函数指针是指针，那么它也具有指针的一些特性。比如：在对指针进行间接访问之前必须要先初始化

//代码一
int f(int);//f函数
int (*pf)(int) = &f;

这是函数初始化的一种方法。

//代码二
int f(int);
int (*pf)(int) = f;

代码一和代码二是等效的。我们用下面一个代码查看，发现其打印出来的地址是一样的。

在数组中，数组名是数组首元素的地址。而函数名则是函数的首地址。在函数名使用的时候我们所用的编译器会将函数名转化为一个函数指针，&操作符只是显示地说明了函数将隐式执行的任务。

如果你需要将函数的地址存储起来，这个时候你就可能会需要用到函数指针了

void test()
{
	printf("hehe\n");
}
//下面的哪一个语句有能力存放函数test的地址呢？
void (*pfun1)(); //语句1
void *pfun2(); //语句2

存储地址应该需要用到的是指针

语句1:

pfun1首先和 * 操作符结合，那么它是一个指针。后面有一个函数调用操作符，表明它是一个函数指针。它所指向的函数

返回值类型是void

语句2：

pfun2首先和（）结合，那么它是一个函数。 *和前面的void结合，表明这个函数的返回值类型是void*

所以选择语句1。

6.函数指针数组

我们知道数组是存储一组相同类型的数据，在此之前我们再来回顾一下指针数组

int *arr[10];
//数组的每个元素是int*

这是一个数组，数组存放了10个int*类型的数据。

按照这个思路，我们把很多函数的地址存放在数组中，那么它就是一个函数指针数组。

下面我们一起来实现它

首先它是一个数组 [ ], 存放的数据类型为函数指针，int (*)()类型的是函数指针

int (*parr1[10])();
int *parr2[10]();
int (*)() parr3[10];

7.指向函数指针数组的指针

经过我们上面这么多的推导，这个也就很容易就能表示出来

指向函数指针数组的指针是一个 指针， 指针指向一个 数组 ，数组的元素都是 函数指针

void test(const char* str)
{
 printf("%s\n", str);
}
int main()
{
 //函数指针pfun
 void (*pfun)(const char*) = test;
 //函数指针的数组pfunArr
 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;
 //指向函数指针数组pfunArr的指针ppfunArr
 void (*(*ppfunArr)[10])(const char*) = &pfunArr;
 return 0;
}

8.回调函数

回调函数：回调函数就是将一个函数的函数指针作为参数传递给另一个函数，而这个函数就是回调函数。

回调函数不是由该函数的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进行响应。

库函数中的qsort函数就是一个典型的回调函数

总结

本篇文章就到这里了，希望能够给你带来帮助，也希望您能够多多关注海外IDC网的更多内容！

【本文转自：韩国站群服务器 欢迎转载】