C语言学习笔记----指针【一】|易语言交流

悠然南山

总版主

发帖: 6808

黑豆: 158

威望: 24650

贡献值: 0

交易币: 0

红豆: 426

只看楼主倒序阅读 0 发表于: 2013-04-21

指针变量

（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);
printf("\n");
for(i=9;i>=0;i--)
printf("%d",a);
}

数组名法

main()
{
int a[10],i;
for(i=0;i<10;i++)
scanf("%d",&a);
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);
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);
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等价于*(x+i);
{
....
}

形参和实参都是指针变量

main()
{
int a[10];
int *p;
p=a;
..
sort(p,10) //指针作为实参
}
sort(int *x,int n) //指针作为形参，x首先接受实参数组a的首地址，x等价于*(x+i);
{
....
}

形参是数组名、实参是指针变量

main()
{
int a[10];
int *p;
p=a;
..
sort(a,10)
}
sort(int x[],int n) //指针作为形参，x首先接受实参数组a的首地址，x等价于*(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.png

（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的发生了变化，也就是指向发生了改变，指向了下一个空间。