C指针

指针是Ｃ语言中广泛使用的一种数据类型。利用指针变量可以表示各种数据结构；使用数组和字符串；处理内存地址。

1.1 地址指针的基本概念
在计算机中，所有的数据都是存放在存储器中的。一般把存储器中的一个字节称为一个内存单元，不同的数据类型所占用的内存单元数不等，如整型量占2个单元，字符量占1个单元等，在前面已有详细的介绍。为了正确地访问这些内存单元，必须为每个内存单元编上号。根据一个内存单元的编号即可准确地找到该内存单元。内存单元的编号也叫做地址。既然根据内存单元的编号或地址就可以找到所需的内存单元，所以通常也把这个地址称为指针。 内存单元的指针和内存单元的内容是两个不同的概念。 可以用一个通俗的例子来说明它们之间的关系。我们到银行去存取款时，银行工作人员将根据我们的帐号去找我们的存款单， 找到之后在存单上写入存款、取款的金额。在这里，帐号就是存单的指针， 存款数是存单的内容。对于一个内存单元来说，单元的地址即为指针，其中存放的数据才是该单元的内容。在Ｃ语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。

1.2 变量的指针和指向变量的指针变量
变量的指针就是变量的地址。存放变量地址的变量是指针变量。即在Ｃ语言中，允许用一个变量来存放指针，这种变量称为指针变量。因此，一个指针变量的值就是某个变量的地址或称为某变量的指针。

为了表示指针变量和它所指向的变量之间的关系，在程序中用“*”符号表示“指向”，例如，i_pointer代表指针变量，而*i_pointer是i_pointer所指向的变量。

1.2.1 定义一个指针变量
对指针变量的定义包括三个内容：

(1)  指针类型说明，即定义变量为一个指针变量；

(2)  指针变量名；

(3)  变量值(指针)所指向的变量的数据类型。

其一般形式为：

类型说明符  *变量名；

其中，*表示这是一个指针变量，变量名即为定义的指针变量名，类型说明符表示本指针变量所指向的变量的数据类型。

例如：    int *p1;

表示p1是一个指针变量，它的值是某个整型变量的地址。或者说p1指向一个整型变量。再如：

int *p2;        /*指向整型变量*/

float *p3;      /*指向浮点变量*/

char *p4;       /*指向字符变量*/

注意，一个指针变量只能指向同类型的变量

1.2.2 指针变量的引用
指针变量使用之前不仅要定义说明，而且必须赋予具体的值。未经赋值的指针变量不能使用。指针变量的赋值只能赋予地址，否则将引起错误。在Ｃ语言中，变量的地址是由编译系统分配的，对用户完全透明，用户不知道变量的具体地址。

1)       &:取地址运算符。

2)       *：指针运算符（或称“间接访问” 运算符）。

Ｃ语言中提供了地址运算符&来表示变量的地址。

其一般形式为：

    &变量名；

如&a表示变量a的地址，&b表示变量b的地址。变量本身必须预先说明。

设有指向整型变量的指针变量p，如要把整型变量a 的地址赋予p可以有以下两种方式：

(1)  指针变量初始化的方法

    int a;

    int *p=&a;

(2)  赋值语句的方法

    int a;

    int *p;

    p=&a;

不允许把一个数赋予指针变量，故下面的赋值是错误的：

int *p;

p=1000;

被赋值的指针变量前不能再加“*”说明符，如写为*p=&a 也是错误的。

假设:

int i=200, x;

int *ip;

我们定义了两个整型变量i,x,还定义了一个指向整型数的指针变量ip。i,x中可存放整数,而ip中只能存放整型变量的地址。我们可以把i的地址赋给ip:

ip=&i;

此时指针变量ip指向整型变量i,假设变量i的地址为1800,这个赋值可形象理解为下图所示的联系。

  以后我们便可以通过指针变量ip间接访问变量i,例如:

     x=*ip;

运算符*访问以ip为地址的存贮区域,而ip中存放的是变量i的地址,因此,*ip访问的是地址为1800的存贮区域(因为是整数,实际上是从1800开始的两个字节),它就是i所占用的存贮区域, 所以上面的赋值表达式等价于

     x=i;

另外,指针变量和一般变量一样,存放在它们之中的值是可以改变的,也就是说可以改变它们的指向,

