C语言-指针变量和变量指针

指针

预备知识

内存地址

• 字节：字节是内存的容量单位，英文名Byte，1Byte=8bits

• 地址：系统为了便于区分每一个字节面对它们的逐一进行编号（编号是唯一的），称为内存地址，简称地址。int a=5；

基地址（首地址）

• 单字节数据：对于单字节数据而言，其地址就是其字节编号。举例：char a='A'

• 多字节数据：对于多字节数据而言，其地址是所有字节中编号最小的那个，称为基地址()

取地址符

• 每个变量都是一块的内存，都可以通过取址符&获取其地址。

• 例如：

   int a=100;printf("整型变量a的地址是：%p\n",&a);//64位系统，是12位16进制int c='x';printf("字符变量c的地址是：%c");

• 主语：

  • 虽然不同的变量的尺寸是不同的，但是它们的地址尺寸是一致的。

  • 不同的地址虽然形式上看起来是一样的，但由于它们代表的内存尺寸和类型都不同，因此它们在逻辑上严格区分的。

为什么要引入指针

• 为函数修改实参提供支持。

• 为动态内存管理提供支持。

• 为动态的的数据结构（链表、队列等）提供支持

• 为内存访问提拱了另一种途径。

变量指针与指针变量

指针概念

内存单元与地址机制

• 内存单元划分

  • 系统将内存划分为连续的基本存储单元，每个单元的容量为1字节（8bits）

  • 每个内存单元拥有唯一编号。称为内存地址（十六进制表示：）

• 变量存储特性

  • 变量根据数据类型占据不同数量的内存单元：

    • char 类型占1个字节（1个单元）

    • int 类型占4个字节（4个单元）

    • double类型占8个字节（8个单元）

  • 变量的基地址(首地址)是其首个内存单元的地址(首地址一般是这个一组编号中最小的那个)

变量指针与指针变量

对比维度	变量指针	指针变量
本质	内存地址（首地址\基地址） 变量指针其实就是变量的首地址	存储地址的普通变量
操作符	&(取地址符)	*（声明符，解引用符，如：int *p）
代码示例	&a（获取变量a地址）	int* p =&a
核心特性	不可修改（地址由系统分配）	可修改指向（p=&b）

指向：

指针变量中存放 谁 的地址，就说明该指针变量指向了 谁

指针的尺寸

系统类型	指针尺寸	地址位数	十六进制显示长度
32位系统	4字节(int)	32bit	8位（如0x0804A000)
64位系统	8字节(long)	48bit	12位(如0x7FFDEADBEEF)

指针的本质

• 变量指针：数据的门牌号（&a）

• 指针变量：存储门牌号的笔记本（int *p）

• 指向操作：通过门牌号访问数据（*p）

 int a=10;printf("%d\n",a);//访问a的值​int *p=&a;printf("%d\n",*p);//访问p指向a的值，其实就是访问a的值

小贴士：

Linux系统中打印地址时，最多显示12个十六进制数，为什么? Linux64位操作系统中，一个内存地址占8个字节，一个字节8bit位，所以一个地址88=64bit位,每4个bit可以表示1个十六进制数; 64个bit位用十六进制表示最多有16个数值位; 系统为了寻址方便，默认当前计算机系统没必要寻址64bit为，只寻址了48个bit为，所以用12个十六进制数表示一个地址 二进制: 01001010 十六进制:0x4A 416+10=74 注意: 在Linux64位操作系统中，指针类型的变量占8个字节的内存空间 在Linux32位操作系统中，指针类型的变量占4个字节的内存空间

内存数据的存取方式

在c语言中对内存数据(变量、数组元素等)的存取有两种方式：

直接存取

• 通过基本类型（整型、浮点型、字符型）的变量，访问这个变量代表内存空间的数据

• 通过数组元素的引用，访问这个引用代表的内存空间数据

   //基本类型变量int a=10；//存printf("%d\n",a);//取​//数组元素int arr[]={11,12,13};//存arr[0]=66;//存printf("%d\n",arr[0]);//取

