初识指针和指针变量
说到指针，估计还是有很多小伙伴都还是云里雾里的，有点“知其然，而不知其所以然”。但是，不得不说，学了指针，c语言才能算是入门了。指针是c语言的「精华」，可以说，对对指针的掌握程度，「直接决定」了你c语言的编程能力。
在讲指针之前，我们先来了解下变量在「内存」中是如何存放的。
在程序中定义一个变量，那么在程序编译的过程中，系统会根据你定义变量的类型来分配「相应尺寸」的内存空间。那么如果要使用这个变量，只需要用变量名去访问即可。
通过变量名来访问变量，是一种「相对安全」的方式。因为只有你定义了它，你才能够访问相应的变量。这就是对内存的基本认知。但是，如果光知道这一点的话，其实你还是不知道内存是如何存放变量的，因为底层是如何工作的，你依旧不清楚。
那么如果要继续深究的话，你就需要把变量在内存中真正的样子是什么搞清楚。内存的最小索引单元是1字节，那么你其实可以把内存比作一个超级大的「字符型数组」。在上一节我们讲过，数组是有下标的，我们是通过数组名和下标来访问数组中的元素。那么内存也是一样，只不过我们给它起了个新名字：地址。每个地址可以存放「1字节」的数据，所以如果我们需要定义一个整型变量，就需要占据4个内存单元。
那么，看到这里你可能就明白了：其实在程序运行的过程中，完全不需要变量名的参与。变量名只是方便我们进行代码的编写和阅读，只有程序员和编译器知道这个东西的存在。而编译器还知道具体的变量名对应的「内存地址」，这个是我们不知道的，因此编译器就像一个桥梁。当读取某一个变量的时候，编译器就会找到变量名所对应的地址，读取对应的值。
初识指针和指针变量
那么我们现在就来切入正题，指针是个什么东西呢？
所谓指针，就是内存地址（下文简称地址）。c语言中设立了专门的「指针变量」来存储指针，和「普通变量」不一样的是，指针变量存储的是「地址」。
定义指针
指针变量也有类型，实际上取决于地址指向的值的类型。那么如何定义指针变量呢：
很简单：类型名* 指针变量名
char*pa;//定义一个字符变量的指针，名称为pa int*pb;//定义一个整型变量的指针，名称为pb float*pc;//定义一个浮点型变量的指针，名称为pc
注意，指针变量一定要和指向的变量的类型一样，不然类型不同可能在内存中所占的位置不同，如果定义错了就可能导致出错。
取地址运算符和取值运算符
获取某个变量的地址，使用取地址运算符&，如：
char*pa=&a; int*pb=&f;
如果反过来，你要访问指针变量指向的数据，那么你就要使用取值运算符*，如：
printf(%c,%d ,*pa,*pb);
这里你可能发现，定义指针的时候也使用了*，这里属于符号的「重用」，也就是说这种符号在不同的地方就有不同的用意：在定义的时候表示「定义一个指针变量」，在其他的时候则用来「获取指针变量指向的变量的值」。
直接通过变量名来访问变量的值称之为直接访问，通过指针这样的形式访问称之为间接访问，因此取值运算符有时候也成为「间接运算符」。
比如：
//example01 //代码来源于网络，非个人原创 #include intmain(void) { chara='f'; intf=123; char*pa=&a; int*pf=&f; printf(a=%c ,*pa); printf(f=%d ,*pf); *pa='c'; *pf+=1; printf(now,a=%c ,*pa); printf(now,f=%d ,*pf); printf(sizeofpa=%d ,sizeof(pa)); printf(sizeofpf=%d ,sizeof(pf)); printf(theaddrofais:%p ,pa); printf(theaddroffis:%p ,pf); return0; }
程序实现如下：
//consequence 01 a = f f = 123 now, a = c now, f = 124 sizeof pa = 4 sizeof pf = 4 the addr of a is: 00eff97f the addr of f is: 00eff970
避免访问未初始化的指针
voidf() { int*a; *a=10; }
像这样的代码是十分危险的。因为指针a到底指向哪里，我们不知道。就和访问未初始化的普通变量一样，会返回一个「随机值」。但是如果是在指针里面，那么就有可能覆盖到「其他的内存区域」，甚至可能是系统正在使用的「关键区域」，十分危险。不过这种情况，系统一般会驳回程序的运行，此时程序会被「中止」并「报错」。要是万一中奖的话，覆盖到一个合法的地址，那么接下来的赋值就会导致一些有用的数据被「莫名其妙地修改」，这样的bug是十分不好排查的，因此使用指针的时候一定要注意初始化。
指针和数组
有些读者可能会有些奇怪，指针和数组又有什么关系？这俩货明明八竿子打不着井水不犯河水。别着急，接着往下看，你的观点有可能会改变。
数组的地址
我们刚刚说了，指针实际上就是变量在「内存中的地址」，那么如果有细心的小伙伴就可能会想到，像数组这样的一大摞变量的集合，它的地址是啥呢？
我们知道，从标准输入流中读取一个值到变量中，用的是scanf函数，一般貌似在后面都要加上&，这个其实就是我们刚刚说的「取地址运算符」。如果你存储的位置是指针变量的话，那就不需要。
//example02 intmain(void) { inta; int*p=&a; printf(请输入一个整数：); scanf(%d,&a);//此处需要& printf(a=%d ,a); printf(请再输入一个整数：); scanf(%d,p);//此处不需要& printf(a=%d ,a); return0; }
程序运行如下：
//consequence 02 请输入一个整数：1 a = 1 请再输入一个整数：2 a = 2
在普通变量读取的时候，程序需要知道这个变量在内存中的地址，因此需要&来取地址完成这个任务。而对于指针变量来说，本身就是「另外一个」普通变量的「地址信息」，因此直接给出指针的值就可以了。
试想一下，我们在使用scanf函数的时候，是不是也有不需要使用&的时候？就是在读取「字符串」的时候：
//example03 #include intmain(void) { charurl[100]; url[99]=''; printf(请输入techzone的域名：); scanf(%s,url);//此处也不用& printf(你输入的域名是：%s ,url); return0; }
程序执行如下：
//consequence 03 请输入techzone的域名：www.techzone.ltd 你输入的域名是：www.techzone.ltd
因此很好推理：数组名其实就是一个「地址信息」，实际上就是数组「第一个元素的地址」。咱们试试把第一个元素的地址和数组的地址做个对比就知道了：
//example03v2 #include intmain(void) { charurl[100]; printf(请输入techzone的域名：); url[99]=''; scanf(%s,url); printf(你输入的域名是：%s ,url); printf(url的地址为：%p ,url); printf(url[0]的地址为：%p ,&url[0]); if(url==&url[0]) { printf(两者一致！); } else { printf(两者不一致！); } return0; }
程序运行结果为：
//comsequense 03 v2 请输入techzone的域名：www.techzone.ltd 你输入的域名是：www.techzone.ltd url的地址为：0063f804 url[0]的地址为：0063f804 两者一致！
这么看，应该是实锤了。那么数组后面的元素也就是依次往后放置，有兴趣的也可以自己写代码尝试把它们输出看看。
指向数组的指针
刚刚我们验证了数组的地址就是数组第一个元素的地址。那么指向数组的指针自然也就有两种定义的方法：
... char*p; //方法1 p=a; //方法2 p=&a[0];
指针的运算
当指针指向数组元素的时候，可以对指针变量进行「加减」运算，+n表示指向p指针所指向的元素的「下n个元素」，-n表示指向p指针所指向的元素的「上n个元素」。并不是将地址加1。
如：
//example04 #include intmain(void) { inta[]={1,2,3,4,5}; int*p=a; printf(*p=%d,*(p+1)=%d,*(p+2)=%d ,*p,*(p+1),*(p+2)); printf(*p->%p,*(p+1)->%p,*(p+2)->%p ,p,p+1,p+2); return0; }
执行结果如下：
//consequence 04 *p = 1, *(p+1) = 2, *(p+2) = 3 *p -> 00aff838, *(p+1) -> 00aff83c, *(p+2) -> 00aff840
有的小伙伴可能会想，编译器是怎么知道访问下一个元素而不是地址直接加1呢？
其实就在我们定义指针变量的时候，就已经告诉编译器了。如果我们定义的是整型数组的指针，那么指针加1，实际上就是加上一个sizeof(int)的距离。相对于标准的下标访问，使用指针来间接访问数组元素的方法叫做指针法。
其实使用指针法来访问数组的元素，不一定需要定义一个指向数组的单独的指针变量，因为数组名自身就是指向数组「第一个元素」的指针，因此指针法可以直接作用于数组名：
... printf(p->%p,p+1->%p,p+2->%p ,a,a+1,a+2); printf(a=%d,a+1=%d,a+2=%d,*a,*(a+1),*(a+2)); ...
执行结果如下：
p->00aff838,p+1->00aff83c,p+2->00aff840 b=1,b+1=2,b+2=3
现在你是不是感觉，数组和指针有点像了呢？不过笔者先提醒，数组和指针虽然非常像，但是绝对「不是」一种东西。
甚至你还可以直接用指针来定义字符串，然后用下标法来读取每一个元素：
//example05 //代码来源于网络 #include #include intmain(void) { char*str=ilovetechzone!; inti,length; length=strlen(str); for(i=0;i
程序运行如下：
//consequence 05 i love techzone!
在刚刚的代码里面，我们定义了一个「字符指针」变量，并且初始化成指向一个字符串。后来的操作，不仅在它身上可以使用「字符串处理函数」，还可以用「下标法」访问字符串中的每一个字符。
当然，循环部分这样写也是没毛病的：
... for(i=0,i
这就相当于利用了指针法来读取。
指针和数组的区别
刚刚说了许多指针和数组相互替换的例子，可能有的小伙伴又开始说：“这俩货不就是一个东西吗？”
随着你对指针和数组越来越了解，你会发现，c语言的创始人不会这么无聊去创建两种一样的东西，还叫上不同的名字。指针和数组终究是「不一样」的。
比如笔者之前看过的一个例子：
//example06 //代码来源于网络 #include intmain(void) { charstr[]=ilovetechzone!; intcount=0; while(*str++!='') { count++; } printf(总共有%d个字符。 ,count); return0; }
当编译器报错的时候，你可能会开始怀疑你学了假的c语言语法：
//error in example 06 错误(活动)e0137表达式必须是可修改的左值 错误c2105“++”需要左值
我们知道，*str++ != ‘’是一个复合表达式，那么就要遵循「运算符优先级」来看。具体可以回顾《c语言运算符优先级及ascii对照表》。
str++比*str的优先级「更高」，但是自增运算符要在「下一条语句」的时候才能生效。所以这个语句的理解就是，先取出str所指向的值，判断是否为，若是，则跳出循环，然后str指向下一个字符的位置。
看上去貌似没啥毛病，但是，看看编译器告诉我们的东西：表达式必须是可修改的左值
++的操作对象是str，那么str到底是不是「左值」呢？
如果是左值的话，那么就必须满足左值的条件。
❝
拥有用于识别和定位一个存储位置的标识符
存储值可修改
❞
第一点，数组名str是可以满足的，因为数组名实际上就是定位数组第一个元素的位置。但是第二点就不满足了，数组名实际上是一个地址，地址是「不可以」修改的，它是一个常量。如果非要利用上面的思路来实现的话，可以将代码改成这样：
//example06v2 //代码来源于网络 #include intmain(void) { charstr[]=ilovetechzone!; char*target=str; intcount=0; while(*target++!='') { count++; } printf(总共有%d个字符。 ,count); return0; }
这样就可以正常执行了：
//consequence 06 v2 总共有16个字符。
这样我们就可以得出：数组名只是一个「地址」，而指针是一个「左值」。
指针数组？数组指针？
看下面的例子，你能分辨出哪个是指针数组，哪个是数组指针吗？
int*p1[5]; int(*p2)[5];
单个的我们都可以判断，但是组合起来就有些难度了。
答案：
int*p1[5];//指针数组 int(*p2)[5];//数组指针
我们挨个来分析。
指针数组
数组下标[]的优先级是最高的，因此p1是一个有5个元素的「数组」。那么这个数组的类型是什么呢？答案就是int*，是「指向整型变量的指针」。因此这是一个「指针数组」。
那么这样的数组应该怎么样去初始化呢？
你可以定义5个变量，然后挨个取地址来初始化。
不过这样太繁琐了，但是，并不是说指针数组就没什么用。
比如：
//example07 #include intmain(void) { char*p1[5]={ 人生苦短，我用python。, php是世界上最好的语言！, onemorething..., 一个好的程序员应该是那种过单行线都要往两边看的人。, c语言很容易让你犯错误；c++看起来好一些，但当你用它时，你会发现会死的更惨。 }; inti; for(i=0;i<5;i++) { printf(%s ,p1[i]); } return0; }
结果如下：
//consequence 07 人生苦短，我用python。 php是世界上最好的语言！ one more thing... 一个好的程序员应该是那种过单行线都要往两边看的人。 c语言很容易让你犯错误；c++看起来好一些，但当你用它时，你会发现会死的更惨。
这样是不是比二维数组来的更加直接更加通俗呢？
数组指针
()和[]在优先级里面属于「同级」，那么就按照「先后顺序」进行。
int(*p2)将p2定义为「指针」， 后面跟随着一个5个元素的「数组」，p2就指向这个数组。因此，数组指针是一个「指针」，它指向的是一个数组。
但是，如果想对数组指针初始化的时候，千万要小心，比如：
//example08 #include intmain(void) { int(*p2)[5]={1,2,3,4,5}; inti; for(i=0;i<5;i++) { printf(%d ,*(p2+i)); } return0; }
visual studio 2019报出以下的错误：
//error and warning in example 08 错误(活动)e0146初始值设定项值太多 错误c2440“初始化”: 无法从“initializer list”转换为“int (*)[5]” 警告c4477“printf”: 格式字符串“%d”需要类型“int”的参数，但可变参数 1 拥有了类型“int *”
这其实是一个非常典型的错误使用指针的案例，编译器提示说这里有一个「整数」赋值给「指针变量」的问题，因为p2归根结底还是指针，所以应该给它传递一个「地址」才行，更改一下：
//example08v2 #include intmain(void) { inttemp[5]={1,2,3,4,5}; int(*p2)[5]=temp; inti; for(i=0;i<5;i++) { printf(%d ,*(p2+i)); } return0; }//error and warning in example 08 v2 错误(活动)e0144int * 类型的值不能用于初始化 int (*)[5] 类型的实体 错误c2440“初始化”: 无法从“int [5]”转换为“int (*)[5]” 警告c4477“printf”: 格式字符串“%d”需要类型“int”的参数，但可变参数 1 拥有了类型“int *”
可是怎么还是有问题呢？
我们回顾一下，指针是如何指向数组的。
inttemp[5]={1,2,3,4,5}; int*p=temp;
我们原本以为，指针p是指向数组的指针，但是实际上「并不是」。仔细想想就会发现，这个指针实际上是指向的数组的「第一个元素」，而不是指向数组。因为数组里面的元素在内存中都是挨着个儿存放的，因此只需要知道第一个元素的地址，就可以访问到后面的所有元素。
但是，这么来看的话，指针p指向的就是一个「整型变量」的指针，并不是指向「数组」的指针。而刚刚我们用的数组指针，才是指向数组的指针。因此，应该将「数组的地址」传递给数组指针，而不是将第一个元素的地址传入，尽管它们值相同，但是「含义」确实不一样：
//example08v3 //example08v2 #include intmain(void) { inttemp[5]={1,2,3,4,5}; int(*p2)[5]=&temp;//此处取地址 inti; for(i=0;i<5;i++) { printf(%d ,*(*p2+i)); } return0; }
程序运行如下：
//consequence 08 1 2 3 4 5
指针和二维数组
在上一节《c语言之数组》我们讲过「二维数组」的概念，并且我们也知道，c语言的二维数组其实在内存中也是「线性存放」的。
假设我们定义了：int array[4][5]
array
array作为数组的名称，显然应该表示的是数组的「首地址」。由于二维数组实际上就是一维数组的「线性拓展」，因此array应该就是指的指向包含5个元素的数组的指针。
如果你用sizeof()去测试array和array+1的话，就可以测试出来这样的结论。
*(array+1)
首先从刚刚的问题我们可以得出，array+1同样也是指的指向包含5个元素的数组的指针，因此*(array+1)就是相当于array[1]，而这刚好相当于array[1][0]的数组名。因此*(array+1)就是指第二行子数组的第一个元素的地址。
*(*(array+1)+2)
有了刚刚的结论，我们就不难推理出，这个实际上就是array[1][2]。是不是感觉非常简单呢？
总结一下，就是下面的这些结论，记住就好，理解那当然更好：
*(array+i)==array[i] *(*(array+i)+j)==array[i][j] *(*(*(array+i)+j)+k)==array[i][j][k] ...
数组指针和二维数组
我们在上一节里面讲过，在初始化二维数组的时候是可以偷懒的：
intarray[][3]={ {1,2,3}, {4,5,6} };
刚刚我们又说过，定义一个数组指针是这样的：
int(*p)[3];
那么组合起来是什么意思呢？
int(*p)[3]=array;
通过刚刚的说明，我们可以知道，array是指向一个3个元素的数组的「指针」，所以这里完全可以将array的值赋值给p。
其实c语言的指针非常灵活，同样的代码用不同的角度去解读，就可以有不同的应用。
那么如何使用指针来访问二维数组呢？没错，就是使用「数组指针」：
//example09 #include intmain(void) { intarray[3][4]={ {0,1,2,3}, {4,5,6,7}, {8,9,10,11} }; int(*p)[4]; inti,j; p=array; for(i=0,i<3,i++) { for(j=0,j<4,j++) { printf(%2d,*(*(p+i)+j)); } printf( ); } return0; }
运行结果：
//consequence 09 0 1 2 3 4 5 6 7 8 9 10 11
void指针
void实际上是无类型的意思。如果你尝试用它来定义一个变量，编译器肯定会「报错」，因为不同类型所占用的内存有可能「不一样」。但是如果定义的是一个指针，那就没问题。void类型中指针可以指向「任何一个类型」的数据，也就是说，任何类型的指针都可以赋值给void指针。
将任何类型的指针转换为void是没有问题的。但是如果你要反过来，那就需要「强制类型转换」。此外，不要对void指针「直接解引用」，因为编译器其实并不知道void指针会存放什么样的类型。
//example10 #include intmain(void) { intnum=1024; int*pi=# char*ps=techzone; void*pv; pv=pi; printf(pi:%p,pv:%p ,pi,pv); printf(*pv:%d ,*pv); pv=ps; printf(ps:%p,pv:%p ,ps,pv); printf(*pv:%s ,*pv); }
这样会报错：
//error in example 10 错误c2100非法的间接寻址 错误c2100非法的间接寻址
如果一定要这么做，那么可以用「强制类型转换」：
//example10v2 #include intmain(void) { intnum=1024; int*pi=# char*ps=techzone; void*pv; pv=pi; printf(pi:%p,pv:%p ,pi,pv); printf(*pv:%d ,*(int*)pv); pv=ps; printf(ps:%p,pv:%p ,ps,pv); printf(*pv:%s ,pv); }
当然，使用void指针一定要小心，由于void指针几乎可以「通吃」所有类型，所以间接使得不同类型的指针转换变得合法，如果代码中存在不合理的转换，编译器也不会报错。
因此，void指针能不用则不用，后面讲函数的时候，还可以解锁更多新的玩法。
null指针
在c语言中，如果一个指针不指向任何数据，那么就称之为「空指针」，用「null」来表示。null其实是一个宏定义：
#definenull((void*)0)
在大部分的操作系统中，地址0通常是一个「不被使用」的地址，所以如果一个指针指向null，就意味着不指向任何东西。为什么一个指针要指向null呢？
其实这反而是一种比较指的推荐的「编程风格」——当你暂时还不知道该指向哪儿的时候，就让它指向null，以后不会有太多的麻烦，比如：
//example11 #include intmain(void) { int*p1; int*p2=null; printf(%d ,*p1); printf(%d ,*p2); return0; }
第一个指针未被初始化。在有的编译器里面，这样未初始化的变量就会被赋予「随机值」。这样指针被称为「迷途指针」，「野指针」或者「悬空指针」。如果后面的代码对这类指针解引用，而这个地址又刚好是合法的话，那么就会产生莫名其妙的结果，甚至导致程序的崩溃。因此养成良好的习惯，在暂时不清楚的情况下使用null，可以节省大量的后期调试的时间。
指向指针的指针
开始套娃了。其实只要你理解了指针的概念，也就没什么大不了的。
//example12 #include intmain(void) { intnum=1; int*p=# int**pp=&p; printf(num:%d ,num); printf(*p:%d ,*p); printf(**p:%d ,**pp); printf(&p:%p,pp:%p ,&p,pp); printf(&num:%p,p:%p,*pp:%p ,&num,p,*pp); return0; }
程序结果如下：
//consequence 12 num: 1 *p: 1 **p: 1 &p: 004ff960, pp: 004ff960 &num: 004ff96c, p: 004ff96c, *pp: 004ff96c
当然你也可以无限地套娃，一直指下去。不过这样会让代码可读性变得「很差」，过段时间可能你自己都看不懂你写的代码了。
指针数组和指向指针的指针
那么，指向指针的指针有什么用呢？
它可不是为了去创造混乱代码，在一个经典的实例里面，就可以体会到它的用处：
char*books[]={ 《c专家编程》, 《c和指针》, 《c的陷阱与缺陷》, 《cprimerplus》, 《python基础教程（第三版）》 };
然后我们需要将这些书进行分类。我们发现，其中有一本是写python的，其他都是c语言的。这时候指向指针的指针就派上用场了。首先，我们刚刚定义了一个指针数组，也就是说，里面的所有元素的类型「都是指针」，而数组名却又可以用指针的形式来「访问」，因此就可以使用「指向指针的指针」来指向指针数组：
... char**python; char**clang[4]; python=&books[5]; clang[0]=&books[0]; clang[1]=&books[1]; clang[2]=&books[2]; clang[3]=&books[3]; ...
因为字符串的取地址值实际上就是其「首地址」，也就是一个「指向字符指针的指针」，所以可以这样赋值。
这样，我们就利用指向指针的指针完成了对书籍的分类，这样既避免了浪费多余的内存，而且当其中的书名要修改，只需要改一次即可，代码的灵活性和安全性都得到了提升。
常量和指针
常量，在我们目前的认知里面，应该是这样的：
520, 'a'
或者是这样的：
#definemax1000 #defineb'b'
常量和变量最大的区别，就是前者「不能够被修改」，后者可以。那么在c语言中，可以将变量变成像具有常量一样的特性，利用const即可。
constintmax=1000; constchara='a';
在const关键字的作用下，变量就会「失去」本来具有的可修改的特性，变成“只读”的属性。
指向常量的指针
强大的指针当然也是可以指向被const修饰过的变量，但这就意味着「不能通过」指针来修改它所引用的值。总结一下，就是以下4点：
❝
指针可以修改为指向不同的变量
指针可以修改为指向不同的常量
可以通过解引用来读取指针指向的数据
不可以通过解引用来修改指针指向的数据
❞
常量指针
指向非常量的常量指针
指针本身作为一种「变量」，也是可以修改的。因此，指针也是可以被const修饰的，只不过位置稍稍「发生了点变化」：
... int*constp=# ...
这样的指针有如下的特性：
❝
指针自身不能够被修改
指针指向的值可以被修改
❞
指向常量的常量指针
在定义普通变量的时候也用const修饰，就得到了这样的指针。不过由于限制太多，一般很少用到：
... intnum=100; constintcnum=200; constint*constp=&cnum; ...
工控电脑在“5G智能汽车”中的作用是什么
闪存存储引领全球存储产业发展方向
华为双面玻璃新机nova lite比荣耀8青春版还漂亮
更新鸿蒙操作系统好有什么好处
浅析AMP汽车连接器的应用
初识指针和指针变量
国内研法的32层3DNAND闪存芯片已经大规模生产？对于国产你期待吗？
E拆解：华为 Mate50 Pro主板上有哪些IC？
小米旗下多款产品荣获2023年度评选奖项
3D线束设计按整车开发的四个阶段
诺基亚智能手机价格有望下调15%
电容式触摸感应按键解决方案
电子芯片龙头股票有哪些
企业参展须知
台积电称不会向美方提供机密数据
XBee-PRO 900HP异步周期休眠模式介绍
Nubia Watch现在可以在线预订
欧盟委员会表示并未通知成员国政府避免使用华为的5G设备
LED车灯有望成为汽车照明的一种潮流
如何将知识产权IP用作资产和抵押品
在讲指针之前，我们先来了解下变量在「内存」中是如何存放的。
在程序中定义一个变量，那么在程序编译的过程中，系统会根据你定义变量的类型来分配「相应尺寸」的内存空间。那么如果要使用这个变量，只需要用变量名去访问即可。
通过变量名来访问变量，是一种「相对安全」的方式。因为只有你定义了它，你才能够访问相应的变量。这就是对内存的基本认知。但是，如果光知道这一点的话，其实你还是不知道内存是如何存放变量的，因为底层是如何工作的，你依旧不清楚。
那么如果要继续深究的话，你就需要把变量在内存中真正的样子是什么搞清楚。内存的最小索引单元是1字节，那么你其实可以把内存比作一个超级大的「字符型数组」。在上一节我们讲过，数组是有下标的，我们是通过数组名和下标来访问数组中的元素。那么内存也是一样，只不过我们给它起了个新名字：地址。每个地址可以存放「1字节」的数据，所以如果我们需要定义一个整型变量，就需要占据4个内存单元。
那么，看到这里你可能就明白了：其实在程序运行的过程中，完全不需要变量名的参与。变量名只是方便我们进行代码的编写和阅读，只有程序员和编译器知道这个东西的存在。而编译器还知道具体的变量名对应的「内存地址」，这个是我们不知道的，因此编译器就像一个桥梁。当读取某一个变量的时候，编译器就会找到变量名所对应的地址，读取对应的值。
初识指针和指针变量
那么我们现在就来切入正题，指针是个什么东西呢？
所谓指针，就是内存地址（下文简称地址）。c语言中设立了专门的「指针变量」来存储指针，和「普通变量」不一样的是，指针变量存储的是「地址」。
定义指针
指针变量也有类型，实际上取决于地址指向的值的类型。那么如何定义指针变量呢：
很简单：类型名* 指针变量名
char*pa;//定义一个字符变量的指针，名称为pa int*pb;//定义一个整型变量的指针，名称为pb float*pc;//定义一个浮点型变量的指针，名称为pc
注意，指针变量一定要和指向的变量的类型一样，不然类型不同可能在内存中所占的位置不同，如果定义错了就可能导致出错。
取地址运算符和取值运算符
获取某个变量的地址，使用取地址运算符&，如：
char*pa=&a; int*pb=&f;
如果反过来，你要访问指针变量指向的数据，那么你就要使用取值运算符*，如：
printf(%c,%d ,*pa,*pb);
这里你可能发现，定义指针的时候也使用了*，这里属于符号的「重用」，也就是说这种符号在不同的地方就有不同的用意：在定义的时候表示「定义一个指针变量」，在其他的时候则用来「获取指针变量指向的变量的值」。
直接通过变量名来访问变量的值称之为直接访问，通过指针这样的形式访问称之为间接访问，因此取值运算符有时候也成为「间接运算符」。
比如：
//example01 //代码来源于网络，非个人原创 #include intmain(void) { chara='f'; intf=123; char*pa=&a; int*pf=&f; printf(a=%c ,*pa); printf(f=%d ,*pf); *pa='c'; *pf+=1; printf(now,a=%c ,*pa); printf(now,f=%d ,*pf); printf(sizeofpa=%d ,sizeof(pa)); printf(sizeofpf=%d ,sizeof(pf)); printf(theaddrofais:%p ,pa); printf(theaddroffis:%p ,pf); return0; }
程序实现如下：
//consequence 01 a = f f = 123 now, a = c now, f = 124 sizeof pa = 4 sizeof pf = 4 the addr of a is: 00eff97f the addr of f is: 00eff970
避免访问未初始化的指针
voidf() { int*a; *a=10; }
像这样的代码是十分危险的。因为指针a到底指向哪里，我们不知道。就和访问未初始化的普通变量一样，会返回一个「随机值」。但是如果是在指针里面，那么就有可能覆盖到「其他的内存区域」，甚至可能是系统正在使用的「关键区域」，十分危险。不过这种情况，系统一般会驳回程序的运行，此时程序会被「中止」并「报错」。要是万一中奖的话，覆盖到一个合法的地址，那么接下来的赋值就会导致一些有用的数据被「莫名其妙地修改」，这样的bug是十分不好排查的，因此使用指针的时候一定要注意初始化。
指针和数组
有些读者可能会有些奇怪，指针和数组又有什么关系？这俩货明明八竿子打不着井水不犯河水。别着急，接着往下看，你的观点有可能会改变。
数组的地址
我们刚刚说了，指针实际上就是变量在「内存中的地址」，那么如果有细心的小伙伴就可能会想到，像数组这样的一大摞变量的集合，它的地址是啥呢？
我们知道，从标准输入流中读取一个值到变量中，用的是scanf函数，一般貌似在后面都要加上&，这个其实就是我们刚刚说的「取地址运算符」。如果你存储的位置是指针变量的话，那就不需要。
//example02 intmain(void) { inta; int*p=&a; printf(请输入一个整数：); scanf(%d,&a);//此处需要& printf(a=%d ,a); printf(请再输入一个整数：); scanf(%d,p);//此处不需要& printf(a=%d ,a); return0; }
程序运行如下：
//consequence 02 请输入一个整数：1 a = 1 请再输入一个整数：2 a = 2
在普通变量读取的时候，程序需要知道这个变量在内存中的地址，因此需要&来取地址完成这个任务。而对于指针变量来说，本身就是「另外一个」普通变量的「地址信息」，因此直接给出指针的值就可以了。
试想一下，我们在使用scanf函数的时候，是不是也有不需要使用&的时候？就是在读取「字符串」的时候：
//example03 #include intmain(void) { charurl[100]; url[99]=''; printf(请输入techzone的域名：); scanf(%s,url);//此处也不用& printf(你输入的域名是：%s ,url); return0; }
程序执行如下：
//consequence 03 请输入techzone的域名：www.techzone.ltd 你输入的域名是：www.techzone.ltd
因此很好推理：数组名其实就是一个「地址信息」，实际上就是数组「第一个元素的地址」。咱们试试把第一个元素的地址和数组的地址做个对比就知道了：
//example03v2 #include intmain(void) { charurl[100]; printf(请输入techzone的域名：); url[99]=''; scanf(%s,url); printf(你输入的域名是：%s ,url); printf(url的地址为：%p ,url); printf(url[0]的地址为：%p ,&url[0]); if(url==&url[0]) { printf(两者一致！); } else { printf(两者不一致！); } return0; }
程序运行结果为：
//comsequense 03 v2 请输入techzone的域名：www.techzone.ltd 你输入的域名是：www.techzone.ltd url的地址为：0063f804 url[0]的地址为：0063f804 两者一致！
这么看，应该是实锤了。那么数组后面的元素也就是依次往后放置，有兴趣的也可以自己写代码尝试把它们输出看看。
指向数组的指针
刚刚我们验证了数组的地址就是数组第一个元素的地址。那么指向数组的指针自然也就有两种定义的方法：
... char*p; //方法1 p=a; //方法2 p=&a[0];
指针的运算
当指针指向数组元素的时候，可以对指针变量进行「加减」运算，+n表示指向p指针所指向的元素的「下n个元素」，-n表示指向p指针所指向的元素的「上n个元素」。并不是将地址加1。
如：
//example04 #include intmain(void) { inta[]={1,2,3,4,5}; int*p=a; printf(*p=%d,*(p+1)=%d,*(p+2)=%d ,*p,*(p+1),*(p+2)); printf(*p->%p,*(p+1)->%p,*(p+2)->%p ,p,p+1,p+2); return0; }
执行结果如下：
//consequence 04 *p = 1, *(p+1) = 2, *(p+2) = 3 *p -> 00aff838, *(p+1) -> 00aff83c, *(p+2) -> 00aff840
有的小伙伴可能会想，编译器是怎么知道访问下一个元素而不是地址直接加1呢？
其实就在我们定义指针变量的时候，就已经告诉编译器了。如果我们定义的是整型数组的指针，那么指针加1，实际上就是加上一个sizeof(int)的距离。相对于标准的下标访问，使用指针来间接访问数组元素的方法叫做指针法。
其实使用指针法来访问数组的元素，不一定需要定义一个指向数组的单独的指针变量，因为数组名自身就是指向数组「第一个元素」的指针，因此指针法可以直接作用于数组名：
... printf(p->%p,p+1->%p,p+2->%p ,a,a+1,a+2); printf(a=%d,a+1=%d,a+2=%d,*a,*(a+1),*(a+2)); ...
执行结果如下：
p->00aff838,p+1->00aff83c,p+2->00aff840 b=1,b+1=2,b+2=3
现在你是不是感觉，数组和指针有点像了呢？不过笔者先提醒，数组和指针虽然非常像，但是绝对「不是」一种东西。
甚至你还可以直接用指针来定义字符串，然后用下标法来读取每一个元素：
//example05 //代码来源于网络 #include #include intmain(void) { char*str=ilovetechzone!; inti,length; length=strlen(str); for(i=0;i
//consequence 05 i love techzone!
在刚刚的代码里面，我们定义了一个「字符指针」变量，并且初始化成指向一个字符串。后来的操作，不仅在它身上可以使用「字符串处理函数」，还可以用「下标法」访问字符串中的每一个字符。
当然，循环部分这样写也是没毛病的：
... for(i=0,i
指针和数组的区别
刚刚说了许多指针和数组相互替换的例子，可能有的小伙伴又开始说：“这俩货不就是一个东西吗？”
随着你对指针和数组越来越了解，你会发现，c语言的创始人不会这么无聊去创建两种一样的东西，还叫上不同的名字。指针和数组终究是「不一样」的。
比如笔者之前看过的一个例子：
//example06 //代码来源于网络 #include intmain(void) { charstr[]=ilovetechzone!; intcount=0; while(*str++!='') { count++; } printf(总共有%d个字符。 ,count); return0; }
当编译器报错的时候，你可能会开始怀疑你学了假的c语言语法：
//error in example 06 错误(活动)e0137表达式必须是可修改的左值 错误c2105“++”需要左值
我们知道，*str++ != ‘’是一个复合表达式，那么就要遵循「运算符优先级」来看。具体可以回顾《c语言运算符优先级及ascii对照表》。
str++比*str的优先级「更高」，但是自增运算符要在「下一条语句」的时候才能生效。所以这个语句的理解就是，先取出str所指向的值，判断是否为，若是，则跳出循环，然后str指向下一个字符的位置。
看上去貌似没啥毛病，但是，看看编译器告诉我们的东西：表达式必须是可修改的左值
++的操作对象是str，那么str到底是不是「左值」呢？
如果是左值的话，那么就必须满足左值的条件。
❝
拥有用于识别和定位一个存储位置的标识符
存储值可修改
❞
第一点，数组名str是可以满足的，因为数组名实际上就是定位数组第一个元素的位置。但是第二点就不满足了，数组名实际上是一个地址，地址是「不可以」修改的，它是一个常量。如果非要利用上面的思路来实现的话，可以将代码改成这样：
//example06v2 //代码来源于网络 #include intmain(void) { charstr[]=ilovetechzone!; char*target=str; intcount=0; while(*target++!='') { count++; } printf(总共有%d个字符。 ,count); return0; }
这样就可以正常执行了：
//consequence 06 v2 总共有16个字符。
这样我们就可以得出：数组名只是一个「地址」，而指针是一个「左值」。
指针数组？数组指针？
看下面的例子，你能分辨出哪个是指针数组，哪个是数组指针吗？
int*p1[5]; int(*p2)[5];
单个的我们都可以判断，但是组合起来就有些难度了。
答案：
int*p1[5];//指针数组 int(*p2)[5];//数组指针
我们挨个来分析。
指针数组
数组下标[]的优先级是最高的，因此p1是一个有5个元素的「数组」。那么这个数组的类型是什么呢？答案就是int*，是「指向整型变量的指针」。因此这是一个「指针数组」。
那么这样的数组应该怎么样去初始化呢？
你可以定义5个变量，然后挨个取地址来初始化。
不过这样太繁琐了，但是，并不是说指针数组就没什么用。
比如：
//example07 #include intmain(void) { char*p1[5]={ 人生苦短，我用python。, php是世界上最好的语言！, onemorething..., 一个好的程序员应该是那种过单行线都要往两边看的人。, c语言很容易让你犯错误；c++看起来好一些，但当你用它时，你会发现会死的更惨。 }; inti; for(i=0;i<5;i++) { printf(%s ,p1[i]); } return0; }
结果如下：
//consequence 07 人生苦短，我用python。 php是世界上最好的语言！ one more thing... 一个好的程序员应该是那种过单行线都要往两边看的人。 c语言很容易让你犯错误；c++看起来好一些，但当你用它时，你会发现会死的更惨。
这样是不是比二维数组来的更加直接更加通俗呢？
数组指针
()和[]在优先级里面属于「同级」，那么就按照「先后顺序」进行。
int(*p2)将p2定义为「指针」， 后面跟随着一个5个元素的「数组」，p2就指向这个数组。因此，数组指针是一个「指针」，它指向的是一个数组。
但是，如果想对数组指针初始化的时候，千万要小心，比如：
//example08 #include intmain(void) { int(*p2)[5]={1,2,3,4,5}; inti; for(i=0;i<5;i++) { printf(%d ,*(p2+i)); } return0; }
visual studio 2019报出以下的错误：
//error and warning in example 08 错误(活动)e0146初始值设定项值太多 错误c2440“初始化”: 无法从“initializer list”转换为“int (*)[5]” 警告c4477“printf”: 格式字符串“%d”需要类型“int”的参数，但可变参数 1 拥有了类型“int *”
这其实是一个非常典型的错误使用指针的案例，编译器提示说这里有一个「整数」赋值给「指针变量」的问题，因为p2归根结底还是指针，所以应该给它传递一个「地址」才行，更改一下：
//example08v2 #include intmain(void) { inttemp[5]={1,2,3,4,5}; int(*p2)[5]=temp; inti; for(i=0;i<5;i++) { printf(%d ,*(p2+i)); } return0; }//error and warning in example 08 v2 错误(活动)e0144int * 类型的值不能用于初始化 int (*)[5] 类型的实体 错误c2440“初始化”: 无法从“int [5]”转换为“int (*)[5]” 警告c4477“printf”: 格式字符串“%d”需要类型“int”的参数，但可变参数 1 拥有了类型“int *”
可是怎么还是有问题呢？
我们回顾一下，指针是如何指向数组的。
inttemp[5]={1,2,3,4,5}; int*p=temp;
我们原本以为，指针p是指向数组的指针，但是实际上「并不是」。仔细想想就会发现，这个指针实际上是指向的数组的「第一个元素」，而不是指向数组。因为数组里面的元素在内存中都是挨着个儿存放的，因此只需要知道第一个元素的地址，就可以访问到后面的所有元素。
但是，这么来看的话，指针p指向的就是一个「整型变量」的指针，并不是指向「数组」的指针。而刚刚我们用的数组指针，才是指向数组的指针。因此，应该将「数组的地址」传递给数组指针，而不是将第一个元素的地址传入，尽管它们值相同，但是「含义」确实不一样：
//example08v3 //example08v2 #include intmain(void) { inttemp[5]={1,2,3,4,5}; int(*p2)[5]=&temp;//此处取地址 inti; for(i=0;i<5;i++) { printf(%d ,*(*p2+i)); } return0; }
程序运行如下：
//consequence 08 1 2 3 4 5
指针和二维数组
在上一节《c语言之数组》我们讲过「二维数组」的概念，并且我们也知道，c语言的二维数组其实在内存中也是「线性存放」的。
假设我们定义了：int array[4][5]
array
array作为数组的名称，显然应该表示的是数组的「首地址」。由于二维数组实际上就是一维数组的「线性拓展」，因此array应该就是指的指向包含5个元素的数组的指针。
如果你用sizeof()去测试array和array+1的话，就可以测试出来这样的结论。
*(array+1)
首先从刚刚的问题我们可以得出，array+1同样也是指的指向包含5个元素的数组的指针，因此*(array+1)就是相当于array[1]，而这刚好相当于array[1][0]的数组名。因此*(array+1)就是指第二行子数组的第一个元素的地址。
*(*(array+1)+2)
有了刚刚的结论，我们就不难推理出，这个实际上就是array[1][2]。是不是感觉非常简单呢？
总结一下，就是下面的这些结论，记住就好，理解那当然更好：
*(array+i)==array[i] *(*(array+i)+j)==array[i][j] *(*(*(array+i)+j)+k)==array[i][j][k] ...
数组指针和二维数组
我们在上一节里面讲过，在初始化二维数组的时候是可以偷懒的：
intarray[][3]={ {1,2,3}, {4,5,6} };
刚刚我们又说过，定义一个数组指针是这样的：
int(*p)[3];
那么组合起来是什么意思呢？
int(*p)[3]=array;
通过刚刚的说明，我们可以知道，array是指向一个3个元素的数组的「指针」，所以这里完全可以将array的值赋值给p。
其实c语言的指针非常灵活，同样的代码用不同的角度去解读，就可以有不同的应用。
那么如何使用指针来访问二维数组呢？没错，就是使用「数组指针」：
//example09 #include intmain(void) { intarray[3][4]={ {0,1,2,3}, {4,5,6,7}, {8,9,10,11} }; int(*p)[4]; inti,j; p=array; for(i=0,i<3,i++) { for(j=0,j<4,j++) { printf(%2d,*(*(p+i)+j)); } printf( ); } return0; }
运行结果：
//consequence 09 0 1 2 3 4 5 6 7 8 9 10 11
void指针
void实际上是无类型的意思。如果你尝试用它来定义一个变量，编译器肯定会「报错」，因为不同类型所占用的内存有可能「不一样」。但是如果定义的是一个指针，那就没问题。void类型中指针可以指向「任何一个类型」的数据，也就是说，任何类型的指针都可以赋值给void指针。
将任何类型的指针转换为void是没有问题的。但是如果你要反过来，那就需要「强制类型转换」。此外，不要对void指针「直接解引用」，因为编译器其实并不知道void指针会存放什么样的类型。
//example10 #include intmain(void) { intnum=1024; int*pi=# char*ps=techzone; void*pv; pv=pi; printf(pi:%p,pv:%p ,pi,pv); printf(*pv:%d ,*pv); pv=ps; printf(ps:%p,pv:%p ,ps,pv); printf(*pv:%s ,*pv); }
这样会报错：
//error in example 10 错误c2100非法的间接寻址 错误c2100非法的间接寻址
如果一定要这么做，那么可以用「强制类型转换」：
//example10v2 #include intmain(void) { intnum=1024; int*pi=# char*ps=techzone; void*pv; pv=pi; printf(pi:%p,pv:%p ,pi,pv); printf(*pv:%d ,*(int*)pv); pv=ps; printf(ps:%p,pv:%p ,ps,pv); printf(*pv:%s ,pv); }
当然，使用void指针一定要小心，由于void指针几乎可以「通吃」所有类型，所以间接使得不同类型的指针转换变得合法，如果代码中存在不合理的转换，编译器也不会报错。
因此，void指针能不用则不用，后面讲函数的时候，还可以解锁更多新的玩法。
null指针
在c语言中，如果一个指针不指向任何数据，那么就称之为「空指针」，用「null」来表示。null其实是一个宏定义：
#definenull((void*)0)
在大部分的操作系统中，地址0通常是一个「不被使用」的地址，所以如果一个指针指向null，就意味着不指向任何东西。为什么一个指针要指向null呢？
其实这反而是一种比较指的推荐的「编程风格」——当你暂时还不知道该指向哪儿的时候，就让它指向null，以后不会有太多的麻烦，比如：
//example11 #include intmain(void) { int*p1; int*p2=null; printf(%d ,*p1); printf(%d ,*p2); return0; }
第一个指针未被初始化。在有的编译器里面，这样未初始化的变量就会被赋予「随机值」。这样指针被称为「迷途指针」，「野指针」或者「悬空指针」。如果后面的代码对这类指针解引用，而这个地址又刚好是合法的话，那么就会产生莫名其妙的结果，甚至导致程序的崩溃。因此养成良好的习惯，在暂时不清楚的情况下使用null，可以节省大量的后期调试的时间。
指向指针的指针
开始套娃了。其实只要你理解了指针的概念，也就没什么大不了的。
//example12 #include intmain(void) { intnum=1; int*p=# int**pp=&p; printf(num:%d ,num); printf(*p:%d ,*p); printf(**p:%d ,**pp); printf(&p:%p,pp:%p ,&p,pp); printf(&num:%p,p:%p,*pp:%p ,&num,p,*pp); return0; }
程序结果如下：
//consequence 12 num: 1 *p: 1 **p: 1 &p: 004ff960, pp: 004ff960 &num: 004ff96c, p: 004ff96c, *pp: 004ff96c
当然你也可以无限地套娃，一直指下去。不过这样会让代码可读性变得「很差」，过段时间可能你自己都看不懂你写的代码了。
指针数组和指向指针的指针
那么，指向指针的指针有什么用呢？
它可不是为了去创造混乱代码，在一个经典的实例里面，就可以体会到它的用处：
char*books[]={ 《c专家编程》, 《c和指针》, 《c的陷阱与缺陷》, 《cprimerplus》, 《python基础教程（第三版）》 };
然后我们需要将这些书进行分类。我们发现，其中有一本是写python的，其他都是c语言的。这时候指向指针的指针就派上用场了。首先，我们刚刚定义了一个指针数组，也就是说，里面的所有元素的类型「都是指针」，而数组名却又可以用指针的形式来「访问」，因此就可以使用「指向指针的指针」来指向指针数组：
... char**python; char**clang[4]; python=&books[5]; clang[0]=&books[0]; clang[1]=&books[1]; clang[2]=&books[2]; clang[3]=&books[3]; ...
因为字符串的取地址值实际上就是其「首地址」，也就是一个「指向字符指针的指针」，所以可以这样赋值。
这样，我们就利用指向指针的指针完成了对书籍的分类，这样既避免了浪费多余的内存，而且当其中的书名要修改，只需要改一次即可，代码的灵活性和安全性都得到了提升。
常量和指针
常量，在我们目前的认知里面，应该是这样的：
520, 'a'
或者是这样的：
#definemax1000 #defineb'b'
常量和变量最大的区别，就是前者「不能够被修改」，后者可以。那么在c语言中，可以将变量变成像具有常量一样的特性，利用const即可。
constintmax=1000; constchara='a';
在const关键字的作用下，变量就会「失去」本来具有的可修改的特性，变成“只读”的属性。
指向常量的指针
强大的指针当然也是可以指向被const修饰过的变量，但这就意味着「不能通过」指针来修改它所引用的值。总结一下，就是以下4点：
❝
指针可以修改为指向不同的变量
指针可以修改为指向不同的常量
可以通过解引用来读取指针指向的数据
不可以通过解引用来修改指针指向的数据
❞
常量指针
指向非常量的常量指针
指针本身作为一种「变量」，也是可以修改的。因此，指针也是可以被const修饰的，只不过位置稍稍「发生了点变化」：
... int*constp=# ...
这样的指针有如下的特性：
❝
指针自身不能够被修改
指针指向的值可以被修改
❞
指向常量的常量指针
在定义普通变量的时候也用const修饰，就得到了这样的指针。不过由于限制太多，一般很少用到：
... intnum=100; constintcnum=200; constint*constp=&cnum; ...
工控电脑在“5G智能汽车”中的作用是什么
闪存存储引领全球存储产业发展方向
华为双面玻璃新机nova lite比荣耀8青春版还漂亮
更新鸿蒙操作系统好有什么好处
浅析AMP汽车连接器的应用
初识指针和指针变量
国内研法的32层3DNAND闪存芯片已经大规模生产？对于国产你期待吗？
E拆解：华为 Mate50 Pro主板上有哪些IC？
小米旗下多款产品荣获2023年度评选奖项
3D线束设计按整车开发的四个阶段
诺基亚智能手机价格有望下调15%
电容式触摸感应按键解决方案
电子芯片龙头股票有哪些
企业参展须知
台积电称不会向美方提供机密数据
XBee-PRO 900HP异步周期休眠模式介绍
Nubia Watch现在可以在线预订
欧盟委员会表示并未通知成员国政府避免使用华为的5G设备
LED车灯有望成为汽车照明的一种潮流
如何将知识产权IP用作资产和抵押品