前言:我们在前面学过了指针的一些简单知识。
1、指针就是一个变量,用来存放地址,地址唯一表示一块内存空间。
2、指针的大小是固定的4/8个字节(32位平台/64位平台)
3、指针是有类型,指针的类型决定了指针的±整数的步长,指针解引用操作的时候的权限。
4、指针运算
(如若记不太清,请点击
对于了解字符指针,我们来看一个例子:
#include
int main()
{
char ch = 'w';
char* pc = &ch;//pc是指向一个字符变量的指针
char* p = "hello world";//"hello world"是一个常量字符串
//上面的表达式的作用是将:常量字符串"hello world"的第一个字符的地址赋值给p
printf("%c\n", *p);
printf("%s\n", p);
return 0;
}
在这段代码中,我们可以看到字符创建有两种方式:1、指向字符变量的指针。2、指向常量字符串的指针。但是我们需要注意的事,在面对指向常量字符串时,此时p指针指向的是第一个字符的地址,因此我们在打印整个字符串时,只需要给出地址即可,不需要解引用,因为*p是h,也就是第一个字符,并且p指向的内容是无法更改的,因为“hello world”是常量字符串,不能更改,类似*p=‘w’;这类代码无法实现。
关于数组指针,我们原来曾经简单的介绍过,我们来看这样一个例子:
#include
//指针数组
int main()
{
char* arr1[5];//arr1是存放字符指针的数组
int* arr2[4];//arr2是一个整型指针的数组
int a = 10;
int b = 20;
int c = 30;
int d = 40;
int* arr3[4] = { &a,&b,&c,&d };
int i = 0;
for (i = 0; i < 4; i++)
{
printf("%d ", *(arr3[i]));
}
return 0;
}
我们创建了4个整型变量,并且将每个变量的地址按顺序取出存放进数组,此时这数组的类型就是整型指针数组。当我们打印时,对数组内容进行解引用,再按顺序打印出来就可以了。
数组指针,顾名思义是指针,类型是数组类型的指针,那么我们如何定义一个数组指针呢?
#include
int main()
{
//int a = 10;
//int* pi = &a;
//char ch = 'w';
//char* pc = &ch;
int arr[10] = { 0 };
int* p = arr;
int (*parr)[10] = &arr;
return 0;
}
我们定义一个arr[10]的int型数组,我们知道arr数组名表示的数组首元素的地址,首元素是int类型,因此我们定义p指针时是int*类型,而数组名取地址是整个数组,因此要存放到数组指针中,也就是int(*parr)[10],此时可以将整个数组的地址存放入数组指针中去。
大家可能会问,这种数组指针的运用场景是什么?什么时候会用到呢?我们来看这样一个例子:
#include
void print2(int (*p)[5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
printf("%d ", (*(p+i)[j]);
}
printf("\n");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,2,3,4,5,6,3,4,5,6,7 };
print2(arr, 3, 5);
return 0;
}
当我们打印一个二维数组时,如何打印呢?我们可以看到,我们将数组名arr传入函数中去,函数的参数定义为一个数组指针,为什么需要这样呢?我们知道,数组名是首元素的地址,那么在二维数组中数组名是不是首元素地址呢?是的,不过需要变通一下,在二维数组中,我们可以将二维数组看成一个一维数组的数组,以例题为例,我们可以将数组arr看成是一个三个元素的一位数组,而三个元素中分别表示一个数组。而数组名就可以理解为第0行数组的地址,那么此时传参是一个数组的地址,在函数定义时,我们就需要定义一个数组指针,所以接下来打印的过程中对p进行解引用表示第0行,然后用j变量访问这一行中每个元素。这种写法感觉好难理解,是的,那么就没有简单的写法了吗?当然有!
void print2(int arr[3][5], int r, int c)
{
int i = 0;
for (i = 0; i < r; i++)
{
int j = 0;
for (j = 0; j < c; j++)
{
printf("%d ", arr[i][j]);
}
printf("\n");
}
}
我们将print2函数写成这种形式,直接将参数写成数组的形式,打印也是以数组的形式打印,我们发现也是可以实现的,而且更容易理解,所以对于数组指针,我们遇见的时候并不太多,但是也是需要了解学习的。
我们来看这样一组例子:
#include
void test(int arr[])
{
}
void test(int arr[10])
{
}
void test(int *p)
{
}
int main()
{
int arr[10] = {0};
test(arr);
return 0;
}
我们在创建一个一维数组arr时,将一维数组调用函数,我们可以两种方式传参。第一种,参数部分创建类似数组(并不是真的创建了数组,用于理解),这样是语法所允许的,当然可以不用给出数组大小;第二种,传参传过去的是数组首元素的地址,因此我们用指针进行接收,因此参数创建可以使用指针。我们再看指针数组的传参。
#include
void test2(int* *p)
{
}
void test2(int* arr[])
{
}
void test2(int *arr[10])
{
}
int main()
{
int* arr[10] = { 0 };
test2(arr);
return 0;
}
同理,指针数组的传参跟整型数组传参类似,唯一需要注意的是第二种传参方式,在第二种传参过程中,数组中元素类型是指针类型,因此,传参首元素地址是二级指针,因此我们需要创建二级指针来接收一级指针。
我们来看二维数组如何传参:
#include
void test(int arr[3][5])
{
}
void test(int arr[][5])
{
}
void test(int (*p)[5])
{
}
int main()
{
int arr[3][5] = { 0 };
test(arr);
return 0;
}
二维数组传参跟一维数组传参极其相似:同样是两种方式传参,但又需要注意的几点,第一种方式:在传参时,我们可以用数组接收,但是省略行和列时,需要要注意跟定义二维数组一样,是不能省略列的。第二种方法:用指针接收,我们需要注意的是二维数组的首元素不是第0行,第0列的元素。而是整个第0行,因此首元素的地址可以看作是一个一位数组的地址,因此我们需要创建数组指针接收,同时元素个数就是列数。
我们来看一级指针如何传参
#include
void print(int *ptr,int sz)
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(ptr + i));
}
}
int main()
{
int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
int* p = arr;
int sz = sizeof(arr) / sizeof(arr[0]);
print(p, sz);
return 0;
}
在这段代码中我们应用到了指针传参,我们可以看到,在一级指针传参的过程中,我们使用指针来接收的,当然我们也可以使用数组来接收,不过我们很少这样来进行传参,大家可以尝试一下。
二级指针传参:
#include
void test(int** ppa)
{
}
int main()
{
int a = 10;
int* pa = &a;
int** ppa = &pa;
test(ppa);
return 0;
}
我们可以看到二级指针传参,就可以用二级指针来接收,并不需要过多复杂的操作。
函数指针顾名思义,就是用来指向函数的指针,用来存放函数地址的。
#include
int Add(int x, int y)
{
return x + y;
}
int main()
{
printf("%p", &Add);
printf("%p", Add);
int (*pf)(int, int) = &Add;//pf用来存放函数的地址-pf就是函数指针变量
return 0;
}
在这段代码中,我们发现函数名Add和取地址函数&Add的效果是一样的,都是表示函数的地址,这一点是跟数组不一样的。我们如何定义一个函数指针来接收一个函数地址呢?其实跟数组指针类似,pf是指针名,先跟*结合,类型是函数,所以(int,int)分别表示int x和int y,返回类型是int,在最前面加上int。
那么,我们如何使用函数指针呢?
#include
int Add(int x, int y)
{
return x + y;
}
int main()
{
int (*pf)(int, int) = &Add;
//方法1
int ret = Add(2, 3);
printf("%d\n", ret);
//方法2
ret = (*pf)(4, 5);
printf("%d\n",ret);
return 0;
}
方法1,是我们经常使用的一种直接使用的方法,而方法2,也很好理解,pf是指向函数的指针,因此我们在解引用后直接就是函数,我们将参数传到函数就可以完成了。
函数指针数组,是用来存放函数指针的数组,类型也就是函数指针。我们来看例子:
#include
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
int Mul(int x, int y)
{
return x * y;
}
int Div(int x, int y)
{
return x / y;
}
int main()
{
int* arr[10];//整型指针数组
int(*pf1)(int, int) = &Add;
int(*pf2)(int, int) = ⋐
int(*pf3)(int, int) = &Mul;
int(*pf4)(int, int) = &Div;
int(*arr[4])(int, int) = { pf1,pf2,pf3,pf4 };
return 0;
}
我们定义了4个函数,分别是Add(),Sub(),Mul(),Div(),这四个函数的类型都是int 函数名(int,int),因此我们知道这四个函数指针的类型是int(*)(int,int)类型,那么函数指针数组的类型就是int(*\arr[4])(int, int),从而将函数指针存放进数组里。
在理解指向函数指针数组的指针时,我们需要逐步往上分析,首先我们先看简单的,正好将前面的复习一下:
1、数组指针:
#include
int main()
{
int arr[10];
int(*p)[10] = &arr;
return 0;
}
p指针指向的时arr数组,所以p叫做数组指针。
2、整型指针数组的指针
#include
int main()
{
int* arr[10];
int* (*p)[10] = &arr;
return 0;
}
创建一个整型指针数组arr[10],p指向这个数组,因此,p叫做指向整形指针数组的指针。
3、指向函数指针数组的指针
#include
int Add(int x,int y)
{
return x + y;
}
int main()
{
int (*p)(int, int) = &Add;
int(*parr[5])(int, int);
int(*(*pparr)[5])(int, int)=&parr;
return 0;
}
创建一个Add()函数,p指针指向函数Add(),所以p指针叫函数指针,parr[5]是一个数组,存放类型int(*)(int,int)指针的数组,所以parr[5],叫做函数指针数组,pparr是一个指针,指向parr的地址,所以叫做指向函数指针数组的指针。
回调函数就是一个通过函数指针调用的函数。如果你把函数的指针(地址)作为参数传递给另一个函数,当这个指针被用来调用其所指向的函数时,我们就说这是回调函数。回调函数不是由该函数的实现方直接调用,而是在特定的事件或条件发生时由另外的一方调用的,用于对该事件或条件进行响应。
举个例子:
#include
int Add(int x, int y)
{
return x + y;
}
int Sub(int x, int y)
{
return x - y;
}
void Calc(int (*pf)(int, int))
{
int ret = pf(3, 5);
printf("%d\n",ret);
}
int main()
{
Calc(Add);
Calc(Sub);
return 0;
}
在这段代码中,我们创建一个Calc()函数,我们将函数Add()和Sub()的地址传给了Calc()函数,在Calc()函数中,我们创建了函数指针,用函数指针来指向我们所需要调用的函数,所以我们说函数Calc()通过函数指针调用的函数,因此Calc()调用Add()函数时,就叫做Add()是Calc()函数的回调函数;同样的,如果函数调用Sub()函数,就叫做Sub()函数是Calc()函数的回调函数。
好了,关于指针进阶的知识涉及的还是比较深入的,我们在后面也会举一些例子和例题来更深入了解,希望这次的学习能够帮助到大家,如果有疑问或者错误,希望大家指出来,谢谢各位!