Интерпретация int (* a) [3]

При работе с массивами и указателями на C быстро обнаруживается, что они никоим образом не эквивалентны, хотя это может показаться на первый взгляд. Я знаю о различиях в L-значениях и значениях R. Тем не менее, в последнее время я попытался выяснить тип указателя, который я мог бы использовать в сочетании с двумерным массивом, т.е.

int foo[2][3];
int (*a)[3] = foo;

Однако я просто не могу понять, как компилятор "понимает" определение типа a, несмотря на правильные правила приоритета оператора для * и []. Если вместо этого я должен был использовать typedef, проблема станет значительно проще:

int foo[2][3];
typedef int my_t[3];
my_t *a = foo;

В нижней строке, может ли кто-нибудь ответить мне на вопросы о том, как компилятор читает термин int (*a)[3]? int a[3] прост, int *a[3] также прост. Но тогда почему это не int *(a[3])?

EDIT: Конечно, вместо "typecast" я имел в виду "typedef" (это была просто опечатка).

Ответ 1

Во-первых, вы имеете в виду "typedef", а не "typecast" в своем вопросе.

В C указатель типа T может указывать на объект типа T:

int *pi;
int i;
pi = &i;

Вышеприведенное просто понять. Теперь сделаем это немного сложнее. Кажется, вы знаете разницу между массивами и указателями (т.е. Вы знаете, что массивы не указатели, они иногда ведут себя как они). Итак, вы должны понимать:

int a[3];
int *pa = a;

Но для полноты: в присваивании имя a эквивалентно &a[0], то есть указателю на первый элемент массива a. Если вы не уверены в том, как и почему это работает, есть много ответов, объясняющих, когда имя массива "распадается" на указатель, а когда нет:

Мой ответ на вопрос под названием тип массива,
Другой ответ с примерами экземпляров, когда имя массива не распадается на указатель, а
Ответ на то, что разрушает массив.

Я уверен, что есть много таких вопросов и ответов на SO, я только что упомянул некоторые из найденных в результате поиска.

Вернуться к теме: когда у нас есть:

int foo[2][4];

foo имеет тип "array [2] массива [3] of int". Это означает, что foo[0] представляет собой массив из 3 int s, а foo[1] - массив из 3 int s.

Теперь скажем, мы хотим объявить указатель, и мы хотим назначить его foo[0]. То есть мы хотим сделать:

/* declare p somehow */
p = foo[0];

Вышеизложенное по форме не отличается от строки int *pa = a;, так как типы a и foo[0] совпадают. Итак, нам нужно int *p; как наше объявление p.

Теперь главное помнить о массивах - это то, что "правило" о разложении массива на указатель на его первый элемент применяется только один раз. Если у вас есть массив массива, то в контекстах значения имя массива не будет распадаться на тип "указатель на указатель", а скорее на "указатель на массив". Возврат к foo:

/* What should be the type of q? */
q = foo;

Имя foo выше является указателем на первый элемент foo, то есть мы можем написать выше:

q = &foo[0];

Тип foo[0] - это "массив [3] of int". Поэтому нам нужно q быть указателем на "массив [3] of int":

int (*q)[3];

Скобки вокруг q необходимы, потому что [] связывается сильнее, чем * в C, поэтому int *q[3] объявляет q как массив указателей, и нам нужен указатель на массив. int *(q[3]), сверху, эквивалентен int *q[3], т.е. массив из 3 указателей на int.

Надеюсь, что это поможет. Вы также должны прочитать C для smarties: массивы и указатели для действительно хорошего учебника по этой теме.

О чтении деклараций в целом: вы читаете их "наизнанку", начиная с имени "переменной" (если есть). Вы уходите влево как можно больше, если только есть [] прямо справа, и вы всегда считаете круглые скобки. cdecl должен быть в состоянии помочь вам в некоторой степени:

$ cdecl
cdecl> declare p as  pointer to array 3 of int
int (*p)[3]
cdecl> explain int (*p)[3]
declare p as pointer to array 3 of int

Чтобы прочитать

int (*a)[3];

      a            # "a is"
    (* )           # parentheses, so precedence changes.
                   # "a pointer to"
        [3]        # "an array [3] of"
int        ;       # "int".

Для

int *a[3];

     a             # "a is"
      [3]          # "an array [3] of"
    *              # can't go right, so go left.
                   # "pointer to"
int      ;         # "int".

Для

char *(*(*a[])())()

          a         # "a is"
           []       # "an array of"
         *          # "pointer to"
        (    )()    # "function taking unspecified number of parameters"
      (*        )   # "and returning a pointer to"
                 () # "function"
char *              # "returning pointer to char"

(Пример из вопрос c-faq 1.21. На практике, если вы читаете такое сложное выражение, есть что-то серьезно неправильное с код!)

