【零基础C语言】指针解析3

17.字符指针变量

在指针类型中我们通常使用char*

代码展示

int main()
{
	char ch = 'w';
	char* p = &ch;
	*p = 's';
	printf("%c", ch);
	return 0;
}

int main()
{
	char ch[] = "hello ouquyang!";
	char* pch = &ch;
	printf("%s", pch);
	return 0;
}

上述代码中，并不是将字符串放入指针中，而是将字符或字符串首字符的
地址存放在指针中，在使用时顺藤摸瓜就可以打印出后面内容了

如剑指offer上的一题

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

字符数组str1和str2都是独立开创的两个空间，所以指向的对象是不一样的
而字符指针str3和str4指向的是同一块空间，同一个地址，所以是相同的。

18.数组指针变量

之前我们知道指针数组是用来存放指针的数组，数组中存放的是地址（指针）
那么数组指针变量是指针变量

整型指针变量：int* pint ;存放的是整形变量的地址，
 能够指向整形数据的指针

浮点型指针变量：float* pf;存放浮点型变量的地址，
 能够指向浮点型数据的指针

判断一下

int* p1[5];//指针数组 - 用来存放指针的数组

int(*p2)[5];//数组指针 - 用来指向数组地址的指针

int (*p)[10];

解析：p先与*结合，说明p是一个指针变量，然后指向的是一个大小为10
整型的数组，所以p是指针，指向一个数组，称作数组指针

19.数组指针如何初始化

int arr[10] = { 0 };
&arr;//得到整个数组的地址

int main()
{
	int arr[10] = { 0 };
	int(*p)[10] = &arr;
	return 0;
}

数组指针类型解析：
int - p指向的数组元素类型
*p - 说明p是数组指针的变量名
[10] - p指向数组的元素个数

20.二维数组传参的本质

void text(int arr[3][3], int r, int c)
{
	int i = 0;
	int j = 0;
	for (i = 0; i < r; i++)
	{
		
		for (j = 0; j < c; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}

void text2(int(*p)[3], 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][3] = { {1,2,3},{4,5,6},{7,8,9} };
	text(arr, 3, 3);
	printf("\n");
	text2(arr, 3, 3);
	return 0;
}

21.函数指针变量

函数存在地址

void text()
{
	printf("hehe\n");
}
int main()
{
	printf("text  = %p\n", text);
	printf("&text = %p\n", &text);

	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写上或者省略都是可以的

void (*p)(int, int)
void - p指向函数的返回类型
*p - 函数指针变量名
(int, int)p指向函数参数类型和个数
函数指针变量的使用
通过函数指针调用指针指向的函数

int add(int x, int y)
{
	return x + y;
}

int main()
{
	int(*p)(int, int) = add;

	printf("%d\n", (*p)(2, 3));

	printf("%d\n", p(2, 5));

	return;
}

22.typedef 关键字

 typedef 关键字可以更改复杂的名称

举例：
/*typedef unsigned int uint*/

对于指针的重命名
举例：
/*typedef int* ptr_t*/

对于数组指针的重命名
举例：
int(*)[5];
/*typedef int (*parr_t)[5]*/

对于函数指针重命名也是一样的
举例：
void(*)(int);
/*typedef void(*pfun_t)(int)*/

知道上面的命名方法以后，我们可以试着简化以下代码

代码1

  (*(void (*)())0)();
typedef void (*pfun_t)(int);

代码2

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

23.函数指针数组

指针数组
如：
 int* arr[10];
每个元素的类型是int*

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

24.转移表

计算器的实现

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 diu(int x, int y)//除法
{
	return x / y;
}

int main()
{
	int (*parr1[5])(int) = { 0, add,sub,mul,diu };
	int x = 0;
	int y = 0;
	int input = 1;
	int ret = 0;
	do 
	{
			printf("**************************\n");
			printf("*****1.add     2.sub******\n");
			printf("*****3.mul     4.diu******\n");
			printf("*********0. exit**********\n");
			printf("**************************\n");
			printf("请选择： ");
			scanf("%d", &input);
		if (input >= 1 && input <= 4)
		{
			printf("请输入你要计算的数字： ");
			scanf("%d %d", &x, &y);
			ret = (*parr1[input])(x, y);
			printf("ret = %d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出游戏！");
		}
		else
		{
			printf("输入错误，请重新输入！");
		}
		
	} while (input);
	
	return 0;

}

24.回调函数 - 计算器

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 meun(void)//菜单选择
{
	printf("**************************\n");
	printf("*****1.add     2.sub******\n");
	printf("*****3.mul     4.div******\n");
	printf("*********0. exit**********\n");
	printf("**************************\n");
	printf("请选择： ");

}

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("ret = %d\n", ret);
}

int main()
{
	int input = 1;
	do
	{
		meun();
		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("退出程序");
			break;
		default:
			printf("选择错误");
			break;
		}
	} while (input);
	return 0;
}

25.qsort函数的使用和模拟实现

qsort函数的使用

原型
void qsort(void* base, //指针，指向的是待排序数组的第一个元素
            size_t num, //是base指向的待排序数组的元素个数
            size_r size， //base指向的待排序数组的元素大小
            int(*compar)(const void*, const void*)//函数指针 - 指向的就是两个元素的比较函数
            );

 void* 类型的指针是无具体类型的指针，不可以解引用，也不能进行+-整数的运算

qsort函数的使用者需要实现一个比较函数

int int_cmp(const void* p1, const void* p2)
{
	return (*(int*)p1 - *(int*)p2);
}

int main()
{
	int arr[] = { 1,3,5,7,9,2,4,6,8,0 };
	int i = 0;
	qsort(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;
}

25.1使用qsort函数排序结构数据

struct Stu //学生
{
	char name[20];//名字
	int age;//年龄
};

//假设拿年龄来比较
int int_cmp_age(const void* s1, const void* s2)
{
	return ((struct Stu*)s1)->age - ((struct Stu*)s2)->age;
}


int int_cmp_name(const void* s1, const void* s2)
{
	return (((struct Stu*)s1)->name - ((struct Stu*)s2)->name);
}

void text1()
{
	struct Stu s[] = { {"zhangsan",20},{"lisi",18},{"wangsan",28} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), int_cmp_age);
}

void text2()
{
	struct Stu s[] = { {"zhangsan",20},{"lisi",18},{"wangsan",28} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), int_cmp_name);
}

int main()
{
	text1();
	text2();
	return 0;
}

qsort函数的模拟实现
使⽤回调函数，模拟实现qsort（采⽤冒泡的⽅式）。
注意：这⾥第⼀次使⽤ void* 的指针，讲解 void* 的作⽤。

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