c的详细学习（8）指针学习（二）

（1）指针与二维数组

一个数组的名字代表该数组的的首地址，是地址常量（作为形式参数的数组名除外），这一规定对二维数组或更高维数组同样适用。

在c语言中定义的任何一个二维数组实际上都可以看做是一个一维数组，该一维数组中的每一个成员又是一个一维数组。

若有定义int d[3][4],i,j;且0<=i<=2,0<=j<=3;

1.数组元素d[i][j]的表示方法为:

d[i][j]

*(d[i]+j)

*(*(d+i)+j)

(*(d+i))[j]

*(&d[0][0]+4*i*j)

*(d[0]+4*i+j)

2.数组元素d[i][j]地址的表示方法为:

&d[i][j]

d[i]+j

*(d+i)+j

&((*(d+i))[j])

&d[0][0]+4*i*j

d[0]+4*i*j

例如：设数组d的首地址是无符号十进制整数40000，则各表示形式、含义与地址的关系如下所示。其中地址值增减变化随程序运行环境的不同而不同

二维数组d各表示形式、含义与地址的关系

d                        二维数组名，数组首地址，第0行首地址
d[],*(d+),*d           第0行第0列元素d[][]的地址
d+                      第1行首地址
d[],*(d+)              第1行第0列元素d[][]的地址
d[]+,*d[+]+,&d[][] 第1行第2列元素d[][]地址                 

二维数组名d是指向行的，例如d+2表示二维数组d第2行的首地址；一维数组名d[0],d[1],d[2]是指向各自对应的列元素的，例如d[0]+2表示元素d[0]+2表示元素d[0][2]的地址。*d与*(d+1)都不代表任何数组元素。

例子：将a矩阵与b矩阵相加，所得之和存入c矩阵中。a,b,c矩阵都是3*4的矩阵

 #include<stdio.h>
 #include<stdlib.h>
 #include<time.h>

 int i,j;
 void maxtrix(int *x,int *y,int *z){
     for(i=;i<;i++){
         for(j=;j<;j++){
             *(z+i*+j)=*(x+i*+j)+*(y+i*+j);
         }
    }
 }
 int main(){
     srand((int)time(NULL));
     int (*p)[][],a[][],b[][],c[][];
     printf("The value of a:\n");
     for(i=;i<;i++){
         for(j=;j<;j++){
           *(a[i]+j)=(int)rand%;
         }
     }
     printf("the value of b:\n");
     for(i=;i<;i++){
         for(j=;j<;j++){
           *(*(b+i)+j)=(int)rand%;
         }
     maxtrix(*a,b[],&c[][]);
     }
     printf("The value of c:");
     printf("%d",a[][]);
     return ;
 }

这个程序运行时会出现错误，以后再讨论。

3.指针数组

如果一个数组的元素都是指针变量，则称这个数组是指针数组。

指针数组定义的一般形式：

类型说明符 *数组名[]......

4.指针与字符串数组

字符数组中每个元素都是一个字符，而字符串数组中指的是数组中的每个成员都是存放字符串的数组。

1）直接给字符串数组赋初值

char b[4][8]={"Turbo C","FORTRAN","BASIC","Foxpro"};

char   b[][8]={"Turbo C","FORTRAN","BASIC","Foxpro"};

2)用给字符型指针数组赋初值的方式构成字符串数组

char *f[4]={"Turbo C","FORTRAN","BASIC","Foxpro"};

char *f[]={"Turbo C","FORTRAN","BASIC","Foxpro"};

实例：利用数字月份查找其英文月份名：

 #include<stdio.h>

 char *month_name(int n){
     char *name[]={
     "Illegal month",
     "January","February","March",
     "April","May","June","July",
     "August","September","October",
     "November","December"};
     return (n<|n>)?name[]:name[n];
 } 

 int main(){
     int n;
     scanf("%d",&n);
     printf("%d month name is %s\n",n,month_name(n));
     return ;
 }

5.指向数组的指针变量

指向数组的指针变量定义的一般形式：

类型说明符 （*变量名）[正整型常量表达式];

功能：定义一个名为"变量名"的指针变量，该指针变量所指向的是一个具有"正整型常量表达式"个元素的一维数组，该数组的每个元素都是"类型说明符"类型的。

例如：int (*p)[10],定义p是一个指针变量，它所指向的对象是一个具有10个元素的数组int型数组。

这种形式定义的指针一般用于指向二维的数组。