通过指针访问它所指向的一个变量是以间接访问的形式进行的,所以比直接访问一个变量要费时间,而且不直观,因为通过指针要访问哪一个变量,取决于指针的值(即指向),例如"*p2=*p1;"实际上就是"j=i;",前者不仅速度慢而且目的不明。但由于指针是变量,我们可以通过改变它们的指向,以间接访问不同的变量,这给程序员带来灵活性,也使程序代码编写得更为简洁和有效。

指针变量可出现在表达式中, 设

int x,y，*px=&x;

指针变量px指向整数x,则*px可出现在x能出现的任何地方。例如:

y=*px+5;  /*表示把x的内容加5并赋给y*/

y=++*px;  /*px的内容加上1之后赋给y，++*px相当于++(*px)*/

y=*px++;  /*相当于y=*px; px++*/

例1.1

main()

{ int a,b;

  int *pointer_1, *pointer_2;

  a=100;b=10;

  pointer_1=&a;

  pointer_2=&b;

  printf("%d,%d/n",a,b);

  printf("%d,%d/n",*pointer_1, *pointer_2);

}

1) 在开头处虽然定义了两个指针变量pointer_1和pointer_2，担它们并未指向任何一个整型变量。只是提供两个指针变量，规定它们可以指向整型变量。程序第5、6行的作用就是使pointer_1指向a，pointer_2指向b。

2) 最后一行的*pointer_1和*pointer_2就是变量a和b。最后两个printf函数作用是相同的。

3) 程序中有两处出现*pointer_1和*pointer_2，请区分它们的不同含义。

4) 程序第5、6行的“pointer_1=&a”和 “pointer_2=&b”不能写成“*pointer_1=&a”和 “*pointer_2=&b”。

10.2.3 指针变量作为函数参数

函数的参数不仅可以是整型、实型、字符型等数据，还可以是指针类型。它的作用是将一个变量的地址传送到另一个函数中。

例1.2 输入的两个整数按大小顺序输出。今用函数处理，而且用指针类型的数据作函数参数。

swap(int *p1,int *p2)

{int temp;

 temp=*p1;

 *p1=*p2;

 *p2=temp;

}

main()

{

int a,b;

int *pointer_1,*pointer_2;

  scanf("%d,%d",&a,&b);

  pointer_1=&a;pointer_2=&b;

  if(a<b) swap(pointer_1,pointer_2);

  printf("/n%d,%d/n",a,b);

  }

swap是用户定义的函数，它的作用是交换两个变量（a和b）的值。swap函数的形参p1、p2是指针变量。程序运行时，先执行main函数，输入a和b的值。然后将a和b的地址分别赋给指针变量pointer_1和pointer_2，使pointer_1指向a，pointer_2指向b。

接着执行if语句，由于a〈b，因此执行swap函数。注意实参pointer_1和pointer_2是指针变量，在函数调用时，将实参变量的值传递给形参变量。采取的依然是“值传递”方式。因此虚实结合后形参p1的值为&a，p2的值为&b。这时p1和pointer_1指向变量a，p2和pointer_2指向变量b

接着执行执行swap函数的函数体使*p1和*p2的值互换，也就是使a和b的值互换。

函数调用结束后，p1和p2不复存在（已释放）

最后在main函数中输出的a和b的值是已经过交换的值。

例1.3 请注意，不能企图通过改变指针形参的值而使指针实参的值改变。

swap(int *p1,int *p2)

{int *p;

 p=p1;

 p1=p2;

 p2=p;

}

main()

{

int a,b;

int *pointer_1,*pointer_2;

  scanf("%d,%d",&a,&b);

  pointer_1=&a;pointer_2=&b;

  if(a<b) swap(pointer_1,pointer_2);

  printf("/n%d,%d/n",*pointer_1,*pointer_2);

  }

例1.4 输入a、b、c3个整数，按大小顺序输出。

swap(int *pt1,int *pt2)

{int temp;

 temp=*pt1;

 *pt1=*pt2;

 *pt2=temp;

}

exchange(int *q1,int *q2,int *q3)

{ if(*q1<*q2)swap(q1,q2);

if(*q1<*q3)swap(q1,q3);

if(*q2<*q3)swap(q2,q3);

}

main()

