精华内容
下载资源
问答
  • 2021-11-15 16:28:24

    指针数组:存储指针的数组

    *pa[n] //an array of pointers

    注意这里[]优先级高于*,因此pa是一个包含三个指针的数组 。

     指向指针数组的指针

    *(*pd)[n] //pointers to an array of pointers
    auto pd = &pa; // *(*pd)[n] = &pa;

    (*pd)让pd先于*结合,说明pd是一个指针,指向一个包含三个元素的数组。换句话说,这里将原本的数组名pa 替换为 *pd,*pd就是指针数组,(*pd)[i]就是数组元素,即指针。可以使用auto关键字自动生成指向指针数组的指针。

    指向指针的指针

    auto pc = pa; //a pointer to a pointer 
    // **pc = pa
    // pc[i] = pa[i] *pc[i] = *pa[i] using the same way

    我的理解是,对于较为复杂的表达式先找到核心成分,指针数组?指针?在此基础上,如果想定义指向XXX的指针,只需要将核心部分换成指针

    更多相关内容
  • 定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。在C语言中,我们将第 0 个元素的地址称为数组的首地址。以上面的数组为例,下图是 arr 的指向: 数组名的本意是表示...

    数组(Array)是一系列具有相同类型的数据的集合,每一份数据叫做一个数组元素(Element)。数组中的所有元素在内存中是连续排列的,整个数组占用的是一块内存。以int arr[] = { 99, 15, 100, 888, 252 };为例,该数组在内存中的分布如下图所示:

    定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。在C语言中,我们将第 0 个元素的地址称为数组的首地址。以上面的数组为例,下图是 arr 的指向:

    数组名的本意是表示整个数组,也就是表示多份数据的集合,但在使用过程中经常会转换为指向数组第 0 个元素的指针,所以上面使用了“认为”一词,表示数组名和数组首地址并不总是等价。初学者可以暂时忽略这个细节,把数组名当做指向第 0 个元素的指针使用即可,我们将在 VIP教程《数组和指针绝不等价,数组是另外一种类型》和《数组到底在什么时候会转换为指针》中再深入讨论这一细节。

    下面的例子演示了如何以指针的方式遍历数组元素:

     
    
    1. #include <stdio.h>
    2. int main(){
    3. int arr[] = { 99, 15, 100, 888, 252 };
    4. int len = sizeof(arr) / sizeof(int); //求数组长度
    5. int i;
    6. for(i=0; i<len; i++){
    7. printf("%d ", *(arr+i) ); //*(arr+i)等价于arr[i]
    8. }
    9. printf("\n");
    10. return 0;
    11. }

    运行结果:
    99  15  100  888  252

    第 5 行代码用来求数组的长度,sizeof(arr) 会获得整个数组所占用的字节数,sizeof(int) 会获得一个数组元素所占用的字节数,它们相除的结果就是数组包含的元素个数,也即数组长度。

    第 8 行代码中我们使用了*(arr+i)这个表达式,arr 是数组名,指向数组的第 0 个元素,表示数组首地址, arr+i 指向数组的第 i 个元素,*(arr+i) 表示取第 i 个元素的数据,它等价于 arr[i]。

    arr 是 int*类型的指针,每次加 1 时它自身的值会增加 sizeof(int),加 i 时自身的值会增加 sizeof(int) * i, 这在《C语言指针变量的运算》中已经进行了详细讲解。

    我们也可以定义一个指向数组的指针,例如:

     
    
    1. int arr[] = { 99, 15, 100, 888, 252 };
    2. int *p = arr;

    arr 本身就是一个指针,可以直接赋值给指针变量 p。arr 是数组第 0 个元素的地址,所以int *p = arr;也可以写作int *p = &arr[0];。也就是说,arr、p、&arr[0] 这三种写法都是等价的,它们都指向数组第 0 个元素,或者说指向数组的开头。

    再强调一遍,“arr 本身就是一个指针”这种表述并不准确,严格来说应该是“arr 被转换成了一个指针”。这里请大家先忽略这个细节,我们将在 VIP教程《数组和指针绝不等价,数组是另外一种类型》和《数组到底在什么时候会转换为指针》中深入讨论。

    如果一个指针指向了数组,我们就称它为数组指针(Array Pointer)。

    数组指针指向的是数组中的一个具体元素,而不是整个数组,所以数组指针的类型和数组元素的类型有关,上面的例子中,p 指向的数组元素是 int 类型,所以 p 的类型必须也是int *

    反过来想,p 并不知道它指向的是一个数组,p 只知道它指向的是一个整数,究竟如何使用 p 取决于程序员的编码。

    更改上面的代码,使用数组指针来遍历数组元素:

     
    
    1. #include <stdio.h>
    2. int main(){
    3. int arr[] = { 99, 15, 100, 888, 252 };
    4. int i, *p = arr, len = sizeof(arr) / sizeof(int);
    5. for(i=0; i<len; i++){
    6. printf("%d ", *(p+i) );
    7. }
    8. printf("\n");
    9. return 0;
    10. }

    数组在内存中只是数组元素的简单排列,没有开始和结束标志,在求数组的长度时不能使用sizeof(p) / sizeof(int),因为 p 只是一个指向 int 类型的指针,编译器并不知道它指向的到底是一个整数还是一系列整数(数组),所以 sizeof(p) 求得的是 p 这个指针变量本身所占用的字节数,而不是整个数组占用的字节数。

    也就是说,根据数组指针不能逆推出整个数组元素的个数,以及数组从哪里开始、到哪里结束等信息。不像字符串,数组本身也没有特定的结束标志,如果不知道数组的长度,那么就无法遍历整个数组。

    上节我们讲到,对指针变量进行加法和减法运算时,是根据数据类型的长度来计算的。如果一个指针变量 p 指向了数组的开头,那么 p+i 就指向数组的第 i 个元素;如果 p 指向了数组的第 n 个元素,那么 p+i 就是指向第 n+i 个元素;而不管 p 指向了数组的第几个元素,p+1 总是指向下一个元素,p-1 也总是指向上一个元素。

    更改上面的代码,让 p 指向数组中的第二个元素:

     
    
    1. #include <stdio.h>
    2. int main(){
    3. int arr[] = { 99, 15, 100, 888, 252 };
    4. int *p = &arr[2]; //也可以写作 int *p = arr + 2;
    5. printf("%d, %d, %d, %d, %d\n", *(p-2), *(p-1), *p, *(p+1), *(p+2) );
    6. return 0;
    7. }

    运行结果:
    99, 15, 100, 888, 252

    引入数组指针后,我们就有两种方案来访问数组元素了,一种是使用下标,另外一种是使用指针。

    1) 使用下标

    也就是采用 arr[i] 的形式访问数组元素。如果 p 是指向数组 arr 的指针,那么也可以使用 p[i] 来访问数组元素,它等价于 arr[i]。

    2) 使用指针

    也就是使用 *(p+i) 的形式访问数组元素。另外数组名本身也是指针,也可以使用 *(arr+i) 来访问数组元素,它等价于 *(p+i)。

    不管是数组名还是数组指针,都可以使用上面的两种方式来访问数组元素。不同的是,数组名是常量,它的值不能改变,而数组指针是变量(除非特别指明它是常量),它的值可以任意改变。也就是说,数组名只能指向数组的开头,而数组指针可以先指向数组开头,再指向其他元素。

    更改上面的代码,借助自增运算符来遍历数组元素:

     
    
    1. #include <stdio.h>
    2. int main(){
    3. int arr[] = { 99, 15, 100, 888, 252 };
    4. int i, *p = arr, len = sizeof(arr) / sizeof(int);
    5. for(i=0; i<len; i++){
    6. printf("%d ", *p++ );
    7. }
    8. printf("\n");
    9. return 0;
    10. }

    运行结果:
    99  15  100  888  252

    第 8 行代码中,*p++ 应该理解为 *(p++),每次循环都会改变 p 的值(p++ 使得 p 自身的值增加),以使 p 指向下一个数组元素。该语句不能写为 *arr++,因为 arr 是常量,而 arr++ 会改变它的值,这显然是错误的。

    关于数组指针的谜题

    假设 p 是指向数组 arr 中第 n 个元素的指针,那么 *p++、*++p、(*p)++ 分别是什么意思呢?

    *p++ 等价于 *(p++),表示先取得第 n 个元素的值,再将 p 指向下一个元素,上面已经进行了详细讲解。

    *++p 等价于 *(++p),会先进行 ++p 运算,使得 p 的值增加,指向下一个元素,整体上相当于 *(p+1),所以会获得第 n+1 个数组元素的值。

    (*p)++ 就非常简单了,会先取得第 n 个元素的值,再对该元素的值加 1。假设 p 指向第 0  个元素,并且第 0 个元素的值为 99,执行完该语句后,第 0  个元素的值就会变为 100。

    展开全文
  • 关于数组指针和指向数组指针的指针及其new的一些个人理解及其小例子,详细可以参见我的CSDN博客中的文章http://blog.csdn.net/shizhixin/article/details/7050592
  • 一、C 语言数组指针指向数组的指针) 二、C 语言字符串指针(指向字符串的指针) 三、C 语言指针数组(数组每个元素都是指针) 四、二维数组指针(指向二维数组的指针) 五、指针数组和二维数组指针的区别: ...

    目录

    一、C 语言数组指针(指向数组的指针)

    二、C 语言字符串指针(指向字符串的指针)

    三、C 语言指针数组(数组每个元素都是指针)

    四、二维数组指针(指向二维数组的指针)

    五、指针数组和二维数组指针的区别:

    六、常见指针变量的例子集合:见下图


    一、C 语言数组指针(指向数组的指针)

    定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。 在 C 语言中,我们将第 0 个元素的地址称为数组的首地址。 以上面的数组为例,下图是 arr 的指向:

    #include <stdio.h>
    int main(){
    int arr[] = { 99, 15, 100, 888, 252 };
    int len = sizeof(arr) / sizeof(int); //求数组长度
    int i;
    for(i=0; i<len; i++){
    printf("%d ", *(arr+i) ); //*(arr+i)等价于arr[i]
    }
    printf("\n");
    return 0;
    }
    
    运行结果:
    99 15 100 888 252

    ② 定义一个指向数组的指针:

    int arr[] = { 99, 15, 100, 888, 252 };
    int *p = arr;

           arr 本身就是一个指针,可以直接赋值给指针变量 p。 arr 是数组第 0 个元素的地址,所以 int *p = arr;也可以写作int *p = &arr[0];。也就是说, arr、 p、 &arr[0] 这三种写法都是等价的,它们都指向数组第 0 个元素,或者说指向数组的开头。
    ③ 两种方案来访问数组元素:
    1) 使用下标
    也就是采用 arr[i] 的形式访问数组元素。如果 p 是指向数组 arr 的指针,那么也可以使用 p[i] 来访问数组元素,它等价于 arr[i]。
    2) 使用指针
    也就是使用 *(p+i) 的形式访问数组元素。另外数组名本身也是指针,也可以使用 *(arr+i) 来访问数组元素,它等价于 *(p+i)。

    ④ 关于数组指针的谜题:

    *和++优先级(一样,从右往左)

    假设 p 是指向数组 arr 中第 n 个元素的指针,那么 *p++、 *++p、 (*p)++ 分别是什么意思呢?
           *p++ 等价于 *(p++),表示先取得第 n 个元素的值,再将 p 指向下一个元素。

           *++p 等价于 *(++p),会先进行 ++p 运算,使得 p 的值增加,指向下一个元素,整体上相当于 *(p+1),所以会获得第 n+1 个数组元素的值。
           (*p)++ 就非常简单了,会先取得第 n 个元素的值,再对该元素的值加 1。假设 p 指向第 0 个元素,并且第 0个元素的值为 99,执行完该语句后,第 0 个元素的值就会变为 100。

    二、C 语言字符串指针(指向字符串的指针)

    ① 字符串数组:

    char str[] = "http://c.biancheng.net";
    int len = strlen(str), i;
    //直接输出字符串
    printf("%s\n", str);
    //每次输出一个字符
    for(i=0; i<len; i++){
    printf("%c", str[i]);
    }

    ② 字符串指针:

    C 语言还支持另外一种表示字符串的方法,就是直接使用一个指针指向字符串:

    char *str = "http://c.biancheng.net";
    
    char *str;
    str = "http://c.biancheng.net";
    
    上面两个相同

    字符串中的所有字符在内存中是连续排列的, str 指向的是字符串的第 0 个字符。

    char *str = "http://c.biancheng.net";
    int len = strlen(str), i;
    
    //直接输出字符串
    printf("%s\n", str);
    
    //使用*(str+i)
    for(i=0; i<len; i++){
    printf("%c", *(str+i));
    
    //使用str[i]
    for(i=0; i<len; i++){
    printf("%c", str[i]);
    }
    
    以上三种均可

    :都可以使用*或[ ]获取单个字符,这两种表示字符串的方式是不是就没有区别了呢?
    :有!它们最根本的区别是在内存中的存储区域不一样字符数组存储在全局数据区栈区,第二种形式的字符串存储在常量区。全局数据区和栈区的字符串(也包括其他数据)有读取和写入的权限,而常量区的字符串(也包括其他数据)只有读取权限,没有写入权限。

    三、C 语言指针数组(数组每个元素都是指针)

    一个数组中的所有元素保存的都是指针,那么我们就称它为指针数组
    此处一定要类比普通的指针使用方法

    int a = 16, b = 932, c = 100;
    
    //定义一个指针数组
    int *arr[3] = {&a, &b, &c};//也可以不指定长度,直接写作 int *parr[]
    
    //定义一个指向指针数组的指针
    int **parr = arr;
    
    printf("%d, %d, %d\n", *arr[0], *arr[1], *arr[2]);
    printf("%d, %d, %d\n", **(parr+0), **(parr+1), **(parr+2));
    
    运行结果:
    16, 932, 100
    16, 932, 100

           arr 是一个指针数组,它包含了 3 个元素,每个元素都是一个指针,在定义 arr 的同时,我们使用变量 a、 b、 c 的地址对它进行了初始化,这和普通数组是多么地类似。
           parr 是指向数组 arr 的指针,确切地说是指向 arr 第 0 个元素的指针,它的定义形式应该理解为 int *(*parr),括号中的*表示 parr 是一个指针,括号外面的 int *表示 parr 指向的数据的类型。 arr 第 0 个元素的类型为 int *,所以在定义 parr 时要加两个 *。
           第一个 printf() 语句中, arr[i] 表示获取第 i 个元素的值,该元素是一个指针,还需要在前面增加一个 * 才能取得它指向的数据,也即 *arr[i] 的形式。
           第二个 printf() 语句中, parr+i 表示第 i 个元素的地址, *(parr+i) 表示获取第 i 个元素的值(该元素是一个指针),**(parr+i) 表示获取第 i 个元素指向的数据。

    #include <stdio.h>
    int main(){
    char *str[3] = {
    "https://blog.csdn.net/qq_38351824/article/category/9343538",
    "百度搜索",
    "sumjess"
    };
    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    return 0;
    }
    
    等价于
    
    #include <stdio.h>
    int main(){
    char *str0 = "https://blog.csdn.net/qq_38351824/article/category/9343538";
    char *str1 = "百度搜索";
    char *str2 = "sumjess";
    char *str[3] = {str0, str1, str2};
    printf("%s\n%s\n%s\n", str[0], str[1], str[2]);
    return 0;
    }
    
    

    需要注意的是,字符数组 str 中存放的是字符串的首地址不是字符串本身,字符串本身位于其他的内存区域, 和字符数组是分开的。
    也只有当指针数组中每个元素的类型都是 char *时,才能像上面那样给指针数组赋值,其他类型不行。

    四、二维数组指针(指向二维数组的指针)

    二维数组在概念上是二维的,有行和列,但在内存中所有的数组元素都是连续排列的,它们之间没有“缝隙”。以下面的二维数组 a 为例:

    int a[3][4] = { {0, 1, 2, 3}, {4, 5, 6, 7}, {8, 9, 10, 11} };


    C 语言允许把一个二维数组分解成多个一维数组来处理。对于数组 a,它可以分解成三个一维数组,即 a[0]、 a[1]、a[2]。每一个一维数组又包含了 4 个元素,例如 a[0] 包含 a[0][0]、 a[0][1]、 a[0][2]、 a[0][3]。

    假设数组 a 中第 0 个元素的地址为 1000,那么每个一维数组的首地址如下图所示:

           为了更好的理解指针和二维数组的关系,我们先来定义一个指向 a 的指针变量 p:int (*p)[4] = a;括号中的*表明 p 是一个指针,它指向一个数组,数组的类型为 int [4],这正是 a 所包含的每个一维数组的类型。[ ]的优先级高于*, ( )是必须要加的,如果赤裸裸地写作 int *p[4],那么应该理解为 int *(p[4]), p 就成了一个指针数组,而不是二维数组指针。
           对指针进行加法(减法)运算时,它前进(后退)的步长与它指向的数据类型有关, p 指向的数据类型是 int [4],那么 p+1 就前进 4×4 = 16 个字节, p-1 就后退 16 个字节,这正好是数组 a 所包含的每个一维数组的长度。也就是说, p+1 会使得指针指向二维数组的下一行, p-1 会使得指针指向数组的上一行。
           数组名 a 在表达式中也会被转换为和 p 等价的指针!
           下面我们就来探索一下如何使用指针 p 来访问二维数组中的每个元素。按照上面的定义:

    1. p 指向数组 a 的开头,也即第 0 行; p+1 前进一行,指向第 1 行
    2. *(p+1)表示取地址上的数据,也就是整个第 1 行数据。注意是一行数据,是多个数据,不是第 1 行中的第 0 个。
    3. *(p+1)+1 表示第 1 行第 1 个元素的地址。如何理解呢?
      *(p+1)单独使用时表示的是第 1 行数据,放在表达式中会被转换为第 1 行数据的首地址,也就是第 1 行第 0 个
      元素的地址,因为使用整行数据没有实际的含义,编译器遇到这种情况都会转换为指向该行第 0 个元素的指针;
      就像一维数组的名字,在定义时或者和 sizeof、 & 一起使用时才表示整个数组,出现在表达式中就会被转换为指向数组第 0 个元素的指针。
    4. *(*(p+1)+1)表示第 1 行第 1 个元素的。很明显,增加一个 * 表示取地址上的数据。
      a+i == p+i
      a[i] == p[i] == *(a+i) == *(p+i)
      a[i][j] == p[i][j] == *(a[i]+j) == *(p[i]+j) == *(*(a+i)+j) == *(*(p+i)+j)
      
      【实例】使用指针遍历二维数组
      
      #include <stdio.h>
      int main(){
      int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
      int(*p)[4];
      int i,j;
      p=a;
      for(i=0; i<3; i++){
      for(j=0; j<4; j++) printf("%2d ",*(*(p+i)+j));
      printf("\n");
      }
      return 0;
      }
      
      运行结果:
      0 1 2 3
      4 5 6 7
      8 9 10 11

      下面是一个简单的例子

    五、指针数组和二维数组指针的区别:

    指针数组和二维数组指针在定义时非常相似,只是括号的位置不同:

    int *(p1[5]);    指针数组,可以去掉括号直接写作 int *p1[5];
    int (*p2)[5];    二维数组指针,不能去掉括号

           指针数组和二维数组指针有着本质上的区别:指针数组是一个数组,只是每个元素保存的都是指针,以上面的 p1为例,在 32 位环境下它占用 4×5 = 20 个字节的内存。二维数组指针是一个指针,它指向一个二维数组,以上面的 p2 为例,它占用 4 个字节的内存。

    六、常见指针变量的例子集合:

    常见指针变量的定义
    定 义含 义
    int *p;p 可以指向 int 类型的数据,也可以指向类似 int arr[n] 的数组。
    int **p;p 为二级指针,指向 int * 类型的数据。
    int *p[n];p 为指针数组。 [ ] 的优先级高于 *,所以应该理解为 int *(p[n]);
    int (*p)[n];p 为二维数组指针。
    int *p();p 是一个函数,它的返回值类型为 int *。
    int (*p)();p 是一个函数指针,指向原型为 int func() 的函数。

    ① 二级指针:指向一级指针的地址

    #include <stdio.h>
    int main(){
    
    int a[2] = {0,1};
    
    int *pt1 = &a[1];   // 将 a[1] 的地址赋值给pt1 
    
    int **pt = &pt1;    // 二级指针 将指针pt1的地址赋值给pt 
    
    printf("利用二级指针pt 获取pt1的指针地址 :%p\n",pt );
    printf("显示自己(指针pt1)的地址 :         %p\n",&pt1 );
    
    return 0;
    }

    ② 指针数组:[ ]优先级高于 *,所以应该理解为  int * ( p[n] );

    #include <stdio.h>
    int main(){
    
    int a[4] = {0,1,2,3};
    
    int *pt[4] = { a, &a[1], &a[2], &a[3]};
    
    printf("显示  %p\n",&pt );     //打印数组的首地址, 
    printf("显示  %p\n",&pt[0] );  //也是数组第一个元素的地址 
    
    printf("显示  %p \n",pt[2]);   //打印第三个元素的地址
    printf("显示  %p \n", &a[2]);  //验证第三个元素的地址 是否正确 
    
    printf("显示  %d \n", a[2]);    //打印数组第三个数据 
    printf("显示  %d \n",*pt[2]);   //验证pt[2]到底是不是表示第三个元素的地址
    printf("显示  %d \n", *&a[2]);  //再次验证第三个元素的地址 是否正确 
    
    return 0;
    }

    ③ 二维数组指针

    #include <stdio.h>
    int main()
    {
    int a[3][4]={0,1,2,3,4,5,6,7,8,9,10,11};
    
    int i = 1 ,j = 2;
    
    int(*p)[4];  //二维数组指针p 
    
    p=a;  //二维数组指针p 指向 数组a的首地址
    
    printf("第i行,第j个元素的地址是 : %p \n",   (*(p+i)+j) );  //第i行,第j个元素的地址 
    printf("第i行,第j个元素的数值是 : %d \n", * (*(p+i)+j) );  //第i行,第j个元素的数值
    
    printf("验证:\n");
    
    printf("第i行,第j个元素的地址是 : %p \n",   &a[1][2] );  //第i行,第j个元素的地址 
    printf("第i行,第j个元素的数值是 : %d \n",    a[1][2] );  //第i行,第j个元素的数值
    
    return 0;
    }

    ④ int *p();  函数返回值类型为  int *

    #include <stdio.h>
    
    int n = 100;
    
    int *test(void) //返回一个int *类型(地址) 
    {
     return &n;
    }
    
    int main()
    {
     int *p , n;
     
     p = test();  //指针p指向这个地址 
     n = *p;      //从这个地址获取值 
     
     printf("value = %d\n", n); //该地址的值是否为 100 
     
     return 0;
    }

    ⑤ 函数指针:int (*p)() ; 

    #include <stdio.h>
    
    int m = 99;
    
    int *test(int * a) //第一个*代表返回一个int *类型(返回一个地址) 
    {                  //第二个*传入一个地址
     return a;         //return 返回一个地址 
    }
    
    int main()
    {
     int *p ;         //定义一个指针变量 
     int *(*pt)(int *c) = test ;  //第一个*函数指针:int (*p)() ;第一个* 是要与 test 函数参数列表一致。  
                                  //第二个*函数指针:int (*p)() ;
                                  //第三个*函数指针:int (*p)() ;第二个括号中的int *c 是要与 test 函数参数列表一致。 
                                  //下面再对比解释下。                              
                                  //int *(*pt)(int *c)     对比看一下实际就是将*pt = test ;其他部分一致 
                                  //int * test(int * a)    而*pt = test 就是pt指向函数首地址 	
    							  					  
     p = (*pt)(&m);   //函数(*pt)(&m)返回一个地址,指针p指向这个地址 
    //---------------------------------------------------------------------------------------------------//
    //上面的内容其实就做了一个简单的事情,将指针p指向全局变量m的地址(即p=&m),转这么一圈使用来学习指针的//
    // 下面就来验证,我们之前做的是对。                          
    	
     printf("m的地址为          :%p\n",&m);//这是m的地址 
     printf("验证指针:m的地址为:%p\n",p); //这是经过风波的m的地址,用来验证我们之前的一通指针操作是否正确
      
     printf("m的value =          %d\n",m); //该地址的值是否为 99
     printf("验证指针:m的value= %d\n",*p); //这是经过风波的m的值,用来验证我们之前的一通指针操作是否正确 
     
     return 0;
    }

     

    展开全文
  • 数组指针顾名思义是指向数组的指针,数组指针存放的是数组的地址 这里的int(*p)[10] 括号*p的意思是让p先和*号配对确保是个指针,然后去掉*p可以知道指针p变量指向的是一个数组,有10个元素,每个元素是int类型 ...

    &数组名与数组名

    &数组名表示的是取出整个数组的地址,而不是首元素地址,所以它+1步长跳过整个数组

    数组名sizeof单独使用时或者被&数组名时表示的是整个数组,其余都指首元素地址

    数组指针的使用:

    数组指针顾名思义是指向数组的指针,数组指针存放的是数组的地址

    这里的int(*p)[10]    括号*p的意思是让p先和*号配对确保是个指针,然后去掉*p可以知道指针p变量指向的是一个数组有10个元素每个元素是int类型

      一般用法是这样的:二维数组的首元素是第一行数组 

     

     

    展开全文
  • C语言数组指针指向数组的指针)

    千次阅读 2017-05-19 01:23:43
    数组(Array)是一系列具有相同类型的数据的集合,每一份数据叫做一个数组元素(Element)。...定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。在C语言中,我们
  • 区分指向数组元素的指针指向数组指针指针数组 指向数组元素的指针 这类指针比较常见,例如 int a[3] = {1, 2, 3}; int *p; p = a;//将数组的地址(也即数组首元素的地址)赋给指针p,相当于指针p指向数组的首...
  • 数组指针指向数组的指针.c
  • 数组指针是指数组的开始地址(首地址),数组元素的指针就是数组元素的地址。 a[3]=6;下标法引用数组元素,也可以用指针引用数组元素。 int a[5]={5,6,7,8,9};能引用的是0--4,只要是数组,那么数组元素的内存...
  • Go 数组指针(指向数组的指针)

    千次阅读 2019-03-20 12:23:29
    demo.go(数组指针): package main import "fmt" func main() { ...a // p数组指针指向数组的指针) fmt.Println(*p) // [1 2 3 4 5] fmt.Println((*p)[0]) // 1 *p[0]的写法是错误的,...
  • 指向数组指针与指向整形数的指针

    千次阅读 2019-05-09 22:02:09
    最近看书看到二维数组指针的章节,将一个二维数组名字赋值给一个指向整形数的指针,咋看没毛病,其实还是数组指针的概念没有理清楚,先放代码。 #include <stdio.h> int Array[1][2]={1,2}; int main...
  • 数组指针——指向数组对象的指针

    千次阅读 2020-04-20 22:52:49
    数组指针——指向数组对象的指针 数组(Array)是一系列具有相同类型的数据的集合,每一份数据叫做一个数组元素(Element)。数组中的所有元素在内存中是连续排列的,整个数组占用的是一块内存。以int arr[] = { 99,...
  • 指向数组指针

    千次阅读 2018-03-24 16:17:39
    数组指针数组指针是一个指针,是指一个数组的指针,数组两字表示这个指针指向一个数组的首地址,并且这个指针加1时移动的位置是整个数组的长度。2.指针数组一个可行的指针数组定义如下:char *arr[4] = {"...
  • 默认是指向数组中第一个元素通过移动或改变指针的位置,可以访问数组中的任意元素。对于数组指针的控制PHP提供了以下几个内建函数可以利用。 ★current():取得目前指针位置的内容资料。 ★key():读取目前指针所指向...
  • 指向数组 指向数组首元素 数组指针
  • 数组指针和指针数组

    万次阅读 多人点赞 2019-09-17 16:39:06
    指向数组指针指针的数组:是一个数组,什么样的数组呢?装着指针的数组。 然后,需要明确一个优先级顺序:()>[]>*,所以: (*p)[n]:根据优先级,先看括号内,则p是一个指针,这个指针指向一个一维...
  • 数组:一组数据的集合...当然数组中除了存储一般常见的数据类型外,也可以用来存放指针,此时的数组就叫指针数组指针数组指针数组的元素全为指针。它的声明方法是:数据类型 * 数组名[数组长度];例如int arr[5];
  • 关于C语言中数组指针、函数指针、指针数组、函数指针数组、指向函数指针数组的指针一直比较绕,稍微整理一下。 到底是指针还是数组? 其实到底是指针还是数组还是看变量名与[]先结合还是*先结合。我们知道C语言中 的...
  • C++声明指向数组指针

    千次阅读 2020-10-05 18:29:20
    它为一个整型数组分配内存,并把vp声明为一个指向整型的指针,并把它初始化为指向 vector数组的第1个元素。 vector和vp具有相同的类型:指向整型的指针。 第2个声明是非法的。它正确地创建了 matrix数组,并把mp声明...
  • 指向数组指针: char *p = new char;定义指向动态分配的字符变量的指针; char *p = new char[3];定义指向动态分配的一维字符数组的指针,p指向数组首个元素的地址,即(p+1)为数组第二个元素的地址; char (*p)[3]...
  • 1.问文俊的题 2. 注意*和[]等价 注意行指针(类型(*指针变量名)[m];)和列指针(*p)的区分 m是列数 注意运行结果
  • 二是如何定义指向数组指针以及如何赋值等。 很简单,快速记录! 先给出一个案例,判断下面这两个声明以及赋值合法吗? int vector[10], *vp = vector; int matrix[3][10], *mp = matrix; 第一个声明是合法的...
  • 主要介绍了C++中的指针结构体数组以及指向结构体变量的指针的用法,是C++入门学习中的基础知识,需要的朋友可以参考下
  • 数组指针与指针数组

    2021-01-20 14:02:37
    什么是数组指针:能够指向数组的指针。 定义一个int (*p)[10],首先()的优先级高于[]所以p首先是一个指针,指向的是一个整形的一维数组,所以是数组指针数组指针是一个指针不是数组 因为数组指针指向的是数组,...
  • \n指向数组指针p1 的地址为:%u\n" , ( unsigned int ) p1 ) ; printf ( "p1 + 1为:%u\n\n" , ( unsigned int ) ( p1 + 1 ) ) ; char * p2 [ 10 ] ; printf ( "char *p2[10];\n指针数组p2 的地址...
  • 多维数组名作为函数参数传递:在二维数组中,数组名a是指向首行a[0]的指针,也就是说a=&a[0]; a[0]是指向首元素a[0][0]的指针,也就是说a[0]=&a[0][0]
  • 【c++】 typedef类型自定义:定义指向数组指针、指向指针的数组1.定义指向包含10个int变量的数组的指针类型2.定义包含10个int指针的数组类型 1.定义指向包含10个int变量的数组的指针类型 typedef int (* pints)[10...
  • 指向数组指针的理解

    千次阅读 2019-05-08 17:37:28
    指向数组指针的理解 开发工具与关键技术:Visual Studio、C++ 作者:张国军 撰写时间:2019年05月03日 数组和指针是两种不同的类型,数组具有确定数量的元素,而指针只是一个标量值。数组可以在某些情况下转换为...
  • C语言程序设计 第10章 指针 第2讲数组指针指向数组的指针变量 328677005 C语言课程交流群 1. 指针变量指向一维数组 提纲 2. 一维数组元素的表示法 3. 指针变量的运算 1.指针变量指向一维数组 C语言程序设计 一维...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 568,011
精华内容 227,204
关键字:

指向数组的指针

友情链接: 香农费诺哈夫曼.rar