C语言 深入理解指针

在C语言初始指针中（C语言 初识指针-CSDN博客），了解到关于指针的基本概念以及一些性质和用处，接下来将更进一步了解指针，指针与其他概念的联系。

指针与数组

数组名的理解

初始指针中我们做了用数组首元素地址来打印数组的操作，用到了&arr[0]的操作，但其实数组名就是首元素的地址。

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("&arr[0] = %p\n", &arr[0]);
	printf("arr     = %p\n", arr);
	return 0;
}

可以看到两个结果一模一样。

再看下面这种情况。

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	printf("%zd", sizeof(arr));
	return 0;
}

如果他是首元素地址。那一个int类型不该是4个字节吗，为什么是40个呢？

事实上，sizeof(arr)是一种数组名特殊的用法，在sizeof内部arr代表整个数组的大小。

而arr代表整个数组时还有另外一种情况，那就是&arr。

&arr取出来的是整个数组的地址。但打印出来是一样的，就算取出整个数组的地址，显示的还是第一个元素的地址。

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("&arr[0] = %p\n", &arr[0]);
	printf("arr     = % p\n", arr);
	printf("&arr    = %p\n", &arr);
	return 0;
}

那区别在哪呢？

#include <stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	printf("&arr[0]   = %p\n", &arr[0]);
	printf("&arr[0]+1 = %p\n", &arr[0] + 1);
	printf("arr       = % p\n", arr);
	printf("arr+1     = % p\n", arr + 1);
	printf("&arr      = % p\n", &arr);
	printf("&arr+1    = %p\n", &arr + 1);
	return 0;
}

区别就在于当我们对其进行加减整数运算时，首元素地址（数组名）加减一时跳过的是一个元素的大小，而对&arr加减一时，跳过的是一整个数组的大小。

一维数组传参

有了对数组名的理解，接下来来数组的传参。

#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;
 }

可以看到传参给函数没有打印出正确的结果，实质上传给函数参数为arr[]时，打印的是这个指针变量的大小，其实跟传arr（数组名）是一样的。

#include<stdio.h>
void test(int* arr)//参数写成指针形式
{
	printf("%d\n", sizeof(arr));
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	test(arr);
	return 0;
}

可以看到sizeof(arr)的大小为8个字节，而不是整个数组的大小，其实就是打印的是指针变量的大小，而在64位系统下，一个指针变量大小为8个字节。

一维数组中形参部分可以写成数组的形式，也可以写成数组名的形式。

二级指针

指针也是一种变量，而是变量就会有地址，二级指针就是用来存放一个指针的地址变量。

#include<stdio.h>
int main()
{
	int a = 10;

	int* p = &a;

	int** pa = &p;

	printf("%p\n", p);
	printf("%p\n", pa);

	return 0;
}

这就是二级指针的用处。

*pa其实是找到了p的地址，**pa是先找打p的地址，然后再*p找到a。

指针数组

指针数组的理解

指针数组，理解应为存放指针的数组。

数组有存放int 类型的，有存放char类型的

把里面的变量换成指针即为指针数组，例如int *类型指针数组

指针数组的每一个元素又是一块地址，可以指向一块区域

指针数组模拟二维数组

#include <stdio.h>
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;
}

数组指针

由上面指针数组的理解，我们可以得出数组指针是存放一个数组的指针

tips：看后两个字是什么来记忆，指针数组顾名思义是一个数组，而数组指针就是一个指针。

数组指针的初始化

#include<stdio.h>
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,0 };
	int(*p)[10] = &arr;

	return 0;
}

p和&arr是一样的，类型都一样就是数组指针。

二维数组传参

有了数组指针的理解，接下来要看看对二维数组理解。

#include <stdio.h>
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");
	}
}
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);
	return 0;
}

二维数组的传参可以直接将形参的类型写成实参，例如上述代码，传给test的一个参数就是int a[3][5]。

又根据对数组名的理解，数组名在除了那两个特殊的情况下，都代表首元素的地址，而二维数组的首元素地址就是第一行的元素，即arr->int [5]类型。那么arr就可以写成int(*)[5]的指针形式，传参的形参可以用这个类型的指针来接受arr。

#include <stdio.h>
void test(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("\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);
	return 0;
}

所以二维数组的传参可以直接将二维数组传给函数，也可以以指针的方式传给函数，以指针的形式传参时，注意形参的接受形式，应为int (*p)arr[列数]。

函数指针

函数也是有地址的。既然有地址，就应该有一个对应的变量可以存放他的地址。

#include <stdio.h>
void test()
{
	printf("hehe\n");
}
int main()
{
	printf("test:  %p\n", test);
	printf("&test: %p\n", &test);
	return 0;
}

可以看到函数名和&函数名的地址都是一样的。

函数指针的创建

 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;//x和y写上或者省略都是可以的

 函数指针变量的写法和数组指针其实类似。

函数指针的创建应如上图片的标准。有返回类型 有函数的参数和个数，有函数指针的变量名称。

 函数指针的使用

#include <stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf3)(int, int) = Add;
	printf("%d\n", (*pf3)(2, 3));
	printf("%d\n", pf3(3, 5));
	return 0;
}

函数指针的变量名加上函数的参数即可使用，函数指针变量名前可以加*，也可以不加*，没有影响。

typedef定义关键字

有时候函数指针的参数很多很长，不方便使用，那么可以用typedef简化。

typedef 可以定义一些变量名例如

typedef unsigned int unt

这样后面再使用无符号整数的时候，用unt即可。指针类型也是如此。

而数组指针和函数指针有些不同的地方就是，定义的名字要写在括号里面，*后面。

将int(*)[5] 改成parr_t

typedef int(*parr_t)[5];

将void(*)(int)改成pfun_t 

typedef void(*pfun_t)(int);

函数指针数组

 int (*parr1[3])();

函数指针数组的定义方法如上述代码。

应注意的是parr1与[]先结合，所以parr1[3]这个数组里面的内容就是int(*)()类型的函数指针。