C语言/c++指针详细讲解【超详细】【由浅入深】

指针用法简单介绍

指针，是内存单元的编号。

内存条分好多好多小单元，一个小单元有 8 位，可以存放 8 个 0 或 1；也就是说，内存的编号不是以位算的，而是以字节算的，不是一个 0 或 1 是一个编号，而是 8 个 0 或 1 合在一起是一个编号。这个编号，就是地址。

内存条就分为好多小格子，一个格子一个编号（地址），相当于房子，一个房子一个地址。

[所谓的指针，就是地址。]

*p表示的是以p的内容为地址的变量

#include  int main() { int* p;//p是变量的名字，int*表示变量p存放的是int类型变量的地址 //int* 是p的数据类型，p是变量的名字。所谓的int*类型，就是可以存放int类型变量的地址的变量的类型 int i = 3; /*   i是整型int类型的变量，可以把变量i的地址放到变量p里   &i表示i的地址，&是取址符，表示获取一个变量的地址  */ p = &i;//把int类型的变量放到int*类型中 /*   类似的，double* p只能存放double类型的变量的地址，   而不能存放int类型的变量的地址  */  /*    关于对p=&i的理解：    p存放了i的地址，所以根据p可以知道i的位置，进而找到i。    所以说，p指向i。    p不是i，i也不是p；修改i的值不会改变p的值，修改p的值也不会影响i的值    举个例子：[小明]（指针变量p）手里拿了一张写了[小红家庭地址]（变量）的[纸条]（指针变量p存储的i地址&i），    小红的家庭发生任意改变，比如小红家新买了一辆汽车、丢了一袋垃圾，小明手中的纸条都不会发生改变    （变量i的值发生任意改变，+1或者-1，都不会影响指针变量p里存放的值）    小明在手里原本写着小红家庭地址的纸条上进行任意修改，小红的家的位置也不会发生任何变化    （原本存放变量i的地址的指针变量p的值发生任意变化也不会影响变量i的值）   */   /* int* p;int i; p和i都是变量，p是能存放其他类型的变量的地址的指针变量，i是只能存放其相应类型的值的普通的整型变量。 指针和地址是一个概念，指针变量也可以叫做地址变量 指针变量p存放了变量i的地址---指针变量p指向了变量i    */ printf("%d", *p == i);//1-->说明*p和i的值是一样的 /*   如果一个指针指向了某个变量，则：   *指针变量<---等价于--->普通变量   如：   如果p是指针变量，p存放了普通变量i的地址，则p指向i   *p<---等价于--->i   *p和i可以彼此之间相互替换使用  */  /*   *p表示的是以p的内容为地址的变量   */ return 0; }

指针和指针变量的区别:

指针就是地址，地址就是指针。

地址[指针]就是内存单元的编号。

指针变量是存放地址[指针]的变量

指针[地址]和指针变量是两个不同的概念

但是，有时候在叙述的时候，会把指针变量简称为指针，但是二者不是一回事儿

指针的重要性

·指针可以表示一些复杂的数据结构（比如用链表表示的一些数据结构）

·快速的传递数据

·使函数返回一个以上的值

·能直接访问硬件

·能够方便的处理字符串

·是面向对象语言中引用的基础

指针是C语言的灵魂

指针的定义

指针就是地址，地址就是指针。那么，指针和地址到底是什么?

地址

·内存单元的编号（就像房门牌号一样）

·地址是从0开始的非负整数

·[地址的范围，取决于系统的位数。在32位系统中，一个地址的范围是从0到2^32-1，即从0到4294967295。而在64位系统中，一个地址的范围是从0到2^64-1，即从0到18446744073709551615。这些范围都是基于系统的内存大小和寻址能力来确定的。]

指针

·指针就是地址，地址就是指针

·指针变量就是存放内存单元编号的变量，或者说，指针变量就是存放地址/指针的变量

·指针[地址]和指针变量是两个不同的概念。但是，有时候在叙述的时候，会把指针变量简称为指针，但是二者不是一回事儿

·指针的本质就是一个操作受限的非负整数

