指针的进阶

1.字符指针（char * ）

一般这样子使用：

   int main()
   {
    char pw = 'c';
	char* ch = &pw;
	*ch = 'c';
	return 0;
    }

但更多是这样子使用：

   int main()
   {
    char* pw = "chang world";
	printf("%s\n", pw);
	return 0;
    }
    //输出为 change world 

值得注意的是：上面代码的意思是把一个常量字符串的首字符 c 的地址存放到指针变量 pw中,是把字符串 change world 放到字符指针 pw 里了。

2.指针数组 （“指针数组在我博客“指针的初阶讲到过”）

• 指针数组是数组，是存放指针的数组。
  举个例子：

  int arr1[7];
  char arr2[7];
  int* arr3[5];  

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

3.数组指针

数组指针是指针

     int (*p2)[10]  

解释：p先和*结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指 向一个数组，叫数组指针

4. &数组名 与 数组名

	int arr[10] = { 1, 2, 3, 4, 5, 6, 7, 8, 9 ,10};
	printf("%p\n", arr);
	printf("%p\n", &arr);
	printf("%p\n", arr+1);
	printf("%p\n", &arr+1);
	system("pause");
	return 0;

输出结果为：

• 其实&arr和arr，虽然值是一样的，但是意义是不一样的， &arr 表示的是数组的地址，而不是数组首元素的地址（闭上眼睛体会）。
• 数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40

5.数组指针的使用

#include<stdio.h>
#include<stdlib.h>
void print_arr1(int arr[3][5], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i<row; i++)
	{
		for (j = 0; j<col; j++) 
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
void print_arr2(int(*arr)[5], int row, int col)
{
	int i = 0;
	int j = 0;
	for (i = 0; i<row; i++)
	{
		for (j = 0; j<col; j++)
		{
			printf("%d ", arr[i][j]);
		}
		printf("\n");
	}
}
int main()
{
	int arr[2][5] = { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };
	print_arr1(arr, 2, 5);
	
	print_arr2(arr, 2, 5);
	//数组名arr，表示首元素的地址
	//但是二维数组的首元素是二维数组的第一行
	//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
	//可以用数组指针来接收
	system("pause");
	return 0;
}

6.数组参数，指针参数

• 一维数组传参

void test(int arr[])
{} 
void test(int arr[10])
{} 
void test(int *arr)//推荐
{}

• 二维数组传参

void test(int arr[3][5])
{}
void test(int arr[][5])
{}
void test(int (*arr)[5])
{} 
void test(int **arr)
{}

二维数组在传参时，函数形参的设计只能省略第一个 [ ]的数字。 //因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。

• 一级指针传参

void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i<sz; i++)
	{
		printf("%d\n", *(p + i));
	} 
}
int main()
{
	int arr[5] = { 1, 2, 3, 4, 5 };
	int *p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	print(p, sz); 
	//一级指针变量p，传给函数
	system("pause");
	return 0;
}

• 二级指针传参

void print(int** pp)
{
		printf("%d\n",**pp);
}
int main()
{
	int a = 10;
	int *p = &a;
	int **pp = &p;
	print(pp); 
	//二级指针变量pp，传给函数
	system("pause");
	return 0;
}

7.函数指针

void test()
{
	printf("hello world\n");
}
int main()
{
	printf("%p\n", test);
	printf("%p\n", &test);
	//输出两个都为函数的指针，但是第一种常用
	system("pause");
	return 0;
}

输出为：

如何调用函数指针？举个例子：

void test()
{
	printf("hello world\n");
}
int main()
{
	void(*p)() = test;
	p();//或者(*p)()，但最多用的是p();
	system("pause");
	return 0;
}

8.回调函数

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

#include <stdio.h>
#include<stdlib.h>

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* arr, 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 *)arr + j * size, (char *)arr + (j + 1)*size) > 0)
			{
				swap((char *)arr + j * size, (char *)arr + (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");
	system("pause");
	return 0;
}