C语言-指针进阶（9.1）
目录
思维导图：
1. 字符指针
2. 指针数组
3. 数组指针
3.1 数组指针的定义
3.2 &数组名VS数组名
3.3 数组指针的使用
4. 数组传参和指针传参
4.1 一维数组传参
4.2 二维数组传参
4.3 一级指针传参
4.4 二级指针传参
写在最后
思维导图：
1. 字符指针
顾名思义，字符指针就是存放字符的指针
char* 就是字符指针的类型。
例：
#include
int main()
{
char ch = 'a';//字符
char* p = &ch;//p就是字符指针
*p = 'b';
printf("%c", *p);
return 0;
} 输出：
输出：b例2：
#include
int main()
{
char arr[] = "abcdef";
char* pa = arr;//字符指针存放字符串首字符地址
printf("%s\n", pa);
return 0;
} 输出：
输出：abcdef例3：
有这样一道面试题：
#include
int main()
{
//str1和str2是开辟一块内存空间存放的字符串
//所以他们分别在不同的内存地址
char str1[] = "hello bit.";
char str2[] = "hello bit.";
//字符串"hello bit."是常量字符串
//C语言会将常量字符串单独存储到一个区域
const char* str3 = "hello bit.";
const char* str4 = "hello bit.";
//所以str1和str2在不同地址存放
//而str3和str4位于同一个地址
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 and str2 are not same
str3 and str4 are same2. 指针数组
指针数组是什么？
是数组，每个元素是指针的数组。
例：
int* arr1[10];//整形指针的数组
char* arr2[5];//字符指针的数组
int** arr3[15];//二级整形指针的数组3. 数组指针
3.1 数组指针的定义
那数组指针又是什么？
是指针，指向数组的指针。
那我们该怎么更好判断数组与指针的关系呢？
可以看主语是什么，例如：红红的苹果是 苹果。
那么，数组指针自然是 指针，指针数组自然是 数组。
例：
int arr[10];
int(*p)[10] = &arr;//注意看：*p与()结合，这是一个指针，指针数组
//&arr 取出的是整个arr数组的地址3.2 &数组名VS数组名
我们直接上代码：
#include
int main()
{
int arr[10] = { 0 };
printf("%p\n", arr);
printf("%p\n", &arr);
return 0;
} 输出：
输出：
00CFF88C
00CFF88C结果发现打印出来的都是首元素地址
那 arr 与 &arr 究竟有什么区别呢？
#include
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;
} 输出：
输出：
arr = 00AFFC7C
&arr= 00AFFC7C
arr+1 = 00AFFC80
&arr+1= 00AFFCA4所以在本质上，
arr是首元素的值，
而&arr是整个数组的地址。
3.3 数组指针的使用
我们可以用于接收一个二维数组的传参：
例：
#include
void print_arr1(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 print_arr2(int(*arr)[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");
}
}
int main()
{
int arr[3][5] = { 1,2,3,4,5,6,7,8,9,10 };
print_arr1(arr, 3, 5);//二维数组的数组名其实表示的是
//二维数组第一行的地址，
print_arr2(arr, 3, 5);//也就是一个数组的地址
return 0;
} 输出：
输出：
1 2 3 4 5
6 7 8 9 10
0 0 0 0 0
1 2 3 4 5
6 7 8 9 10
0 0 0 0 04. 数组传参和指针传参
4.1 一维数组传参
例：
#include
//arr
void test(int arr[])//可以接收，数组元素个数不是必要的
{}
void test(int arr[10])//可以接收，与原数组一模一样便于观察
{}
void test(int* arr)//可以接收，arr是数组首元素地址，可以用指针接收
{}
//***********************//
//arr2
void test2(int* arr[20])//可以接收，与原数组一模一样便于观察（当然，形参名可以自定义）
{}
void test2(int** arr)//可以接收，int*是数组元素类型，arr是数组首元素地址，用指针接收
{}
int main()
{
int arr[10] = { 0 };
int* arr2[20] = { 0 };
test(arr);
test2(arr2);
return 0;
} 4.2 二维数组传参
例：
void test(int arr[3][5])//可以接收，与原数组一模一样便于观察
{}
void test(int arr[][])//不能接收
{}
void test(int arr[][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;
}4.3 一级指针传参
例：
#include
void print(int* p, int sz)//用指针接收
{
int i = 0;
for (i = 0; i < sz; i++)
{
printf("%d ", *(p + i));//*(p + i)也可以写成 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]);
print(p, sz);//将指针传参
return 0;
} 输出：
输出：
1 2 3 4 5 6 7 8 9 04.4 二级指针传参
例：
#include
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;
} 输出：
输出：
num = 10
num = 10写在最后：
以上就是本篇文章的内容了，感谢你的阅读。
如果喜欢本文的话，欢迎点赞和评论，写下你的见解。
如果想和我一起学习编程，不妨点个关注，我们一起学习，一同成长。
之后我还会输出更多高质量内容，欢迎收看。