一，字符指针

字符指针 char* 一般的的使用：

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

还有另一种用法：

int main()
{
	const char* pc = "hello world";//这是把一个字符串都放进指针变量里了吗？
	printf("%s\n", pc);
	return 0;
}

下面我们用一个例子来说明：

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都是数组首元素的地址，由于str1与str2是两个数组显然他们的首地址不同，但是“hello world”这是个常量字符串，str3，str4里面存放的是这个常量字符串首元素的地址，这个常量字符串只会在内存中存放一次。

二，指针数组

上一节中我们已经介绍指针数组，就是数组中的各个元素都是指针类型的变量。这次我们举一个指针数组的例子，用指针数组来模拟实现一个二维数组：

int main()
{
	int a[5] = { 1,2,3,4,5 };
	int b[5] = { 2,3,4,5,6 };
	int c[5] = { 3,4,5,6,7 };
	int* p[3] = { a,b,c };
	int i = 0;
	int j = 0;
	for (i = 0; i < 3; i++)
	{
		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");
	}
	return 0;
}

无论采用上方哪种输出格式，最终结果都是一样的。

三，数组指针

指针数组的定义
数组指针是数组呢？还是指针呢？
大家已经知道指针数组是数组，那么想必大家已经猜到数组指针是一种指针。
没错，数组指针是指针的一种类型，是一种指向数组的指针。

int  (*p)  [5];

因为[] 的优先级高于* 所以为了确保是指针变量我们就得加上（）确保p先与 *结合。
数组名与&数组名
对于下面数组：

int arr[10];

arr与&arr分别是什么呢？
我么看一段代码：

int main()
{
	int arr[10] = { 0 };
	printf("%p\n", arr);
	printf("%p\n", &arr);
	return 0;
}

可以看到，没有任何区别，但是真的没有区别吗？

int main()
{
	int arr[10] = { 0 };
	printf("arr = %p\n", arr);
	printf("&arr= %p\n", &arr);
	printf("arr+1 = %p\n", arr + 1);
	printf("&arr+1= %p\n", &arr + 1);
	return 0;
}

可以看出数组名+1跳过一个整型的大小。
&数组名+1跳过的是一个数组的大小是40个字节。
数组指针的应用

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[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
	print_arr1(arr, 3, 5);
	//数组名arr，表示首元素的地址
	//但是二维数组的首元素是二维数组的第一行
	//所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
	//可以数组指针来接收
	print_arr2(arr, 3, 5);
	return 0;
}

二维数组名传参的时候，可以用数组指针来接收。

四，数组参数，指针参数

一维数组传参

void test(int arr[])//ok?
{}
void test(int arr[10])//ok?
{}
void test(int* arr)//ok?
{}
void test2(int* arr[20])//ok?
{}
void test2(int** arr)//ok?
{}
int main()
{
	int arr[10] = { 0 };
	int* arr2[20] = { 0 };
	test(arr);
	test2(arr2);
	return 0;
}

这几种方式都是正确的。
二维数组传参

void test(int arr[3][5])//ok？
{}
void test(int arr[][])//ok？
{}
void test(int arr[][5])//ok？
{}
//总结：二维数组传参，函数形参的设计只能省略第一个[]的数字。
//因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。
//这样才方便运算。
void test(int* arr)//ok？
{}
void test(int* arr[5])//ok？
{}
void test(int(*arr)[5])//ok？
{}
void test(int** arr)//ok？
{}
int main()
{
	int arr[3][5] = { 0 };
	test(arr);
	return 0;
}

我们画叉的的方式都是不可以的，你可以思考一下，是什么原因呢？
一级指针传参

#include <stdio.h>
void print(int* p, int sz)
{
	int i = 0;
	for (i = 0; i < sz; i++)
	{
		printf("%d\n", *(p + i));
	}
}
int main()
{
	int arr[10] = { 1,2,3,4,5,6,7,8,9 };
	int* p = arr;
	int sz = sizeof(arr) / sizeof(arr[0]);
	//一级指针p，传给函数
	print(p, sz);
	return 0;
}

二级指针传参

void test(int** ptr)
{
	printf("num = %d\n", **ptr);
}
int main()
{
	int n = 10;
	int* p = &n;
	int** pp = &p;
	test(pp);
	test(&p);
	return 0;
}

问题思考：

void test(*p)

这样的函数我们可以传什么参数呢？
1，&变量
2，一级指针
3，一维数组的数组名

void test(** p)

这样的函数呢？
1，&一级指针
2，二级指针
3，指针数组

谢谢观看，我们下期再见。