浅浅的复习一下基本知识吧
指针就是个变量，用来存放地址，地址唯一标识一块内存空间
内存会划分为小的内存单元，每个内存单元都有一个编号，这个编号就称为地址，这地址也叫作指针。所以内存编号 = 地址 =指针 ,指针或地址要存储可以放到指针变量中。
我们常说的指针实际为指针变量。
指针的大小是固定的4/8个字节（32位平台/64位平台）
指针是有类型的，指针的类型决定了指针±整数的步长 ，指针解引用操作的时候的权限
指针的运算
接下来我们继续探讨指针的高级主题吧
🐾字符指针
🌅字符指针的定义
字符指针：是指向字符的指针，类型为char*
🌅字符指针的用途
指向单个字符
char ch = 'w'; char* pc = &ch;
指向字符串的首地址
char* pa = "abcdef"; printf("%c\n",*pa);
用图像来深入理解：
1️⃣pc存有ch的地址，因此可通过解引用操作访问ch
2️⃣存放在指针里的是字符串首元素的地址，所以可以通过首元素的地址，从而打印出整个字符串
3️⃣字符串在内存空间上是连续存放的，即打印的abcdef是连续的。
为了防止常量字符串被改变，我们可以用const修饰，const的详细用法可以看我这篇博客十分钟深入理解const用法🌋
const char* pa = "abcdef";
✅例题
这是一道经典的面试题：
#include <stdio.h> 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; }
结果如下:
我们分析得知：
1️⃣ 这里str3和str4指向的是一个同一个常量字符串。C/C++会把常量字符串存储到单独的一个内存区域，当几个指针。指向同一个字符串的时候，他们实际会指向同一块内存。
2️⃣但是用相同的常量字符串去初始化不同的数组的时候就会开辟出不同的内存块开辟出不同的内存块。所以str1和str2不同，str3和str4不同。
🐾指针数组
🌅指针数组的定义
顾名思义→是一个存放指针的数组
int arr[10];//存放整型的数组 char arr2[10];//存放字符的数组 int* arr3[10];//存放整型指针的数组 char* ch[5];//存放字符指针的数组
🌅指针数组的应用
//不常见的方法 int a = 10; int b = 20; int c = 30; int* p1 = &a; int* p2 = &b; int* p3 = &c; int* arr[3] = { &a,&b,&c };
图解：
//常见的方法 #define _CRT_SECURE_NO_WARNINGS #include<stdio.h> 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 }; for (int i = 0; i < 3; i++) { for (int j = 0; j < 5; j++) { printf("%d ",parr[i][j]); //printf("%d ", *(parr[i]+j)); //printf("%d ", *(*(parr+i)+j)); } printf("\n"); } return 0; }
图解：
通过访问数组指针的时候，把[ ]当成运算符：
parr[i][j]等价于*(*(parr + i) + j)
🐾数组指针
🌅数组指针的定义
数组指针是指针？还是数组？
答案是：指针。
我们已经熟悉：
整形指针： int * pint; 能够指向整形数据的指针。
浮点型指针： float * pf;能够指向浮点型数据的指针。
打个比方：好孩子，主语应该是孩子，所以通过类比我们知道
数组指针：能够指向数组的指针
为了方便我们理解一个复杂的指针类型，我总结出一个小法宝，屡试不爽。
一个复杂的指针类型通常是由多个运算符组合 而成，我们首要目的就是要捋清楚运算符的优先级，哪个先哪个后，那指针的类型不就手到擒来吗？
指针里的运算符主要有三种，它们的优先级是：（）> [ ] > *
变量首次与*结合，就会变成指针，与[ ]结合就会变成数组。
可以结合（）变成函数，也可以通过（）来改变优先级。
接下来，我们实战一下吧
int* p[10]; int(*p)[10]; int p(int); Int (*p)(int); int *(*p(int))[3]; //上述的p分别是什么？
解释
int* p1[10]
解释：p1和[ ]先结合，说明p1是个数组名，数组有十个元素，每个元素是int*。所以p1是一个数组，里面存放的是指针，叫整型指针数组
int (*p)[10]
解释：p先和 *结合，说明p是一个指针变量，然后指着指向的是一个大小为10个整型的数组。所以p是一个指针，指向一个数组，叫整型数组指针。
这里要注意：[]的优先级要高于*号的，所以必须加上（）来保证p先和*结合。
int p(int)
解释：从P 处起,先与( )结合,说明P 是一个函数,然后进入( )里分析,说明该函数有一个整型变量的参数,然后再与外面的int 结合,说明则是参数为整型，返回值是整型的函数
Int (*p)(int)
解释：P 先与*结合,说明P 是一个指针,然后与( )结合,说明指针指向的是一个函数,函数的参数是int整型，返回值也是int，所以P 是一个指向有一个整型参数且返回类型为整型的函数指针
int *(*p(int))[3]
解释：P先与( )结合,说明P 是一个参数为int的函数,然后与*结合，说明函数返回的是一个指针,再与[ ]结合,说明返回的指针指向的是一个数组,再与*结合,说明数组里的元素是指针,最后与int 结合,说明指针指向的内容是整型数据。
所以P 是一个参数为int型且返回一个指向由整型指针组成的数组指针函数.
🌅浅探究指针
指针是一个特殊的变量，它里面存储的数值被解释成为内存里的一个地址。要搞清一个指针需要搞清指针的四个方面，下面我们继续探究🛫
🌳指针的类型
从语法的角度看，你只要把指针声明语句里的指针名字去掉，剩下的部分就是这个指针的类型。这是指针本身所具有的类型。让我们看看例一中各个指针的类型：
int*ptr;//指针的类型是int* char*ptr;//指针的类型是char* int**ptr;//指针的类型是int** int(*ptr)[3];//指针的类型是int(*)[3] int*(*ptr)[4];//指针的类型是int*(*)[4]
怎么样？找出指针的类型的方法是不是很简单🥸？
🌳指针所指向的类型
当你通过指针来访问指针所指向的内存区时，指针所指向的类型决定了编译器将把那片内存区里的内容当做什么来看待。
从语法上看，你只须把指针声明语句中的，指针名字和名字左边的指针声明符*去掉剩下的就是指针所指向的类型。例如：
int*ptr; //指针所指向的类型是int char*ptr; //指针所指向的的类型是char int**ptr; //指针所指向的的类型是int* int(*ptr)[3]; //指针所指向的的类型是int()[3] int*(*ptr)[4]; //指针所指向的的类型是int*()[4]
我们找到规律：
二者通过加减*可以互推
🌳指针的值
指针的值：指针里存放的地址
int a = 8; int *p = &a; *p = 0; printf("%d\n",a);
指针的值：p本身的值，p里存放这变量a的内存的起始地址。
指针所指向的内存区就是从指针的值所代表的那个内存地址开始，长度为sizeof(指针所指向的类型)的一片内存区。
以后，每遇到一个指针，都应该问问：这个指针的类型是什么？指针指的类型是什么？该指针指向了哪里？（重点注意）
🌳指针占据的大小
指针本身占了多大的内存？你只要用函数sizeof(指针的类型)测一下就知道了。
32位平台下占4个字节，64位平台占8个字节
🌅&数组名VS数组名
int arr[10];
arr 和 &arr 分别是啥？
我们知道arr是数组名，数组名表示数组首元素的地址。
那&arr数组名到底是啥？ 我们看一段代码：
#include <stdio.h> int main() { int arr[10] = {0}; printf("%p\n", arr); printf("%p\n", &arr); return 0; }
结果如下：
可见数组名和&数组名打印的地址是一样的。
难道两个是一样的吗？
我们再看一段代码：
#include <stdio.h> 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和arr，虽然值是一样的，但是意义应该不一样的。
实际上： &arr 表示的是数组的地址，而不是数组首元素的地址。（细细体会一下）
本例中 &arr 的类型是： int(*)[10] ，是一种数组指针类型
数组的地址+1，跳过整个数组的大小，所以 &arr+1 相对于 &arr 的差值是40.
通常情况下，数组名都是数组首元素的地址
🌍敲黑板~重点：有两个例外
① sizeof(数组名)，计算整个数组的大小，sizeof内部单独放一个数组名，数组名表示整个数组。
② &数组名，取出的是数组的地址。&数组名，数组名表示整个数组。
③除这两种外，数组名都是数组首元素的地址。
🌅数组指针的使用
那数组指针是怎么使用的呢？
既然数组指针指向的是数组，那数组指针中存放的应该是数组的地址。
void print1(int arr[], int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", arr[i]); } printf("\n"); } //形参写成指针的形式 void print2(int *arr, int sz) { int i = 0; for (i = 0; i < sz; i++) { printf("%d ", *(arr+i)); } printf("\n"); } int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; //写一个函数打印arr数组的内容 int sz = sizeof(arr) / sizeof(arr[0]); print1(arr, sz); print2(arr, sz); return 0; }
结果如下👇🏻：
当我们把数组传给函数时，有两种方法：👇🏻
int arr[ ]数组接收，其本质也是指针，因为编译器会把数组转化成指针！
指针接收，接收的数组名是首元素的地址。
当我们用数组指针来接收：👇🏻
void print1(int(*p)[10], int sz) { int i = 0; for (i = 0; i < 10; i++) { //*p 相当于数组名，数组名又是首元素的地址，所以*p就是&arr[0] printf("%d ", *((*p) + i)); } printf("\n"); } int main() { int arr[10] = { 1,2,3,4,5,6,7,8,9,10 }; //写一个函数打印arr数组的内容 int sz = sizeof(arr) / sizeof(arr[0]); print1(&arr, sz); return 0; }
但是我很不推荐用这种方法，这种写法比较别扭, 有一种脱裤子放屁、画蛇添足的感觉。
所以数组指针很少应用在一维数组上
我们通常会用数组指针来接收二维数组👇🏻
void print_arr1(int arr[3][5], int row, int col) { int i = 0; for (i = 0; i < row; i++) { for (int 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++) { for (int j = 0; j < col; j++) { //arr+i是指向第i行的 //*（arr+i）相当于拿到了第i行，也相当于第i行的数组名 //数组名表示首元素的地址，（*arr+i）也就是第i行第一个元素的地址 //printf("%d ", （*（arr+i）+j）); printf("%d ", arr[i][j]); } printf("\n"); } } int main() { int arr[3][5] = { 1,2,3,4,5, 6,7,8,9,10, 11,12,13,14,15 }; print_arr1(arr, 3, 5); print_arr2(arr, 3, 5); return 0; }
数组名arr，表示首元素的地址
但是二维数组的首元素是二维数组的第一行
所以这里传递的arr，其实相当于第一行的地址，是一维数组的地址
可以数组指针来接收
结果如下：👇🏻
所以最优解就是：使用数组指针来接收二维数组
📜 小练习
学习完了指针数组和数组指针，我们来一起回顾一下并看看下面代码的意思：👇🏻
int arr[5]; int *parr1[10]; int (*parr2)[10]; int (*parr3[10])[5];
arr是一个整型数组，每个元素是int类型的，有5个元素
.
parr1 首先和[ ]结合，所以是一个数组，数组10个元素，每个元素的类型是int*
.
parr2 首先和*结合，所以是一个指针， 指向的数组有10个元素，每个元素的类型是int
.
parr3 首先和[ ]，所以是一个数组，数组有10个元素，每个元素的类型是：int（*)[5]
parr3 是存放数组指针的数组
🐾数组参数和指针参数
在写代码的时候难免要把【数组】或者【指针】传给函数，那函数的参数该如何设计呢？
🌅 一维数组传参
判断以下接收方式“河里”吗？👇🏻
void test(int arr[])//ok? {} void test(int arr[10])//ok? {} void test(int arr[100])//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); }
以上方式都合理，接下来我们逐一分析一波：
形参写成数组形式：形参部分的数组大小可以省略
形参写成指针形式：要注意传的元素的类型，若传的是一级指针，则用二级指针来接收
🌅 二维数组传参
void test(int arr[3][5])//ok？ {} void test(int arr[][])//ok？ {} void test(int arr[][5])//ok？ {} int main() { int arr[3][5] = {0}; test(arr); }
分析如下：
那我们是不是有疑问说：为什么可以省略二维数组的行数，但不能省略列数❓
答：二维数组在内存中的地址排列方式是按行排列的连续存放，第一行排列完之后再排列第二行，以此类推
如果我们不知道列数，也就不知道一行能放多少个。
只要知道了列数，放完后就会知道放了多少行
继续判断以下接收方式“河里”吗？👇🏻
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); }
分析如下：
总结：
二维数组传参，函数形参的设计只能省略第一个[]的数字。
因为对一个二维数组，可以不知道有多少行，但是必须知道一行多少元素。这样才方便运算。
形参类型要相匹配：指向数组首行的地址，类型要相匹配
开个小灶：
int arr[10]; test(arr);
🤔形参为数组时，其本质还是指针 ！编译器会把数组转化成指针
