精华内容
下载资源
问答
  • 函数指针 函数指针数组 指针函数 数组指针 指针数组
    指针与数组:
        指针与一维数组:
           int arrInt[] = {1,2,3,4,5};
           int* pa = arrInt;
           *pa <==> arrInt[0];
           *(pa+1) <==> arrInt[1];

           *(pa+2)=6; <==> arrInt[2]=6;


       void func(int*);

       void func(int arr[]); // 与void func(int*); 形式是一样的

       void func(int arr[4]); // 只接收元素个数为4的整形数组


    函数指针:
        void func1();
        void func2(int);
        void func3(int, double);
        int* func4();
      声明函数指针:
        void (*pf1)();              // pf1表示返回值void,没有参数的函数。
        void (*pf2)(int);           // pf2表示返回值void,参数只有一个int的函数。
        void (*pf3)(int, double);   // pf3表示返回值void,参数顺序为int、double的函数。
        int* (*pf4)();              // pf4表示返回值int*,无参的函数。
      函数指针赋值:(函数名就是一个内存地址)
        pf1 = func1;
        pf2 = func2;
        pf3 = func3;
        pf4 = func4;
      函数指针调用:
        (*pf1)(); 调用func1
        (*pf2)(1); 调用func2
        (*pf3)(1, 1.3); 调用func3
        (*p4)();    调用func4


    函数指针数组:
        void (*pf[3])(); 声明3个指向void func();函数的指针


    指针函数:
        返回值为指针的函数形似int* func();


    指针数组:(存放指针的数组)
        int *pa[3]; // []优先级高于*,[]先与int结合组成数组,再由int*声明数组元素为指针。
        int a,b,c;
        pa[0] = &a;
        pa[1] = &b;
        pa[2] = &c;
    数组指针:(指向数组的指针,也叫行指针)
        int (*pa)[3]; // ()、[]优先级一样高,从左到右结合,首先是()强调pa是指针,然后是[3]pa指向有三个元素的一维数组。
        int arrInt[3] = {1,2,3};
        pa = arrInt;
        pa++; //跨越一个数组长度,越界操作。


        数组指针通常与二维数组联用:
        int arrDoubleInt[4][3];
        pa = arrDoubleInt[0]; // 指向第一行
        pa[0][1] == *(*(pa+0)+1) == 第一行第二列数据。
        pa++;               // 指向第二行
        

    展开全文
  • 数组指针和指针数组的区别 数组指针(也称行指针) 定义 int (*p)[n]; ()优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的长度是n,也可以说是p的步长。也就是说执行p+1时,p要跨过n个...

    一:数组指针和指针数组的区别

    数组指针(也称行指针)
    定义 int (*p)[n];
    ()优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的长度是n,也可以说是p的步长。也就是说执行p+1时,p要跨过n个整型数据的长度。  元素表示为 (*p)[i];

    如要将二维数组赋给一指针,应这样赋值:
    int a[3][4];
    int (*p)[4]; //该语句是定义一个数组指针,指向含4个元素的一维数组。
     p=a;        //将该二维数组的首地址赋给p,也就是a[0]或&a[0][0]
     p++;       //该语句执行过后,也就是p=p+1;p跨过行a[0][]指向了行a[1][]

    所以数组指针也称指向一维数组的指针,亦称行指针。

    指针数组
    定义 int *p[n];
    []优先级高,先与p结合成为一个数组,再由int*说明这是一个整型指针数组,它有n个指针类型的数组元素。这里执行p+1时,则p指向下一个数组元素,这样赋值是错误的:p=a;因为p是个不可知的表示,只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值,a的首地址的值。   
    如要将二维数组赋给一指针数组:
    int *p[3];
    int a[3][4];
    p++; //该语句表示p数组指向下一个数组元素。注:此数组每一个元素都是一个指针
    for(i=0;i<3;i++)
    p[i]=a[i]
    这里int *p[3] 表示一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2]
    所以要分别赋值。

    这样两者的区别就豁然开朗了,数组指针只是一个指针变量,似乎是C语言里专门用来指向二维数组的,它占有内存中一个指针的存储空间。指针数组是多个指针变量,以数组形式存在内存当中,占有多个指针的存储空间。
    还需要说明的一点就是,同时用来指向二维数组时,其引用和用数组名引用都是一样的。
    比如要表示数组中i行j列一个元素:
    *(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]

    优先级:()>[]>*

    出处:http://www.cnblogs.com/hongcha717/archive/2010/10/24/1859780.html

    二:指针函数与函数指针的区别

    指针函数:是一个函数,它的返回值类型是一个指针,比如 int *fun(int *a,int *b);

    函数指针:每一个函数都有一个入口地址,指向这个入口地址的指针为函数指针。 比如 int (*fun)(int *a,int *b);可以看出函数名就是一个指针。

    三:函数指针数组:

    顾名思义,是一个数组,其中的每一个元素都是指向某一个函数入口地址的指针。

    比如将所有的排序算法都放在一个数组里:

    void (*fun[])(int *,int )

    {

          maopao_sort;//冒泡

          xuanze_sort;//选择

         。。。

    }

    注意里面所有函数的参数列表都必须与这个数组前的参数列表参数数目相同。即这些函数的声明类型都是void 函数名(int *,int).



    展开全文
  • 指针 指针数组 指针数组的指针 数组指针 数组指针的数组 函数指针 函数指针数组 指向函数指针数组的指针

           指针是c语言的灵魂所在,然而因为其过于灵活,在使用的过程中难免出错。接下来我们简单分析一下常见的指针运用。

    指针:

         1  一级指针

             char *p1 =  “abcdef”;

          2  二级指针

             char **p2 = &p1;

    指针数组:

         1 char *arr[5] ;  (在数组中存放5个char* 指针)

    指针数组指针

         1 char* arr[5];

            char * (*parr)[5] = &arr;

           parr就是指向指针数组arr的指针 (即parr为指针数组的指针)

    数组指针:

         1   int   arr[5] = {1,2,3,4,5};

              int  (*p)[5] = &arr ;          p即为指向数组的指针,又称数组指针

    数组指针的数组:

          int arr1[3] = {1,2,3};

          int arr2[3] = {4,5,6};

          int (*parr[2])[3]={arr1,arr2};


    函数指针:

      先写一个简单的函数

            int add(int x, int y)

             {

                return x+y;

             }

        int  (*pfun)(int, int);

                pfun = add;

    这样一来  pfun就是指向函数add的指针(即函数add的指针)。

    下面是定义一个函数指针的方法:



    指向函数指针数组的指针:

               函数指针数组也是指针数组,在这个数组中存放的是函数的指针

        eg: 我们先写加减乘除四个子函数。

             

            int (*pfunarr[4])(int, int) = {add, sub, mul, div};//这个数组就是函数指针数组      pfunarr就是指向函数指针数组的指针

    展开全文
  • 可以使用指针变量指向数组的首地址,也可以使用指针变量指向函数代码的首地址,指向函数代码首地址的指针变量称为函数指针。 1.函数指针定义 函数类型 (*指针变量名)(形参列表); “函数类型”说明函数的返回...
    函数指针】

           在程序运行中,函数代码是程序的算法指令部分,它们和数组一样也占用存储空间,都有相应的地址。可以使用指针变量指向数组的首地址,也可以使用指针变量指向函数代码的首地址,指向函数代码首地址的指针变量称为函数指针。

    1.函数指针定义

    函数类型 (*指针变量名)(形参列表);

    “函数类型”说明函数的返回类型,由于“()”的优先级高于“*”,所以指针变量名外的括号必不可少,后面的“形参列表”表示指针变量指向的函数所带的参数列表。

    例如:

    int (*f)(int x);

    double (*ptr)(double x);

    在定义函数指针时请注意:
       
    函数指针和它指向的函数的参数个数和类型都应该是—致的;

    函数指针的类型和函数的返回值类型也必须是一致的。

    2.函数指针的赋值

    函数名和数组名一样代表了函数代码的首地址,因此在赋值时,直接将函数指针指向函数名就行了。

    例如,

    int func(int x);   /* 声明一个函数 */

    int (*f) (int x);    /* 声明一个函数指针 */

    f=func;            /* 将func函数的首地址赋给指针f */

    赋值时函数func不带括号,也不带参数,由于func代表函数的首地址,因此经过赋值以后,指针f就指向函数func(x)的代码的首地址。

    3.通过函数指针调用函数

    函数指针是通过函数名及有关参数进行调用的。

    与其他指针变量相类似,如果指针变量pi是指向某整型变量i的指针,则*p等于它所指的变量i;如果pf是指向某浮点型变量f的指针,则*pf就等价于它所指的变量f。同样地,*f是指向函数func(x)的指针,则*f就代表它所指向的函数func。所以在执行了f=func;之后,(*f)和func代表同一函数。

    由于函数指针指向存储区中的某个函数,因此可以通过函数指针调用相应的函数。现在我们就讨论如何用函数指针调用函数,它应执行下面三步:

    首先,要说明函数指针变量。

    例如:int (*f)(int x);

    其次,要对函数指针变量赋值。

    例如: f=func;    (func(x)必须先要有定义)

    最后,要用 (*指针变量)(参数表);调用函数。

    例如:    (*f)(x);(x必须先赋值)


    【例】任意输入n个数,找出其中最大数,并且输出最大数值。

    main()

    {

            int f();

            int i,a,b;

            int (*p)();    /* 定义函数指针 */

            scanf("%d",&a);

            p=f;            /* 给函数指针p赋值,使它指向函数f */

            for(i=1;i<9;i++)

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

                    a=(*p)(a,b);    /* 通过指针p调用函数f */

            }

            printf("The Max Number is:%d",a)

    }


    f(int x,int y)

    {

        int z;

        z=(x>y)?x:y;

        return(z);

    }

    运行结果为:

    343 -45 4389 4235 1 -534 988 555 789↙

    The Max Number is:4389


    【指针函数】

    一个函数不仅可以带回一个整型数据的值,字符类型值和实型类型的值,还可以带回指针类型的数据,使其指向某个地址单元。

            返回指针的函数,一般定义格式为:

            类型标识符    *函数名(参数表)

    int *f(x,y);

    其中x,y是形式参数,f是函数名,调用后返回一个指向整型数据的地址指针。f(x,y)是函数,其值是指针。

    如:char *ch();表示的就是一个返回字符型指针的函数,请看下面的例题:

    【例】将字符串1(str1)复制到字符串2(str2),并输出字符串2.

    #include "stdio.h"

    main()

    {

        char *ch(char *,char *);

        char str1[]="I am glad to meet you!";

        char str2[]="Welcom to study C!";

        printf("%s",ch(str1,str2));

    }

    char *ch(char *str1,char *str2)

    {

        int i;

        char *p;

        p=str2
       
        if(*str2==NULL) exit(-1);

        do

        {

            *str2=*str1;

            str1++;

            str2++;

        }while(*str1!=NULL);

        return(p);

    }


    通过分析可得

    函数指针是一个指向函数的指针,而指针函数只是说明他是一个返回值为指针的函数,

    函数指针可以用来指向一个函数。

     

     

     

     

     

     

     

     

    数组指针(也称行指针)
    定义 int (*p)[n];
    ()优先级高,首先说明p是一个指针,指向一个整型的一维数组,这个一维数组的长度是n,也可以说是p的步长。也就是说执行p+1时,p要跨过n个整型数据的长度。

    如要将二维数组赋给一指针,应这样赋值:
    int a[3][4];
    int (*p)[4]; //该语句是定义一个数组指针,指向含4个元素的一维数组。
     p=a;        //将该二维数组的首地址赋给p,也就是a[0]或&a[0][0]
     p++;       //该语句执行过后,也就是p=p+1;p跨过行a[0][]指向了行a[1][]

    所以数组指针也称指向一维数组的指针,亦称行指针。

    指针数组
    定义 int *p[n];
    []优先级高,先与p结合成为一个数组,再由int*说明这是一个整型指针数组,它有n个指针类型的数组元素。这里执行p+1是错误的,这样赋值也是错误的:p=a;因为p是个不可知的表示,只存在p[0]、p[1]、p[2]...p[n-1],而且它们分别是指针变量可以用来存放变量地址。但可以这样 *p=a; 这里*p表示指针数组第一个元素的值,a的首地址的值。
    如要将二维数组赋给一指针数组:
    int *p[3];
    int a[3][4];
    for(i=0;i<3;i++)
    p[i]=a[i];
    这里int *p[3] 表示一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2]
    所以要分别赋值。

    这样两者的区别就豁然开朗了,数组指针只是一个指针变量,似乎是C语言里专门用来指向二维数组的,它占有内存中一个指针的存储空间。指针数组是多个指针变量,以数组形式存在内存当中,占有多个指针的存储空间。
    还需要说明的一点就是,同时用来指向二维数组时,其引用和用数组名引用都是一样的。
    比如要表示数组中i行j列一个元素:
    *(p[i]+j)、*(*(p+i)+j)、(*(p+i))[j]、p[i][j]

     

    优先级:()>[]>*

     



    展开全文
  • 函数 数组 指针预习

    2018-01-26 13:01:09
    1. 数组指针之间的关系? 答:变量在内存存放是有地址的,数组在内存存放也同样具有地址。对于数组来说,数组名就是数组在内存存放的数组首元素地址。...2. 数组作为参数传递给函数时,可以通过sizeof得到数组
  • 理解 指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针
  • 指针数组 首先从名字就可以知道这是一个数组,是存放指针的数组。 先看几种指针数组: int * 数组指针 函数指针 函数指针数组 指向函数指针数组的指针
  • 开门见山,今天的主要内容是:指针数组,数组指针函数指针,函数指针数组,函数指针数组指针。 看见题目是不是有点晕晕的感觉,没关系等看完这篇博客你会觉得他们其实也很好理解的! 接下来我一个一个介绍。 一....
  • 1.理解 指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针 写博客,将连接发给我。
  • 对于这几个概念,用以下几幅图进行解析:1.数组指针 2.指针数组 3.函数指针、函数指针数组、函数指针数组指针 如有错误,恳请指点。
  • 简单理解—指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针 指针数组 指针数组,顾名思义是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有...
  • 指针函数数组指针函数指针、函数指针数组和指向函数指针数组的指针
  • 1.理解 指针数组 ...数组指针 函数指针 函数指针数组 指向函数指针数组的指针 1.理解 指针数组 #include int main() { int i=0; //指针数组 char *arr[3]={"aaaaa","bbbbb","ccccc",};  
  • 函数指针数组指针 指针数组 指针数组就是存放指针的数组,与一般数组相同,只是所存放的是指针 用法与平常数组无异。 int* arr[10]; // int*为数组类型,表明其中存放的是整型指针,数组长度为10 数组指针...
  • 指针数组指针数组到底是指针还是数组呢?指针数组是数组,是一个存放指针的数组,也就是数组元素全为指针的数组。例如,一个一维指针数组的定义:int *ptr_array[10]。数组指针知道指针数组是什么之后,那么数组指针...
  • 指针数组:数组元素全为指针的数组称为指针数组。...数组指针数组指针是指向数组地址的指针,其本质为指针;例:int (*p)[10]; p即为指向数组的指针,又称数组指针。[10]代表的就是这个数组指针所指向
  • 文章目录前言一、指针数组二、数组指针三、函数指针四、函数指针的数组五、指向函数指针数组的指针1.引入库2.读入数据总结 前言 学习C语言中指针问题的学习笔记,对于指针数组、数组指针函数指针、函数指针数组...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 29,381
精华内容 11,752
关键字:

函数数组指针