指针
预备知识
内存地址
-
字节：字节是内存的容量单位，英文名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都指向了变量aprintf("%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 10q=&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); // 输出 45return 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;} -
