指针
- 指针是什么
话说福尔摩斯派华生到威尔爵士居住的城堡去取回一个重要的数据。白天，在书房里，威尔爵士当着福尔摩斯和华生的面亲自将数据锁在了书柜中编号为3010的抽屉，用手电筒一照，只见里面有一张纸条，上面赫然写着6个大字：地址2000。华生眼前一亮，迅速的找到了编号为2000的抽屉，取出了重要的数据123，完成了任务。
可以用下图描述几个数据之间的关系。
文章图片
img 说明：
（1）数据藏在一个内存地址单元中，地址是2000.
（2）地址2000又由Pointer单元所指认，Pointer单元的地址为3010.
（3）123的直接地址是2000,123的间接地址是3010,3010中存的是直接地址2000.
（4）称Pointer单元为指针变量，2000是指针变量的值。
由此可见，指针变量是一种特殊的变量，它存放的不是数据，而是另一种变量的地址。这个存放数据的变量被称为指针变量所指向的目标变量。**由于通过指针变量中的地址可以直接访问它指向的目标变量，常把指针变量简称为指针。
**
指针变量是一种存放地址的特殊变量，其特殊性表现在类型和值上。从变量角度讲，指针变量也具有变量的要素：
（1）指针变量的命名，与一般变量命名相同，遵循c语言的命名规则。
（2）指针变量的类型，是指针变量所指向的变量的类型，而不是自身的类型。
（3）在实验楼的环境中，指针变量在内存中占用8个字节。
- 指针变量
#include
int main()
{
int a=100,b=10;
int *pointer_1,*pointer_2;
//定义指向整型数据的指针变量pionter_1,pionter_2
pointer_1=&a;
//把变量a的地址赋给指针变量pointer_1
pointer_2=&b;
printf("a=%d,b=%d\n",a,b);
printf("%p,%p\n",pointer_1,pointer_2);
//输出a和b在内存中的地址
printf("*pointer_1=%d,*pointer_2=%d\n",*pointer_1,*pointer_2);
//输出变量a和b的值 return 0;
}
运行结果：
文章图片
img 代码中如果指针打印出为负数，则需要将打印的类型
%d调整为%ld才可以正常输出。调整成%p去匹配指针型最佳。程序分析：
（1）在开头处定义了两个指针变量point_1和point_2。但此时他们并未指向任何一个变量，只是提供两个指针变量，规定他们可以指向整形变量，至于指向哪一个整形变量，要在程序语句中指定。程序第6,7两行的作用就是使point_1指向a，point_2指向b，此时point_1的值为&a（即a的地址），point_2的值为&b。
（2）第10行输出*point_1和*point_2的值，其中的“*”表示“指向”。*point_1表示“指针变量point_1所指向的变量”，也就是变量a。*point_2表示“指针变量point_2所指向的变量”，也就是变量b。从运行结果来看他们也就是100和10.
（3）程序中有两处出现*point_1和*point_2，但是两者含义不同。程序第5行的*point_1和*point_2表示定义两个指针变量*point_1和*point_2。它们前面的“*”只是表示该变量是指针变量。程序最后10行中的printf函数中的*point_1和*point_2则表示指针变量point_1和point_2所指向的变量。
- 定义指针变量
类型名 * 指针变量名
如
int * point_1,* point_2;
上面定义的、基类型为int的指针变量point_1和point_2只能用来指向整形的变量。
注意：我们在这里再次强调一遍，在定义指针变量时要注意，指针变量前面的“*”表示该变量的类型为指针型变量。指针变量名是point_1和point_2，而不是*point_1和*point_2。这是和定义整形或实型变量不同的。上面程序6行和7行是不能写成
* point_1=&a；和 *point_2=&b;
的。因为a的地址是赋给指针变量point_1，而不是赋值给* point_1（即变量a）。- 引用指针变量
p=&a;
//把a的地址赋给指针变量p指针变量p的值是变量a的地址，p指向a。
（2）引用指针变量指向的变量。
如果已经执行
p=&p即指针变量p指向了整形变量a，则printf("%d\n";
,*p);
其作用是以整数形式输出指针变量p所指向的变量的值，即变量a的值。如果有以下赋值语句：
*p=1;
表示将整数1赋给p当前所指向的变量，如果p指向变量a，则相当于把1赋给a，即
a=1;
.（3）引用指针变量的值。如：
printf("%o\n";
,p);
作用是以八进制数形式输出指针变量p的值，如果p指向了a，就是输出了a的地址，即&a。
注意：比较地址运算符&和指针运算符*的差异：
文章图片
Alt text
- 程序举例
解题思路：用指针的方法来处理这个问题。不交换整形变量的值，而是交换两个指针变量的值。
编写程序：
#include
int main()
{
int *p1,*p2,*p,a,b;
printf("please enter two integer number:");
scanf("%d,%d",&a,&b);
p1=&a;
p2=&b;
if(a运行结果：
文章图片
Alt text 程序分析
输入23和42，由于a
文章图片
Alt text 注意：a和b的值并未交换，他们仍然保持原值，但p1和p2的值改变了。p1的值原来为&a，后来变为&b。这样输出* p1和* p2时，实际上输出变量b和a的值，所以先输出42，然后输出23.
程序中
p=p1;
p1=p2;
p2=p;
这个语句是我们之前使用过的方法，两个变量的值交换要利用第三个变量。实际上学到指针我们可以用更加简洁的方法把p=p1;
p1=p2;
p2=p;
改为p1=&b,p2=&a，这样就不需要定义中间变量p，使得程序更加简洁。#include int main()
{
int *p1,*p2,a,b;
a=rand();
b=rand();
p1=&a;
p2=&b;
printf("p1=%p,p2=%p\n",p1,p2);
printf("*p1=%d,*p2=%d\n",*p1,*p2);
printf("a=%d,b=%d\n",a,b);
if (a- 指针变量作为函数参数
编写程序10-3，要求实现的功能和10-2相同，只不过这次我们采用函数来处理，而且用指针类型的数据做函数的参数。
#include
int main()
{
void swap(int * point_1,int * point_2);
int *p1,*p2,*p,a,b;
printf("please enter two integer number:");
scanf("%d,%d",&a,&b);
p1=&a;
p2=&b;
if(a运行结果为：
文章图片
Alt text 程序分析：
swap是用户自定义函数，它的作用是交换两个变量（a和b）的值。swap函数的两个形参point_1和point_2是指针变量。程序运行时，先执行main函数，输入a和b的值（我们输入的是23和34），然后将a和b的地址分别赋给int 指针变量p1和p2，使p1指向a，p2指向b，见下图a，接着执行if语句，由于a
**
如将swap函数改为下面的形式：
void swap(int x ,int y)
{
int temp;
temp=x;
x=y;
y=temp;
}
如果在main函数中调用swap函数：
swap(a,b);
在函数调用时，a的值传送给x，b的值传送给y，执行完swap函数后，x和y的值是互换了，但并未影响到a和b的值。在函数结束时，变量x和y释放了，main函数中的a和b并未互换。也就是说，这种单向的值传递，形参值的改变不能使实参的值随之改变。
为了使在函数中改变了的变量值能被主调函数main所用，不能采取上述的把要改变的变量作为参数的办法，而应该用指针变量作为函数参数，在函数执行过程中使指针变量所指向的变量值发生变化，函数调用结束后，这些变量值依然保留了下来。
如果想通过函数调用得到n个要改变的值，可以这样做：
（1）在主调函数中设n个变量，用n个指针变量指向它们；
（2）设计一个函数，有n个指针形参，在这个函数中改变n个形参的值；
（3）在主调函数中调用这个函数，在调用时将这n个指针变量作实参，将他们的地址传给该函数的形参。
（4）在执行该函数的过程中，通过形参指针变量，改变它们所指向的n个变量的值；
（5）主调函数中就可以使用这些改变了值的变量了。
通过指针引用数组 可以用一个指针变量指向一个数组元素。例如：
int a[10]={1,2,3,4,5,6,7,8,9,10};
int *P;
p=&a[0];
p=&a[0];
使指针变量p指向a数组的第0号元素。在c语言中，数组名（不包括形参数组名，形参数组并不占据实际的内存单元）代表数组中首元素（即序号为0的元素）的地址。因此，下面两个语句等价：
p=&a[0];
//p的值是a[0]的地址
p=a;
//p的值是数组a首元素（即a[0]）的地址
注意：数组名不代表整个数组，只代表数组首元素的地址。上述
p=a;
的作用是“把a数组的首元素的地址赋给指针变量p”，而不是“把数组a各元素的值赋给p”。- 引用数组元素时指针的运算
- 加减一个整数，如
p+1;或者p-1; - 自加运算，如
p++或者++p - 自减运算，如
p--或者--p
（1）如果指针变量p已指向数组中的一个元素，则p+1指向同一数组中的下一个元素，p-1指向同一数组中的上一个元素。
注意: 执行p+1时并不是将p的值（地址）简单地加1，而是加上一个数组元素所占用的字节数。例如，数组元素是float型，每个元素占4个字节，则p+1意味着使p的值加4个字节，以使它指向下一个元素。p+1所代表的地址实际上是p+1*d，d是一个数组元素所占的字节数。若p的值是2000，则p+1的值不是2001而是2004。
（2）如果p的初值为&a[0],则p+i和a+i就是数组元素a[i]的地址，或者说，他们指向a数组序号为i的元素，见下图，这里注意的是a代表数组首元素的地址，a+1也是地址，它的计算方法同p+1，即它的实际地址为a+1*d。例如，p+9和a+9的值是&a[9],它指向a[9]。
文章图片
Alt text （3）*（p+i）和*(a+i)是p+i或a+i所指向的元素，即a[i]。例如*(p+5)和*(a+5)就是a[5]，三者等价。
根据以上叙述，引用一个数组元素，可以用下面两种方法：
（1）下标法，如a[i]的形式；
（2）指针法，如*（a+1）或*（p+i）。其中a是数组名，p是指向数组元素的指针变量，其初值p=a。
程序举例
有一个整型数组a，有10个元素，要求输出数组中的全部元素。
解题思路：引用数组中各元素的值有3中方法：
（1）下标法，如a[i]；
（2）通过数组名计算数组元素地址，找出元素的值；如
*(a+i)#include
int main()
{
int a[10];
int i;
printf("please enter 10 integer numbers: ");
for(i=0;
i<10;
i++)
scanf("%d",&a[i]);
for(i=0;
i<10;
i++)
printf("%d\t",*(a+i));
//通过数组名和元素序号计算元素地址，再找该元素
return 0;
}
程序中
scanf("%d",&a[i]);
用&a[i])代表a[i]的地址，因此也可用a+i代表（数组名代表数组中首元素（即序号为0的元素）的地址）scanf("%d",&a[i]);
（3）用指针变量指向数组元素。分别写出程序，以便我们比较分析。
p=&a[0];
*(p+i)int main()
{
int a[10];
int *p,i;
printf("please enter 10 integer numbers: ");
for(i=0;
i<10;
i++)
scanf("%d",&a[i]);
for(p=a;
p<(a+10);
p++)//数组名代表数组首个元素的地址
printf("%d\t",*p);
//用指针指向当前的数组元素return 0;
}
3种方法的比较：
（1）第（1）种和第（2）种方法的执行效率是相同的。c编译系统是将a[i]装换为*（a+i）处理的，即先计算元素的地址。因此用第（1）和第（2）种方法找数组元素费时较多。
（2）第（3）种方法比第（1）、第（2）种方法快，用指针变量直接指向元素，不必每次都重新计算地址，像p++这样的自加操作是比较快的。这种有规律的改变地址值（p++）能大大提高执行效率。
（3）用下标比较直观，能直接知道是第几个元素。例如，a[5]是数组中序号为5的元素（注意序号是从0算起）。用地址发或者指针变量的方法不直观，难以很快的判断出当前处理的是哪一个元素。例如，方法（3）中，要仔细分析指针变量p的当前指向，才能判断当前输出的是第几个元素。有经验的程序猿往往喜欢用第（3）种形式，用p++进行控制，程序简洁、高效。对于小白用户最好还是用第（1）种方式，直观，不易出错。
注意：在使用指针变量指向数组元素时，有一些问题需要注意：
（1）可以通过改变指针变量的值指向不同的元素。例如：上述第（3）种方法是用指针变量p来指向元素，用p++使p的值不断改变从而指向不同的元素。如果不用p变化的方法而用数组名a变化的方法行不行呢？假如将上述第（3）中方法中的程序的
for(p=a;
p<(a+10);
p++)
printf("%d\t",*p);
改为
for(p=a;
a<(p+10);
a++)
printf("%d",*a);
是不行的。因为数组名a代表数组首元素的地址，它是一个指针型常量，它的值在程序运行期间是固定不变的。既然a是常量，所以a++是无法实现的。
（2）注意指针变量的当前值。看下例
编写程序：
#include
int main()
{
int *p,i,a[10];
p=a;
printf("please enter 10 integer number:");
for(i=0;
i<10;
i++)
scanf("%d",p++);
//循环结束p=&a[10]for(i=0;
i<10;
i++,p++)
printf("%d\t",*p);
printf("\n");
return 0;
}
运行结果：
文章图片
Alt text 程序分析：显然输出的数值并不是a数组中各元素的值。需要检查和分析程序。
可能大家会觉得上面的程序没有什么问题，即使已被告知此程序有问题，还是找不出问题出在哪里。问题出在指针变量p的指向。指针变量p的初始值为a数组首元素的地址，但经过第一个for循环读入数据后，p已指向a数组的末尾。因此，在执行第2个for循环时，p的起始值不是&a[0]了，而是a+10。由于执行第2个for循环时，每次要执行p++，因此p指向的是a数组下面的10个存储单元。
解决这个问题的方法只需要在第2个for循环之前加一个赋值语句：
p=;
使p的初始值重新等于&a[0]，这样的结果就对了。
利用指针引用数组元素，比较方便灵活，有不少技巧。在专业人员中常喜欢用一些技巧，以使程序简洁。我们来分析下面几种情况
（1）p++使p指向下一个元素a[1].然后若在执行* p，则得到下一个元素a[1]的值。
p++;
* p;
（2）由于++和*同优先级，结合方向为自右而左，因此它等价于*（p++）。先引用p的值，实现*p的运算，然后再使p自增1.
*p++;
（3）*（p++）与*（++p）作用是否相同？答案肯定是不相同的。前者是先取*p的值，然后使p加1.后者是先使p加1，再取*p。
程序分析：这个程序我们可以做一些改动。将函数change中的形参x改成指针变量。相应的实参仍为数组名a（即数组a首元素的地址），将它传给形参指针变量x，这时x就指向a[0]。x+m是a[m]元素的地址。设j和i以及p都是指针变量，用它们指向有关元素。i的初值x，j的初值为x+n-1，见下图。使得*i与*j交换就是a[i]和a[j]交换。
文章图片
enter image description here
#includevoid exchange(int *x,int y);
int main()
{
int i,y,x[10];
for(i=0;
i<10;
i++)
{
x[i]=rand();
printf("x[%d]=%d\n",i,x[i]);
}
exchange(x,10);
for(i=0;
i<10;
i++)
printf("x[%d]=%d\n",i,x[i]);
return 0;
}
void exchange (int *x,int y)
{
int temp,*p,*i,*j, m=(y-1)/2;
;
i=x;
j=x+y-1;
p=x+m;
for(;
i<=p;
i++,j--)// i++=&x[++];
{
temp=*i;
*i=*j;
*j=temp;
} }
归纳分析：如果有一个实参数组，要想在函数中改变数组中的元素的值，实参和形参的对应关系有以下4种情况。
（1）形参和实参都用数组名，例如：
int main()
{
int a[10];
.
.
.
f(a,10);
}int f(int x[],int n)
{
.
.
.
}
由于形参数组名x接收了实参数组首元素a[0]的地址，因此可以认为在函数调用期间，形参数组与实参数组共用一段内存单元，这种形式比较好理解。
（2）实参用数组名，形参用指针变量。例如：
int main()
{
int a[10];
.
.
.
f(a，10)；}void f(int *x,int n)
{
.
.
.
}
实参a为数组名，形参x为int *型的指针变量，调用函数开始后，形参x指向a[0],即x=&a[0],通过x的值的改变，可以指向a数组的任一元素。例11-2就属于此类。
（3）实参形参都用指针变量。例如：
int main()
{
int a[10],*p=a;
//p=&a[0]
.
.
.
f(p,10);
.
.
.
}void f(int *x,int n)
{
.
.
.
}
实参p和形参x都是(int *)型的指针变量。
先使实参指针变量p指向数组a[0],p的值是&a[0]。然后将p的值传给形参指针变量x，x的初始值也是&a[0]，通过x的值的改变可以使x指向数组a的任意元素。
（4） 实参为指针变量，形参为数组名。例如：
int main（）
{
int a[10],*p=a;
.
.
.
f(p,10);
}void f(int x[],int n)
{
.
.
.
.
}
实参p为指针变量，它指向a[0]。形参为数组名x，编译系统把x作为指针变量处理，今将a[0]的地址传给形参x，使x也指向a[0]。也可以理解为形参数组x和a数组共用同一段内存单元。在执行过程中可以使x[i]的值变化，而x[i]就是a[i]。这样，main函数可以使用变化了的数组元素的值。
参考文献 【指针】【1】 实验楼c语言入门教程 指针（1） （https://www.shiyanlou.com/courses/running）
推荐阅读
- C入门|指针与字符串，读取字符串，字符串库函数举例 C语言入门
- c语言|这可能是最全最详细的C语言指针基础教程
- 数据结构|数据结构之链表+常见面试题
- 汇编语言入门-段指针
- C和指针|C和指针 第6章 指针 6.4 间接访问操作符
- 函数指针与回调函数
- 指针的进阶
- 我们什么时候通过引用或指针传递参数（）
- const char *p，char *const p和const char * const p之间的区别