的C指针的指针消歧的阵列/阵列

Question

是什么下面的声明的区别是：

int* arr1[8];
int (*arr2)[8];
int *(arr3[8]);

什么是理解更复杂的声明的一般规则？

Answer 1

int* arr[8]; // An array of int pointers.
int (*arr)[8]; // A pointer to an array of integers

第三个是与第一

的一般规则是算符优先。作为函数指针进入画面，可以得到甚至要复杂得多。

Answer 2

使用 CDECL 计划，由K＆R的建议。

$ cdecl
Type `help' or `?' for help
cdecl> explain int* arr1[8];
declare arr1 as array 8 of pointer to int
cdecl> explain int (*arr2)[8]
declare arr2 as pointer to array 8 of int
cdecl> explain int *(arr3[8])
declare arr3 as array 8 of pointer to int
cdecl>

它的工作原理的其他方式也是。

cdecl> declare x as pointer to function(void) returning pointer to float
float *(*x)(void )

Answer 3

我不知道它是否有一个正式名称，但我把它叫做右左啄（TM）。

开始在变量，然后向右走，和左，右......等等。

int* arr1[8];

ARR1是8个指针为整数数组。

int (*arr2)[8];

ARR2是一个指针（括号块左右）至8点的整数的数组。

int *(arr3[8]);

ARR3是8个指针为整数数组。

这应该可以帮助你解决复杂的声明。

Answer 4

int *a[4]; // Array of 4 pointers to int

int (*a)[4]; //a is a pointer to an integer array of size 4

int (*a[8])[5]; //a is an array of pointers to integer array of size 5 

Answer 5

也可以从在C金科玉律扣除最后两个答案：

  

声明如下使用。

int (*arr2)[8];

如果你恰好解引用ARR2什么？你得到8个整数的数组。

int *(arr3[8]);

如果你从ARR3元素会发生什么？你得到一个指向整数。

此与函数指针处理时也有帮助。采取sigjuice的示例：

float *(*x)(void )

当你提领会发生什么X？你得到你可以不带任何参数调用一个函数。当你调用它会发生什么？这将返回一个指向一个浮子。

运算符优先级总是棘手，虽然。但是，使用括号实际上也令人困惑，因为声明如下使用。至少，对我来说，直观地ARR2貌似8个指针数组整数，但它实际上是周围的其他方式。只是需要一些时间来适应。有足够的理由注释随时添加这些声明，如果你问我：）

修改：例如

顺便说一句，我只是碰到以下情况跌跌撞撞：具有静态矩阵的功能和使用指针运算，看看行指针超出范围。例如：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define NUM_ELEM(ar) (sizeof(ar) / sizeof((ar)[0]))

int *
put_off(const int newrow[2])
{
    static int mymatrix[3][2];
    static int (*rowp)[2] = mymatrix;
    int (* const border)[] = mymatrix + NUM_ELEM(mymatrix);

    memcpy(rowp, newrow, sizeof(*rowp));
    rowp += 1;
    if (rowp == border) {
        rowp = mymatrix;
    }

    return *rowp;
}

int
main(int argc, char *argv[])
{
    int i = 0;
    int row[2] = {0, 1};
    int *rout;

    for (i = 0; i < 6; i++) {
        row[0] = i;
        row[1] += i;
        rout = put_off(row);
        printf("%d (%p): [%d, %d]\n", i, (void *) rout, rout[0], rout[1]);
    }

    return 0;
}

输出：

0 (0x804a02c): [0, 0]
1 (0x804a034): [0, 0]
2 (0x804a024): [0, 1]
3 (0x804a02c): [1, 2]
4 (0x804a034): [2, 4]
5 (0x804a024): [3, 7]

请注意边界的值不会改变，因此编译器可以优化了。这是从你最初可能需要使用不同的：const int (*border)[3]：声明边框为指针的3个整数不会只要变量存在更改值的数组。然而，该指针可以是尖的，在任何时候任何其它这样的阵列。我们希望这种行为的说法，而不是（因为这个函数不改变任何这些整数）。声明如下使用。

（P.S .:随意提高该样品！）

Answer 6

typedef int (*PointerToIntArray)[];
typedef int *ArrayOfIntPointers[];

Answer 7

作为一个经验法则，右一元运算符（如[]，()等）接管左那些偏好。所以，int *(*ptr)()[];将是（只要你能为你走出括号中得到正确的运营商）指向返回指向int数组的函数指针

Answer 8

我想我们可以用简单的规则..

example int * (*ptr)()[];
start from ptr 

“ptr是一个指针，指向” 去向右..its“）”现在去留下了一个“（” 出来向右走“（）”，所以 “哪个不带参数的函数”向左走“并返回一个指针”向右走“到 阵列“去左”整数“

Answer 9

下面是我如何解释它：

int *something[n];

  

请注意上的优先级：数组下标运算符（“[]”）具有比较高的优先级   引用操作（ '*'）。

所以，在这里我们将把 '[]' 前 '*'，使得等价于语句：

int *(something[i]);

  

请注意在声明如何有意义：int num装置（NUM）是（INT），int *ptr或int (*ptr)手段，（在PTR值）   一个（INT），这使得PTR的指针为int。

这可以理解为，（在的东西第i个指数）的（值的值）是一个整数。所以，（某物的第i个索引处的值）是（整数指针），这使得一些整数的指针数组。

在第二个，

int (*something)[n];

要弄明白这句话的，你必须熟悉这个事实：

  

请注意在阵列的指针表示：somethingElse [i]是相当于*（somethingElse + I）

所以，用（*东西）替换somethingElse，我们得到*（*东西+ I），它是一个整数作为每声明。所以，（*东西）给了我们的阵列，这使得东西等效于（指针阵列）。

Answer 10

下面是一个有趣的网站，介绍如何在C阅读复杂类型： http://www.unixwiz.net/techtips/reading-cdecl.html

Answer 11

我想第二个声明是混乱的许多。这里有一个简单的方法来了解它。

允许有一个整数数组，即int B[8]。

让我们也有一个变量A指向B.现在，在的值是B，即(*A) == B。因此，一个指向整数数组。在您的问题，ARR是类似于甲

类似地，在int* (*C) [8]，C是一个指向指针数组为整数。

Answer 12

在指针的整数，如果指针递增然后它进入下一个整数。

在指针的数组，如果指针递增它跳转到下一个阵列