指针数组 订阅
在C语言和C++等语言中,数组元素全为指针变量的数组称为指针数组,指针数组中的元素都必须具有相同的存储类型、指向相同数据类型的指针变量。指针数组比较适合用来指向若干个字符串,使字符串处理更加方便、灵活。一维指针数组的定义形式为:“类型名 *数组标识符[数组长度]”。 [1] 展开全文
在C语言和C++等语言中,数组元素全为指针变量的数组称为指针数组,指针数组中的元素都必须具有相同的存储类型、指向相同数据类型的指针变量。指针数组比较适合用来指向若干个字符串,使字符串处理更加方便、灵活。一维指针数组的定义形式为:“类型名 *数组标识符[数组长度]”。 [1]
信息
主要运用
作为函数的参量
运用领域
计算机编程
本    质
“数组”
来    源
C语言和C++语言
中文名
指针数组
外文名
pointer array
指针数组含义
指针数组,就是说首先是一个数组,而数组的元素是指针,也就是说,如果数组元素都是相同类型的指针,则称这个数组为指针数组。所谓相同类型的指针是说指针所指向的对象类型是相同的。一维指针数组的定义形式为:指针数组中的每一个元素均为指针,即有诸形如“ptr_array[i]”的指针。由于数组元素均为指针,因此ptr_array[i]是指第i+1个元素的指针。 [2]  例如二维指针数组的定义为:char *ptr_array[3][3]={{"asdx","qwer","fdsfaf"},{"44444","555","6666"},{"a78x","q3er","f2f"}};
收起全文
精华内容
下载资源
问答
  • 主要介绍了C++中用new创建二维数组和指针数组实例代码,非常不错,具有参考借鉴价值,需要的朋友参考下
  • 指针数组 首先从名字就可以知道这是一个数组,是存放指针的数组。 先看几种指针数组: 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;
    }




    展开全文
  • 函数指针数组示例

    2014-10-11 13:33:05
    C语言中对函数指针数组不是很了解,老师最近布置了一个作业,就搜集资料写了一个,希望能给大家启发,如果对C语言复杂指针的分析不是很懂得话,可以网上搜索“右左法则”
  • C语言指针数组介绍,定义指针数组,输入输出指针数组 1、什么是指针数组; (1)数组里面的每一个元素不是值而是值,而是指针。 (2)把很多的指针集合在一起,就是一个指针数组 2、定义一个指针数组: ***(p+1) ...

    指针数组

    1、什么是指针数组;

    (1)数组里面的每一个元素不是值而是指针。
    (2)把很多的指针集合在一起,就是一个指针数组

    2、定义一个指针数组:

    类型标识符 *数组名[长度];
    比如:int *a[4];
    定义了一个数组名为a,它里面含有几个四个元素,他们分别是a[0],a[1],a[2],a[3],它们每个都是一个指针。

    3、如何给指针数组赋初值:

    //其中a是一个普通数组,b是指针数组,即b数组当中的每一个值都是指针
    int a[3] = {1,2,3},*b[3]={a,a+1,a+2};
    printf("%d",*b[0]);
    

    a ----------> a[0] <--------b[0]
    a+1 ------> a[1] <--------b[1]
    a+2 ------> a[2] <--------b[2]

    #include<stdio.h> 
    void main(){
    	int a[4]={1,2,3,4},*b[4]={a,a+1,a+2,a+3};
    	*b[0]=*b[0]+1;//2
    	*b[1]=*b[1]+1;//3
    	printf("%d,%d",a[0],a[1]);//2 3
    }
    

    在这里插入图片描述
    变换

     #include<stdio.h> 
    void main(){
    	int a[4]={1,2,3,4},*b[4]={a,a+1,a+2,a+3};
    	*b[0]=*b[0]+1;//2
    	*b[1]=*b[1]+1;//3
    	printf("%d,%d,%d",a[0],a[1],**b);//2 3 2
    }
    

    在这里插入图片描述

    **(p+1) 和 *(*p+1)的区别
    	#include<stdio.h> 
    void main(){
    	int a=1,b=4,*p[2]={&a,&b};
    	**(p+1)=a*b;//b=a*b=4
    	*(*p+1)=a+b;//*(p[0]+1)
    	printf("a=%d,b=%d",a,b);
    }
    

    在这里插入图片描述
    变换

    #include<stdio.h> 
    void main(){
     
     	char *aa[2]={"abcd","ABCD"};
    	printf("%s",*(aa+1));
    }
    

    在这里插入图片描述
    在这里插入图片描述

    展开全文
  • 数组指针和指针数组

    万次阅读 多人点赞 2019-09-17 16:39:06
    首先,理解一下数组指针和指针数组这两个名词: “数组指针”和“指针数组”,只要在名词中间加上“的”字,就知道中心了—— 数组的指针:是一个指针,什么样的指针呢?指向数组的指针。 指针的数组:是一个数组...

    首先,理解一下数组指针和指针数组这两个名词:

    “数组指针”和“指针数组”,只要在名词中间加上“的”字,就知道中心了——

    数组的指针:是一个指针,什么样的指针呢?指向数组的指针。

    指针的数组:是一个数组,什么样的数组呢?装着指针的数组。

    然后,需要明确一个优先级顺序:()>[]>*,所以:

    (*p)[n]:根据优先级,先看括号内,则p是一个指针,这个指针指向一个一维数组,数组长度为n,这是“数组的指针”,即数组指针;

    *p[n]:根据优先级,先看[],则p是一个数组,再结合*,这个数组的元素是指针类型,共n个元素,这是“指针的数组”,即指针数组。

    根据上面两个分析,可以看出,p是什么,则词组的中心词就是什么,即数组“指针”和指针“数组”。
     

    int *p1[5];
    int (*p2)[5];

    首先,对于语句“int*p1[5]”,因为“[]”的优先级要比“*”要高,所以 p1 先与“[]”结合,构成一个数组的定义,数组名为 p1,而“int*”修饰的是数组的内容,即数组的每个元素。也就是说,该数组包含 5 个指向 int 类型数据的指针,如图 1 所示,因此,它是一个指针数组。

                                           图1 

    其次,对于语句“int(*p2)[5]”,“()”的优先级比“[]”高,“*”号和 p2 构成一个指针的定义,指针变量名为 p2,而 int 修饰的是数组的内容,即数组的每个元素。也就是说,p2 是一个指针,它指向一个包含 5 个 int 类型数据的数组,如图 2 所示。很显然,它是一个数组指针,数组在这里并没有名字,是个匿名数组。

                                        

                                                                   图2 

    由此可见,对指针数组来说,首先它是一个数组,数组的元素都是指针,也就是说该数组存储的是指针,数组占多少个字节由数组本身决定;而对数组指针来说,首先它是一个指针,它指向一个数组,也就是说它是指向数组的指针,在 32 位系统下永远占 4 字节,至于它指向的数组占多少字节,这个不能够确定,要看具体情况。
     

    数组指针 (*p)[n]

    数组指针:是指针——指向数组的指针。

    看下面的例子进行理解

    #include "stdafx.h"
     
     
    int main()
    {
    	//一维数组
    	int a[5] = { 1, 2, 3, 4, 5 };
    	//步长为5的数组指针,即数组里有5个元素
    	int (*p)[5];
    	//把数组a的地址赋给p,则p为数组a的地址,则*p表示数组a本身
    	p = &a;
     
    	//%p输出地址, %d输出十进制
    	//\n回车
    	//在C中,在几乎所有使用数组的表达式中,数组名的值是个指针常量,也就是数组第一个元素的地址,它的类型取决于数组元素的类型。
    	printf("%p\n", a); //输出数组名,一般用数组的首元素地址来标识一个数组,则输出数组首元素地址
    	printf("%p\n", p); //根据上面,p为数组a的地址,输出数组a的地址
    	printf("%p\n", *p); //*p表示数组a本身,一般用数组的首元素地址来标识一个数组
    	printf("%p\n", &a[0]); //a[0]的地址
    	printf("%p\n", &a[1]); //a[1]的地址
    	printf("%p\n", p[0]); //数组首元素的地址
    	printf("%d\n", **p); //*p为数组a本身,即为数组a首元素地址,则*(*p)为值,当*p为数组首元素地址时,**p表示首元素的值1
    	printf("%d\n", *p[0]); //根据优先级,p[0] 表示首元素地址,则*p[0]表示首元素本身,即首元素的值1
    	printf("%d\n", *p[1]); //为一个绝对值很大的负数,不表示a[1]...表示什么我还不知道
     
    	
     
    	//将二维数组赋给指针
    	int b[3][4];
    	int(*pp)[4]; //定义一个数组指针,指向含4个元素的一维数组
    	pp = b; //将该二维数组的首地址赋给pp,也就是b[0]或&b[0],二维数组中pp=b和pp=&b[0]是等价的
    	pp++; //pp=pp+1,该语句执行过后pp的指向从行b[0][]变为了行b[1][],pp=&b[1]
     
    	int k;
    	scanf_s("%d", &k);
     
        return 0;
    }
    
    
     
    

    根据上面二维数组可以得出,数组指针也称指向一维数组的指针,所以数组指针也称行指针。

    指针数组 *p[n]

    指针数组:是数组——装着指针的数组。

    看下面的例子进行理解:

    #include "stdafx.h"
     
     
    int main()
    {
    	int a = 1;
    	int b = 2;
    	int *p[2];
    	p[0] = &a;
    	p[1] = &b;
     
    	printf("%p\n", p[0]); //a的地址
    	printf("%p\n", &a); //a的地址
    	printf("%p\n", p[1]); //b的地址
    	printf("%p\n", &b); //b的地址
    	printf("%d\n", *p[0]); //p[0]表示a的地址,则*p[0]表示a的值
    	printf("%d\n", *p[1]); //p[1]表示b的地址,则*p[1]表示b的值
     
     
    	//将二维数组赋给指针数组
    	int *pp[3]; //一个一维数组内存放着三个指针变量,分别是p[0]、p[1]、p[2],所以要分别赋值
    	int c[3][4];
    	for (int i = 0; i<3; i++)
    		pp[i] = c[i];
     
    	int k;
    	scanf_s("%d", &k);
     
        return 0;
    }
     
    

    最后,从上文来看:

    数组指针是一个指针变量,占有内存中一个指针的存储空间;

    指针数组是多个指针变量,以数组的形式存储在内存中,占有多个指针的存储空间。

     

    了解指针数组和数组指针二者之间的区别之后,继续来看下面的示例代码:

    int arr[5]={1,2,3,4,5};
    int (*p1)[5] = &arr;
    /*下面是错误的*/
    int (*p2)[5] = arr;

    不难看出,在上面的示例代码中,&arr 是指整个数组的首地址,而 arr 是指数组首元素的首地址,虽然所表示的意义不同,但二者之间的值却是相同的。那么问题出来了,既然值是相同的,为什么语句“int(*p1)[5]=&arr”是正确的,而语句“int(*p2)[5]=arr”却在有些编译器下运行时会提示错误信息呢(如在 Microsoft Visual Studio 2010 中提示的错误信息为“a value of type"int*"cannot be used to initialize an entity of type"int(*)[5]"”)?

    其实原因很简单,在 C 语言中,赋值符号“=”号两边的数据类型必须是相同的,如果不同,则需要显示或隐式类型转换。在这里,p1 和 p2 都是数组指针,指向的是整个数组。p1 这个定义的“=”号两边的数据类型完全一致,而 p2 这个定义的“=”号两边的数据类型就不一致了(左边的类型是指向整个数组的指针,而右边的数据类型是指向单个字符的指针),因此会提示错误信息。

    展开全文
  • 文章目录指针数组数组的指针指针数组的指针关于CLion编辑器本地变量定义小技巧代码 C++数组的指针、指针数组指针数组的指针的声明有点绕,防止后面绕晕记不住所以记录下。 指针数组 int *ap[3]; 为啥[3]要放在...


    C++数组的指针、指针数组、指针数组的指针的声明有点绕,防止后面绕晕记不住所以记录下。

    指针数组

    int *ap[3];

    为啥[3]要放在这里呢?[]优先级要高于*,所以[3]表明三个元素的数组,剩下的描述元素的类型,*表明数组元素为指针,int表明指针指向int类型。所以该声明为:具有3个指向int类型的指针的数组。

    数组的指针

    int (*pa)[3];

    [3]表明为三个元素的数组,剩下的部分就是描述元素的类型。(*pi)是一个整体,表明是一个指针变量,变量名为pa。int表明元素为int类型。解释为:具有3个int类型元素的数组的指针。

    指针数组的指针

    int *(*pap)[3];

    知道指针数组的声明*ap[3],那么替换ap变量为一个指针(*apa),代入进去为*(*apa)[3]就是指针数组的指针了。
    反过来,我们将上面的(*pap)看成一个叫pa的变量名为:int *pa[3];它就是具有3个指向int类型的指针的数组,那么该数组的引用,就将pa这个变量名变为一个指针变量,替换为*pap然后代进去加上括号就是上面的声明了int *(*pap)[3];:一个具有3个指向int类型的指针的数组的指针。

    类型指针啥的太麻烦了,有点记不住,C++11版本新增的auto关键字可以省略类型的定义,让编译器来判定值的类型。

    关于CLion编辑器本地变量定义小技巧

    上面一堆指针啥类型啥的,太麻烦了。如果不适用auto关键字,想要自己显示的定义一个复杂的类型,比如"指针数组的指针类型"或者"函数指针数组的指针"的声明,还是比较费劲的。
    CLion的自动创建本地变量的功能很有用。菜单:Main menu | Refactor | Extract | Introduce Variable...可以生成本地变量。
    使用快捷键的演示如下:
    在这里插入图片描述
    使用CLion的快速创建变量的功能,很方便的就根据右值创建了左边的符合的类型变量。

    CLion设置里面keymap搜Introduce Variable可以看到你的快捷键。

    代码

    int a[3];                          //3个int类型元素的数组
    a[0]=1;
    a[1]=2;
    a[2]=3;
    int (*pa)[3] = &a;                 //3个int类型元素的数组的指针
    int *ap[3] = {&a[0], &a[1], &a[2]};//3个int类型元素的指针的数组
    int *(*pap)[3] = &ap;              //3个int类型元素的指针的数组的指针
    
    展开全文
  • c++数组指针和指针数组详解

    千次阅读 多人点赞 2019-03-14 15:33:16
    指针数组指针数组可以说成是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有元素都是指针类型,在32位系统中,指针占四个字节。 数组指针: 数组指针可以说成是”...
  • 数组:一组数据的集合称为数组,它所包含的每一个数据叫做数组元素,例如 int a[4]; 它定义了一个长度为4的整型...指针数组指针数组的元素全为指针。它的声明方法是:数据类型 * 数组名[数组长度];例如int arr[5];
  • 指针数组与数组指针详解

    万次阅读 多人点赞 2016-09-28 21:21:20
    指针数组与数组指针详解1.什么是指针数组和数组指针? 指针数组指针数组可以说成是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有元素都是指针类型,在32位系统中...
  • 函数指针(指向函数的指针) 与数据项类似,函数也有自己的地址。函数的地址是存储其机器代码的内存的开始地址。例如,可以编写将另一个函数的地址作为参数的函数,这样第一个函数将能够找到第二个函数,并运行它。...
  • 数组指针与指针数组

    2021-01-20 14:02:37
    数组指针与指针数组 数组指针: 什么是数组指针:能够指向数组的指针。 定义一个int (*p)[10],首先()的优先级高于[]所以p首先是一个指针,指向的是一个整形的一维数组,所以是数组指针。 数组指针是一个指针不是...
  • ** p——指向指针的指针 ...以整型指针数组为例,先定义一组指向整型的指针数组*p,再定义一组指向整形指针的指针数组**p: #include<iostream> #include<iomanip> #include<string> using namesp...
  • 字符指针数组

    千次阅读 2020-12-01 14:39:24
    指针数组是由指针变量构成的数组,在操作时,既可以对数组元素进行赋值(地址值)和引用,也可以间接访问数组元素所指向的单元内容,改变或引用该单元的内容。 字符指针数组: #include <stdio.h> int ...
  • 指针与二维数组 数组指针 指针数组 多级指针
  • 本文较为详细的分析了关于理解C++指针数组,数组指针,数组名,二维数组的一些技巧。是比较重要的概念,相信对于大家的C++程序设计有一定的帮助作用。 一、关于数组名 假设有数组: int a[3] = {1, 2, 3} 1.数组...
  • [C] 数组指针、指针数组及数组传参

    千次阅读 多人点赞 2019-01-30 18:30:31
    指针字符指针数组指针指针数组 在指针的学习阶段,有不少同学都十分畏惧这个物什,甚至“谈指针色变”。其实对指针的不理解,其实本质上是对内存的不理解,本篇博客就从零开始、系统的来讲解指针这个话题。 首先...
  • 彻底理解指针,指针数组和数组指针,指针函数和函数指针.doc
  • C语言程序设计教案 章节名称 指向数组指针1 授课类型 理论 实验 ?理实一体 实训 实习 班级 地点 周次 星期 节次 授课进度 ?符合 超前 滞后 ?符合 超前 滞后 ?符合 超前 滞后 教学目标 知识目标 1.理解指向数组元素...
  • 数组指针与指针数组的区别在于:数组指针p是一个指针,而指针数组p是一个存放N个指针变量的数组。 一、数组指针int (*p)[n]重点:()优先级高([]、()的优先级是一样的,但它们的方向是从左至右的,所以先运行括号里的...
  • int *p[3]与int (*p)[3]的区别*p[3]这个是一个指针数组,它所代表的意思是数组中的每一个元素都是一个指针变量,而(*p)[3],p是一个指针变量,表示指向一个含有3个整型元素的一维数组。 代码如下:int i,j; int a[2]...
  • 指针数组、数组指针——用指针访问数组方法总结

    万次阅读 多人点赞 2019-01-14 09:51:11
    2.2.2 指向每一行的指针(指针数组方式) 2.2.3 指向整个数组的指针(数组指针方式) 3 总结 1.数组元素的访问 数组中的各元素在内存中是连续分布的,要想访问数组中某一元素,那么就必须知道其地址。 在一....
  • 指针数组定义:如果一个 数组,其元素均为指针型数据,该数组为指针数组,也就是说,指针数组中的每一个元素相当于一个指针变量,它的值都是地址。 形式:一维指针数组的定义形式为:int【类型名】 *p【数组名】 [4]...
  • 1、指针数组与数组指针 详细:http://c.biancheng.net/view/335.html 1.1指针数组 int *p1[5]; 指针数组 首先,因为"[ ]" 的优先级要比" * "的优先级要高,所以所以p1[5]首先是一个数组,然后其元素类型为整型指针...
  • 指针数组、数组指针、数组的区别与联系

    万次阅读 多人点赞 2018-08-06 10:11:44
    指针数组、数组指针、数组的区别与联系! 一:基本定义 1.指针数组 char *arr[4] = {"hello", "world", "shannxi", "xian"}; //arr就是我定义的一个指针数组,它有四个...
  • 详解C语言指针函数、函数指针、函数指针数组

    万次阅读 多人点赞 2018-07-09 11:08:24
    而在指针中,指针函数、函数指针、指针函数数组、函数指针数组、指向函数指针数组的指针等等概念看着又绕又头疼。本问总结了一下以上一些概念以及用法,并给出例程深化理解。 1. 指针函数 指针函数就是返回指针值...
  • 总结指针数组部分的相关知识自己写的一遍博客: 指针是变量单元的地址,地址指向该变量单元,因此地址形象的称为“指针”,通过指针(地址)可以找到内存单元。  (总结)1.指针是存放地址才出现的,地址是为了...
  • 指针数组理解

    千次阅读 2019-05-08 17:40:24
    指针数组理解 开发工具与关键技术:Visual Studio、C++ 作者:张国军 撰写时间:2019年05月06日 指针数组的元素类型是指针。 指针数组的元素存放对象的地址。 说明形式为:类型 * 标识符 [ 表达式 ] ; 先让我们来看...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 874,781
精华内容 349,912
关键字:

指针数组