C语言【指针】一维数组与指针概念
C语言学习笔记----指针【一】
虽然以前学过C语言，但是那个时候才大一，没有认真的学习，最近又回炉看了好久的指针，把我的经验心得写下来和大家一起分享，共同学习。![]()
指针变量
（1） 指针就是内存地址；
系统对变量的访问形式有两种：
直接访问：按变量地址存取变量值的方式
间接访问：
如上所示，int i=3,然后特殊变量P存放的内容是变量i的地址，利用P来访问变量i。2000是变量i空间的地址。3是i的值。变量P指向变量i，P是指向变量i的指针变量。
（2）定义指针变量： int *P,*p1; float *P;
注意：（1） *号毫无意义，如果硬要说意义的话就是：C语言规定所有变量必须先定义后使用，指针变量也是这样，但是为了表示指针变量的特殊性，所以就加了一个*号。
（2）一个指针变量只能指向同一个数据类型，定义*P为int型，那就不能指向float。
（3） 指针变量赋值：int i=3; int *P; P=&i; &是取地址运算符，取i的空间的地址给P。所以P里面存放的是i空间的地址。*P是i空间存放的值，即*P=3；
注意：&i是i空间的地址，是一个整型数据，这个数据赋值给P，但是不能直接给P赋值，如P=1000是不行的，因为变量的地址是由编译系统分配的，用户是不知道的，更不能随便给赋地址值。
（4）&和*辨析：
main()
{
int i=100; int *P;
p=&i;
printf("%d\n",i); 直接访问变量
printf("%d\n",*P); 间接访问变量
}
A. int *P 中的*没有意义，只能说明定义的是一个指针变量，printf(*P)中的*是指针运算符。
B.&*P的计算：&和*的优先级一样，自右向左结合，先计算*P是100，然后计算&是&100.
*&P的计算是一样的，先计算& 再计算*。
C. 指针加1，不是单纯的加1，而是加一个所指变量的字节数。假设整型指针变量P所指的地址是2000，执行P++后，P的地址是2002，因为整型占两个字节。
（5）指针作为函数参数；
#include <stdio.h>
void swap(int *p1,int *p2)
{
int t;
t=*p1; *p1=*p2; *p2=t;
}
main()
{
int a,b; int *q1,*q2;
q1=&a; q2=&b;
printf("请输入两个数字");
scanf("%d,%d",&a,&b); printf("%d,%d\n",a,b);
printf("%d,%d\n",q1,q2);
if(a>b) { swap(q1,q2); }
printf("%d,%d\n",a,b);printf("%d,%d\n",q1,q2);
}
这个实例看出：a,b的值发生了交换，但是q1和q2的值没有交换。在Swap（）函数中*p1和*p2发生了交换，他们的值变换了，但是p1和p2的值并没有发生交换，因为p1和p2是地址，而*p1和*p2是值，我们只对值执行了交换。同理，q1和q2也没有发生变化。
如果不用指针变量作为实参，而用普通变量的话，swap交换后是不能返回到main函数中的，因为定义变量t,*p1和*p2都是是在swap（）函数中定义的，他们都是局部变量。
数组的指针和指向数组的指针变量（一维数组）
(1)一个数组的地址是这个数组的起始地址（&a[0]）,这个起始地址成为数组的指针。
(2)指向数组的指针变量：这个变量中存放了数组的起始地址。要注意，这个指针变量是P而不是*P。
(3)赋值： int a[10],*p; p=&a[0]; 将指针变量P指向数组a[0],&a[0]是数组a的首地址，所以P指向了数组a。
(4) 1.如果数组为int型，则指针变量必须指向int类型；
2. 数组名代表数组的首地址； p=a; p=&a[0]; 这两个语句的作用是一样的。即a=&a[0]
3. 允许用一个已经定义过的数组的地址作为定义指针时的初始化值。
float score[20]; float *p=score;将数组score的首地址赋给p，而不是*p。*在这儿是毫无意义的。
（5）访问地址：p是指向数组a的指针变量，那么数组元素a[5]的地址有如下几种表示形式
p+5 , a+5 ,&a[5];
（6）访问元素： 也有三种方法： *(p+5) , *(a+5), a[5];
（7）指针变量能带下标：p是指向一个数组的指针变量。 p[5]（指针带下标）等价于*（p+5）
(8)假设p指向数组a，指针变量可以取代数组名操作，如p++是可以的，数组名a也可以表示数组的首地址，不过他属于常量，如a++是错误的。
（9）用指针变量对数组中的元素逐个访问时，一般有两种方法：
*（p++）:指针变量p的值发生了变化。
*(p+i):指针变量p的值没有发生变化。
（10）引用以数组元素，有两种方法：下标法和指针发。
任意输入10个数，将10个数按逆序输出：
下标法
main()
{
int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
printf("\n");
for(i=9;i>=0;i--)
printf("%d",a[i]);
}
数组名法
main()
{
int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
printf("\n");
for(i=9;i>=0;i--)
printf("%d",*（a+i));
}
指针变量法A
main()
{
int a[10],i，*p;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
printf("\n");
for(i=9;i>=0;p--)
printf("%d",*(p+i));
}
指针变量法B
main()
{
int a[10],i，*p;
p=a;
for(i=0;i<10;i++)
scanf("%d",&a[i]);
printf("\n");
for(p=a+9;p>=a;p--)
printf("%d",*p);
}
（11）数组指针作为函数参数有两种形式：
形参、实参都是数组名 ：这种方法一般是不用的。
main()
{
int a[10];
..
sort(a,10) //数组名作为实参
}
sort(int x[],int n) //数组名作为形参
{
....
}
形参是指针变量，实参是数组名
main()
{
int a[10];
..
sort(a,10)
}
sort(int *x,int n) //指针作为形参 ，x首先接受实参数组a的首地址，x[i]等价于*(x+i);
{
....
}
形参和实参都是指针变量
main()
{
int a[10];
int *p;
p=a;
..
sort(p,10) //指针作为实参
}
sort(int *x,int n) //指针作为形参 ，x首先接受实参数组a的首地址，x[i]等价于*(x+i);
{
....
}
形参是数组名、实参是指针变量
main()
{
int a[10];
int *p;
p=a;
..
sort(a,10)
}
sort(int x[],int n) //指针作为形参 ，x首先接受实参数组a的首地址，x[i]等价于*(x+i);
{
....
}
指针运算的详细说明：验证实例求真相！
关于++（--）和*的运算总是混在一起，以前总是似是而非的,现在就详细的解决掉！
一：++的运算：
如果n=3 ,则n的值和m的值如下表所示
| n的值 | m的值 | 运算分解 | |
| m=n++ | 4 | 3 | m=n; n=n+1 |
| m=++n | 4 | 4 | n=n+1; m=n |
| m=-n++ | 4 | -3 | m=-n; n=n+1 |
| m=- ++n | 4 | -4 | n=n+1 ;m=-n; |
解析：++是自增运行，自增运算的结果是其本身发生了变化，如指针p=2000，那么p++的值是2001，p值是2001，而如果是p+1,那么p+1的值是2001，但是p的依然是2000，因为p本身没有加1。
m=n++是先赋值再+1，意思是先执行m=n,然后n在执行n+1;以下同理，过程如上表运算分解所示。
二：++和*的综合运算
a=*p++和a=(*p)++的本质区别
（1） a=*p++
| 相当于 | 运算分解 | |
| a=*p++ | a=*(p++) | a=*p ; p=p+1 |
解析： 前面已经说过了++和*的运算符优先级是相同的，他们的运算方向是自右向做。所以
a=*p++相当于a=*(p++),先得到*p，然后p+1->p;
含义： 先取出P所指向的单元中的内容3赋值给a ,然后再使p指向下一个地址单元2002，在这个过程中，a值变成了3，指针变量p指向了2002这个空间。
（2）a=(*p)++
| 相当于 | 运算分解 | |
| a=(*p)++ | a=(*p)++ | a=*p ; *p=*p+1 |
解析： 先取出变量p所指向的空间中的内容赋值给a,然后p所指向的空间中的内容加1.
需要注意的是,当p中的内容赋值给a后，p所指向的空间中的内容加1，而不是指针变量p加1，指针变量p并没有发生改变，也就是说p的指向并没有变化，还是指向原来的空间，但是p所指向的内容变化了。而在（1）中，p的发生了变化，也就是指向发生了改变，指向了下一个空间。