精华内容
参与话题
问答
  • 指针 指针数组 指针数组的指针 数组指针 数组指针的数组 函数指针 函数指针数组 指向函数指针数组的指针

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

    指针数组

    首先从名字就可以知道这是一个数组,是存放指针的数组。
    先看几种指针数组:
    int *arr1[10];
    char *arr2[5];
    char **arr3[6];
    因为 [ ] 的优先级是高于 * 的,所以数组名会先于 [ ] 相结合组成数组。 再于 int * / char *类型结合,组成存放该类型的数组。



    指针数组因为存放的都是指针所以不管是 int *   char * 还是 char ** 其大小都是四个字节。

    数组指针

    从名字看就知道是指针,是指向一个数组的指针。

    int (*p)[10];
    char (*p)[10];
    由数组指针知道 [ ] 的优先级是高于 *  的,所以用()来提升指针先结合。

    int (*p)[10];  //  是一个指向10个整形的一维数组的指针
    char (*p)[10]; //  是一个指向10个字符型的一维数组的指针

    数组的存储方式



    因为指向的是一个数组,所以大小由数组决定


    函数指针

    指向函数的指针,通俗的说也就是函数的地址
    void(*pfun)();
    pfun 先和*结合,说明pfun是指针,指针指向的是一个函数,指向的函数无参数,返回值类型为void
    也就是说 其可以保存函数的地址



    函数指针数组

    int (*parr[3])();
    parr先与 [ ]结合,说明是一个数组,再与*结合,说明数组存放的是指针,指针都指向的是函数
    函数指针数组的使用(转移表)
    例子:计算器
    #include<stdio.h>
    
    int add( x, y)
    {
    	return x + y;
    }
    int sub(x,y)
    {
    	return x - y;
    }
    int mul(x,y)
    {
    	return x * y;
    }
    int div(x,y)
    {
    	return x / y;
    }
    int main()
    {
    	int x, y;
    	int input = 1;
    	int ret = 0;
    	int(*parr[5])(int x, int y) = { 0, add, sub, mul, div }; //转移表
    	while (input)
    	{
    		printf("*******************************\n");
    		printf("***** 1.add         2.sub *****\n");
    		printf("***** 3.mul         4.div *****\n");
    		printf("*******************************\n");
    		printf("请选择:");
    		scanf("%d", &input);
    		if ((input > 0 && input < 5))
    		{
    			printf("输入你要计算的数:\n");
    			scanf("%d  %d", &x, &y);
    			ret = (*parr[input])(x, y);
    		}
    		else
    			printf("输入有误!\n");
    		printf("%d\n", ret);
    	}
    	return 0;
    }
    输出结果:


    指向函数指针数组的指针 

    这是一个指针,指向一个数组,这个数组是一个函数指针数组,数组中的元素都是函数指针

    定义方式:

    #include<stdio.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
    	void (*(*ppfunArr)[10])(const char* str) = &pfunArr;
    	//指向函数指针数组pfunArr的指针ppfunArr
    	return 0;
    }




    展开全文
  • 函数指针 函数指针数组 指针函数 数组指针 指针数组
    指针与数组:
        指针与一维数组:
           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[5];

    int (*p)[5];

    有没有很简单,但是有很多初学者很是分不清楚;第一个是指针数组,第二个是数组指针。且看小僧给大家捋一捋,首先要明白符号优先级问题,“[ ]”的优先级高于“*”,所以p先和谁结合就表示谁。"int *p[5]" p先和[ ]结合,理所当然是数组了,只不过数组元素为 int * 型;"int (*p)[5]" “()”的优先级高于“[ ]”,p先和“*”结合,理所当然是指针,只不过该指针指向 int 型数组的内容,是不是搜一贼。

    指针数组:首先他是一个数组,数组的元素都是指针,数组占多少个字节由数组本身决定。

    数组指针:首先他是一个指针,他指向一个数组。是不是很难懂,且看下图

    希望你们看了不会太晕

    二、函数指针,函数指针数组

         函数指针,看到这里你肯定会照猫画虎,(首先他是一个指针,他指向一个函数)很对,就是这样的。接下来我们细细研究,先看张图

    来几片代码瞧一瞧

    (1) char *(*fun1)(char *p1,char *p2);(2) char * *fun2(char p1,char p2);

    有没有很复杂的样子,第一题看起来像函数,其实他是函数指针,fun1是指针变量,他指向一个函数。这个函数有两个指针类型的参数,返回值为 char * 型;第二题看起来像指针,其实他是一个函数,fun2是函数名,参数为两个指针,返回值为 char 型二级指针。 函数指针也很简单吧,其实他和普通指针一样,我们使用他的好处在于,可以将实现同一功能的多个模块统一起来标识,这样可以使函数的接口与实现分开。

    三、函数指针数组,函数指针数组指针有了上面了的基础我们很容易掌握这两个

    函数指针数组:首先它是一个数组,数组元素为函数指针。(不干说,还是来个栗子:char *(* a[4])(char *p);它是一个数组,数组名为 a ,数组内有四个指向函数的指针;这个指针指向一些返回值类型为指向字符的指针,参数为指向字符的指针的函数。)

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

    来个例子看看他们的威力:

    #include <stdio.h>
    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 div(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, div }; //转移表
    		while (input)
    		{
    			printf( "*************************\n" );
    			printf( " 1:add 2:sub \n" );
    			printf( " 3:mul 4:div \n" );
    			printf( "*************************\n" );
    			printf( "请选择:" );
    			scanf( "%d", &input);
    			if ((input <= 4 && input >= 1))
    			{
    				printf( "输入操作数:" );
    				scanf( "%d %d", &x, &y);
    				ret = (*p[input])(x, y);
    			}
    			else
    				printf( "输入有误\n" );
    			printf( "ret = %d\n", ret);
    		}
    		return 0;
    }
    这计算器还可以吧,看看运算结果如何


    四、叨叨几句,不要看起来很复杂,其实学起来也复杂,但是学懂了会很有赶脚。
    好好学习,天天向上大笑
    初学者欢迎大家指正

    展开全文
  • 什么是指针? 什么是指针数组?什么是数组指针?什么是函数指针?什么是函数指针数组?什么是函数指针数组的指针.....
  • 1.理解 指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针 写博客,将连接发给我。
  • 指针函数、数组指针、函数指针、函数指针数组和指向函数指针数组的指针
  • 理解指针数组、数组指针、函数指针、函数指针数组、指向函数指针数组的指针 指针数组
  • 四、函数指针数组 五、指向函数指针数组的指针 目录 1.指针数组 2.数组指针 3.函数指针 4.函数指针数组 5.函数指针数组的指针 一、指针数组 1.是一个存放指针的数组 2.举一个栗子 int *...
  • 简单理解—指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针 指针数组 指针数组,顾名思义是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有...
  • 开门见山,今天的主要内容是:指针数组,数组指针,函数指针,函数指针数组函数指针数组指针。 看见题目是不是有点晕晕的感觉,没关系等看完这篇博客你会觉得他们其实也很好理解的! 接下来我一个一个介绍。 一....
  • 1.理解 指针数组 数组指针 函数指针 ...函数指针数组 指向函数指针数组的指针 1.理解 指针数组 #include int main() { int i=0; //指针数组 char *arr[3]={"aaaaa","bbbbb","ccccc",};  
  • 函数指针数组&amp;&amp;函数指针数组指针 指针数组 指针数组就是存放指针的数组,与一般数组相同,只是所存放的是指针 用法与平常数组无异。 int* arr[10]; // int*为数组类型,表明其中存放的是整型...
  • 理解指针数组、数组指针、函数指针、函数指针数组、指向函数指针数组的指针。 1. 指针数组 是数组,存放指针的数组。 2. 数组指针 是指针 3.函数指针 存放函数的地址 4.函数指针数组 5.指向函数...
  • 1:指针数组  顾名思义它是数组,一个指针数组。 eg:  int *arr1[10] 整形指针数组,并且数组的每个元素都是int* char **arr2[5] 二级 字符指针数组   数组指针  ...指向函数指针数组的指针
  • 对于这几个概念,用以下几幅图进行解析:1.数组指针 2.指针数组 3.函数指针、函数指针数组函数指针数组指针 如有错误,恳请指点。
  • 1.转移表(函数指针数组) 2.指向函数指针数组的指针(函数指针数组指针)
  • 对于指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针的简单理解 指针是c语言的精华,相当重要。 1. 指针数组 &amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;nbsp;&amp;amp;...
  • 对于指针有几个比较难的概念,下面做一些简单的分析:数组指针:是指针,该指针有能力指向一个数组指针数组:是数组,是一个存放指针的数组函数指针:是指针,该指针有能力指向一个函数函数指针数组:是数组,是一个...
  • 在指针的学习过程中有这么几种指针在定义是经常会让我们犯错:函数指针、函数指针数组函数指针数组的指针。下面我们逐个了解这几种指针。 一、 函数指针 函数指针顾名思义:指向函数的指针。 我们知道整型、浮点型...
  • 对指针数组,数组指针,函数指针,函数指针数组,指向函数指针数组的指针的理解。。。。
  • 指针数组 | 数组指针 | 函数指针 | 函数指针数组 | 指向函数指针数组的指针  怎么样?这个标题是否让你还没浏览文章就眼花缭乱了?(笑)别畏惧,看这些词组中有一个共同的特点,就是都有一个词:指针。顾名思义,...
  • 一、了解本质 我们先得知道他们各自的本质是什么,对于用汉语描述的...函数指针数组 指向函数指针数组的指针 那么对于表达式来说是怎样的呢: int *p[10]; -> 指针数组 int (*p)[10]; -> 数组指针 int (*p)(); -> 函
  • 函数指针数组回顾一下:char *(*pf)(char *p);//函数指针上面代码表示定义的是一个函数指针pf,pf是一个指针变量,那么,pf就可以存储在以个数组里面。如下:char *(*pf[3])(char *p);//函数指针数组上述代码定义的...

空空如也

1 2 3 4 5 ... 20
收藏数 25,268
精华内容 10,107
关键字:

函数指针数组