{

int a,b,c,*p1,*p2,*p3;

  scanf("%d,%d,%d",&a,&b,&c);

  p1=&a;p2=&b; p3=&c;

  exchange(p1,p2,p3);

  printf("/n%d,%d,%d /n",a,b,c);

  }

 

1.2.4 指针变量几个问题的进一步说明
指针变量可以进行某些运算，但它只能进行赋值运算和部分算术运算及关系运算。

1.       指针运算符

1)       取地址运算符&:取地址运算符&是单目运算符，其结合性为自右至左，其功能是取变量的地址。在scanf函数及前面介绍指针变量赋值中，我们已经了解并使用了&运算符。

2)       取内容运算符*:取内容运算符*是单目运算符，其结合性为自右至左，用来表示指针变量所指的变量。在*运算符之后跟的变量必须是指针变量。

需要注意的是指针运算符*和指针变量说明中的指针说明符*不是一回事。在指针变量说明中，“*”是类型说明符，表示其后的变量是指针类型。而表达式中出现的“*”则是一个运算符用以表示指针变量所指的变量。

例1.5

main(){

  int a=5,*p=&a;

  printf ("%d",*p);

}

 

    表示指针变量p取得了整型变量a的地址。printf("%d",*p)语句表示输出变量a的值。

2.       指针变量的运算

1)       赋值运算：指针变量的赋值运算有以下几种形式。

     指针变量初始化赋值，前面已作介绍。

     把一个变量的地址赋予指向相同数据类型的指针变量。

例如：

int a,*pa;

pa=&a;    /*把整型变量a的地址赋予整型指针变量pa*/

把一个指针变量的值赋予指向相同类型变量的另一个指针变量。如：

    int a,*pa=&a,*pb;

    pb=pa;    /*把a的地址赋予指针变量pb*/

由于pa,pb均为指向整型变量的指针变量，因此可以相互赋值。

把数组的首地址赋予指向数组的指针变量。例如：

    int a[5],*pa;

    pa=a;

    (数组名表示数组的首地址，故可赋予指向数组的指针变量pa)

也可写为：

    pa=&a[0];  /*数组第一个元素的地址也是整个数组的首地址，也可赋予pa*/

当然也可采取初始化赋值的方法：

    int a[5],*pa=a;

把字符串的首地址赋予指向字符类型的指针变量。例如：

    char *pc;

    pc="C Language";

或用初始化赋值的方法写为：

    char *pc="C Language";

这里应说明的是并不是把整个字符串装入指针变量，而是把存放该字符串的字符数组的首地址装入指针变量。在后面还将详细介绍。

把函数的入口地址赋予指向函数的指针变量。例如：

    int (*pf)();

    pf=f;     /*f为函数名*/

2)       加减算术运算

    对于指向数组的指针变量，可以加上或减去一个整数n。设pa是指向数组a的指针变量，则pa+n,pa-n,pa++,++pa,pa--,--pa运算都是合法的。指针变量加或减一个整数n的意义是把指针指向的当前位置(指向某数组元素)向前或向后移动n个位置。应该注意，数组指针变量向前或向后移动一个位置和地址加1或减1在概念上是不同的。因为数组可以有不同的类型，各种类型的数组元素所占的字节长度是不同的。如指针变量加1，即向后移动1 个位置表示指针变量指向下一个数据元素的首地址。而不是在原地址基础上加1。例如：

    int a[5],*pa;

    pa=a;      /*pa指向数组a，也是指向a[0]*/

pa=pa+2;   /*pa指向a[2]，即pa的值为&pa[2]*/

指针变量的加减运算只能对数组指针变量进行，对指向其它类型变量的指针变量作加减运算是毫无意义的。

3)       两个指针变量之间的运算：只有指向同一数组的两个指针变量之间才能进行运算，否则运算毫无意义。

    两指针变量相减：两指针变量相减所得之差是两个指针所指数组元素之间相差的元素个数。实际上是两个指针值(地址)相减之差再除以该数组元素的长度(字节数)。例如pf1和pf2是指向同一浮点数组的两个指针变量，设pf1的值为2010H，pf2的值为2000H，而浮点数组每个元素占4个字节，所以pf1-pf2的结果为(2000H-2010H)/4=4，表示pf1和 pf2之间相差4个元素。两个指针变量不能进行加法运算。 例如，pf1+pf2是什么意思呢?毫无实际意义。

    两指针变量进行关系运算：指向同一数组的两指针变量进行关系运算可表示它们所指数组元素之间的关系。例如：

