精华内容
下载资源
问答
  • 指针数组指针数组,及就是一个数组它的所有元素都是指针。形式为: int *p[数组个数]#include<stdio.h> int main() { int arr[4]={1,2,3,4}; int *p[4]; int i = 0; for(i=0;i<4;i++) { ...

    指针数组

    指针数组,及就是一个数组它的所有元素都是指针。

    形式为: int *p[数组个数]
    #include<stdio.h>
    int main()
    {
        int arr[4]={1,2,3,4};
        int *p[4];
        int i = 0;
        for(i=0;i<4;i++)
        {
            p[i]=&arr[i];
            printf("%d\n",*p[i]);
        }
        *p=&arr[0];
        printf("%d",**p);
        return 0;
    }
    1.p[i]=&arr[i];//p[i]是一个指针,它用来保存arr[i]的地址
    2.printf(“%d\n”,*p[i]);//对p[i]解引用后就可以访问arr[i]了
    3.*p=&arr[0];//对p表示指针p首元素地址,对p解引用即就是指针p,并将arr[0]的地址保存在*p里
    4.printf(“%d”,**p);//再对*p解引用就可以访问到arr[0]了

    数组指针

    数组指针,就是指针,只不过这里的指针指向了一个数组而已。

    它的形式为:int (*p)[所指向数组元素个数]
    #include<stdio.h>
    int main()
    {
        int arr[5]={1,2,3,4,5};
        int arr1[2][3]={1,2,3,4,5,6};
        int (*p)[5];
        int (*p1[2])[3];
        p=&arr;
        p1[0]=&arr1[0];
        printf("%d ",*((*p+2)));
        printf("%d ",*(*p1[0]+1));
        return 0;
    }
    1.(*p)[5]是一个数组指针,p=&arr,即将数组arr的地址赋给指针p。
    2.在用指针访问数组arr中某一个元素时,对p解引用降级为数组arr的首元素地址并加上要跳过的元素个数,然后再解引用,就可以访问到这块空间。
    3.二维数组其实也是一样的道理。

    函数指针

    函数指针顾名思义,指向函数的指针

    #include<stdio.h>
    void fun(int x,int y)
    {
        if(y>x)
        {
            printf("b>a");
        }
        else
            printf("a>b");
    }
    int main()
    {
        void (*pfun)(int ,int);
        int a = 1,b =2;
        pfun=&fun;
        (*pfun)(a,b);
        return 0;
    }
    
    #这里声明一个函数指针void (*pfun)(int ,int); 它的类型是无返回类型
    pfun=&fun,将函数的地址复制给指针pfun,解引用pfun,(*pfun)(a,b)就可以访问这块空间了。

    程序的运行结果:Max=7

    函数指针数组

    定义:一个函数指针数组,及就是一个数组,而数组的每个元素就是指针,指针指向函数。

    例如:

    char*(pf[3])(char p);

    这里数组名为pf,数组内储存了三个元素指向函数的指针。指针指向有一个返回类型为char*、参数为char*的函数。
    #include<stdio.h>
    #include<string.h>
    char*fun1(char*p)
    {
        printf("%s\n",p);
        return p;
    }
    char*fun2(char*p)
    {
        printf("%s\n",p);
        return p;
    }
    char*fun3(char*p)
    {
        printf("%s\n",p);
        return p;
    }
    
    int main()
    {
        char*(*pf[3])(char*p);
        //*(pf)=fun1;
        //*(pf+1)=&fun2;
        //*(pf+2)=fun3;
        //*(*(pf))("fun1");
        //*(*(pf+1))("fun2");
        //*(*(pf+2))("fun3");
        pf[0]=fun1;
        pf[1]=fun2;
        pf[2]=fun3;
        *pf[0]("fun1");
        *pf[1]("fun2");
        *pf[2]("fun3");
    
    
        return 0;
    }
    对这段代码分析:

    在主函数中定义了一个char*类型的函数指针数组,数组有三个指向返回类型为char*的函数的指针。
    来看一下下面这段代码吧!
    Alt text
    1.pf为指针数组的地址,对它解引用*(pf)即pf降级为指针pf[1],并将函数的地址保存在这个指针中,所以对pf解引用的效果和pf[]的效果是一样的。
    2.对(pf)解引用即就可以访问这块空间了,同上:(*pf)就等同于对pf[]解引用。

    函数指针数组的指针

    看到这,也许会想它是一个什么玩意啊,其实它就是一个指向函数指针数组的指针。

    例如:

    char*(*(*pf2)[3])(char*p);

    这里的pd2是一个指针(*(*pf2)[3])是一个指针数组而内部的(*pf2)是一个指针,所以它整体是一个指针。

    下面先来看一个例子:

    #include<stdio.h>
    #include<string.h>
    char*fun1(char*p)
    {
        printf("%s\n",p);
        return p;
    }
    char*fun2(char*p)
    {
        printf("%s\n",p);
        return p;
    }
    char*fun3(char*p)
    {
        printf("%s\n",p);
        return p;
    }
    int main()
    {
        char*(*(pf1[3]))(char*p);
        char*(*(*pf2)[3])(char*p);
        pf2=&pf1;
        pf1[0]=fun1;
        pf1[1]=fun2;
        pf1[2]=fun3;
        *(*(*pf2))("fun1");
        *(*(*pf2+1))("fun2");
        *(*(*pf2+2))("fun3");
        return 0;
    }
    1.这里的pf1是一个指针数组且每个指针数组的元素指向一个函数,故这里的char*(*(pf1[3]))(char*p);是一个函数指针数组。
    2.而这里的pf2是一个指针,每一个指针,每一个指针指向一个函数指针数组的元素。

    分析如下:

    (1)用pf2来保存pf1的地址通过pf1来访问函数。
    (2)用pf1[]来保存函数地址。
    (3)对pf2解引用pf2得到pf1,再解引用pf2)得到函数地址,再解引用(*(*pf2))即可访问到函数。

    展开全文
  • 指针 数组 函数

    2017-12-19 22:55:29
    1.指针数组指针数组是数组,这个数组用来存放指针。 例:int *arr[10]; 整形指针数组; char **arr[10]; 字符型的二级指针数组 2.数组指针:数组指针是指针,指针指向的是数组。 例:int (*p)[10]; 数组指针(...

    1.指针数组:指针数组是数组,这个数组用来存放指针。

    例:int  *arr[10];   整形指针数组;      char  **arr[10];   字符型的二级指针数组

    2.数组指针:数组指针是指针,指针指向的是数组。

    例:int (*p)[10];    数组指针([ ] 的优先级高于*,所以需要加上( )来保证p先与*结合)

    3.函数指针:函数指针是指针,指针指向的是一个函数。

    例:void (*P)( );   ————>( )的优先级高于* 。

    4.函数指针数组:函数指针数组是数组 ,是将函数的地址存到一个数组中。

    例:int (*arr[10])( );    arr先与[ ]结合,说明arr是一个数组,数组的内容是int (*)( )类型的函数指针。

    5.指向函数指针数组的指针:是一个指针,指针指向一个数组,数组中的元素都是函数指针。

    例:void (*(*arr)[10])( );       



    判断一个复杂的式子到底是什么类型,就看其数组名左右相邻的元素,谁的优先级高,先与谁结合,则为此类型。


    而在一段很长的一段描述中,想要迅速的判断出究竟是什么类型,只需要看这段描述中的最后两个字,即为类型。例如 “指向函数指针数组的指针”这段话中的最后两个字为“指针”,则可以迅速判断出,此式的类型为指针类型。


    只要掌握方法和技巧,判断指针数组和函数就变得很简单啦!

    展开全文
  • 什么是函数指针:是指针,有能力指向一个函数,既可以通过指针调用函数,亦可通过函数名直接表示。 接下来我们看张图: 在这里,你肯定会想函数名怎么会有地址,存在于哪里? 接下来,我们看两段代码:(1). ...

    1.函数指针

    什么是函数指针:是指针,有能力指向一个函数,既可以通过指针调用函数,亦可通过函数名直接表示。

    接下来我们看张图:

    在这里,你肯定会想函数名怎么会有地址,存在于哪里?

    接下来,我们看两段代码:(1). char *(*fun1)(char *p1,char *p2)(2).(2) char * *fun2(char p1,char p2)

    第一个看起来更像函数第一题看起来像函数,其实他是函数指针,fun1是指针变量,他指向一个函数。这个函数有两个指针类型的参数,返回值为 char * 型;第二题看起来像指针,其实他是一个函数,fun2是函数名,参数为两个指针,返回值为 char 型二级指针。

    2.函数指针数组

    什么是函数指针数组:是数组,这个数组中的元素就是我们前面所提到的函数指针。( 比如:char *(* a[4])(char *p);它是一个数组,数组名为 a ,数组内有四个指向函数的指针;这个指针指向一些返回值类型为指向字符的指针,参数为指向字符的指针的函数。)

    函数指针数组指针:首先它是一个指针,这个指针指向数组,这个数组里面存的都是指向函数的指针。(比如:char (*(* a)[4])(char *p); 这个指针指向包含了4个元素的数组;这个数组里面存的是指向函数的指针;这个指针指向一些返回值类型为指向字符的指针,参数为指向字符的指针的函数。

    用函数指针数组的实现:

    #include<stdio.h>
    #include<windows.h>
    #pragma warning(disable:4996)
    int add(int a, int b)
    {
    	return a + b;
    }
    int sub(int a, int b)
    {
    	return a - b;
    }
    int mul(int a, int b)
    {
    	return a * b;
    }
    int chu(int a, int b)
    {
    	return a / b;
    }
    int main()
    {
    	int x, y;
    	int input = 1;
    	int ret = 0;
    	int(*p[5])(int x, int y) = { 0,add,sub,mul,chu};//转移表
    	while (input)
    	{
    		printf("******************************\n");
    		printf("1:add                   2:sub \n");
    		printf("3:mul                   4:chu \n");
    		printf("******************************\n");
    		printf("请选择:");
    		scanf("%d", &input);
    		if (input <= 4 && input>=1)
    		{
    			printf("请输入操作数:");
    			scanf("%d %d", &x, &y);
    			ret = (*p[input])(x, y);
    			printf("ret=%d\n", ret);
    		}
    		else
    		{
    			printf("输入错误\n");
    			printf("ret=%d\n", ret);
    		}
    	}
    	system("pause");
    	return 0;
    }

    3.指向函数指针数组的指针

    函数指针数组的指针:就是一个指针,该指针指向函数指针数组,这个数组里的元素是函数指针。

    #include<stdio.h>
    #include<windows.h>
    void test(const char* str)
    {
    	printf("%s\n", str);
    }
    int main()
    {
    	void (*pfun)(const char*) = test;//函数指针pfun
    	void (*pfunarr[5])(const char* str);//函数指针数组pfunarr
    	pfunarr[0] = test;
    	void (*(*ppfunarr)[10])(const char*) = &pfunarr;//指向函数指针数组pfunarr的指针ppfunarr
    	system("pause");
    	return 0;
    }

    通过以上的了解 ,相信大家对指针的概念有了以下了解,在这里我还有以下建议:在分析指针还是数组之前,我们一定不要马虎,不要心急,弄清[ ]与*的结合性,从里到外一步步分析。这样能避免出错,让我们正确分析。

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

           指针是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就是指向函数指针数组的指针

    展开全文
  • 数组里面的每一个内容都为指针 类似于int数组,char 数组,指针数组 *char[] = {"aaa", "bbb"} 指针数组:先说明类型 类型为指针 再说明内容 内容为数组;指针指向的数组 (*char)[] 数组名本身就是一个指针 -_-! ...
  • 指针常量和常量指针  要想搞清楚这一对,必须先知道const关键字;const关键字用来修饰一个变量,表示该变量是只读变量,不可以修改的;(在C语言中const修饰的变量是可以用指针来强制改变的,但在C++中是不行的;)...
  • 指针数组 首先从名字就可以知道这是一个数组,是存放指针的数组。 先看几种指针数组: int * 数组指针 函数指针 函数指针数组 指向函数指针数组的指针
  • 理解 指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针
  • ![图片说明](https://img-ask.csdn.net/upload/201805/08/1525778822_142150.png) !...!...!...!...想请教各位大佬这几个题中指针所代表的含义 如果能解释一下题目的解题过程就更好了 最近学指针 真的是被它搞得有点晕
  • 指针数组函数 利用指针数组函数 结合冒泡排序来对一个数组里面的数进行排序 //冒泡排序 #include<iostream> using namespace std; void Bibblesort(int* arr, int len)//数组首地址,长度 { for (int i = 0; ...
  • 数组指针的定义 数组名的指针,即数组首元素地址的指针。即是指向数组的指针。...指针数组是数组元素为指针的数组(例如 int *p[3],定义了p[0],p[1],p[2]三个指针),其本质为数组。 例如:{int a[4]
  • 首先,看如下8个题,如果您能不看任何资料的情况下做对。那么恭喜您,这块应该基本没问题了。...5,定义一个具有10个指针数组,这些指针都是指向整形数的 6,定义一个指向有10个整形数 数组指针
  • 1.理解 指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针 写博客,将连接发给我。
  • 简单理解—指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针 指针数组 指针数组,顾名思义是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有...
  • 1.理解 指针数组 数组指针 函数指针 ...函数指针数组 指向函数指针数组的指针 1.理解 指针数组 #include int main() { int i=0; //指针数组 char *arr[3]={"aaaaa","bbbbb","ccccc",};  

空空如也

空空如也

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

指针数组函数