精华内容
下载资源
问答
  • 指针 指针数组 指针数组的指针 数组指针 数组指针的数组 函数指针 函数指针数组 指向函数指针数组的指针

           指针是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.引入库2.读入数据总结 前言 学习C语言中指针问题的学习笔记,对于指针数组、数组指针、函数指针、函数指针数组...


    前言

    本文为学习C语言过程中关于指针问题的笔记,对于指针数组、数组指针、函数指针、函数指针数组以及指向函数指针数组的指针等易混淆的概念进行阐述,以便以后复习查阅

    一、指针数组

    指针数组,顾名思义即数组元素全都为指针的数组。
    一维指针数组的定义形式为:“指针类型 * 数组名[数组长度]”
    例如,一个一维指针数组:

    int* parr[10]; //存放整型指针的数组
    char* pch[5];//存放字符型指针的数组 
    
    由于数组元素均为指针,因此arr[i]是指数组第i+1个元素的指针 关于二维指针数组的定义为:
    char* parr[][3] = {{"111", "5678", "9878"}, {"abhs", "jjsh", "fjsk"}, {"dksj", "sjcn", "kdsk"}};
    
    二维数组中的元素亦可以表示为"*(*(parr+i))"。又因为"()"的优先级较"*"高,且"*"是右结合的,因此可以写作**(parr+i),表示第'i+1'行的第一个元素。*(*(parr+i)+j)表示第i+1行第j+1个元素。

    二、数组指针

    数组指针实质上是一个指针,它指向数组,存放的是数组的地址。
    一维数组指针的定义形式为:“指针类型(*指针变量名)[数组长度]”
    例如:

    int *p1[10];//指针数组
    int (*p2)[10];//数组指针
    此处p2先于*结合,说明p是一个指针变量,然后指针指向的是一个大小为10个整型
    的数组。所以p是一个指针,指向一个数组,叫数组指针
    这里要注意:[]的优先级高于*号,所以必须加上()来保证p先与*结合
    int (*parr3[10])[5]//数组指针的数组 
    parr3是一个数组,该数组有10个元素,每个元素是一个数组指针,每个数组指针
    指向的数组有5个元素,每个元素是int

    三、函数指针

    函数指针是指向函数的指针,它是存放函数地址的一个指针,本身是一个指针变量,只不过该指针指向函数。
    其声明形式为:函数返回值类型(*指针变量名)(函数参数类型)
    例如:

    int ADD(int x, int y)
    {
    int z = x + y;
    return z;
    }
    int main()
    {
    int a = 10;
    int b = 20;
    int(*pa)(int, int) = ADD;//函数指针
    printf("%d\n", (*pa)(2, 3));
    return 0;
    }
    
    void print(char*str)
    {
       printf("%s\n", str);
    }
    int main()
    {
       void (*p) (char*)= print;
       (*p)("hello world");
       return 0;
    }
    

    四、函数指针的数组

    函数指针数组,就是一个存放函数指针的数组,该数组的每一个元素都是函数指针。
    它的声明形式一般为:
    函数返回值类型(*数组名[数组长度])(函数参数类型)
    应用:

    double Add(double x, double y)
    {
       return x + y;
    }
    double Sub(double x, double y)
    {
       return x - y;
    }
    double Mul(double x, double y)
    {
       return x * y;
    }
    double Div(double x, double y)
    {
       return x / y;
    }
    int main()
    {
       //指针数组
       double* arr[5];
       //需要一个数组,这个数组可以存放四个函数的地址 - 函数指针的数组
       //double(*pa) (double, double) = Add;//Sub/Mul/Div
       double(*parr[4]) (double, double) = {Add,Sub,Mul,Div};
       //函数指针的数组
       int i = 0;
       for (i = 0; i < 4; i++)
       {
       	printf("%lf\n", parr[i](2,3));
       }
       return 0;
    }
    
    函数指针数组的用途:转移表; 使用函数指针数组可以简化switch case语句的使用,可以对之前编写的简单计算器添加计算功能时进行简化。

    五、指向函数指针数组的指针

    理所当然地,函数指针数组也可以使用指针指向,叫做指向函数指针数组的指针。这个指针指向一个数组,这个数组叫做函数指针数组,数组里面的每个元素存放的是函数的指针,这些函数的指针,分别指向函数。 例如:
    int Add(int x, int y)
    {
    	return x + y;
    }
    int main()
    {
    	int arr[10] = { 0 };
    	int(*p)[10] = &arr;//取出数组的地址
    	int(*pf)(int, int);//函数指针
    	int(*pfArr[4])(int, int);//pfArr是一个数组 - 函数指针的数组
    	//指向函数指针数组的指针,指针指向一个数组,数组的元素都是函数指针
    	//ppfArr是一个指向[函数指针数组]的指针
    	int (*(*ppfArr)[4])(int,int) = &pfArr;
    	//ppfArr是一个数组指针,指针指向的数组有4个元素
    	//指向数组的每个元素类型是一个函数指针int(*)(int,int)
    	return 0;
    }
    

    总结

    指针数组、数组指针、函数指针、函数指针数组以及指向函数指针数组的指针十分易混淆,要多多回顾,勤加练习。

    展开全文
  • 指针数组 首先从名字就可以知道这是一个数组,是存放指针的数组。 先看几种指针数组: 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++;               // 指向第二行
        

    展开全文
  • 理解 指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针
  • 什么是指针? 什么是指针数组?什么是数组指针?什么是函数指针?什么是函数指针数组?什么是函数指针数组的指针.....
  • 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
收藏数 29,463
精华内容 11,785
关键字:

函数指针数组