pf1==pf2表示pf1和pf2指向同一数组元素；

pf1>pf2表示pf1处于高地址位置；

pf1<pf2表示pf2处于低地址位置。

指针变量还可以与0比较。

设p为指针变量，则p==0表明p是空指针，它不指向任何变量；

p!=0表示p不是空指针。

空指针是由对指针变量赋予0值而得到的。例如：

#define NULL 0

int *p=NULL;

对指针变量赋0值和不赋值是不同的。指针变量未赋值时，可以是任意值，是不能使用的。否则将造成意外错误。而指针变量赋0值后，则可以使用，只是它不指向具体的变量而已。

例1.6

main(){

  int a=10,b=20,s,t,*pa,*pb; /*说明pa,pb为整型指针变量*/

  pa=&a;                     /*给指针变量pa赋值，pa指向变量a*/

  pb=&b;                     /*给指针变量pb赋值，pb指向变量b*/

  s=*pa+*pb;                 /*求a+b之和,(*pa就是a,*pb就是b)*/

  t=*pa**pb;                 /*本行是求a*b之积*/

  printf("a=%d/nb=%d/na+b=%d/na*b=%d/n",a,b,a+b,a*b);

  printf("s=%d/nt=%d/n",s,t);

}

1.3       数组指针和指向数组的指针变量

一个数组包含若干元素，每个数组元素都在内存中占用存储单元，它们都有相应的地址。所谓数组的指针是指数组的起始地址，数组元素的指针是数组元素的地址。

1.3.1 指向数组元素的指针
一个数组是由连续的一块内存单元组成的。数组名就是这块连续内存单元的首地址。一个数组也是由各个数组元素(下标变量)组成的。每个数组元素按其类型不同占有几个连续的内存单元。一个数组元素的首地址也是指它所占有的几个内存单元的首地址。

定义一个指向数组元素的指针变量的方法，与以前介绍的指针变量相同。例如：

    int a[10]；   /*定义a为包含10个整型数据的数组*/

    int *p；      /*定义p为指向整型变量的指针*/

应当注意，因为数组为int型，所以指针变量也应为指向int型的指针变量。下面是对指针变量赋值：

p=&a[0];

把a[0]元素的地址赋给指针变量p。也就是说，p指向a数组的第0号元素。

C语言规定，数组名代表数组的首地址，也就是第0号元素的地址。因此，下面两个语句等价：

p=&a[0];

p=a;

在定义指针变量时可以赋给初值：

int *p=&a[0];

它等效于：

int *p;

p=&a[0];

当然定义时也可以写成：

    int *p=a;

    p,a,&a[0]均指向同一单元，它们是数组a的首地址，也是0 号元素a[0]的首地址。应该说明的是p是变量，而a,&a[0]都是常量。在编程时应予以注意。

数组指针变量说明的一般形式为：

类型说明符  *指针变量名；

其中类型说明符表示所指数组的类型。从一般形式可以看出指向数组的指针变量和指向普通变量的指针变量的说明是相同的。

1.3.2 通过指针引用数组元素
C语言规定：如果指针变量p已指向数组中的一个元素，则p+1指向同一数组中的下一个元素。

引入指针变量后，就可以用两种方法来访问数组元素了。

如果p的初值为&a[0],则：

1)       p+i和a+i就是a[i]的地址，或者说它们指向a数组的第i个元素。

2)       *(p+i)或*(a+i)就是p+i或a+i所指向的数组元素，即a[i]。例如，*(p+5)或*(a+5)就是a[5]。

3)       指向数组的指针变量也可以带下标，如p[i]与*(p+i)等价。

根据以上叙述，引用一个数组元素可以用：

1)       下标法，即用a[i]形式访问数组元素。在前面介绍数组时都是采用这种方法。

2)       指针法，即采用*(a+i)或*(p+i)形式，用间接访问的方法来访问数组元素，其中a是数组名，p是指向数组的指针变量，其处值p=a。

例1.7 输出数组中的全部元素。（下标法）

main(){

  int a[10],i;

  for(i=0;i<10;i++)

    a[i]=i;

  for(i=0;i<5;i++)

    printf("a[%d]=%d/n",i,a[i]);

}

