数组指针 订阅
数组指针,指的是数组名的指针,即数组首元素地址的指针。即是指向数组的指针。例:int (*p)[10]; p即为指向数组的指针,又称数组指针。 展开全文
数组指针,指的是数组名的指针,即数组首元素地址的指针。即是指向数组的指针。例:int (*p)[10]; p即为指向数组的指针,又称数组指针。
信息
外文名
array pointer
运用领域
计算机编程
本    质
指针
中文名
数组指针
源    于
编程语言,如c,c++
数组指针本质与区别
数组指针是指向数组地址的指针,其本质为指针; 指针数组是数组元素为指针的数组(例如 int *p[3],定义了p[0],p[1],p[2]三个指针),其本质为数组。数组指针的使用在某些情况下与指针数组很相似,要注意区别。
收起全文
精华内容
下载资源
问答
  • 指针 指针数组 指针数组的指针 数组指针 数组指针的数组 函数指针 函数指针数组 指向函数指针数组的指针

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

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

    万次阅读 多人点赞 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 这个定义的“=”号两边的数据类型就不一致了(左边的类型是指向整个数组的指针,而右边的数据类型是指向单个字符的指针),因此会提示错误信息。

    展开全文
  • 指针数组与数组指针详解

    万次阅读 多人点赞 2016-09-28 21:21:20
    指针数组与数组指针详解1.什么是指针数组和数组指针? 指针数组:指针数组可以说成是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有元素都是指针类型,在32位系统中...

    指针数组与数组指针详解

    1.什么是指针数组和数组指针?

    • 指针数组:指针数组可以说成是”指针的数组”,首先这个变量是一个数组,其次,”指针”修饰这个数组,意思是说这个数组的所有元素都是指针类型,在32位系统中,指针占四个字节。
    • 数组指针:数组指针可以说成是”数组的指针”,首先这个变量是一个指针,其次,”数组”修饰这个指针,意思是说这个指针存放着一个数组的首地址,或者说这个指针指向一个数组的首地址。
      根据上面的解释,可以了解到指针数组和数组指针的区别,因为二者根本就是种类型的变量。

    2.指针数组和数组指针到底是什么?

    2.1指针数组

    首先先定义一个指针数组,既然是数组,名字就叫arr

    char *arr[4] = {"hello", "world", "shannxi", "xian"};
    //arr就是我定义的一个指针数组,它有四个元素,每个元素是一个char *类型的指针,这些指针存放着其对应字符串的首地址。

    (当一个变量出现左右都出现一个运算符时,没有记住运算符优先级的人就会纠结arr变量到底跟哪一个运算符先结合。如果是自己定义一个指针数组,搞不清楚运算符的优先级,那么就加上小括号(),比如定义一个指针数组,可以写成char *(arr[4]),不过在定义之前一定要清楚自己定义的变量,如果目的是一个数组,那就把arr[4]括起来,如果是一个指针,就把*arr括起来。如果是看到一段这样的代码,可以从他的初始化来分别它是数组还是指针,很明显,我这定义的是一个数组,如果是指针,会用NULL来初始化。)

    这个指针数组有多大呢?答案是16个字节,因为它是一个指针数组。(这是废话,正话下面说)
    每当出现这些问题时,脑子里一定要第一时间反应出内存映像图

    内存映像象图内容权限
    栈区函数中的普通变量可读可写
    堆区动态申请的内存可读可写
    静态变量区static修饰的变量可读可写
    数据区用于初始化变量的常量只读
    代码区代码指令只读

    这里最左侧一列是一个很简陋但能说明意思的内存图,一般情况下,从栈区到代码区,是从高地址到低地址。栈向下增长,堆向上增长。

    arr[4]是一个在主函数定义的数组。把它对应到对应到内存中,arr是一个在栈区,有四个元素的数组,而每一个数组又是一个指针,所以说它的四个元素各占四个字节,所以变量arr的大小是16个字节。

    那么就有人问了?初始化arr的{“hello”, “world”, “shannxi”, “xian”};的是什么鬼?
    这四个不是什么鬼,他们也存在在内存中,只是跟arr这个变量不在同一段空间,它们被分配在只读数据区,数组arr[4]的四个指针元素,分别存放着这四个字符串的首地址,想象一下,从栈区有四只无形的手指向数据区的空间。arr+1会跳过四个字节,。也就是一个指针的大小
    这就相当与定义char *p1 = “hello”,char *p1 = “world”,char *p3 = “shannxi”, char *p4 = “xian”,这是四个指针,每个指针存放一个字符串首地址,然后用arr[4]这个数组分别存放这四个指针,就形成了指针数组。

    2.2数组指针

    首先来定义一个数组指针,既然是指针,名字就叫pa

    char (*pa)[4];
    

    如果指针数组和数组指针这俩个变量名称一样就会是这样:char *pa[4]和char (*pa)[4],原来指针数组和数组指针的形成的根本原因就是运算符的优先级问题,所以定义变量是一定要注意这个问题,否则定义变量会有根本性差别!

    pa是一个指针指向一个char [4]的数组,每个数组元素是一个char类型的变量,所以我们不妨可以写成:char[4] (*pa);这样就可以直观的看出pa的指向的类型,不过在编辑器中不要这么写,因为编译器根本不认识,这样写只是帮助我们理解。

    既然pa是一个指针,存放一个数组的地址,那么在我们定义一个数组时,数组名称就是这个数组的首地址,那么这二者有什么区别和联系呢?

    char a[4];,
    

    a是一个长度为4的字符数组,a是这个数组的首元素首地址。既然a是地址,pa是指向数组的指针,那么能将a赋值给pa吗?答案是不行的!因为a是数组首元素首地址,pa存放的却是数组首地址,a是char 类型,a+1,a的值会实实在在的加1,而pa是char[4]类型的,pa+1,pa则会加4,虽然数组的首地址和首元素首地址的值相同,但是两者操作不同,所以类型不匹配不能直接赋值,但是可以这样:pa = &a,pa相当与二维数组的行指针,现在它指向a[4]的地址。

    3.指针数组和数组指针的使用

    3.1指针数组在参数传递时的使用

    指针数组常用在主函数传参,在写主函数时,参数有两个,一个确定参数个数,一个这是指针数组用来接收每个参数(字符串)的地址

    int main(int argc, char *argv[])
    

    此时可以想象内存映像图,主函数的栈区有一个叫argv的数组,这个数组的元素是你输入的参数的地址,指向着只读数据区。

    如果是向子函数传参,这和传递一个普通数组的思想一样,不能传递整个数组过去,如果数组很大,这样内存利用率很低,所以应该传递数组的首地址,用一个指针接收这个地址。因此,指针数组对应着二级指针

    void fun(char **pp);//子函数中的形参
    fun(char *p[]);//主函数中的实参
    

    3.2指针数组的排序

    指针数组的排序非常有趣,因为这个数组中存放的是指针,通过比较指针指向的空间的大小,排序这些空间的地址。函数实现如下:

    void sort(char **pa, int n)//冒泡排序
    {
        int i, j;
        char *tmp = NULL;
    
        for(i = 0; i < n-1; i++){
            for(j = 0; j < n-1-i; j++){
                if((strcmp(*pa+j), *(pa+j+1)) > 0){
                    tmp = *(pa + j);
                    *(pa + j) = *(pa + j + 1);
                    *(pa + j + 1) = tmp;
                }
            }
        }
    }
    

    在函数中定义指针数组,并且打印结果如下:

    char *pa[4] = {"abc", "xyz", "opq", "xyz"};
    
    [root@menwen-linux test]# ./test 
    abc
    ijk
    opq
    xyz
    

    数组指针传参时的使用

    数组指针既然是一个指针,那么就是用来接收地址,在传参时就接收数组的地址,所以数组指针对应的是二维数组。

    void fun(int (*P)[4]);//子函数中的形参,指针数组 
    
    a[3][4] = {0};//主函数中定义的二维数组
    fun(a);//主函数调用子函数的实参,是二维数组的首元素首地址
    
    展开全文
  • 数组指针

    千次阅读 2018-07-06 21:08:06
    数组指针本质上是一个指针,数组是指针指向的类型,表示指针指向一个数组,因此数组指针就是指向数组的指针。 int a[3]={1,2,3}; int( * p)[3]; p=&amp;a;

    数组指针本质上是一个指针,数组是指针指向的类型,表示指针指向一个数组,因此数组指针就是指向数组的指针。

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

    int( * p)[3];

    p=&a;

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

    2021-01-20 14:02:37
    数组指针与指针数组 数组指针: 什么是数组指针:能够指向数组的指针。 定义一个int (*p)[10],首先()的优先级高于[]所以p首先是一个指针,指向的是一个整形的一维数组,所以是数组指针数组指针是一个指针不是...
  • 详解C语言中的数组指针与指针数组

    万次阅读 多人点赞 2018-05-06 21:52:39
    ·详解数组指针与指针数组 ·数组指针 一、区分 首先我们需要了解什么是数组指针以及什么是指针数组,如下图: int *p[5]; int (*p)[5]; 数组指针的意思即为通过指针引用数组,p先和*结合,说明了p是一个指针...
  • 指针数组 首先从名字就可以知道这是一个数组,是存放指针的数组。 先看几种指针数组: int * 数组指针 函数指针 函数指针数组 指向函数指针数组的指针
  • 指针数组、数组指针——用指针访问数组方法总结

    万次阅读 多人点赞 2019-01-14 09:51:11
    目录 1.数组元素的访问 ...2.2.3 指向整个数组的指针(数组指针方式) 3 总结 1.数组元素的访问 数组中的各元素在内存中是连续分布的,要想访问数组中某一元素,那么就必须知道其地址。 在一...
  • 理解 指针数组 数组指针 函数指针 函数指针数组 指向函数指针数组的指针
  • 关于数组指针和指向数组指针的指针及其new的一些个人理解及其小例子,详细可以参见我的CSDN博客中的文章http://blog.csdn.net/shizhixin/article/details/7050592
  • 数组:一组数据的集合...当然数组中除了存储一般常见的数据类型外,也可以用来存放指针,此时的数组就叫指针数组指针数组指针数组的元素全为指针。它的声明方法是:数据类型 * 数组名[数组长度];例如int arr[5];
  • 数组指针:数组也是一种类型,也可以创建数组指针数组指针是指针,是指向数组的指针。请看下列例子:int (*p)[10];是数组指针,是一个指向10个整型元素数组的指针。那如何区别数组指针和指针数组呢?这里有一个小...
  • 指针数组 int a=10,b=20; int *arr[2]={&a,&b}; //指针数组,数组  printf("%p %p\n\n",arr[0],&a); // 000000000062FE3C 000000000062FE3C ...数组指针 int (*parr)[2]; parr=&arr; //数组指针,指针  prin
  • 数组指针与指针数组的区别在于:数组指针p是一个指针,而指针数组p是一个存放N个指针变量的数组。 一、数组指针int (*p)[n]重点:()优先级高([]、()的优先级是一样的,但它们的方向是从左至右的,所以先运行括号里的...
  • 数组指针】 仅此一篇 让你深刻理解数组指针

    千次阅读 多人点赞 2020-04-27 00:12:34
    数组指针,顾名思义,就是指向数组的指针。 我们是这样定义它的:int(* p)[n] = { }; (n为要定义的个数) 按照优先级运算 ()与[ ] 优先级相同,根据结合律,就从左向右运算。 ()里是*p,先定义了指针,所以p是个...
  • 指针数组与数组指针   当我们在学习指针与数组时总会遇到两个令人容易混淆的概念:数组指针与指针数组。   在这里数组指针是指向数组的指针,其本质为指针指向的对象是数组。由于数组的形式多样所以数组指针的...
  • 主要介绍了C++指针数组、数组指针、数组名及二维数组技巧汇总,对于深入理解C++数组与指针来说非常重要,需要的朋友可以参考下
  • C语言中,我们知道,指针变量一种特殊的变量,专门用来...指针数组、数组指针、函数指针、函数指针数组、指向函数指针数组的指针 1.指针数组  指针数组强调的是数组,并且数组元素是指针类型 例:int *arr[5]//ar
  • 数组和指针,数组指针,指针数组1.数组和指针关系及基本使用通过指针进行运算2. 数组指针(也称行指针)定义3.指针数组定义指针优先级4.指针数组和数组指针的区别 1.数组和指针 关系及基本使用 数组是一个数据的...
  • 首先,需要理解一下数组指针和指针数组这两个名词: “数组指针”和“指针数组”,只要在名词中间加上“的”这个字,就知道中心了 数组的指针:是一个指针,指向数组的指针。 指针的数组:是一个数组,装着指针的...
  • 指针数组与数组指针  指针数组 指针数组是一个数组,数组的元素保存的是指针; 数组指针 数组指针是一个指针,该指针指向的是一个数组; #include &lt;stdio.h&gt; #define SIZE 5 int main(int ...
  • c++数组指针和指针数组详解

    千次阅读 多人点赞 2019-03-14 15:33:16
    数组指针可以说成是”数组的指针”,首先这个变量是一个指针,其次,”数组”修饰这个指针,意思是说这个指针存放着一个数组的首地址,或者说这个指针指向一个数组的首地址。 指针数组 首先先定义一个指针数组,既然...
  • 指针数组,数组指针,以及函数指针,以及堆中的分配规则
  • 指针数组与数组指针的区别

    万次阅读 多人点赞 2019-03-01 19:56:23
    b、数组指针:是指一个指向数组的指针,它其实还是一个指针,只不过是指向数组而已; 定义形式:int (*p)[10]; 其中,由于[]的优先级高于*,所以必须添加(*p). 区分方法: 主要看后面的两个字是什么(前面是修饰作用...
  • 指针 与 数组 ( 指针 | 数组 | 指针运算 | 数组访问方式 | 字符串 | 指针数组 | 数组指针 | 多维数组 | 多维指针 | 数组参数 | 函数指针 | 复杂指针解读)
  • 二、数组指针 三、函数指针 四、函数指针数组 五、指向函数指针数组的指针 目录 1.指针数组 2.数组指针 3.函数指针 4.函数指针数组 5.函数指针数组的指针 一、指针数组 1.是一个存放指针的...
  • 数组指针、指针数组与二级指针数组指针与指针数组数组指针指针数组二级指针二级指针的特性指向指针数组的数组指针与二级指针测试代码 数组指针与指针数组 数组指针是指针,意为指向数组的指针; 指针数组是数组,意...
  • 指针与二维数组 数组指针 指针数组 多级指针

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 868,278
精华内容 347,311
关键字:

数组指针