[“非负整数”，指地址是“从0开始的非负整数”。

“操作受限”，指针之间的运算只可以进行减法，不能进行加乘除运算]

指针可以进行那些运算

为什么指针只可以进行减法，不能进行加乘除运算？

两个指针相减的结果是一个整数值，表示两个指针之间相隔的元素个数或者内存单元的数目。 在数组中，如果两个指针指向同一个数组的元素，那么它们相减的结果就是它们之间相隔的元素个数。这个结果是一个整数，表示两个指针之间有多少个元素。例如，如果一个指针指向数组的第i个元素，另一个指针指向数组的第j个元素，那么它们的差值就是j-i，表示它们之间相隔的元素个数。 同样地，在内存中，如果两个指针指向不同的内存单元，那么它们相减的结果就是它们之间相隔的内存单元数目。这个结果是一个整数，表示两个指针之间有多少个内存单元。例如，如果一个指针指向内存地址A，另一个指针指向内存地址B，那么它们的差值就是B-A，表示它们之间相隔的内存单元数目。 需要注意的是，两个指针相减的结果是一个整数值，而不是地址量。这个整数值表示两个指针之间相隔的数据个数，而不是它们的内存地址差值。因此，在计算两个指针相减的结果时，应该将它们的地址值进行整数相减，而不是将它们的内存地址直接相减。 总之，两个指针相减的结果是一个整数值，表示两个指针之间相隔的元素个数或者内存单元的数目。这个结果是根据指针所指向的数据类型和内存布局来确定的。通过计算指针之间的差值，程序员可以方便地进行数组遍历、内存管理和其他相关操作。

然而，两个指针[地址]相加，就像一个门牌号加上另一个门牌号一样，没有实际意义。一个门牌号在减去另一个门牌号得到的整数就可以表示两个房间之间相差了多少个房间。（比如，房间1006和房间1001之间差了5个房间；1006-1001=5）。同样的两个指针[地址]（门牌号）相乘或相除也没有实际意义。

但是指针还可以与整数进行相加减。

指针与整数的加减表示指针在内存空间中向下或向上移动整数个单位。这个单位的大小取决于指针所指变量的类型。例如，如果是指向short型变量的指针，那么每次移动2个字节；如果是指向double型变量的指针，那么每次移动8个字节。当指针变量增加1时，其增加的值等于指向的类型占用的内存字节数。 指针与整数的加减运算在数组中位置的移动和内存地址的偏移中有实际应用。例如，通过将指针变量增加1，可以使其指向下一个数组元素，从而实现数组的遍历。同样地，通过指针与整数的加减运算，可以方便地访问和操作内存中的不同位置，实现动态内存分配、函数参数传递和数据结构实现等功能。 需要注意的是，指针与整数的加减运算是有单位的，以它所指向数据类型的字节数为单位进行加减。在C语言中，指针加法是以所指向数据类型的大小为单位的，例如int类型的指针加1就意味着偏移4个字节（假设int类型占用4个字节）。 总之，指针与整数的加减运算表示指针在内存空间中的移动。这种运算在数组索引、指针移动和内存访问等操作中具有重要意义，使程序员能够灵活地操作内存和数据结构，实现高效的数据处理和内存管理。

就行门牌号1003，加上一个整数2，就变成了门牌号1005的房间的地址；减去一个整数3，就变成了门牌号1000的房间的地址。

同样的，指针和整数之间不能进行乘除运算，没有实际意义。

【如果两个指针变量指向的是同一块连续空间中的不同存储单元，这两个指针变量才可以相减】

基本类型指针

[知识点前面已经说了，这里看几个代码示例：]

示例一

注意下面的代码的错误：

#include <stdio.h> int main(){     int* p;     int i=5;     *p=i;     printf("%d",*p);     return 0; }

*p指针变量只是进行了声明（给变量起名字和确定类型），而没有进行定义（给变量分配空间），没有给变量分配空间就无法进行初始化（赋值）。如果没有进行定义，那么这个变量的空间就是不确定的、随机的。

