C语言笔记15

指针2

1.数组名的理解

int arr[ 10 ] = { 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 };

int *p = &arr[ 0 ];17391692786

arr是数组名，数组名是首元素地址，&arr[0]就是取出首元素的地址放在指针变量p中。

#include <stdio.h>
int main()
{int arr[2][10] = { 1,2,3,4,5,6,7,8,9,10 };//一行为10个元素，一共两行；//printf("&arr[0] = %p\n", &arr[0]);//printf("arr = %p\n", arr);printf("%p\n", &arr[0]);//arr[0]是第一行一维数组的数组名，&数组名，打印第一行数组的地址（十六进制）  printf("%p\n", arr[0]);//arr[0]是第一行的数组名，数组名是首元素的地址，打印第一行数组第一个元素的地址printf("%p\n", *arr);//arr是二维数组的数组名，*arr代表取出二维数组的首元素 这个二维数组由两个一维数组组成，即*arr代表arr[0],*arr==*(arr+0)==arr[0]printf("%d\n", *arr);//地址打印为十进制printf("==============\n");printf("%p\n", &arr[1]); //arr[1]是第二行一维数组的数组名，&数组名，打印第二行数组的地址printf("%p\n", arr[1]);//arr[1]是第二行的数组名，数组名是首元素的地址，打印第二行数组第一个元素的地址printf("%p\n", *(arr + 1));//arr是二维数组的数组名，arr + 1代表访问第二行元素，*(arr + 1)获取第二行元素数组的地址  *(arr + 1)==arr[1]printf("%d\n", *(arr + 1));//地址打印为十进制printf("==============\n");printf("%p\n", *(arr + 1)+1);//*(arr + 1)获取第二行元素数组的地址   *(arr + 1)+1获取第二行第二个元素的地址printf("%p\n", &arr[1][1]);//获取第二行第二个元素的地址printf("==============\n");printf("%d\n", sizeof(arr));//特例：sizeof(数组名）表示计算arr数组的大小（数组空间内存）printf("%d\n", sizeof(arr[0]));//特例：sizeof(数组名）表示计算arr数组的大小（数组空间内存） arr[0]是第一行一维数组的数组名printf("%d\n", sizeof(arr[1]));//特例：sizeof(数组名）表示计算arr数组的大小（数组空间内存） arr[1]是第二行一维数组的数组名printf("%p\n", &arr);//特例：&数字名  表示整个二位数组的地址printf("==============\n");printf("%p\n", &arr[0] + 1);//&arr[0]获取第一行数组的地址  &arr[0] + 1获取第二行数组的地址printf("%p\n", &arr + 1);//&arr获取二维数组的地址  &arr+ 1 跳过此二维数组到下一个地方（跳过20*4=80Byte）return 0;
}

其实数组名就是数组⾸元素(第⼀个元素)的地址是对的，但是有两个例外：

• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩，单位是字节

• &数组名，这⾥的数组名表⽰整个数组，取出的是整个数组的地址（整个数组的地址和数组⾸元素的地址是有区别的）

除此之外，任何地⽅使⽤数组名，数组名都表⽰⾸元素的地址。

2.一维数组传参的本质

#include < stdio.h>
void test(int arr[])
{int sz2 = sizeof(arr) / sizeof(arr[0]);printf("sz2 = %d\n", sz2);}
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };int sz1 = sizeof(arr) / sizeof(arr[0]);printf("sz1 = %d\n", sz1);test(arr);return 0;
}
//运行结果可以发现 sz1=10，sz2=1；

为什么这个函数的结果不对呢?

这就要搞清楚函数中传的参数是啥，也就是函数中传的参数是啥，从上方代码可test(arr);arr是一个一维数组，也是个数组名，刚从1.数组名的理解知道除了两个例外，任何地⽅使⽤数组名，数组名都表⽰⾸元素的地址。所以说传给函数test是数组的地址，那么sizeof（地址）=4或8（要看在32位系统还是64位系统），int sz2 = sizeof(arr) / sizeof(arr[0]);这个arr和arr[0]都是地址，所以sz2=1；

再看一个：

void test1(int arr[])//参数写成数组形式，本质上还是指针
{printf("%d\n", sizeof(arr));
}
void test2(int* arr)//参数写成指针形式
{printf("%d\n", sizeof(arr));//计算⼀个指针变量的⼤⼩}
int main()
{int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };test1(arr);test2(arr);return 0;
}
//运行结果可以发现 sizeof(arr)=4；说明一维数组传参传的就是地址

