指针进阶学习复盘

1、字符指针

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

int main()
{
	
	char* pc = "abcdef" ;//pc存放的是字符串首字母的地址
	//*pc = 'w';//这种更改方式错误，可在创建指针p时在前面加上const
	printf("%c\n", *pc);
	printf("%s\n", pc);

	return 0;
}

int main()
{
	
	char* pc1 = "abcdef";
	char* pc2 = "abcdef";
	char arr1[] = "abcdef";
	char arr2[] = "abcdef";
	if (pc1 == pc2)
	{
		printf("pc1=pc2\n");
	}
	else
	{
		printf("pc1!=pc2\n");
	}
	if (arr1 == arr2)
	{
		printf("arr1=arr2\n");
	}
	else
	{
		printf("arr1!=arr2\n");
	}
	return 0;
}

两者的区别就在于：pc1 和 pc2 指向的是常量字符串，是储存在常量区的，而常量的数据是不能被修改的，所以同一个数据不会被多次创建，只会在常量区进行一次数据的创建，相当于p1 、 p2 指向的是同一个内容。而arr1 和 arr2 是在栈区创建了两个不同的空间，其内容是用字符串来初始化的，所以两者的地址不同。

2、指针数组

int main()
{
	int a = 1;
	int b = 2;
	int c = 3;
	int* p1 = &a;
	int* p2 = &b;
	int* p3 = &c;
	int* arr[] = { p1,p2,p3 };
	int i = 0;
	for (i = 0; i < 3; i++)
	{
		printf("%d ", *arr[i]);
	}

	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* 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 main()
{
	int arr[5] = { 1,2,3,4,5 };
	int(*p)[5] = &arr;
	int i = 0;
	for (i = 0; i < 5; i++)
	{
		printf("%d ", (*p)[i]);
	}
	return 0;
}

4、数组传参和指针传参

4.1、一维数组

void print(int arr[], int sz)//形参为数组
{}
void print1(int* arr, int sz)//形参为整型指针
{}
void print2(int (*p)[10], int sz)//形参为数组指针
{}
int main()
{
	int arr[10] = { 0 };
	int sz = sizeof(arr) / sizeof(arr[0]);
 
	print(arr, sz);
 
	return 0;
}

4.2、二维数组

此处需注意二维数组首元素的地址为第一行的地址

void print(int arr[3][5], int c, int r)//形参为数组
{}
void print1(int (*arr)[5], int c, int r)//形参为首元素指针
{}
void print(int (*p)[3][5], int c, int r)//形参为二维数组指针
{}
int main()
{
	int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
 
	print(arr, 3, 5);
 
	return 0;
}

4.3、一级指针传参

void test(int* ptr,int sz)//使用一级指针接收
{}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	test(p, sz);//p是一级指针

	return 0;
}

4.4、二级指针传参

void test(char** ppc)//将二级指针传给函数，函数的接收方式只有这种
{}
int main()
{
	char a = 'a';
	char* pa = &a;
	char** ppa = &pa;
	test(ppa);//二级指针
	return 0;
}

若函数接收的是二级指针，那么传递的参数可以是什么

void test(char** pc)
{}
int main()
{
	char a = 'a';
	char* p = &a;
	char** pp = &p;
	test(&p);//可以传一级指针的地址
	test(pp);//可以传二级指针

	char* arr[4];
	test(arr);//可以传指针数组的指针
	return 0;
}

5、函数指针

int Add(int x, int y)
{
	return x + y;
}
int test(char* str)
{}
int main()
{
	int(*pf)(int, int) = Add;//pf是Add函数的指针
	int(*pc)(char*) = test;//pc是test函数的指针
	int ret = Add(2, 3);
	int ret = (*pf)(2, 3);
	int ret = pf(2, 3);//这三种调用写法都对
	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 (*pf1)(int, int) = Add;
	int (*pf2)(int, int) = Sub;
	int (*pf3)(int, int) = Mul;
	int (*pf4)(int, int) = Div;

	int (*pf[4])(int, int) = { Add,Sub,Mul,Div };
    //pf先与[4]结合，是数组，再与*结合，数组元素是指针类型，后面加()，是函数类型，且两个参数都是整型
	int i = 0;
	for (i = 0; i < 4; i++)
	{
		printf("%d\n", pf[i](8, 2));
	}
	return 0;
}

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

int Add(int x, int y)
{
	return x + y;
}
int main()
{
	int (*pf)(int, int) = &Add;//函数指针
	int (*pfarr[4])(int, int);//函数指针数组
	int (*(*p3)[4])(int, int) = &pfarr;//p3是指向函数指针数组的指针
	return 0;
}

8、回调指针

void test()
{
	printf("hello\n");
}
void print_hello(void(*p)() )
{
	p();
}
int main()
{
	print_hello(test);
	return 0;
}