视频链接:bilibili

关于指针需要注意的地方

只有以下两种情况数组名表示的是整个数组
1.sizeof(数组名)
2.&数组名
除此之外数组名表示的都是首元素地址

一、字符指针

是一个指向字符的指针

int main()
{
	char ch = 'w';
	char* p = &ch;
	//char* ch2 = "abcdef";//ch2里放的是字符串a的地址
	const char* ch2 = "abcdef";//常量字符串不允许被修改，int前面加const，修饰的是*ch2
	//char* const ch2 = "abcdef";//const修饰的是ch2这个地址
	return 0;
}

二、指针数组

是一个数组，是用来存放指针的数组

int main()
{
	int arr1[] = { 1,2,3,4,5,6 };
	int arr2[] = {2,3,4,5,6,7};
	int arr3[] = {3,4,5,6,7,8};
	int* parr[] = { 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("\n");
	}
	return 0;
}

三、数组指针

数组指针是一个指针，用来存放数组的指针

int *p1[10];//p1指的是一个存放指针的数组，这个数组中存储的是10个int类型的指针
int (*p2)[10];//p2指的是一个指针，指针指向数组，数组中有10个元素，括号优先级高于[]

int main()
{
	char* arr[5];
	char* (* pa)[5] = &arr;
	return 0;
}

void print1(int (*p)[5],int x, int y )
{
	int i = 0;
	for(i=0;i<3;i++)
	{
		int j = 0;
		for(j=0;j<5;j++)
		{
			//体会下面解引用的不同方法
			printf("%d ", *(*(p+i)+j));
			printf("%d ", *(p[i]+j));
			printf("%d ", *(p+i)[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);//arr--数组名--数组名就是首元素地址
	return 0;
}

思考下面代码表示是什么意思

int arr[5];
int *parr1[10];
int (*parr2)[10];
int (*parr3[10])[5];

四、数组传参

一维数组传参

void test(int arr)//不行
void test(int arr[5])//可以
void test(int arr[])//可以
void test(int* arr[])//可以
void test1(int* arr[])//可以
void test1(int* arr[5])//可以，arr2是一个指针数组，既然是数组就可以用指针接收
void test1(int** arr)//可以，arr2内存储是指针，那么可以用二级指针接收

int main()
{
	int arr[5] = { 0 };
	int* arr2[5] = { 0 };//指针数组，数组的每个元素是指针，arr2表示的是首元素地址，
	//可以用首元素地址的地址来接收
	test(arr);
	test1(arr2);
	return 0;
}

二维数组传参
二维数组传参时，行可以省略，列不可省略

void test(int arr[3][5])//可以
void test(int *arr)//不行
void test(int *arr[5])//不行
void test(int (* arr)[5])//可以
void test(int **arr)//不行

int main()
{
	int arr[3][5] = { 0 };
	test(arr);
	return 0;
}

五、函数指针

指向函数的指针， 需要明确函数也有地址
&函数名和函数名都是函数的地址。而函数指针在调用的时候可以使用解引用也可以不解引用

int Add(int x, int y)
{
	int z = x + y;
	return z;
}
int main()
{
	int a = 10;
	int b = 20;
	//printf("%d\n", Add(a, b));
	//printf("%p\n", &Add);
	int (*pa)(int, int) = Add;//将函数Add的地址存到pa这个函数指针中。
	printf("%d\n", (*pa)(2,3));
	return 0;
}
**思考下面代码的含义**
(*(void (*)())0)();

六、函数指针数组

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

int Add(int x, int y)
{
	return x + y;
}
int Sub(int x, int y)
{
	return x - y;
}
int main()
{
	//int (*pa)(int, int) = Add;
	int (*pa[2])(int, int) = {Add, Sub};
	int i = 0;
	for (i = 0; i < 2; i++)
	{
		printf("%d\n", pa[i](2, 3));//5  -1  函数指针在调用的时候可以使用解引用也可以不解引用
	}
	return 0;
}

函数指针数组—也可以称为转移表

//实现一个计算器的功能
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 menu()
{
	printf("----------------------------------\n");
	printf("---------1.Add   2.Sub -----------\n");
	printf("---------3.Mul   4.Div -----------\n");
	printf("--------     0.exit   ------------\n");
	printf("----------------------------------\n");
}
int main()
{
	int input = 0;
	int a = 0;
	int b = 0;
	do
	{
		menu();
		printf("请选择:>");
		scanf_s("%d", &input);
		printf("请输入两个操作数:>");
		scanf_s("%d%d", &a, &b);
		//paArr是一个函数指针数组--转移表
		int (*paArr[])(int, int) = {0, Add, Sub, Mul, Div};
		if (input>=1 && input<=5)
		{
			int ret = paArr[input](a,b);
			printf("%d\n", ret);
		}
		else if (input == 0)
		{
			printf("退出");
			break;
		}
		else
		{
			printf("输出错误");
		}
	} while (input);
	return 0;
}

七、指向[函数指针数组]的指针

int main()
{
	int arr[5] = { 0 };
	//pf是一个函数指针
	int (*pf)(int,int);
	int(*pf)[5] = &arr;//p是一个数组指针
	//pfArr是一个数组
	//是一个函数指针数组，包含5个元素
	//每个元素的类型是一个函数指针
	//函数指针的类型是int (*)(int,int)
	int (*pfArr[5])(int,int);
	//ppfArr是一个指针
	//是一个数组指针，指向的数组有5个元素
	//每个元素的类型是一个函数指针
	//函数指针的类型是int (*)(int,int)
	int (*(*ppfArr)[5])(int, int) = &pfArr;//ppfArr是一个指向[函数指针数组]的指针
	return 0;
}

八、回调函数

通过函数指针调用的函数，用于解决代码冗余的问题，如果把函数的地址作为参数传递给另一个函数，

#include <stdio.h>
//设计一个main函数，用于调用一个回调函数
//设计一个print函数，实现打印字符串的功能
//设计一个回调函数，用于接收函数地址，
//并且在回调函数内部调用print函数
void print(char *str)//print函数是打印字符串的
{
	printf("%s\n", str);
}

void test(void (*p)(char*))//test函数是一个回调函数
{

	printf("haha\n");
	p("bit");//调用test接收到的函数指针，找到对应的函数进行调用
}

int main()
{
	test(print);
	return 0;
}