几个注意的问题：

1)       指针变量可以实现本身的值的改变。如p++是合法的；而a++是错误的。因为a是数组名，它是数组的首地址，是常量。

2)       要注意指针变量的当前值

3)       虽然定义数组时指定它包含10个元素，但指针变量可以指到数组以后的内存单元，系统并不认为非法。

4)       *p++，由于++和*同优先级，结合方向自右而左，等价于*(p++)。

5)       *(p++)与*(++p)作用不同。若p的初值为a，则*(p++)等价a[0]，*(++p)等价a[1]。

6)       (*p)++表示p所指向的元素值加1。

7)       如果p当前指向a数组中的第i个元素，则

*(p--)相当于a[i--]；

*(++p)相当于a[++i]；

*(--p)相当于a[--i]。

1.4       字符串的指针指向字符串的针指变量

1.4.1 字符串的表示形式
  在C语言中，可以用两种方法访问一个字符串。

1)        用字符数组存放一个字符串，然后输出该字符串。

例1.8

main(){

  char string[]=”I love China!”;

  printf("%s/n",string);

}

说明：和前面介绍的数组属性一样，string是数组名，它代表字符数组的首地址。

2)        用字符串指针指向一个字符串。

例1.9

main(){

  char *string=”I love China!”;

  printf("%s/n",string);

}

字符串指针变量的定义说明与指向字符变量的指针变量说明是相同的。只能按对指针变量的赋值不同来区别。对指向字符变量的指针变量应赋予该字符变量的地址。

如：

    char c,*p=&c;

表示p是一个指向字符变量c的指针变量。

而：

    char *s="C Language";

则表示s是一个指向字符串的指针变量。把字符串的首地址赋予s。

上例中，首先定义string是一个字符指针变量，然后把字符串的首地址赋予string(应写出整个字符串，以便编译系统把该串装入连续的一块内存单元)，并把首地址送入string。程序中的：

char *ps="C Language";

等效于：

char *ps;

ps="C Language";

例1.10 输出字符串中n个字符后的所有字符。

main(){

  char *ps="this is a book";

  int n=10;

  ps=ps+n;

  printf("%s/n",ps);

}

运行结果为：

book

在程序中对ps初始化时，即把字符串首地址赋予ps，当ps= ps+10之后，ps指向字符“b”，因此输出为"book"。

例1.11 在输入的字符串中查找有无‘k’字符。

main(){

  char st[20],*ps;

  int i;

  printf("input a string:/n");

  ps=st;

  scanf("%s",ps);

  for(i=0;ps[i]!='/0';i++)

    if(ps[i]=='k'){

       printf("there is a 'k' in the string/n");

       break;

    }

  if(ps[i]=='/0') printf("There is no 'k' in the string/n");

} 

1.4.2 使用字符串指针变量与字符数组的区别
    用字符数组和字符指针变量都可实现字符串的存储和运算。但是两者是有区别的。在使用时应注意以下几个问题：

1.     字符串指针变量本身是一个变量，用于存放字符串的首地址。而字符串本身是存放在以该首地址为首的一块连续的内存空间中并以‘/0’作为串的结束。字符数组是由于若干个数组元素组成的，它可用来存放整个字符串。

2.     对字符串指针方式

char *ps="C Language";

可以写为：

    char *ps;

ps="C Language";

而对数组方式：

    static char st[]={"C Language"};

不能写为：

    char st[20];

    st={"C Language"};

而只能对字符数组的各元素逐个赋值。

     从以上几点可以看出字符串指针变量与字符数组在使用时的区别，同时也可看出使用指针变量更加方便。

前面说过，当一个指针变量在未取得确定地址前使用是危险的，容易引起错误。但是对指针变量直接赋值是可以的。因为C系统对指针变量赋值时要给以确定的地址。

因此，

    char *ps="C Langage";

或者

    char *ps;

    ps="C Language";

都是合法的。

1.5       函数指针变量
    在Ｃ语言中，一个函数总是占用一段连续的内存区，而函数名就是该函数所占内存区的首地址。我们可以把函数的这个首地址(或称入口地址)赋予一个指针变量，使该指针变量指向该函数。然后通过指针变量就可以找到并调用这个函数。我们把这种指向函数的指针变量称为“函数指针变量”。

