指针的进阶

基础知识

内存会划分为一个个内存单元。每个内存单元都有一个独立的编号 — 编号也称为地址。

地址在C语言中也称为指针。

指针(地址)需要存在 — 存储在变量之中，这个变量称之为指针变量。

指针的大小是固定的4/8个字节（32位平台/64位平台。

地址是物理电线上产生的，

32位机器 — 32根地址线 — 1/0

32个0/1组成的二进制序列，把这个二进制序列作为地址，32为bit位才能存储这个地址

所以指针变量大小也就是4个字节。

64位机器同理

指针是有类型的，指针类型决定了指针的+-整数的步长，指针解引用的操作权限。

---

字符指针

int main()
{
 char ch = 'w';
 char *pc = &ch;
 *pc = 'w';
 return 0;
}

如上代码，这是字符指针一般的使用方式，通过指针变量来改变所指向地址的内容。字符指针还有以下实例用法：

int main()
{
	char arr[] = "abcdef";
	const char* p = "abcdef";
}

我们看到， 代码 const char* pstr = "hello bit.";是否会被理解为将字符串放入了字符指针p中呢？

其中本质是把字符串的首字符地址放入p中、

理解了这一点，我们来看如下的一道面试题;

#include <stdio.h>
int main()
{
 char str1[] = "hello bit.";
 char str2[] = "hello bit.";
 const char *str3 = "hello bit.";
 const char *str4 = "hello bit.";
 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;
}

这里最终输出是什么样的呢？我们在IDE中来运行：

str1与str2不相同，str3与str4相同

str1与str2是两个数组分别存储着字符串，且实际上是存储这两个地址，str3与str4是指向字符的首地址，则二者相同。

指针数组

顾名思义，指针数组是一个存放指针的数组。

如下图的指针数组是什么意思呢？

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

下列代码是对指针数组的小小应用：

模拟实现二维数组

int main()
{
	int arr1[] = { 1,2,3,4,5 };
	int arr2[] = { 2,3,4,5,6 };
	int arr3[] = { 3,4,5,6,7 };

	//指针数组
	int* arr[3] = { arr1,arr2,arr3 };

	//模拟实现二维数组
	int i = 0;
	for (i = 0; i < 3; i++) {
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d",arr[i][j]);
		}
	}
}

---

数组指针

指向数组的指针，存放的是数组的的地址的指针变量

其表现形式为：

int (*p)[10];

p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫数组指针。
这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。

&数组名VS数组名

对于数组名的理解，数组名是数组首元素的地址。

但是任然存在例外：

1.sizeof()，这里的数组名是受云素的地址，数组名表示整个数组，计算的是整个数组的大小。

2.&数组名，这里的数组名表示整个数组，&取出的是整个数组的地址。

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

在vs上监视的情况是这样的：

二者的意义是完全不同的， &这里的数组名表示整个数组，&取出的是整个数组的地址。

数组指针的使用

数组指针的使用，一般在二维数组使用时比较方便

void Print(int (*p)[5], int r, int c)
{
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", arr[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 };
	Print(arr, 3, 5);

	return 0;
}

二维数组的每一行，可以理解为二维数组的一个元素，而每一行，又是一个一维数组。即二维数组可以看作一维数组的数组。

二维数组的数组名—>数组首元素的地址

则代表第一行的地址—>一维数组的地址—>数组的地址

则二维数组传参，形参是数组指针。

数组参数、指针参数

一维数组传参

一维数组传参，形参的部分可以是数组，也可以是指针，如下所示：

//一维数组传参，形参的部分可以是数组，也可以是指针
void test1(int arr[5], int sz)
{}
void test2(int* p, int sz)
{}

int main()
{
	int arr[5] = { 0 };
	test1(arr, 5);
	test2(arr, 5);
	return 0;
}

二维数组传参

二维数组传参，形参的部分可以是数组，也可以是指针

void test3(char arr[3][5], int r, int c)
{}

void test4(char (*p)[5], int r, int c)
{}
int main()
{
	char arr[3][5] = {0};
	test3(arr, 3, 5);
	test4(arr, 3, 5);

	return 0;
}

当然，二维数组传参，函数形参设计只能省略第一个[]的数字，二维数组必须知道有多少一行有多少个元素，这样才方便运算。

一维指针传参

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

当一个函数的参数部分为一级指针，只要传参类型与传参类型匹配的上。

类似于void text(char *p)这样的函数，无论是text(&ch)或text(p)还是text(arr)都是可行的，传参都是地址。

二级指针传参

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

函数指针

既然数组指针，是指向数组的指针。同理，函数指针，也就是指向函数的指针

我们来看以下代码：

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

执行结果为： 

我们可以发现，函数名就是函数的指针，而&函数名也是函数的地址，假设pf为函数的指针变量

则存储方式如下：

void (*pf)() = &texxt;

 或者也可以利用ttypedef重定义函数，例如：

typedef int(*parr_t)[10];
typedef int (*pf_t)(int, int) ;

这样的话，就可以在主函数中，可以使用pf_t以及parr_t代替原本函数指针名称。