如果没有给指针变量分配内存空间，那么这个指针变量所指向的内存位置是不确定的、随机的。这意味着，当你试图通过这个指针进行读写操作时，你可能会不小心覆盖了其他重要的数据，或者访问了不属于你的内存空间（称为“越界”）。这会导致程序出现未定义的行为，可能是程序崩溃、数据损坏或其他不可预测的结果。

示例二

#include  int main() { int i = 5; int* p; int* q; p = &i; //*q=p; /*   错误：*q是int类型的变量，p是int*类型的变量，类型不一样，不能进行赋值  */  //*q=*p;  /*    错误：*q没有进行定义就给他赋值   */   //p=q;   /* 错误：q没定义，q变量存储的是int*类型的数据，但是是不确定的、随机的、垃圾值 把q存储的垃圾值赋值给p，p存储的东西也变成了垃圾值    */ return 0; }

用指针交换两个变量的值

#include <stdio.h> void jiaohuan(int a,int b){     int t=a;     a=b;     b=t; } int main(){     int a=3;     int b=5;     jiaohuan(a,b);     printf("%d,%d",a,b);//3,5     return 0; }

在这个代码中，经过jiaohuan(int a,int b)函数后，a、b的值没有发生变化。因为虽然函数jiaohuan(int a,int b)中的参数变量的名字是a、b，但是这是形参变量，形参变量不会影响函数外的变量。即使jiaohuan(int a,int b)中的参数变量的变量名换成别的c、d等等都是一样的

上述代码没有实现想要的功能，接下来用代码实现：

#include <stdio.h> void jiaohuan(int* p,int* q){     int * t=p;     p=q;     q=t; } int main(){     int a=3;     int b=5;     jiaohuan(&a,&b);     printf("%d,%d",a,b);//3,5     return 0; }

对于函数jiaohuan()，传参数的时候传的是&a,&b，不能是a和b。因为函数的形参列表里面的参数是int*类型的。所以这个函数传递的参数也只能是指针（地址），而不能是一个值。

之前不太明白。我想：如果传参数的时候传的是a,b，为什么函数的形参列表里面的参数变量的类型不能是*p、*q类型的？[原理，*p是表达式而不是变量。对于int* p,只能是int*类型的p变量而不是int类型的*p变量]

但是，上面这个代码也不能实现交换两个变量的值的功能。

因为：函数jiaohuan()交换的不是a、b的值而是p、q的值。p、q是形参，不会改变实际的实参a、b的值。

开始的时候把a的地址传递给了p，把b的地址传递给了q。函数结束后，p存储的是b的地址，q存储的是a的地址。函数使得p和q存储的地址进行了交换，不会影响a和b。

没有任何一个语言可以改变静态变量的位置。变量就相当于一个房子，可以改变房子里的东西，但是无法把房子连根拔起换到别的地方。

形参的变化不会影响到实参

#include <stdio.h> void jiaohuan(int* p,int* q){     int  t=*p;     *p=*q;     *q=t; } int main(){     int a=3;     int b=5;     jiaohuan(&a,&b);     printf("%d,%d",a,b);//5,3     return 0; }

这个代码就可以实现交换两个变量的值的功能了。

在函数中，p存储的是a的地址，*p表示的是int类型的以p的内容（a的地址）为地址的“变量”。所以，p指向a，同理，q指向b。

*p等价于a，*q等价于b

所以，在变量中，变量（盒子）里的东西（值）进行了交换，而不是（盒子）的地址进行了交换。

*的三种含义

1. 乘法
2. 定义指针
   1. int * p;定义了一个名字叫p的变量，int*表示p只能存放int类型的变量的地址
3. 指针运算符
   1. 该运算符放在已经定义好的指针变量的前面
   2. 如果p是一个已经定义好的指针变量，则*p表示以p的内容为地址的变量

int* p; *p = a;

这两行代码中，两个*的含义是不一样的！！！

如何通过被调函数修改主函数中普通变量的值

#include <stdio.h> void f(int* p,int* q){     *p=1;     *q=2; } int main(){     int a=3;     int b=5;     f(&a,&b);     printf("%d,%d",a,b);//1,2     return 0; }