间接存取

• 通过指针变量，间接访问内存中的数据

• 解引用符*:读作声明符或者解引用符。如果*前面有数据类型，读作声明指针；如果*前面没有数据类型，读作解引用。

  案例

    #include <stdio.h>int main(int argc,char *argv[]){// 定义一个普通变量int a = 3;​// 定义一个指针变量，并赋值int* p = &a; // *p前面的数据类型是用来修饰 = 后面的 a的类型// 访问变量a，直接访问printf("直接访问-%d\n",a);// 访问变量a，通过指针变量p访问，间接访问printf("间接访问-%d\n",*p);// *p 叫做解引用// 访问指针变量p的值，也就是访问变量a的地址 %p 输出 变量的地址printf("地址访问-%p,%p,%p\n",p,&p,&a);return 0;}​​

  变量指针与指针变量

  指针变量的定义

  语法：

   数据类型 *变量列表

  举例：

   int a;//普通变量，拥有真实的数据存放空间int *a_,*b_;//指针变量，无法存放数据，只能存储其他变量的地址

  注意：指针变量的值只能是8、12位的十六进制整数

  注意：

  ①虽然定义指针变量*a，是在变量名前加上*，但是实际变量名依然为a，而不是*a

  ②使用指针变量间接访问内存数据时，指针变量必须要明确的指向。（指向：指针变量存放谁的地址，就指向谁）

  ③如果想要借助指针变量间接访问指针变量保存的内存地址上的数据，可以使用指针变量前加*，来间接返回访问。指针变量前加*，如果不带数据类型，就称之为对指针变量解引用

   int i=5,*p;p=&i;//将i的地址赋值给指针变量p;printf("%lx,%p,%p\n",p,p,&p); %p-&p（p自己的地址）  %p- p(i对应的地址)printf("%d\n",*p);解引用所储存变量空间的地址*p=10;//间接给p对应的地址上的数据空间赋值，也就是给变量i赋值printf("%d,%d\n",*p,i);//10 10

  ④指针变量只能指向同类型的变量，借助指针变量访问内存，一次访问内存

  大小是取决于指针变量的类型

   int a=10;int *p=&a;//*p前面的类型是p指向变量a的类型，这个类型要么完全一致，要么可以转换

  ⑤指针变量在定义时可以初始化，这一点和普通变量是一样的。

   int a=5;int *p=&a;//定义指针变量的同时初始化printf("%d\n",*p);​int b;int *p1=&b; //指针初始化的时候，不需要关注指向变量空间中是否有值printf("%d\n",*p1); 会出错

  指针变量的使用

  使用

  • 指针变量的赋值

     //方式1int a, *p;p=&a;// 先定义，后赋值​​//方式2int a1,*p1,*q1=&al; //定义并初始化p1=ql;//其实就是变量赋值，指针变量q1的值赋值给p1，此时q1和p1同时指向a1

  • 操作指针变量的值

     int a,*p,*q=&a;p=q;//将指针变量q的值赋值给指针变量p，此时p和q都指向了变量a​printf("%p",p);//访问的是指针变量p的值（也就是变量a的地址）printf("%p",q);

  • 操作指针变量指向的值

     int a=6;*q=&a,b=25;//一定要注意指针变量q的变量名就是q*q=10;//访问q指向的变量a的空间，其实就是间接的给a赋值（a=10）printf("%d,%d\n",*q,a);//10  10​q=&b;//一个指针变量只能同一时刻指向一个变量，但是一个变量可以同时被多个指针变量指向​printf("%d,%d\n",*q,a);// 25  10

  两个指针运算符使用

  • &取地址运算符。&a是变量a的地址。这个是变量指针

  • *指针运算符、解引用符、间接访问运算符，*p是指针变量p指向的对象值。这个是指针变量。

  案例

  案例1

  • 需求：通过指针变量访问整型变量

  • 分析：

  • 代码：

     #include <stdio.h>​void main(){int a=3,b=4,*p1=&a,*p2=&b;printf("a=%d,b=%d\n",*p1,*p2);​}

  案例2

  • 需求：声明a，b两个变量，使用间接存取的方式实现数据交换。

  • 分析：

  • 代码：

     #include <stdio.h>int main(){int a=3,b=4,*p_a=&a,*p_b=&b,*p_t;printf("交换前为%d,%d\n",*p_a,*P_b);//3,4//交换位置p_t=p_a;P_a=P_b;p_b=p_t;printf("交换后为%d,%d,%d,%d\n",*p_a,*P_b);}

    总结：此时改变的只是指针的指向，原始变量a，b中数据并没有发生改变

  • 代码：数据改变，不推荐

     #include <stdio.h>int main(){int a=3,b=4,*p_a=&a,*p_b=&b,temp;printf("交换前为%d,%d\n",*p_a,*P_b);//3,4//交换位置temp=*p_a;*P_a=*P_b;*p_b=temp;printf("交换后为%d,%d\n",*p_a,*P_b);}

    总结：此时改变的只是指针的指向，原始变量a，b中数据发生改变

  案例3

  • 需求：输入a、b两个整数，按先大后小的顺序输出a和b

  • 分析：

  • 代码：指向改变

     #include <stdio.h>int main(){int a=3,b=4,*p_a=&a,*p_b=&b,*p_t;if(a<b){p_t=p_a;P_a=P_b;p_b=p_t;}//交换位置printf("按从小到大的顺序输出a，b的值%d>%d\n",*p_a,*P_b);}

  • 代码：

     #include <stdio.h>int main(){int a=3,b=4,*p_a=&a,*p_b=&b,temp;printf("交换前为%d,%d\n",*p_a,*P_b);//3,4if(a<b){//交换位置temp=*p_a;*P_a=*P_b;*p_b=temp;}printf("按从小到大的顺序输出a，b的值%d>%d\n",*p_a,*P_b);}

  指针变量做函数参数

  指针变量做函数参数往往传递的是变量的地址（基地址），借助与指针变量间接访问是可以修改实参变量数据的。

  案例：

  • 需求：有a，b两个变量，要求交换后输出（要求函数处理，用指针变量做函数的参数）

  • 方式1：交换指向（指针指向发生改变，指针指向的对象的值不变）

     #include <stdio.h>//定义一个函数，实现两个数的交换​void swap(int *p_a,int *p_b){int *p_t;//以下写法只会改变指针指向 不会改变指向对象的值p_t=p_a;P_a=P_b;p_b=p_t;printf("%d,%d\n",*P_a,*p_b);}​int main(){int a=3,b=5,*p_a=&a,*p_b=&b,*p_t;swap(&a,&b);printf("a=%d,b=%d\n",a,b)return 0;}

  • 方式2：交换数据(指针指向不改变，指针指向对象的值发生变化)

     #include <stdio.h>​void swap(int *p_a,int *p_b){int temp;//以下写法只会改变指针指向 不会改变指向对象的值temp=*p_a;*P_a=*P_b;*p_b=temp;printf("%d,%d\n",*P_a,*p_b);}​​int main(){int a=3,b=4,*p_a=&a,*p_b=&b,temp;swap(&a,&b);printf("a=%d,b=%d\n",a,b);}

  指针变量指向数组元素

  数组元素指针

  • 数组的指针就是数组中的第一个元素的地址，也就是数组的首地址

  • 数组元素的指针是指数组的首地址。因此，同样可以用指针变量来指向数组或数组元素。

  • 在C语言中，由于数组名代表数组的首地址，因此，数组名实际上也是指针，访问数组名就是访问数组首地址

   #include <stdio.h>//定义一个函数，实现两个数的交换​​​int main(){int arr[]={11,12,13};int *p1=arr[0];int *p2=arr;printf("%p,%p,%p\n",p1,p2,arr);return 0;}

  注意：虽然我们定义一个指针变量接收了数组地址，但不能理解为指针变量指向了数组。而应该理解为指向了数组的元素（默认为第1个元素）。

  指针运算

  指针运算：前提是指针变量必须要指向数组的某个元素。（指针运算只能发生在同一数组）

  序号	指针运算	说明
  1	自增：p++、++p、p=p+1、p+=1	指向下一个元素的地址
  2	自减：p--、--p、p-=1	指向下一个元素的地址
  3	加n个数：p+n（n*sizeof(type)）	后n个元素的（首）地址
  4	减n个数：p-n	前n个元素的（首地址）
  5	指针相减：p1-p2	p1，p2之间相差几个元素
  6	指针比较：p1<p2	前面的指针小于后面的指针

  说明： ①如果指针变量p已指向数组中的一个元素，则p+1指向同一数组中的下一个元素，p-1指向同一数组中的上一个元素。即p+1或p-1也表示地址。但要注意的是，虽然指针变量p中存放的是地址，但p+1并不表示该地址加1，而表示在原地址的基础上加了该数据类型所占的字节数d（d=sizeof(数据类型)）。 ②如果p原来指向a[0]，执行++p后p的值改变了，在p的原值基础上加d，这样p就指向数组的下一个元素a[1]。d是数组元素占的字节数。 ③如果p的初值为&a[0]则p+i和a+i就是数组元素a[i]的地址，或者说，它们指向a数组的第i个元素。 ④*(p+i)或(a+i)是p+i或a+i所指向的数组元素，即a[i]。 ⑤如果指针变量p1和p2都指向同一数组，如执行p2-p1，结果是两个地址之差除以数组元素的长度d。

   #include <stdio.h>​int main(){int arr[]={11,22,33,44,55};int *p1=arr+4;//55等价于arr[4]int *p2=arr+1;//22等价于arr[1]aiprintf("%ld\n",p1-p2);//3      4*4-1*4=12   12(相差的字节数)/4(每个元素的大小ai)=3（元素的大小）return 0;}

  案例

  案例1

  • 需求：通过下标法和指针法遍历数组

  • 代码：

     #include <stdio.h>​//下标法遍历数组void arr1(int arr[],int len){//通过循环遍历for(int i=0;i<len;i++){printf("%-3d",arr[i]);}printf("\n");}​void arr2(int arr[],int len){int *p=arr;register int i=0;for(;i<len;i++){printf("%-3d",*p;p++;}printf("\n");​}​​void arr3(int arr[],int len){int *p=arr;register int i=0;for(;i<len;i++){printf("%-3d",*(arr+i));}printf("\n");}​​int main(){int array[]={11,22,33,44,55};int len=sizeof(arr)/sizeof(arr[0]);arr1(array,len);arr2(array,len);arr3(array,len);return 0;}​​

     #include <stdio.h>​int arr2() {int arr1[] = {11, 22, 33, 44, 55, 66, 77, 88};int *p = arr1;​// 1. 输出数组首元素 11printf("%d\n", *p); ​// 2. 指针后移，输出 22p++;printf("%d\n", *p); ​// 3. 先取值 22，指针再后移。此时 x=22，p 指向 33int x = *p++; printf("%d,%d\n", x, *p); // 输出 22,33​// 4. 指针先前移到 44，取值 44。y=44，p 指向 44int y = *(++p); printf("%d,%d\n", y, *p); // 输出 44,44​// 5. 对当前指向的元素（44）自增，变为 45(*p)++; printf("%d\n", *p); // 输出 45​return 0;}​int main(int argc, char *argv[]) {arr2();return 0;}

    *p++ 先解引用p，然后p这个指针自增

     int arr[]={11,22,33},*p=arr;int x=*p++;     

    (*p)++ 先解引用p，然后使用解引用出来的数据自增

     int arr[]={11,22,33};*p=arr;int x=(*p)++;

  通过指针引用数组元素

  引用一个数组元素，可以用：

  ①下标法：如：arr[i]形式

  ②指针法：如：*（arr+i）或者*（p+i），其中arr是数组名，p是指向数组元素的指针变量，其初始值;p=arr；

  案例：

  需求：有一个整型数组arr，有十个元素，输出数组中的全部元素。

  • 下标法：（通过改变下标输出所有元素）

     #include <stdio.h>void main(){int arr[10];int i;// 给数组元素赋值for(i = 0; i < 10; i++)scanf("%d",&arr[i]);// 遍历数组元素for(i = 0; i < 10; i++)printf("%-4d%",*(arr + i));printf("\n");   }

  • 指针法（地址）：（通过数组名计算出数组元素地址，找出数组元素）

     #include <stdio.h>void main(){int arr[10];int i;// 给数组元素赋值for(i = 0; i < 10; i++)scanf("%d",&arr[i]);// 遍历数组元素for(i = 0; i < 10; i++)printf("%-4d%",arr[i]);printf("\n");   }

  • 指针法（指针变量）：用指针变量指向数组元素

     #include <stdio.h>void main(){int arr[10];int *p, i;// 给数组元素赋值for(i = 0; i < 10; i++)scanf("%d",&arr[i]);// 遍历数组元素for(p = arr; p < (arr + 10); p++)printf("%-4d%",*p);printf("\n");   }

  注意：数组一旦创建，就无法改变其值

  以上三种写法比较：

  • 第种写法和第②种写法执行效率相同。系统是将arr[]转换为*(arr+i)处理的，即先计算出地址，因此比较费时。

  • 第③种方法比①②种方法快。用指针变量直接指向数组元素，不必每次都重新计算地址。(p++)能大大提高执行效率。

  • 用第①种写法比较直观，而用地址法或者指针变量的方法难以很快判断出当前处理的元素。

  使用指针变量指向数组元素时（上面第③种写法），注意以下三点：

  ①*（p--）相当于arr[i--],先*p，在p--；*(p++)相当于arr[i++],先*p，在p++

  ②*（++p）相当于arr[++i]，先++p，在*；*（--p）相当于arr[--i]，先--p，在*

  ③*p++先*p，在p++

  ④（*p）++先*p，在*p++

  *p++ （p++） （*p）++

  具体关系参照下面表格

  数组名做函数参数

  表现形式：

  ①形参和实参都是数组名

   void fun(int arr[],int len){......}void main(){int arr[]={11，22，33}；fun(arr,sizeof(arr)/sizeof(arr[0]));}

  ②实参用数组名，形参用指针变量

   void fun(int *p,int len){......}void main(){int arr[]={11，22，33}；fun(p,sizeof(arr)/sizeof(arr[0]));}

  ③实参和形参都用指针变量

   void fun(int *p,int len){......}void main(){int arr[]={11，22，33}；int *p=arr;fun(p,sizeof(arr)/sizeof(arr[0]));}

  ④实参用指针，形参用数组名

   void fun(int arr[],int len){......}void main(){int arr[]={11，22，33}；int *p=arr;fun(p,sizeof(arr)/sizeof(arr[0]));}

  案例：

  需求：将数组a中n个元素

  分析：

  代码：

   #include <stdio.h>/*** 数组的反转：数组实现*/ void inv(int arr[], int len){// 反转思路：将第0个和len -1个进行对调，将第1个和len-2个进行对调...// 定义循环变量和临时变量register int i = 0, temp;// 遍历数组for(; i < len/2; i++){// 交换temp = arr[i];arr[i] = arr[len - 1 - i];arr[len - 1 - i] = temp;}}/*** 数组的反转：指针实现*/ void inv2(int *p, int len){// 反转思路：将第0个和len -1个进行对调，将第1个和len-2个进行对调...// 定义循环变量和临时变量int *i = p, *j = p + len - 1, temp;// 遍历数组for(; i < j;i++,j--){// 交换temp = *i;*i = *j;*j = temp;}}/*** 遍历数组*/ void list(const int arr[],int len)for(int i = 0; i < len; i++) printf("%-3d",arr[i]);printf("\n");}int main(int argc,char *argv[]){int arr[] = {11,22,33,44,55,66};int len = sizeof(arr) / sizeof(arr[0]);list(arr,len);inv(arr,len);list(arr,len);inv2(arr,len);list(arr,len);return 0;}​