函数指针变量定义的一般形式为：

类型说明符  (*指针变量名)();

其中“类型说明符”表示被指函数的返回值的类型。“(* 指针变量名)”表示“*”后面的变量是定义的指针变量。最后的空括号表示指针变量所指的是一个函数。例如：

    int (*pf)();

表示pf是一个指向函数入口的指针变量，该函数的返回值(函数值)是整型。

例1.12 本例用来说明用指针形式实现对函数调用的方法。

int max(int a,int b){

  if(a>b)return a;

  else return b;

}

main(){

  int max(int a,int b);

  int(*pmax)();

  int x,y,z;

  pmax=max;

  printf("input two numbers:/n");

  scanf("%d%d",&x,&y);

  z=(*pmax)(x,y);

  printf("maxmum=%d",z);

}

   从上述程序可以看出用，函数指针变量形式调用函数的步骤如下：

1)       先定义函数指针变量，如后一程序中第9行 int (*pmax)();定义 pmax为函数指针变量。

2)       把被调函数的入口地址(函数名)赋予该函数指针变量，如程序中第11行 pmax=max;

3)       用函数指针变量形式调用函数，如程序第14行 z=(*pmax)(x,y);

4)       调用函数的一般形式为：

    (*指针变量名) (实参表)

使用函数指针变量还应注意以下两点：

a)       函数指针变量不能进行算术运算，这是与数组指针变量不同的。数组指针变量加减一个整数可使指针移动指向后面或前面的数组元素，而函数指针的移动是毫无意义的。

b)       函数调用中"(*指针变量名)"的两边的括号不可少，其中的*不应该理解为求值运算，在此处它只是一种表示符号。

1.6       指针型函数
    前面我们介绍过，所谓函数类型是指函数返回值的类型。在Ｃ语言中允许一个函数的返回值是一个指针(即地址)，这种返回指针值的函数称为指针型函数。

定义指针型函数的一般形式为：

    类型说明符 *函数名(形参表) 

    { 

        ……          /*函数体*/

    } 

其中函数名之前加了“*”号表明这是一个指针型函数，即返回值是一个指针。类型说明符表示了返回的指针值所指向的数据类型。

如：

    int *ap(int x,int y)

    {

      ......       /*函数体*/

}

表示ap是一个返回指针值的指针型函数，它返回的指针指向一个整型变量。

例1.13 本程序是通过指针函数，输入一个1～7之间的整数，输出对应的星期名。

main(){

  int i;

  char *day_name(int n);  

  printf("input Day No:/n");

  scanf("%d",&i);

  if(i<0) exit(1);

  printf("Day No:%2d-->%s/n",i,day_name(i));

}

char *day_name(int n){

  static char *name[]={ "Illegal day",

                        "Monday",

                        "Tuesday",

                        "Wednesday",

                        "Thursday",

                        "Friday",

                        "Saturday",

                        "Sunday"};

  return((n<1||n>7) ? name[0] : name[n]);

}

本例中定义了一个指针型函数day_name，它的返回值指向一个字符串。该函数中定义了一个静态指针数组name。name数组初始化赋值为八个字符串，分别表示各个星期名及出错提示。形参n表示与星期名所对应的整数。在主函数中，把输入的整数i作为实参，在printf语句中调用day_name函数并把i值传送给形参n。day_name函数中的return语句包含一个条件表达式，n值若大于7或小于1则把name[0]指针返回主函数输出出错提示字符串“Illegal day”。否则返回主函数输出对应的星期名。主函数中的第7行是个条件语句，其语义是，如输入为负数(i<0)则中止程序运行退出程序。exit是一个库函数，exit(1)表示发生错误后退出程序，exit(0)表示正常退出。

应该特别注意的是函数指针变量和指针型函数这两者在写法和意义上的区别。如int(*p)()和int *p()是两个完全不同的量。

int (*p)()是一个变量说明，说明p是一个指向函数入口的指针变量，该函数的返回值是整型量，(*p)的两边的括号不能少。

int *p()则不是变量说明而是函数说明，说明p是一个指针型函数，其返回值是一个指向整型量的指针，*p两边没有括号。作为函数说明，在括号内最好写入形式参数，这样便于与变量说明区别。

