[C语言]指针进阶(Pointer to the advanced)

EnticE152

已于 2023-09-21 20:03:36 修改

阅读量659

点赞数 36

文章标签： c++ c语言

于 2022-10-23 21:37:43 首次发布

本文链接：https://blog.csdn.net/qq_66767938/article/details/127474097

版权

指针进阶：：

指针进阶知识点：

1.字符指针

在指针的类型中我们知道有一种指针类型为字符指针 : char *

一般使用：

#include<stdio.h>
int main()
{
	char ch = 'w';
	char* pc = &ch;
	*pc = 'b';
	printf("%c\n", ch);
	return 0;
}

还有一种使用方式如下：

#include<stdio.h>
int main()
{    
    const char* p = "abcdef";//赋值给p的是字符串首字符的地址
	printf("%s\n", p);
	return 0;
}

本质：const char * pstr = "hello world";本质是把字符串hello world首字符的地址放到了pstr中.

上面代码的意思是把一个常量字符串首字符h的地址存放到指针变量pstr中.

面试题

//下列程序的运行结果为：
#include<stdio.h>
int main()
{
	const char* p1 = "abcdef";
	const char* p2 = "abcdef";
	if (p1 == p2)
	{
		printf("p1 == p2\n");
	}
	else
	{
		printf("p1 != p2\n");
	}
	char arr1[] = "abcdef";
	char arr2[] = "abcdef";
	if (arr1 == arr2)
	{
		printf("arr1 == arr2\n");
	}
	else
	{
		printf("arr1 != arr2\n");
	}
	return 0;
}
//程序的运行结果为：p1 == p2  arr1 != arr2

这里p1和p2指向的是同一个常量字符串，C/C++会把常量字符串存储到单独的一个内存区域(数据区)，当几个指针指向同一个字符串的时候，它们实际会指向同一块内存。但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块，所以p1==p2 arr1!=arr2.

2.指针数组

指针数组的定义：

指针数组是用来存放指针的数组，指针数组作为实参传递给形参时，形参要用二级指针来接收.

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

指针数组的应用：模拟实现二维数组

#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[3] = { arr1,arr2,arr3 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		int j = 0;
		for (j = 0; j < 5; j++)
		{
			//printf("%d ", parr[i][j]);
			printf("%d ", *((parr[i] + j)));
		}
		printf("\n");
	}
	return 0;
}

3.数组指针

数组指针的定义：

数组指针是指针，好比整型指针是用来存放整形的指针，字符指针是用来存放字符的指针，那么数组指针也就是存放数组的指针.

数组指针的表示形式：

int (*p) [10]：p先和 * 结合，说明p是一个指针变量，然后指向的是一个大小为10个整型的数组，所以p是一个指针，指向一个数组，叫数组指针.

注意：[ ]的优先级要高于 * 号的，所以必须加上( )来保证p先和 * 结合.

&数组名 VS 数组名

int main()
{
	char* arr[5] = { 0 };//char* (*p)[5] = &arr;
	char ch = 'w';
	char* p1 = &ch;//一级指针存储变量的地址
	char** p2 = &p1;//二级指针存储一级指针变量的地址
	return 0;
}

#include<stdio.h>
int main()
{
	int arr[10] = { 0 };
	//int* p = &arr;有警告的
	int(*p2)[10] = &arr;
	//p2的类型为int(*)[10]
	printf("%p\n", arr);
	printf("%p\n", arr + 1);
	printf("%p\n", &arr[0]);
	printf("%p\n", &arr[0] + 1);
	printf("%p\n", &arr);
	printf("%p\n", &arr + 1);
	int sz = sizeof(arr);
	printf("%d\n", sz);
	return 0;
}

注：数组名通常表示的都是首元素的地址，但是有两个例外：

1.sizeof(数组名)：这里的数组名表示整个数组，计算的是整个数组的大小，单位是字节.

2.&数组名：这里的数组名表示的依然是整个数组，所以&数组名取出的是整个数组的地址.

实际上&arr表示的是数组的地址，而不是数组首元素的地址，本例中&arr的类型是：int( * )[10]，

是一种数组指针类型，数组的地址+1，跳过整个数组的大小，所以&arr+1相对于&arr的差值是40.

注意：二维数组的首元素是它的第一行，二维数组的数组名表示的是整个第一行一维数组的地址.

