C语言——指针的进阶学习

前言

1. 指针就是个变量，用来存放地址，地址唯一标识一块内存空间
2. 指针的大小是固定的4/8个字节（32位平台/64位平台）
3. 指针是有类型，指针的类型决定了指针的±整数的步长，指针解引用操作的时候的权限

1. 字符指针

---

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

• 像上式中的pc就是一个字符指针，它里面存放了字符ch的地址，对pc进行解引用即可找到ch中的内容为字符‘w’

int main()
{
const char* pstr = "hello bit.";//这里是把一个字符串放到pstr指针变量里了吗？
printf("%s\n", pstr);
return 0;
}

• 这里需要去注意的是这里并不是将整个字符串放进指针变量pstr中了，而是将首元素地址字符’h’放进了指针变量中

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

• 这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。但是用相同的常量字符串去初始化
• 不同的数组的时候就会开辟出不同的内存块。所以str1和str2不同，str3和str4不同。

---

2. 数组指针

数组指针，顾名思义，是一种指针，这种指针指向一个数组

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

• 在上式中第一个式子的星号的优先级和[]相比来说要低，所以它首先表示一个数组，这个数组的元素是int*类型的
• 在第二个式子中，括号的优先级最高，所以它首先表示一个指针，这个指针指向一个数组，数组为10个元素，每个元素是int型的

• 所谓的数组指针，是指上数组的一种指针，形式和(类型）(星号 指针名)[个数]一样

2.1 &数组名VS数组名

• 在c语言中&数组名和数组名在一些情况下是有所不同的，这也是很多人在这里出错的原因

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

• 在这段代码中的arr和&arr的值是一样的，都表示首元素的地址，我们再看下面一段代码

#include <stdio.h>
int main()
{
int arr[10] = { 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跳过一个单位，地址跳过4个字节，但是对于&arr来说是跳过了40个字节，这是跳过了整个数组的大小。
• 这里再加上一个补充的点时，只有&数组名和sizeof(数组名),数组名单独放进里面的时候，这时候数组名表示整个数组，其他的情况都是数组首元素的地址。

---

3. 指针数组

指针数组，顾名思义，就是一个数组，在数组里面存放的是指针

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

---

4. 数组传参和指针传参

4.1 一维数组传参

#include <stdio.h>
void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int* arr)//ok?
{}
void test2(int* arr[20])//ok?
{}
void test2(int** arr)//ok?
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

可以告诉大家的是，上面几个式子都是可以进行一维数组的传参的

4.2 二维数组传参

void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int(*arr)[5])//ok？
{}
void test(int** arr)//ok？
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}

对于二维数组的传参，因为二维数组传参是传第一行的地址，所以可以用第一种，第三种，还有第六种都是可以的，要注意要进行类型匹配。

---

5. 函数指针

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

可以从上图中得到，函数test的地址和test是一样的，因此我们对函数取地址时，要不要&都可以

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

答案是第一个可以存放test的地址，因为在这里还是结合性的问题，前面括号内的内容表示是一个指针，而指向一个函数类型，所以是一个函数指针

• 接下来我们来看几段有趣的代码·

//代码1
(*(void (*)())0)();
//代码2
void (*signal(int , void(*)(int)))(int);

• 代码1 我们要对其进行分开分析，从里面进行分析，0表示一个数字，(void (*)())表一个函数指针的强制类型转化，而后面的()和前面的星号表示是对这个函数指针进行解引用
• 代码2 我们也是要对其进行一个分开的分析，将signal(int , void()(int))看为第一个单位，这个表示一个函数，但是没有返回的类型，因此void ()(int)为返回类型，返回为一个函数指针

• 这里我们可以发现代码的形式很复杂，但是有时候我们必须要使用，那怎么办呢？

typedef void(*pfun_t)(int);
pfun_t signal(int, pfun_t);

• 在这里我们使用类型重定义的语法，但是要注意这里的typedef是不一样的，一般的写法为typedef void(*)(int) pfun_t，但是在这里这样是不可以的，因为星号要和名字在一起，这是一种类型，表示指针，所以要写成typedef void(*pfun_t)(int)的形式

---

6. 函数指针数组

• 函数指针数组，顾名思义，就是一个数组，里面存放的是函数指针。、

• 那么它的形式应该是什么样子的呢，我们还是可以分开来看。

int (*parr1[10])();

• 上面这类形式，怎么来看呢，首先我们要知道方括号的优先结合性比星号高，因此parr1首先是一个数组，那么它的类型是什么呢，就是剩余的部分，剩余的部分是一个函数指针，返回类型为int。

• 函数指针的运用，主要运用在使用多个返回类型和参数类型相同的函数中，可以存放在函数指针数组中。

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

• 根据我们上面的一系列的解释，这个也是一个从小到大的原则，我们可以写出这样一个指向函数指针数组的指针。
• void (*(ppfunArr)[5])(const char)

8. 回调函数

• 回调函数就是一个通过函数指针调用的函数。如果你把函数的指针（地址）作为参数传递给另一个
  函数，当这个指针被用来调用其所指向的函数时，我们就说这是回调函数。回调函数不是由该函数
  的实现方直接调用，而是在特定的事件或条件发生时由另外的一方调用的，用于对该事件或条件进
  行响应。

• 下面是一个使用回调函数实现qsort函数的例子

int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}
void _swap(void* p1, void* p2, int size)
{
	int i = 0;
	for (i = 0; i < size; i++)
	{
		char tmp = *((char*)p1 + i);
		*((char*)p1 + i) = *((char*)p2 + i);
		*((char*)p2 + i) = tmp;
	}
}
void bubble(void* base, int count, int size, int(*cmp)(void*, void*))
{
	int i = 0;
	int j = 0;
	for (i = 0; i < count - 1; i++)
	{
		for (j = 0; j < count - i - 1; j++)
		{
			if (cmp((char*)base + j * size, (char*)base + (j + 1) * size) > 0)
			{
				_swap((char*)base + j * size, (char*)base + (j + 1) * size, size);
			}
		}
	}
}
int main()
{
	int arr[] = { 1, 3, 5, 7, 9, 2, 4, 6, 8, 0 };
	//char *arr[] = {"aaaa","dddd","cccc","bbbb"};
	int i = 0;
	bubble(arr, sizeof(arr) / sizeof(arr[0]), sizeof(int), int_cmp);
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}

• 我们这里要重点介绍一个内容–void*(无类型的指针),这样的指针我们介绍任何类型的内容，但是不可以进行加减乘除等操作，要进行操作必须要进行强制类型转化。**

9. 总结

• 指针的学习道路道阻且长，大家要多多练习，举一反三，谢谢大家。