对于指针型函数定义，int *p()只是函数头部分，一般还应该有函数体部分。

1.7       指针数组和指向指针的指针
1.7.1 指针数组的概念
    一个数组的元素值为指针则是指针数组。 指针数组是一组有序的指针的集合。 指针数组的所有元素都必须是具有相同存储类型和指向相同数据类型的指针变量。

指针数组说明的一般形式为：

    类型说明符 *数组名[数组长度]

其中类型说明符为指针值所指向的变量的类型。

例如：

int *pa[3]

表示pa是一个指针数组，它有三个数组元素，每个元素值都是一个指针，指向整型变量。

例1.14 通常可用一个指针数组来指向一个二维数组。指针数组中的每个元素被赋予二维数组每一行的首地址，因此也可理解为指向一个一维数组。

main(){

int a[3][3]={1,2,3,4,5,6,7,8,9};

int *pa[3]={a[0],a[1],a[2]};

int *p=a[0];

  int i;

  for(i=0;i<3;i++)

      printf("%d,%d,%d/n",a[i][2-i],*a[i],*(*(a+i)+i));

  for(i=0;i<3;i++)

      printf("%d,%d,%d/n",*pa[i],p[i],*(p+i));

}

本例程序中，pa是一个指针数组，三个元素分别指向二维数组a的各行。然后用循环语句输出指定的数组元素。其中*a[i]表示i行0列元素值；*(*(a+i)+i)表示i行i列的元素值；*pa[i]表示i行0列元素值；由于p与a[0]相同，故p[i]表示0行i列的值；*(p+i)表示0行i列的值。读者可仔细领会元素值的各种不同的表示方法。

应该注意指针数组和二维数组指针变量的区别。这两者虽然都可用来表示二维数组，但是其表示方法和意义是不同的。

二维数组指针变量是单个的变量，其一般形式中"(*指针变量名)"两边的括号不可少。而指针数组类型表示的是多个指针(一组有序指针)在一般形式中"*指针数组名"两边不能有括号。例如：

    int (*p)[3];

表示一个指向二维数组的指针变量。该二维数组的列数为3或分解为一维数组的长度为3。

    int *p[3]

表示p是一个指针数组，有三个下标变量p[0]，p[1]，p[2]均为指针变量。

指针数组也常用来表示一组字符串，这时指针数组的每个元素被赋予一个字符串的首地址。指向字符串的指针数组的初始化更为简单。其初始化赋值为：

    char *name[]={"Illagal day",

                  "Monday",

                  "Tuesday",

                  "Wednesday",

                  "Thursday",

                  "Friday",

                  "Saturday",

                  "Sunday"};

完成这个初始化赋值之后，name[0]即指向字符串"Illegal day"，name[1]指向"Monday"......。

指针数组也可以用作函数参数。

例1.15 指针数组作指针型函数的参数。在本例主函数中，定义了一个指针数组name，并对name 作了初始化赋值。其每个元素都指向一个字符串。然后又以name作为实参调用指针型函数day_name，在调用时把数组名name赋予形参变量name，输入的整数i作为第二个实参赋予形参n。在day_ name函数中定义了两个指针变量pp1和pp2，pp1被赋予name[0]的值(即*name)，pp2被赋予name[n]的值即*(name+ n)。由条件表达式决定返回pp1或pp2指针给主函数中的指针变量ps。最后输出i和ps的值。

main(){

  static char *name[]={ "Illegal day",

                        "Monday",

                        "Tuesday",

                        "Wednesday",

                        "Thursday",

                        "Friday",

                        "Saturday",

                        "Sunday"};

  char *ps;

  int i;

  char *day_name(char *name[],int n);

  printf("input Day No:/n");

  scanf("%d",&i);

  if(i<0) exit(1);

  ps=day_name(name,i);

  printf("Day No:%2d-->%s/n",i,ps);

}

char *day_name(char *name[],int n)

{

  char *pp1,*pp2;

  pp1=*name;

  pp2=*(name+n);

  return((n<1||n>7)? pp1:pp2);

}

1.7.2 指向指针的指针
    如果一个指针变量存放的又是另一个指针变量的地址，则称这个指针变量为指向指针的指针变量。

在前面已经介绍过，通过指针访问变量称为间接访问。由于指针变量直接指向变量，所以称为“单级间址”。而如果通过指向指针的指针变量来访问变量则构成“二级间址”。

