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 

Третий, такой же, как первый.

Общее правило: operator precedence. Он может стать еще более сложным, поскольку указатели на функцию попадают в изображение.

Answer 2

Я не знаю, имеет ли оно официальное название, но я называю это правым левым Thingy (TM).

Начните с переменной, затем идите направо, и влево, и вправо ... и так далее.

int* arr1[8]; 

arr1 представляет собой массив из 8 указателей на целые числа.

int (*arr2)[8]; 

arr2 является указателем (скобка блокировать вправо-влево) на массив 8 целых чисел.

int *(arr3[8]); 

arr3 представляет собой массив из 8 указателей на целые числа.

Это должно помочь вам со сложными объявлениями.

Answer 3

Используйте программу cdecl, как это было предложено К & Р.

$ 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 4

Ответ на двух последних также может быть вычтена из золотого правила в C:

декларации следует использовать.

int (*arr2)[8];

Что произойдет, если вы разыменования arr2? Вы получаете массив из 8 целых чисел.

int *(arr3[8]);

Что произойдет, если вы берете элемент из arr3? Вы получаете указатель на целое число.

Это также помогает при работе с указателями на функции. Взять пример sigjuice в:

float *(*x)(void)

Что происходит, когда вы разыменования х? Вы получаете функцию, которую вы можете вызвать без аргументов. Что происходит, когда вы это называете? Он вернет указатель на float.

Однако приоритет оператора всегда сложный. Однако использование круглых скобок также может быть путаным, поскольку декларация следует за использованием. По крайней мере, для меня интуитивно arr2 выглядит как массив из 8 указателей на ints, но на самом деле это наоборот. Просто привыкает. Причина достаточно, чтобы всегда добавить комментарий к этим заявлениям, если вы спросите меня :)

редактировать: пример

Кстати, я наткнулся на следующую ситуацию: функция, которая имеет статическую матрицу и который использует арифметику указателя, чтобы увидеть, не указана ли указатель строки за пределами границ. Пример:

#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 целых чисел, которые не будут изменять значение до тех пор, пока существует переменная. Однако этот указатель может указывать на любой другой такой массив в любое время. Вместо этого мы хотим такого поведения для аргумента (потому что эта функция не меняет ни одного из этих целых чисел). Декларация следует за использованием.

(пс: не стесняйтесь, чтобы улучшить этот образец)

Answer 5

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

Answer 6

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 7

Я думаю, что мы можем использовать простое правило ..

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

"ptr является указателем на" go to right ..its ")" now go left its a "(" выйти наружу вправо "()" так "функции, которая не принимает аргументов" go left "и возвращает указатель «go right» to массив «go left» целых чисел »

Answer 8

В указателе на целое число, если указатель увеличивается, он переходит в следующее целое число.

в массиве указателя, если указатель увеличивается он переходит к следующему массиву

Answer 9

Как правило, правой унарные (как [], (), и т.д.) превалировать над левые. Так, int *(*ptr)()[]; будет указатель, который указывает на функцию, которая возвращает массив указателей на INT (получить правильные операторы, как только вы можете, как вы выходите из скобкой)

Answer 10

Вот как я истолковал его

int *something[n]; 

примечание на старшинство: оператор индекса массива ('[]') имеет более высокий приоритет, чем разыменовывания оператора ('*').

Итак, здесь мы будем применять '[]' перед '*', что делает заявление эквивалентно:

int *(something[i]); 

записку о том, как декларация имеет смысл: int num средства (NUM) is (int), int *ptr или int (*ptr) означает, что значение (value at ptr) равно a (int), что делает ptr указателем на int.

Это может быть прочитано как (значение (значение в i-м индексе чего-то)) является целым числом. Таким образом, (значение в i-м индексе чего-то) является (целым указателем), что делает что-то массив целых указателей.

Во втором,

int (*something)[n]; 

Чтобы разобраться в этом заявлении, вы должны быть знакомы с этим фактом:

записку на указатель представления массива: somethingElse [я] является эквивалентно * (somethingElse + i)

Итак, заменив somethingElse (* something), мы получим * (* something + i), который является целым числом в соответствии с декларацией , Итак, (* something) дал нам массив, который делает что-то эквивалентное (указатель на массив).

Answer 11

Я предполагаю, что вторая декларация вводит в заблуждение для многих. Вот простой способ понять это.

Позволяет иметь массив целых чисел, то есть int B[8].

Давайте также иметь переменную A, которая указывает на B. Теперь значение в точке A равно B, то есть (*A) == B. Следовательно, A указывает на массив целых чисел. В вашем вопросе arr похож на A.

Аналогичным образом, в int* (*C) [8], C является указателем на массив указателей на целое число.