1. 实参必须为该普通变量的地址
2. 形参必须是指针变量
3. 在被调函数中通过[*形参名=…]的方式可以修改主函数相关变量的值

指针和数组

一维数组名

一维数组名是个指针常量，存放的是一维数组的第一个元素的地址

第六行错误，因为一维数组名是常量，不能把一个值赋值给一个常量

#include <stdio.h> int main(){     int a[5];     printf("%#x\n",&a[0]);     printf("%#x\n",a);     return 0; }

地址在内存中以十六进制形式存储

一维数组名是个指针常量，存放的是一维数组的第一个元素的地址

那么，以上代码输出的十六进制应该是一样的

如果一个函数要处理一个一维数组，则需要接收该数组的哪些信息？

（确定一个一维数组需要几个参数？）

两个参数：数组名、数组长度

#include <stdio.h> void f(int *pArr,int len){     for(int i=0;i<len;i++){         printf("%d ",*(pArr+i));     } } int main(){     int a[5]={1,2,3,4,5};     f(a,5);     return 0; }

看下面的例子：

#include <stdio.h> void f(int *pArr,int len){     pArr[3]=999; } int main(){     int a[5]={1,2,3,4,5};     f(a,5);     printf("%d",a[3]);//999     return 0; }

a存放的是一维数组第一个元素的地址

*a等价于a[0]

*(a+1)等价于a[1]

*(a+2)等价于a[2]

……

上面的代码中，函数f()改变了主函数中数组的值：将a传进了函数，*pArr和*a是一样的，相当于两个变量都指向了相同的位置。

一个指针变量占几个字节

假设p指向char类型变量（1个字节）

假设q指向int类型变量（4个字节）

假设r指向double类型变量（8个字节）

p、q、r本身所占字节数是否一样？

#include <stdio.h> int main(){     char ch='a';     int w=1;     double d=1.2;          char* p=&ch;     int* q=&w;     double* r=&d;          printf("%d\n",sizeof(p));//8     printf("%d\n",sizeof(q));//8     printf("%d\n",sizeof(r));//8          return 0; }

这段代码中，指针的大小是固定的，不管它是指向哪种类型的变量。在大多数现代的64位系统上，一个指针的大小是8字节（64位）。所以，不论是指向字符、整数还是双精度浮点数的指针，它们的大小都是8字节。32位系统是4字节

传统数组（静态内存分配）的缺点

1. 数组长度必须事先指定，且只能是常整数，不能是变量
2. 传统形式定义的数组，该数组的内存程序员无法手动释放

数组一旦定义，系统为该数组分配的空间就会一直存在，除非该数组所在的函数终止。

在一个函数运行期间，系统为该函数中数组所分配的空间会一直存在，直到该函数运行完毕，数组的空间才会被系统释放。

1. 数组的长度不能在函数运行的过程中动态的扩充或缩小（数组的长度一旦定义就不能再改变了）
2. A函数定义的数组，在A函数运行期间可以被其他函数使用，但A函数运行完毕之后，A函数中的数组将无法被其他函数使用

传统方式定义的数组不能跨函数使用

使用动态内存分配的动态数组很好的解决了传统数组（静态数组）的这四个缺陷

malloc函数