数组指针在一维数组中的使用(不推荐)：

这里简单介绍一下数组指针在一维数组中的使用，但数组指针不推荐在一维数组使用.

原因在于：数组指针将一维数组升维，一级指针变成二级指针，使其更加复杂化.

#include<stdio.h>
int main()
{
	//代码1
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	//int* p = arr;
	//int i = 0;
	//for (i = 0; i < 10; i++)
	//{
	//	printf("%d ", *(p + i));
	//}
    //printf("\n");
	//代码2 不推荐
	int(*p)[10] = &arr;
	int i = 0;
	int sz = sizeof(arr) / sizeof(arr[0]);
	for (i = 0; i < sz; i++)
	{
		//p是指向数组的 *p其实就相当于数组名 数组名又是首元素的地址 所以*p本质上是数组首元素的地址
		printf("%d ", *( * p + i));
	}
    printf("\n");
	return 0;
}

数组指针在二维数组中的使用：

//打印二维数组(数组指针多用于二维数组或三维数组)
#include<stdio.h>
void print1(int arr[3][5],int row,int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
void print2(int(*p)[5], int row, int col)
{
	int i = 0;
	for (i = 0; i < row; i++)
	{
		int j = 0;
		for (j = 0; j < col; 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} };
	print1(arr, 3, 5);
    printf("\n");
	print2(arr, 3, 5);
	return 0;
}

数组指针的性质：

1. 数组指针+1跳过整个一维数组.
2. 数组指针解引用得到的是数组首元素的地址.
3. 数组指针[ ]的数字不可省略.

注： 1. 形参的一维数组的行可以省略，二维数组行也可以省略但列不可以省略.
2. int(*p)[5]，p的类型是int(*)[5]，p是指向一个整型数组的，数组5个元素，即int[5].
3. 二维数组的数组名是第一行的地址，相当于一个一维数组的地址，所以用数组指针接收
4. p+1跳过了一个5个元素的数组

练习：

int arr[5]         //arr是整型数组
int* parr1[10]     //parr1是整型指针数组
int(*parr2)[10]    //parr2数组指针
int(*parr3[10])[5] //parr3是存放数组指针的数组

4.数组和指针传参

数组的地址不能用二级指针接收的原因：

5.函数指针

函数指针的引入：

首先看一段代码：

#include<stdio.h>
int Add(int x, int y)
{
	return x + y;
}
int main()
{
    printf("%p\n", &Add);
	printf("%p\n", Add);
    return 0;
}

注：对于函数来说单独的函数名和取地址函数名都表示函数的地址.

函数指针的定义与函数调用的三种表示形式：

函数指针：函数指针也是一种指针，一种指向函数的指针.（数组谈存放，指针谈指向）

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int(*pf)(int, int) = &Add;
	//int(*pf)(int, int) = Add;
	int ret = Add(2, 3);
	printf("%d\n", ret);
	ret = (*pf)(2, 3);
	printf("%d\n", ret);
	ret = pf(2, 3);
	printf("%d\n", ret);
	return 0;
}

来自《C陷阱与缺陷》两个有趣的代码之深度剖析

函数指针的用途：模拟实现计算器

//对上述代码进行优化
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");
		default:
			printf("选择错误\n");
		}
	} while (input);
	return 0;
}

6.函数指针数组

函数指针数组的定义：

函数指针存放的是函数的地址，函数指针数组存放的是多个函数的地址.

函数指针数组的表示形式：

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(*pf)(int, int) = Add;
	int(*pfArr[4])(int, int) = { Add,Sub,Mul,Div };
	for (int i = 0; i < 4; i++)
	{
		printf("%d\n", pfArr[i](8, 4));
	}
	return 0;
}

函数指针数组的用途：

函数指针数组模拟实现计算器

#include<stdio.h>
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;
}
int main()
{
	int input = 0;
	int x = 0;
	int y = 0;
	int ret = 0;
	//函数指针数组
	int(*pfArr[5])(int, int) = { 0,Add,Sub,Mul,Div };
	do
	{
		menu();
		printf("请选择:->");
		scanf("%d", &input);
		if (input == 0)
		{
			printf("退出计算器\n");
		}
		else if (input >= 1 && input <= 4)
		{
			printf("请输入两个操作数:->");
			scanf("%d %d", &x, &y);
			ret = pfArr[input](x, y);
			printf("%d\n",ret);
		}
		else
		{
			printf("选择错误\n");
		}
	} while (input);
	return 0;
}

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