例如：int d[3][2],(*p)[2];p=d;

p=d;//p指向第0行，即指向整个数组d[0][0],d[0][1],d[0][2]......；

p++;//p指向第1行，即指向整个数组d[1][0],d[1][1],d[1][2]......;

(2) 二级指针

如果一个变量的值是其他变量的地址，而这些其他变量的值不再是内存地址，则这个变量是一级指针变量；

如果一个变量的值是一级指针的地址，则称这个变量是二级指针变量。

定义方法：

类型说明符   **标识符

int b,*m,**p;

m=&b;

p=&m;

实例1：二级指针输出整型数据：

 #include<stdio.h>

 void swap(int **m,int **n){
     int *i;
     i=*m;
     *m=*n;
     *n=i;
 }
 int main(){
     int a,b,*pa,*pb;
     pa=&a;
     pb=&b;
     scanf("a=%d,b=%d",pa,pb);
     swap(&pa,&pb);
     printf("pa=%d,pb=%d\n",*pa,*pb);
     printf("a=%d,b=%d",a,b);
     return ;
 }

这里输入时要注意一个问题，就是输入时，要满足scanf语句中的格式，必须进行格式的完全匹配。

实例2：二级指针输出字符串型数据

 #include<stdio.h>

 int main(){
     char **p,*address[]={
         "China","Japan","English",""
     };
     p=address;
     for(;**p!='\0';){
         printf("%s\n",*p++);
     }
     return ;
 } 

实例3：指针数组（区别于指向数组的指针）

 #include<stdio.h>

 int main(){
   int x[]={
    ,,,,
   };
   int *y[];
   int **a,b,i;
   for(i=;i<;i++){
       y[i]=&x[i];
   }
   a=y;
   for(b=;b>=;b--){
       printf("%3d",**a);
     a++;
   }
   printf("\n");
     return ;
 } 

本程序还可以写成下面的形式：

  #include<stdio.h>
    void s(int **a){
        int  b;
      for(b=;b<;b++){
        printf("%3d",**a);
        a++;
    }
    printf("\n");
  }
 int main(){
     int x[]={
         ,,,,
     };
     int *y[],i;
     for(i=;i<;i++){
         y[i]=&x[i];
     }
     s(y);
     return ;
 }

本例用二级指针变量输出了数组各元素的值。指针数组名作为函数实参时，形参得到的是实参指针数组的地址，这是一个二级指针。因此，形参可以写成int **a形式，也可以写成int *a[]的形式，两种方法等价。

（3）内存空间的动态分配

1.指向void类型的指针

void 类型是一种抽象的数据类型，如果用指针的void类型说明符定义一个指针变量，则该指针变量并没有被确定存储具体哪一种数据类型变量的地址。

void类型的指针和其他类型的指针可以相互赋值，且不必强制类型转换。

指向任何类型的指针都可以转换为指向void类型，如果将结果再转换为初始指针类型，则可以恢复初始指针类型并不会丢失信息。

 #include<stdio.h>

 int main(){
     float a[]={
       ,,,
     },*p1,*p3;
     //测试void型指针，进行连续的类型转换
     void *p2=a;
     p1=(float *)p2;
     p2=(void *)p1;

     p3=&a[];
     p2=p3;
     p3=(float *)p2;
     printf("a=%p,p1=%p,p2=%p,p3=%p,*p3=%f",a,p1,p2,p3,*p3);
     printf("\n");
     return ;
 }

将void型指针赋值给其他类型时，仍然需要强制类型转换。如上述14行所示。

从运行的结果可以看出，指向void的类型的指针起到了通用指针的作用。

2.常用内存管理函数

在此之前编写的程序，在程序运行之前所需要的变量数或者数组的大小就已经确定了。

C语言提供了一些内存管理函数，这些内存管理函数可以在程序运行期间分配内存空间，即可动态的分配内存空间，也可以将已经分配的内存空间释放。常用的内存管理函数有calloc,malloc,free函数。

1）calloc函数的功能是向系统申请分配连续的内存空间，如果申请获得成功，则把所分配内存区域的首地址作为函数返回值返回，该函数返回的是void类型的指针；如果申请获得成功，则函数返回空指针。原型：void *calloc(unsigned n,unsigned size);

int *p;

p=calloc(20,sizeof(int));

该程序段的功能是申请一块连续的能保存20个int型数据的内存区域，并使p指向该块内存区域。

2)malloc的功能与calloc函数类似，malloc函数用于向系统申请分配一块连续的size个字节的内存区域。