#include  #include //使用malloc函数需要这个头文件 int main() { int i = 5;//分配了4个字节 静态分配 int* p = (int*)malloc(4); /* * 对于这句代码，有以下理解： 1、malloc函数只有一个形参，这个形参是整型 2、malloc（4）是请求系统分配4个字节的内存， 这个函数会返回系统所分配的内存的起始地址。 malloc（4）会返回系统分配的这4个字节的第一个字节的地址 3、(int*)malloc(4) 强制类型转换，将 malloc 返回的 void* 类型转换为 int* 类型。 malloc函数会返回一个 void* 类型的指针[地址]，这个指针指向分配的内存的起始地址。 由于 void* 是一个泛型指针类型，它不包含任何关于所指向数据类型的信息，因此在使用前需要进行类型转换。 在 (int*)malloc(4) 中，将 malloc 返回的 void* 指针转换为 int* 类型。 这意味着我们告诉编译器，我们希望这块内存能够存储整数类型的变量。 4、int* p 定义了一个名为 p 的指针变量，所以p用于存放int类型的数据的地址[指针] 5、最后p指向了4个字节，但本质上p里面只保存了这4个字节中的第一个字节的地址。 这4个字节在用的时候是作为一个整体来用的 6、int* p = (int*)malloc(4); 一共分配了12个字节：其中系统为指针变量p分配了8个字节（64位系统） 还分配了4个字节的空间，这4个字节被p指向（本质上p指向的是这4个字节的第一个字节的地址） 其中，p本身的8个字节是静态分配的，p指向的4个字节是动态分配的 7、p本身的8个字节p具有拥有权，而他指向的4个字节只具有使用权 8、*p不是变量，是表达式。但是*p可以作为变量来使用。*p所指向的内存是通过动态分配的 如果int a=*p; 则可以使用变量a代替表达式*p来使用 */ free(p); //表示把p所指向的内存给释放掉而不会把p本身所占用的内存释放，所谓释放内存，就是系统收回这段内存的使用权，而不会清空这块内存中的数据。被释放后，整个程序都失去了对这段内存的使用权而不仅仅是某个变量 return 0; }

 

#include  #include //使用malloc函数需要这个头文件 void f(int* q) { *q = 200; //free(q); } int main() { int* p = (int*)malloc(sizeof(int)); *p = 10; printf("%d\n", *p);//10 f(p); printf("%d\n", *p);//200 return 0; }

这段代码：

第一次输出*p的值，10

第二次输出*p的值，200

经过f()函数，将p中存储的地址复制给了q，所以在函数f()中，*q和*p是一样的

如果执行了free(q),将起不到修改*p的值的作用，还把p指向的空间给释放掉了，最后输出的时候不会输出200，而是一个不确定的随机的垃圾值

动态一维数组的构造

#include  #include //使用malloc函数需要这个头文件 int main() { int a[5];//int占4个字节，则本数组总共包含20个字节，每4个字节被当做一个int变量来使用 //把系统所分配的20个字节的前4个字节当做a[0]来使用，第5~8个字节当做a[1]来使用…… //只有所在的函数终止的时候这20个字节才会被释放 int len; printf("请输入要创建的数组长度：\n"); scanf("%d", &len); int* p = (int*)malloc(sizeof(int) * len); //在使用上，和静态数组的使用是一样的，相当于int p[len]，只是静态定义的数组不能用len这个变量 /* 这句代码分配了20个字节的内存，p指向了因为是强转成了int*类型， 所以p表示前4个字节，p+1表示第5~8个字节，p+2表示第9~12个字节…… *p等价于p[0],*(p+1)等价于p[1]，*(p+2)等价于p[2]…… 类似的，对于静态定义的数组，也可以有这样的写法 */ return 0; }

动态内存和静态内存的比较

静态内存和动态内存的区别主要表现在以下几个方面：

1. 分配时间：静态内存在程序编译开始阶段分配，动态内存在程序运行时分配。

2. 分配位置：静态内存分配在栈区或全局/静态存储区，动态内存分配在堆区。

3. 分配方式：静态内存由编译器自动分配，动态内存由程序员手动分配。

4. 分配大小：静态内存大小明确，分配时就确定；动态内存无法确定大小，需要指针来指示位置。

5. 管理方式：静态内存由编译器在程序开始运行时分配，并在程序结束时释放；动态内存由程序员在运行时分配和释放。

6. 运行速度：静态内存分配速度快，但占用空间大；动态内存分配速度慢，但节省空间。

7. 安全性：静态内存由编译器管理，安全性较高；动态内存管理需要程序员手动管理，容易出错，安全性较低。

综上所述，静态内存和动态内存的区别主要表现在分配时间、分配位置、分配方式、分配大小、管理方式、运行速度和安全性等方面。在实际编程中，根据需要选择使用哪种类型的内存，以提高程序的效率和安全性。

多级指针

无论是几级指针变量，都是之占8个字节