指向函数指针数组的指针的表示方法：

将数组名和方括号隔开，用星号括起来，变成指针.

注：指向函数指针数组里存放的是取地址函数指针数组的数组名.

#include<stdio.h>
int main()
{
	int (*pfArr[5])(int, int) = { 0,Add,Sub,Mul,Div };
	int(*(*pfArr)[5])(int, int) = &pfArr;
	return 0;
}

8.回调函数之模拟实现qsort函数

冒泡排序的优化：

void BubbleSort(int arr[], int sz)
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;//假设数组已经排好序
		int j = 0;//一趟冒泡排序的过程
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (arr[j] > arr[j + 1])
			{
				int temp = arr[j];
				arr[j] = arr[j + 1];
				arr[j + 1] = temp;
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}

万能指针：

#include<stdio.h>
int main()
{
	int a = 10;
	char* pa = (char*)&a;
	void* pv = &a;
	return 0;
}

深入理解qsort函数：

qsort函数的功能：qsort函数可以排序任意类型的数据

qsort函数的参数：

qsort函数的返回值：

qsort函数的使用：

用qsort函数排序整型数据：

int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}
//测试使用qsort来排序整型数据
void test1()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//把数组排成升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	qsort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}
}
int main()
{
	test1();
	return 0;
}

用qsort函数排序结构体类型数据：

struct Stu
{
	char name[20];
	int age;
};
int cmp_stu_by_name(const void* e1, const void* e2)
{
	//字符串比较函数strcmp的返回值为>0 ==0 <0
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return (((struct Stu*)e1)->age - ((struct Stu*)e2)->age);
}
//测试使用qsort来排序结构体数据
void test2()
{
	struct Stu s[] = { {"zhangsan",15},{"lisi",30},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	qsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
int main()
{
	test2();
	return 0;
}

回调函数：

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

用回调函数模拟实现qsort(冒泡排序版)

void Swap(char* buf1, char* buf2, int width)
{
	int i = 0;
	for (i = 0; i < width; i++)
	{
		char temp = *buf1;
		*buf1 = *buf2;
		*buf2 = temp;
		buf1++;
		buf2++;
	}
}
void BubbleQsort(void* base, int sz, int width, int(*cmp)(const void* e1, const void* e2))
{
	int i = 0;
	for (i = 0; i < sz - 1; i++)
	{
		int flag = 1;
		int j = 0;
		for (j = 0; j < sz - 1 - i; j++)
		{
			if (cmp((char*)base + j * width, (char*)base + (j+1) * width) > 0)
			{
				//交换
				Swap((char*)base + j * width, (char*)base + (j + 1) * width, width);
				flag = 0;
			}
		}
		if (flag == 1)
		{
			break;
		}
	}
}

对qsort(冒泡函数函数版)进行测试排序整形数据：

int cmp_int(const void* e1, const void* e2)
{
	return (*(int*)e1 - *(int*)e2);
}
//测试冒泡排序版qsort排序整型
void test3()
{
	int arr[] = { 9,8,7,6,5,4,3,2,1,0 };
	//把数组排成升序
	int sz = sizeof(arr) / sizeof(arr[0]);
	BubbleQsort(arr, sz, sizeof(arr[0]), cmp_int);
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d ", arr[i]);
	}

}
int main()
{
	test3();
	return 0;
}

对qsort(冒泡函数函数版)进行测试排序结构体类型数据：

struct Stu
{
	char name[20];
	int age;
};
int cmp_stu_by_name(const void* e1, const void* e2)
{
	//字符串比较函数strcmp的返回值为>0 ==0 <0
	return strcmp(((struct Stu*)e1)->name, ((struct Stu*)e2)->name);
}
int cmp_stu_by_age(const void* e1, const void* e2)
{
	return (((struct Stu*)e1)->age - ((struct Stu*)e2)->age);
}
void test4()
{
	struct Stu s[] = { {"zhangsan",15},{"lisi",30},{"wangwu",25} };
	int sz = sizeof(s) / sizeof(s[0]);
	BubbleQsort(s, sz, sizeof(s[0]), cmp_stu_by_name);
	BubbleQsort(s, sz, sizeof(s[0]), cmp_stu_by_age);
}
int main()
{
	test4();
	return 0;
}