从下图可以看到，name是一个指针数组，它的每一个元素是一个指针型数据，其值为地址。Name是一个数据，它的每一个元素都有相应的地址。数组名name代表该指针数组的首地址。name+1是mane[i]的地址。name+1就是指向指针型数据的指针（地址）。还可以设置一个指针变量p，使它指向指针数组元素。P就是指向指针型数据的指针变量。

怎样定义一个指向指针型数据的指针变量呢？如下：

char **p;

p前面有两个*号,相当于*(*p)。显然*p是指针变量的定义形式，如果没有最前面的*，那就是定义了一个指向字符数据的指针变量。现在它前面又有一个*号，表示指针变量p是指向一个字符指针型变量的。*p就是p所指向的另一个指针变量。

从下图可以看到，name是一个指针数组，它的每一个元素是一个指针型数据，其值为地址。name是一个数组，它的每一个元素都有相应的地址。数组名name代表该指针数组的首地址。name+1是mane[i]的地址。name+1就是指向指针型数据的指针（地址）。还可以设置一个指针变量p，使它指向指针数组元素。P就是指向指针型数据的指针变量。

如果有：

p=name+2;

printf(“%o/n”,*p);

printf(“%s/n”,*p);

则，第一个printf函数语句输出name[2]的值（它是一个地址），第二个printf函数语句以字符串形式（%s）输出字符串“Great Wall”。

例1.16使用指向指针的指针。

main()

{char *name[]={"Follow me","BASIC","Great Wall","FORTRAN","Computer desighn"};

 char **p;

 int i;

 for(i=0;i<5;i++)

   {p=name+i;

    printf("%s/n",*p);

   }

}

说明：

p是指向指针的指针变量。

1.7.3 main函数的参数
前面介绍的main函数都是不带参数的。因此main 后的括号都是空括号。实际上，main函数可以带参数，这个参数可以认为是 main函数的形式参数。Ｃ语言规定main函数的参数只能有两个，习惯上这两个参数写为argc和argv。因此，main函数的函数头可写为：

    main (argc,argv)

Ｃ语言还规定argc(第一个形参)必须是整型变量,argv( 第二个形参)必须是指向字符串的指针数组。加上形参说明后，main函数的函数头应写为：

    main (int argc,char *argv[])

    由于main函数不能被其它函数调用，因此不可能在程序内部取得实际值。那么，在何处把实参值赋予main函数的形参呢? 实际上,main函数的参数值是从操作系统命令行上获得的。当我们要运行一个可执行文件时，在DOS提示符下键入文件名，再输入实际参数即可把这些实参传送到main的形参中去。

DOS提示符下命令行的一般形式为：

    C:/>可执行文件名  参数  参数……; 

    但是应该特别注意的是，main 的两个形参和命令行中的参数在位置上不是一一对应的。因为,main的形参只有二个，而命令行中的参数个数原则上未加限制。argc参数表示了命令行中参数的个数(注意：文件名本身也算一个参数)，argc的值是在输入命令行时由系统按实际参数的个数自动赋予的。

例如有命令行为：

    C:/>E24  BASIC  foxpro  FORTRAN

由于文件名E24本身也算一个参数，所以共有4个参数，因此argc取得的值为4。argv参数是字符串指针数组，其各元素值为命令行中各字符串(参数均按字符串处理)的首地址。指针数组的长度即为参数个数。数组元素初值由系统自动赋予。其表示如图所示：

例1.31

main(int argc,char *argv){

  while(argc-->1)

      printf("%s/n",*++argv);

}

本例是显示命令行中输入的参数。如果上例的可执行文件名为e24.exe，存放在A驱动器的盘内。因此输入的命令行为：

    C:/>a:e24 BASIC foxpro FORTRAN

则运行结果为：

BASIC

foxpro

FORTRAN

该行共有4个参数，执行main时，argc的初值即为4。argv的4个元素分为4个字符串的首地址。执行while语句，每循环一次argv值减1，当argv等于1时停止循环，共循环三次，因此共可输出三个参数。在printf函数中，由于打印项*++argv是先加1再打印，故第一次打印的是argv[1]所指的字符串BASIC。第二、三次循环分别打印后二个字符串。而参数e24是文件名，不必输出。