函数的原型：void *malloc(unsigned size);

3)free函数的原型是void free(void *p);其功能是释放p所指向的由calloc函数或者malloc函数已经申请成功的内存区域，free没有返回值。

 #include<stdio.h>
 #include<stdlib.h>

 int main(){
     int i,n,sum=,*p;
     printf("Please input a interger number imply that how many numbers you need to input next:\n");
     //scanf输入数据以空格结尾
     scanf("%d",&n);
     p=(int *)malloc(n*sizeof(int));//也可以改成p=malloc(n*size0f(int));//或者p=(int *)calloc(n,sizeof(int));
     printf("please input %d number:\n",n);
     for(i=;i<n;i++){
         scanf("%d",&p[i]);
         sum+=p[i];
     }
     free(p);
     printf("sum=%d\n",sum);
     return ;
 } 

malloc和calloc函数用于创建动态数组，还与后续的结构体有关。

(4)main函数的参数

在此前写的main函数总是main(),实际上main()函数也可以有参数。

1.命令行参数

在操作系统提示符状态下为了执行某个操作系统命令或某个可执行文件，而键入的一行字符称为命令行。

命令行的一般形式为：命令名[参数1][参数2]......[参数n]

命令名与参数之间以及各参数之间用空格或者Tab键隔开，若参数本身含有空格，则给参数要用""包含起来。

例子：C>copy f1.c  f2.c

2.指针数组作为main函数的形参

在操作系统下运行一个c程序，实际上就是操作系统调用该函数的主函数，主函数再调用其他函数。

主函数main的形参一般有两个参数，例如：

main(int argc,char *argv[]){};

第一个参数是int型，习惯上记作argc,表示命令行中参数的个数(包括命令名在内),在运行c程序时由系统自动计算出参数的个数，第二个参数是指向字符型的指针数组，习惯上记作argv,用来存放命令行中的各个参数。（作为形参，char *argv[]等于char **argv）;名字是可以自定的。

实例：假设以下程序存放在xx.c文件中，编译之后已经生成一个xx.c文件：

 #include<stdio.h>

 int main(int argc,char *argv[]){
     int i=;
     printf("argc=%d",argc);
     printf("argv= ");
     while(i<argc){
         printf("%s  ",argv[i]);
         i++;
     }
     return ;
 } 

将该文本内容保存到Test.c文件中，为了方便我把它放在了桌面C:\Users\JMSun\Desktop，在Cfree中打开之后点击运行，将自动进行编译在桌面产生obj文件和.exe文件：

在Dos窗口中执行下述命令：

cd c:\JMSun\Desktop命令用于进入指定目录的文件夹下，进入之后则可以运用dos下的命令行直接调用函数。

而之所以在dos下能有很多直接用的程序也是这个道理，不过那些可以用的程序一般是配置过系统环境变量的。

本例命令行共有四项，其中Test是执行程序的命令，也是程序的名称，其与三项是命令行参数，argc中存放的是命令行中包括命令在内的字符串的个数。argv中存放的是命令行各项的首地址。ANSI要求argv[argc]的值必须是一个空指针。

(5)指针的编程练习

1.将直角坐标系的一个坐标点(x,y),转换为极坐标系中的坐标值(p,角度)：

 #include<stdio.h>
 #include<math.h> 

 //用变量的地址值当形式参数，改变对应的地址所在单元的值。
 double change(double x,double y,double *p){
     double m;
     m=sqrt(x*x+y*y);
     *p=atan(y/x);
     return m;
 }
  int main(){
     double a,b,c,q;
     printf("please input x,y:\n");
     scanf("%lf%lf",&a,&b);
     c=change(a,b,&q);
     printf("c=%f,1=%f",c,q);
     return ;
 }

2.将10个国家的名字按照字母由小到大的顺序排列：

 #include<stdio.h>
 #include<string.h>
 //用字符数组指针指向字符数组，作为形参
 void sort(char *name[],int n){
     char *temp;
     int i,j,k;
     for(i=;i<n-;i++){
         k=i;
         for(j=i+;j<n;j++){
             if(strcmp(name[k],name[j])>)
                 k=j;
         }
         if(k!=i){
             temp=name[i];
             name[i]=name[k];
             name[k]=temp;
         }
     }
 }
 int main(){
     int n=,i;
     char *name[]={
       "China","America","France","Britain","Canada",
       "Australia","Switzerland","Japan","Italy","Germany"
     };
     sort(name,n);
     for(i=;i<n;i++){
         printf("%s\n",name[i]);
     }
     return ;
 }

