C语言进阶（指针）

一、字符指针

关于字符指针的使用主要有以下两种

#include <stdio.h>
int main()
{
	char ch = 'w';
	char* p1 = &ch;   //把一个字符变量的地址放到字符指针
	
	//因为是常量字符串，所以不能被修改，要加const
	const char* p2 = "abcdef";  //这里存的是字符串首元素的地址
	printf("%c %s", *p1, p2);  //p2不需要*，因为有'\0'
	return 0;
}

字符指针的一些内存问题

int main()
{
    char str1[] = "hello world.";
    char str2[] = "hello world.";
    const char *str3 = "hello world.";
    const char *str4 = "hello world.";
    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不同。

二、指针数组

什么是指针数组？
本身是一个数组，但是数组的每一个元素都是指针

int main()
{
	int* arr1[10];   //整型指针的数组
	char* arr2[4];   //一级字符指针的数组
	char** arr[5];   //二级字符指针的数组
	return 0;
}

指针数组的使用
通过指针数组的元素地址去找

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

	int* arr[4] = { arr1,arr2,arr3,arr4 };

	int i = 0;
	for (i = 0; i < 4; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			printf("%d ", *(arr[i] + j));   //arr[i] = *(arr + i)
			//*(arr[i] + j) = arr[i][j]
		}

		printf("\n");
	}
	return 0;
}

三、数组指针

什么是数组指针？

本身是一个指针变量，指针指向的是一个数组的地址

数组指针的使用
❤️访问数组

//访问arr[0]
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };

	//使用下标
	printf("%d\n", arr[0]);

	//使用指针
	int* p = arr;
	printf("%d\n", *(p + 0));

	//使用数组指针
	int(*p2)[10] = &arr;
	printf("%d", *(p2)[0]);   //*(p2)[0] == arr[0]
	return 0;
}

&arr和arr的区别

• &arr是取出这个数组的地址，arr则是表示这个数组首元素的地址
• 就值而言，&arr和arr的值是一样的，但是就意义而言，&arr + 1是跳过一个数组，arr + 1，则是跳过对应的字节序

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

总结

四、数组传参

❤️数组的传参主要分两种
1、数组传参，数组接收
2、数组传参，指针接收

4.1 一维数组传参

void test(int arr[])
{}
void test(int arr[10])
{}
void test(int* arr)
{}
void test2(int* arr[20])
{}
void test2(int* arr[])
{}
void test2(int** arr)
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
}

4.2 二维数组传参

void test(int arr[3][5])
{}
void test(int arr[][5])  //可以省略行，但是不能省略列
{}

void test(int(*arr)[5])  //原理：传过去的是数组的首元素的地址
{}                       二维数组的首元素是第一个一维数组
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
}

五、指针传参

一级指针传参

void Add(int* num)
{
	*num = 0;
	printf("%d", *num);
}
int main()
{
	int num = 10;
	Add(&num);
	return 0;
}

二级指针传参

void Add(int** pp)
{
	**pp = 0;
	printf("%d", **pp);
}
int main()
{
	int num = 10;
	int* p = #
	int** pp = &p;
	Add(pp);
	return 0;
}

六、函数指针

什么是函数指针？

本身是一个指针变量，指针指向的是一个函数的地址

函数指针的使用

七、函数指针数组

什么是函数指针数组？
本身还是一个数组，用来存放函数地址

函数指针数组的使用
函数指针数组主要可以充当转换表使用，即把一些函数地址传给同一个数组，然后就可以通过调用数组元素来调用函数

#include <stdio.h>
void menu(void)
{
	printf("***********************\n");
	printf("*****1.Add    2.Sub****\n");
	printf("*****3.Mul    4.Div****\n");
	printf("***********************\n");

}
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 input = 0;
	do {
		menu();
		printf("请选择:");
		scanf("%d", &input);
		
		int(*arr[5])(int, int) = { 0,&Add,&Sub,&Mul,&Div };  //可以直接传函数名
                                                          //&函数名==函数名
		if (input > 0 && input < 5)
		{
			int x = 0;
			int y = 0;       //通过调用arr这个数组来调用Add、Sub、Mul、Div等函数
			printf("请输入两个操作数："); 
			scanf("%d %d", &x, &y);
			printf("%d\n", (*arr[input])(x,y));   //也可以写成arr[input](x,y)
		}
	} while (input != 0);
	return 0;
}

八、指向函数指针数组的指针

void test(const char* str)
{
 printf("%s\n", str);
}
int main()
{
 //函数指针pfun
 void (*pfun)(const char*) = test;
 //函数指针的数组pfunArr
 void (*pfunArr[5])(const char* str);
 pfunArr[0] = test;
 //指向函数指针数组pfunArr的指针ppfunArr
 void (*(*ppfunArr)[5])(const char*) = &pfunArr;
 return 0;
}

九、回调函数

9.1 什么是回调函数

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

9.2 回调函数举例（计算器 + 模拟qsort函数）

❤️计算器

void menu()
{
	printf("*******************************\n");
	printf("****** 1. add   2. sub    *****\n");
	printf("****** 3. mul   4. div    *****\n");
	printf("****** 0. exit            *****\n");
	printf("*******************************\n");
}

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 calc(int (*pf)(int, int))
{
	int x = 0;
	int y = 0;
	int ret = 0;
	printf("请输入两个操作数:>");
	scanf("%d %d", &x, &y);
	ret = pf(x, y);
	printf("%d\n", ret);
}

int main()
{
	int input = 0;
	
	do 
	{
		menu();
		printf("请选择:>");
		scanf("%d", &input);
		switch (input)
		{
		case 1:
			calc(Add);
			break;
		case 2:
			calc(Sub);
			break;
		case 3:
			calc(Mul);
			break;
		case 4:
			calc(Div);
			break;
		case 0:
			printf("退出计算器\n");
			break;
		default:
			printf("选择错误\n");
			break;
		}
	} while (input);

	return 0;
}

❤️模拟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 my_sqort(void* base, size_t num, size_t size, int (*compar)(const void*, const void*))
{
	size_t i = 0;
	for (i = 0; i < num - 1; i++)
	{
		size_t j = 0;
		for (j = 0; j < num - 1 - i; j++)
		{
			if (compar((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[10] = { 3,6,8,1,5,0,9,4,2,7 };
	my_sqort(arr, sizeof(arr) / sizeof(arr[0]), sizeof(arr[0]), int_cmp);

	int i = 0;
	for (i = 0; i < sizeof(arr) / sizeof(arr[0]); i++)
	{
		printf("%d ", arr[i]);
	}
	printf("\n");
	return 0;
}