总结：

数组名是数组⾸元素的地址；那么在数组传参的时候，传递的是数组名，也就是说本质上：一维数组传参传递的是数组⾸元素的地址。⼀维数组传参，形参的部分可以写成数组的形式，也可以写成指针的形式。

3.二级指针

指针变量也是变量，是变量就有地址，那指针变量的地址存放在哪⾥？

这就是⼆级指针。

二级指针通俗来讲就是指针的指针，存放指针的指针。

其实三级指针就是存放⼆级指针地址的指针；依次往后推。

int main()
{int a = 100;int* pa = &a;int** pb = &pa;printf("a的地址是：%p\n", pa);printf("pa的地址是：%p", pb);return 0;
}

画个图描述一下

4.指针数组

先说下整形数组：存放整形的数组 int arr1[5] ={1,2,3,4,5} 5个int类型

字符数组：存放字符的数组char arr1[5]={'a','b','c','d','e'} 5个char类型那么指针数组就是存放指针的数组呗，那就有整形指针数组，字符指针数组等等； int* arr1[5]={指针1,指针2,指针3,指针4,指针5} 5个 int* 类型

指针数组的每个元素都是⽤来存放地址（指针）的，⼜可以指向⼀块区域。用以下代码说一下指针数组。

int main()
{int arr1[] = { 1,2,3,4,5 };int arr2[] = { 2,3,4,5,6 };int arr3[] = { 3,4,5,6,7 };//数组名是数组⾸元素的地址，类型是int*的，就可以存放在parr数组中int* parr[3] = { arr1, arr2, arr3 };int i = 0;int j = 0;for (i = 0; i < 3; i++){for (j = 0; j < 5; j++){printf("%d ", parr[i][j]);}printf("\n");}return 0;}

parr[i]是访问parr数组的元素，parr[i]找到的数组元素指向了整型⼀维数组，parr[i][j]就是整型⼀维数组中的元素。上述的代码模拟出⼆维数组的效果，实际上并⾮完全是⼆维数组，因为每⼀⾏并⾮是连续的。

5.数组指针

前面介绍过整形指针类型 int*，字符指针类型 char*，那么数组指针类型该如何表示呢

数组指针意思就是数组的指针，又叫做数组的地址。

整形数组指针：int (*arr)[5];

字符数组指针：char(*arr)[5];

解释：

p先和*结合，说明p是⼀个指针变量，然后指针指向的是⼀个⼤⼩为5个整型的数组。所以p是

⼀个指针，指向⼀个数组，叫数组指针。

这⾥要注意：[ ]的优先级要⾼于*号的，所以必须加上（）来保证p先和*结合

见以下代码所示：

#include <stdio.h>//整形数组指针
//int arr[10] = {0};
//&arr;//得到的就是数组的地址
//找个变量来接收找个数组地址 → int(*p)[10]=&arr
// int (*p) [10] = &arr;
// |     |    |
// |     |    |
// |     |    p指向数组的元素个数
// |     p是数组指针变量名
// p指向的数组的元素类型int main()
{int arr[5] = { 1, 2, 3, 4, 5 };  // 定义一个整形数组int(*p)[5];  // 定义一个指向包含5个整形元素的数组的指针p = &arr;  // 将指针指向数组//int(*p)[5]=&arr;// 通过指针访问数组中的元素for (int i = 0; i < 5; i++){//printf("arr[%d] = %d\n", i, (*p)[i]);printf("arr[%d] = %d\n", i, p[0][i]);}return 0;
}//字符数组指针
int main1() 
{char str[20] = "Hello, world!";  // 定义一个字符数组char(*p)[20];  // 定义一个指向包含20个字符的数组的指针p = &str;  // 将指针指向数组// 通过指针访问数组中的元素printf("String: %s\n", *p);//printf("String: %p\n", p);//printf("String: %p\n", *p);//printf("String: %p\n", p[0]);//printf("String: %c\n", **p);printf("String: %c\n", *p[0]);//**p== *p[0]return 0;
}

6.⼆维数组传参的本质

对于一维数组传参的本质传递的是数组⾸元素的地址，上面已经介绍过了，接下来说一下 ⼆维数组传参的本质。

⾸先我们再次理解⼀下⼆维数组，⼆维数组其实可以看做是每个元素是⼀维数组的数组，也就是⼆维数组的每个元素是⼀个⼀维数组。那么⼆维数组的⾸元素就是第⼀⾏，是个⼀维数组。

就是可以把第一行看作第一个元素记作 arr[0]

第二行看作第二个元素记作 arr[1]

第三行看作第三个元素记作 arr[2]

根据数组名是首元素的地址规则，那么对于二维数组的数组名也是首元素的地址，首元素就是第一行，那么就是第一行的地址,arr[0]就是第一行的数组名。第⼀⾏的⼀维数组的类型就是 int [5] ，所以第⼀⾏的地址的类型就是数组指针类型 int(*)[5]，一维数组传参的本质传递的是数组⾸元素的地址，那么二维数组传递的也是首元素地址只不过这个首元素是个一维数组，也就是传递时第一行一维数组的地址（arr[0]的地址），那么形参也是可以写成指针形式的。

总体来说:

• 一维数组传参的本质传递的是数组⾸元素的地址;

• 二维数组传参的本质传递的是第一行一维数组的地址。

void test(int a[3][5], int r, int c)
{int i = 0;int j = 0;for (i = 0; i < r; i++){for (j = 0; j < c; j++){printf("%d ", a[i][j]);}printf("\n");}
}
//这是之前的传参写法，我们知道了二维数组传参的本质，可以修改如下
void test1(int(*p)[5], int r, int c)
{int i = 0;int j = 0;for (i = 0; i < r; i++){for (j = 0; j < c; j++){//printf("%d ", p[i][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} };//test(arr, 3, 5);test1(arr, 3, 5);return 0;
}

7.函数指针

前面说过数组指针，是代表数组的指针，那么函数指针就是函数的指针（地址），则函数指针变量应该是⽤来存放函数地址的，未来通过地址能够调⽤函数的。

整形数组的指针类型表示为int(*)[5]，那么函数指针类型该如何表示呢，类比来看：

int(*)(int )(int )。

如何创建函数指针变量，如下：

void test()
{printf("hehe\n");
}
void (*pf1)() = &test;
void (*pf2)() = test;int Add(int x, int y)
{return x + y;
}
int(*pf3)(int, int) = Add;
int(*pf3)(int x, int y) = &Add;//函数名就是函数的地址&Add==Add 都可以获取函数的地址，x和y写上或者省略都是可以的 int (*pf3) (int x, int y)
|     |     ------------
|     |       |
|     |       pf3指向函数的参数类型和个数的交代
|     函数指针变量名
pf3指向函数的返回类型int (*) (int x, int y) //pf3函数指针变量的类型

ps：函数名就是函数的地址，可以用函数名来代表函数的地址，也可以用 &函数名来表示

函数指针变量的使⽤，见一下代码

#include <stdio.h>// 一个简单的函数，接收两个整数并返回它们的和
int add(int x, int y)
{return x + y;
}int main()
{// 声明一个函数指针，指向接收两个int参数并返回int的函数//int (*pf)(int, int);// 将函数指针指向具体的函数add//pf = add;int (*pf)(int, int) = add;  // int (*pf)(int, int)=&add;// 使用函数指针调用函数int result = pf(10, 20);int result1 = (*pf)(10, 30);  //注意一定是加上（）不能是 *pf(10, 30)进行调用printf("Result: %d\n", result);  // 输出：Result: 30printf("Result1: %d\n", result1);  // 输出：Result: 40return 0;
}

7.函数指针数组

数组是⼀个存放相同类型数据的存储空间，我们已经学习了指针数组，函数指针数组，是把函数的指针存放在数组里，一般情况是定义多个函数，把多个函数的地址存放在数组中，方便调用。

函数指针数组的定义：int (*parr1[ 3 ])(int ，int );

parr1 先和 [ ] 结合，说明 parr1是数组，数组的内容是 int (*)( int ，int ) 类型的函数指针

函数指针数组应用：设计一个计算器

//转移表  （设计一个简易计算器）
#include <stdio.h>
#include <stdlib.h>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;
}
void menu()
{printf("********************************\n");printf("******   1. add    2. sub  *****\n");printf("******   3. mul    4. diV  *****\n");printf("******   0. exit           *****\n");printf("********************************\n");
}
int main()
{int input = 0;int (*pf[5])(int,int) = {0, add, sub, mul, diV};do{  menu();int x, y = 0;scanf("%d", &input);if (input > 0 && input < 5){printf("请输入操作数:");scanf("%d %d", &x, &y);int ret = pf[input](x, y);printf("%d\n", ret);}else if (input == 0){printf("退出计算器");}else{printf("输入错误，重新输入\n");}} while(input);return 0;
}