3.编写程序，删除字符串的所有尾部空格：

 #include<stdio.h>
 #include<string.h>

 int main(){
       char *p;
     char str[];
     for(int k=;k<;k++){//将字符数组初始化为'\0'不是必须的。
       str[k]='\0';
     }
       p=str;
       printf("Please input a string:\n");
       gets(p);
       printf("打印一边字符串:");
       puts(p);
       //此语句用于将指针移到字符串末尾的'\0'处。
       while((*p)!='\0'){p++;}
     //上述语句等价于while(p++!='\0');p--;
     printf("字符串的长度为%d\n",p-str);
     do
       p--;
     while(*p==' ');//此语句用于将指针位置移动到'\0'前面第一个不为空格的字符上。
     *++p='\0';
     printf("%s",str);//puts(str)等同于printf("%s\n",str);
     return ;
 }

在做这个程序时，犯得错误有“指针前面忘了加*符，导致内存访问错误”,“printf和puts函数的功能的区别有点模糊”。

4.编写函数output和input,其功能分别于gets和puts相同,函数中分别用getchar()和putchar()读入和输出字符：

 #include<stdio.h>
 #include<string.h>
 void input1(char *s)
 {
    int i=;
    char c;
    while((c=getchar())!='\n')
       s[i++]=c;
    s[i]=;
 }
 void input2(char *a){
     char c;
     int i=;
     c=getchar();
     while(c!='\n'){
         a[i++]=c;
         c=getchar();
     }
 }
 void output(char a[]){
     while(*a!='\0'){
         putchar(*a++);
     }
 }
 int main(){
     char *p;
     char str[];
     output("please input a string:\n");
     input1(p);//同于input1;
     output(p);
 }

在本例中我出错的地方是getchar()函数用出错了,char c=getchar();我用成char c;getchar(c);

5.统计一个字符串中所有单词的个数：

 #include<stdio.h>
 #include<string.h>

 int count(char *q){
     char *p=q;
     int flag=;//用于返回的单词个数。
     //将指针指到字符数组的最后的'\0'的位置
     while(*p++!='\0');
     p--; 

     for(p--;q<=p;p--){
       if(*p!=' '&&*(p-)!=' '|*p==' '&&*(p-)==' '){
               continue;
         }else if(*p!=' '&&*(p-)==' '){
             flag++;
         }else if(*p!=' '&&p==q){
             flag++;
         }
     }
     return flag;
 }

 int main(){
   char str[],*p;
   puts("Please input a string containing many space to divide them: ");
   p=str;
   gets(p);
   printf("单词的个数为:%d",count(p));
 } 

不知道应该写什么，自己怎么搞定的好像都不太清晰。醉了！

6.编写一个小学生做加减乘除的程序。例如在操作系统下，键入cal 15 * 15<回车>则在屏幕上显示15*15=225：

  #include<stdio.h>
  #include<stdlib.h>
  #include<string.h>

  int main(int argv,char *argc[]){
      double a,b;
      double result;
      a=atof(argc[]);
      b=atof(argc[]);
     if(strlen(argc[])==){
         if(argc[][]=='+'){
             result=a+b;
          }else if(argc[][]=='-'){
              result=a-b;
         }
          else if(argc[][]=='*'){
              result=a*b;
          }
          else if(argc[][]=='/'){
              result=a/b;
         }
          printf("%lf %s %lf=%lf",a,argc[],b,result);
     }else
      {
          printf("输入错误！\n");
      }
     return ;
  }
  

这里采用了c语言中用于将字符串转化为数的函数，float atof(char *p ); 类似的还有int atoi(char *p);这两个函数都包含在"stdlib"头文件里。

　　在C语言中将字符串转化成整型有两种方法。
　　1 用atoi函数。
　　atoi的功能就是将字符串转为整型并返回。其声明为
　　int atoi(char *str);
　　比如atoi("1234");会返回整型1234。

　　2 用sscanf。
　　sscanf与标准格式化输入函数scanf类似，不过源并非是标准输入，而是字符串。
　　用sscanf可以处理更复杂的字符串。
　　比如字符串char * str = "a=1, b=2";
　　定义int a,b;后
　　可以用
　　sscanf(str,"a=%d, b=%d",&a,&b);
　　来将a,b值提取，计算后，a=1, b=2。