Linux C 程序 指针数组和二级指针(TEN)

指针数组和二级指针

 #include<stdio.h>

 int main(){
         ] = {,,,,};
         ], i;
         int **pp = p;
     //使p指针数组指向每一个a
          ; i <  ; i++){
                 p[i] =&a[i];
         }
     //【】优先级高于* ，*(p[i]) p[i] = &a[i],so==> *p[i] = *&a[i] = a[i]
          ; i <  ; i++){
                 printf("%d ",*p[i]);
         }
         printf("\n");
     //p 和 pp都是二级指针，i=0时,*pp=p[0] ,p[0]=&a[i],*pp=a[0].
     //执行pp++之后,pp指向p[1],*pp=p[1],p[1]=&a[1].
          ; i <  ; i++,pp++){
                 printf("%d ",**pp);
         }

          ;
 }
 output:

指针与数组的 关系

 nclude<stdio.h>

 int main(){
         ][] = {,,,,,,,,,};
         //表示p是一个指针，指向含有五个元素的一维数组
         ],i;
         //p指向二维数组得第一行
         p = a ;
     //p=a 之后 ， p=&a , *p = a[1].
     //p是一个数组指针
          ; i <  ; i++){
                 printf("%d ",(*p)[i]);
         //(*p)[i] 是先取p的内容作为数组的起始地址，然后再去第i个元素。
         //*p[i]是先取以p为起始地址的第i个元素，该元素为指针，然后取该指针的内容。
         }
         printf("\n");
     //p移动到第二行
         p++;
          ; i <  ; i++){
                 printf("%d ",(*p)[i]);
         }
         printf("\n");

         ;
 }

 ] ；//一个指针
 ]  ; //含有五个元素的数组，长度为5，数组中得每一个元素指向一个整型变量。

函数和指针
1.指针作为函数得参数
作用是将一个变量的地址传送到一个函数中

 #include<stdio.h>
 void change(int i , int *p){
         i++;
         if(p != NULL){
                 (*p)++;//根据地址找到变量b，b+1
         }
 }
 int main(){
          , b =  ;
         change(a,&b);
         printf("a=%d,b=%d",a,b);
         ;
 }

2.返回指针得函数
  int *f(int i , int j); 
() 的优先级高于 *
表示 f是一个函数，函数名前有一个指针，表示此函数得返回值类型为指针。

 include<stdio.h>
 //定义一个名称为name得指针数组，每个数组元素都指向一个字符串
 ] = {"monday","tuesday","wednessday","thursday","friday","saturday","sunday"};
 //定义一个指针，这个指针指向一个字符串
 char *message = "wrong input";
 //返回指针的函数
 char *week(int day){
          || day > ){
                 return message ;
         }else{
                 ] ;
         }
 }

 int main(){
         int day ;
         char *p;

         printf("input a number of a week:\n");
         scanf("%d",&day);

         p = week(day);
         printf("%s\n",p);

         ;
 }

3.指向函数的指针：

 #include<stdio.h>

 #define GET_MAX 0
 #define GET_MIN 1

 int get_max(int i , int j){
         return i > j ? i : j ;
 }

 int get_min(int i , int j){
         return i < j ? i : j ;
 }

 int compare(int i , int j , int flag){
         int ret ;
         //声明指向函数的指针
         int (*p)(int ,int);

         if(flag == GET_MAX){
                 p = get_max;//函数名
         }else{
                 p = get_min;
         }

         ret  = p(i , j );
         return ret ;
 }

 int main(){
          , j =  , ret ;
         ret = compare(i , j , GET_MAX);
         printf("max = %d\n",ret);

         ret = compare(i, j , GET_MIN);
         printf("min = %d\n",ret);

 }

不能对指向函数的指针做任何运算。

 int *f(int i , int j);//返回指针的函数
 int (*p)(int i , int j);//指向函数的指针

4.函数指针做形参
函数的参数可以是指针，淡然也可以是指向函数的指针

int get_max(int i , int j,int k , (*p)(int ,int));

该函数接收4个参数，函数内通过指针调用其他函数，信号处理会使用这种技术。
eg:

 #include<stdio.h>

 int get_big(int i , int j){
         return i > j ? i : j ;
 }
 //get_max函数里有个指向函数的指针做参数
 int get_max(int i ,int j ,int k ,int  (*p)(int ,int)){
         int ret ;

         ret = p(i , j );
         ret = p(ret , k);
         return ret ;
 }

 int main(){
          , j =  , k =  , ret ;
         ret = get_max(i , j , k , get_big);
         printf("max = %d",ret);
         ;
 }

5.返回函数指针的函数
eg:

 #include<stdio.h>

 int get_big(int i , int j){
         return i > j ? i : j ;
 }
 //()优先级高于* ， get_function先和()结合，成为一个函数，他的返回值是一个指向函数的指针 int (*)(int ,int)
 int (*get_function(int a))(int ,int ){
         printf("the number is %d",a);
         return get_big;
 }

 int main(){
          , j =  , max ;
         int (*p)(int ,int);
         p = get_function();

         max = p(i , j );
         printf("max number is %d",max);
         ;
 }

数组名始终指向该数组的第一个元素，不允许做a++运算，新申明的指针则可以随意移动