Ответ 2

Каждый раз, когда вы сомневаетесь в сложных объявлениях, вы можете использовать инструмент cdecl в системах Unix:

[/tmp]$ cdecl
Type `help' or `?' for help
cdecl> explain int (*a)[10];
declare a as pointer to array 10 of int

EDIT:

Существует также онлайн-версия этого инструмента здесь.

Благодаря Tiberiu Ana и gf

Ответ 3

Он объявляет указатель на массив из 3 int s.

Скобки необходимы, поскольку следующее объявляет массив из 3 указателей на int:

int* a[3];

Вы получаете лучшую читаемость при использовании typedef:

typedef int threeInts[3];
threeInts* pointerToThreeInts;

Ответ 4

Это означает

объявить как указатель на массив 3 из ИНТ

Смотрите cdecl для справок в будущем.

Ответ 5

Скорее всего, проще компилятор интерпретировать, чем вам. Язык определяет набор правил для того, что представляет собой правильное выражение, и компилятор использует эти правила для интерпретации таких выражений (может показаться сложным, но компиляторы изучены по длине и существует множество стандартизованных алгоритмов и инструментов, возможно, вы захотите читать разбор). cdecl - это инструмент, который будет транслировать выражения C на английский язык. Исходный код доступен на веб-сайте, чтобы вы могли его проверить. В книге "Язык программирования С++" был использован пример кода для написания такой программы, если я не ошибаюсь.

Что касается интерпретации этих выражений самостоятельно, я нашел лучший способ сделать это в книге "Думая на С++ том 1:

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

void (* funcPtr)();

Когда вы смотрите на сложный определение, как это, лучший способ атака начинается с середины и работать свой выход. "Начиная с средний" означает начало с имя переменной, которое является funcPtr. "Работать свой выход" означает поиск направо для ближайшего пункта (ничего в этом случае; скобки прекращают вас), то глядя влево (указатель, обозначенный по звездочке), затем глядя на right (список пустых аргументов с указанием функции, которая не принимает аргументы), затем глядя влево (void, что указывает на функцию не имеет возвращаемого значения). Эта движение вправо-влево-вправо работает с большинство объявлений.

Чтобы просмотреть "начало посередине", ( "funcPtr - это..." ), перейдите вправо (ничего там - вы остановились правая скобка), идите влево и найдите "* ("... указатель на... "), пойдите направо и найдите пустое список аргументов ("... функция, которая не принимает аргументов... "), перейдите к left и найдите пустоту (" funcPtr - это указатель на функцию, которая не принимает аргументы и возвращает void ").

Вы можете скачать книгу бесплатно на сайте загрузки Брюса Экеля. Попробуйте применить его к int (*a)[3]:

Начните с названия в середине, в этом случае a. Пока он читает: "a is..."
Идите вправо, вы сталкиваетесь с закрывающейся скобкой, которая останавливает вас, поэтому вы идете влево и находите *. Теперь вы читаете его: "a - указатель на..."
Идите направо, и вы найдете [3], что означает массив из трех элементов. Выражение принимает вид: 'a является указателем на массив из 3...'
Наконец, вы идете влево и находите int, поэтому, наконец, вы получаете "a - указатель на массив из 3-х целых чисел".

Ответ 6

Почему именно "не int *(a[3])" (ссылаясь на ваш последний вопрос)? int *(a[3]) совпадает с обычным int *a[3]. Скобки являются избыточными. Это массив из 3 указателей на int, и вы сказали, что знаете, что это значит.

int (*a)[3] - это указатель на массив из 3 int (т.е. указатель на тип int[3]). Скобки в этом случае важны. Вы сами представили правильный пример, который делает эквивалентную декларацию через промежуточный typedef.

Простое популярное правило считывания декларации C-кода с наивысшей точностью работает в этом случае отлично. В объявлении int *a[3] нам нужно начинать с a и сначала идти вперёд, т.е. Получить a[3], что означает, что a представляет собой массив из 3-х (и так далее). () in int (*a)[3] меняет это, поэтому мы не можем идти вправо и начинать с *a вместо: a - это указатель на что-то. Продолжая расшифровать декларацию, мы придем к выводу, что это что-то вроде массива 3 int.

В любом случае, найдите хороший учебник по чтению объявлений C, из которых в Сети доступно немало доступных.

Ответ 7

Вы можете найти эту статью полезной:

Чтение C объявлений: руководство для мистифицированных

Я сделал ответ на wiki сообщества (так как это просто ссылка на статью, а не ответ), если кто-то хочет добавить к ней дополнительные ресурсы.

Ответ 8

В ситуациях, когда вы не знаете, что такое объявление для, я нашел очень полезным, так называемый Правило справа.

BTW. После того, как вы это узнали, такие заявления - это торт:)