Чому синтаксис C для масивів, покажчиків та функцій був розроблений таким чином?

Побачивши (і задавши!) Стільки питань, схожих на

Що int (*f)(int (*a)[5])означає C?

і навіть побачивши, що вони створили програму, яка допоможе людям зрозуміти синтаксис С, я не можу не здивуватися:

Чому синтаксис С був розроблений таким чином?

Наприклад, якби я розробляв покажчики, я переклав би "вказівник на 10-елементний масив покажчиків" на

int*[10]* p;

і ні

int* (*p)[10];

Я вважаю, що більшість людей погодиться набагато простіше.

Тож мені цікаво, чому не-інтуїтивний синтаксис? Чи була певна проблема, яку вирішує синтаксис (можливо, двозначність?), Про яку я не знаю?

Я розумію історію цього в тому, що вона базується на двох основних моментах ...

По-перше, автори мови воліли зробити синтаксис змінним-орієнтованим, а не типовим. Тобто, вони хотіли, щоб програміст подивився на декларацію і подумав, "якщо я напишу вираз *func(arg), це призведе до" int; якщо я напишу, *arg[N]я матиму "float", а не ", funcповинен бути вказівником на функцію, що приймає це" і повернення того ".

Запис C у Вікіпедії стверджує, що:

Ідея Рітчі полягала в тому, щоб оголосити ідентифікатори в контекстах, що нагадують їх використання: "декларація відображає використання".

... посилаючись на p122 K&R2, які, на жаль, мені не потрібно подавати, щоб знайти розширену для вас пропозицію.

По-друге, насправді дуже важко придумати синтаксис декларування, який є послідовним, коли ви маєте справу з довільними рівнями непрямості. Ваш приклад може спрацювати для висловлення типу, який ви придумали там, де він працює, але чи він масштабує функцію, що приймає вказівник на масив цих типів і повертає якусь іншу неприємну безлад? (Може, і є, але ви перевірили? Чи можете ви це довести? ).

Пам’ятайте, частина успіху C пояснюється тим, що компілятори написані для багатьох різних платформ, і тому, можливо, було б краще проігнорувати певну ступінь читабельності для полегшення запису компіляторів.

Сказавши це, я не знавець мовної граматики чи написання укладачів. Але я знаю достатньо, щоб знати, що можна багато чого знати;)

Багато диваків мови С можна пояснити тим, як працювали комп’ютери, коли він був розроблений. Об'єм пам'яті було дуже обмежений, тому було дуже важливо мінімізувати розмір самих файлів вихідного коду . Практика програмування ще в 70-х та 80-х роках полягала в тому, щоб вихідний код містив якомога менше символів, і бажано, щоб не було зайвих коментарів до вихідного коду.

Це, звичайно, смішно сьогодні, на жорстких дисках є досить багато необмеженого місця для зберігання. Але це є причиною того, що C має такий дивний синтаксис взагалі.

Що стосується конкретно вказівників масиву, то другим прикладом повинен бути int (*p)[10];(так, синтаксис дуже заплутаний). Я, можливо, прочитав би це як "int pointer to array of ten" ... що має сенс дещо. Якби не дужки, компілятор інтерпретував би це як масив з десяти покажчиків, що дало б декларації зовсім інше значення.

Оскільки вказівники масиву та покажчики функцій мають досить незрозумілий синтаксис на С, то розумне робити - це набрати непридатність. Можливо, так:

Неясний приклад:

int func (int (*arr_ptr)[10])
{
  return 0;
}

int main()
{
  int array[10];
  int (*arr_ptr)[10]  = &array;
  int (*func_ptr)(int(*)[10]) = &func;

  func_ptr(arr_ptr);
}

Неясний, еквівалентний приклад:

typedef int array_t[10];
typedef int (*funcptr_t)(array_t*);


int func (array_t* arr_ptr)
{
  return 0;
}

int main()
{
  int        array[10];
  array_t*   arr_ptr  = &array; /* non-obscure array pointer */
  funcptr_t  func_ptr = &func;  /* non-obscure function pointer */

  func_ptr(arr_ptr);
}

Речі можуть стати ще більш незрозумілими, якщо ви маєте справу з масивами функціональних покажчиків. Або найзрозуміліший з них: функції, що повертають покажчики функцій (м'яко корисні). Якщо ви не використовуєте typedefs для таких речей, ви швидко з’їдете з розуму.

Це досить просто: int *pозначає, що *pце int; int a[5]означає, що a[i]є int.

int (*f)(int (*a)[5])

Значить, що *fє функцією, *aце масив з п'яти цілих чисел, так fце функція, що приймає покажчик на масив з п’яти цілих чисел і повертає int. Однак в C не корисно передавати вказівник на масив.

C декларації дуже рідко ускладнюються.

Також можна уточнити за допомогою typedefs:

typedef int vec5[5];
int (*f)(vec5 *a);

Я думаю, що ви повинні вважати * [] операторами, які приєднані до змінної. * пишеться перед змінною, [] після.

Давайте прочитаємо вираз типу

int* (*p)[10];

Отже, найпотаємніший елемент - p, змінна

p

означає: p - змінна.

Перед змінною є *, оператор * завжди ставиться перед виразом, на який він посилається, отже,

(*p)

означає: змінна p - покажчик. Без () оператор [] праворуч би мав вищий пріоритет, тобто

**p[]

буде розбиратися як

*(*(p[]))

Наступний крок - []: оскільки більше немає (), [], отже, має перевагу над зовнішнім *

(*p)[]

означає: (змінна p - вказівник) на масив. Тоді у нас є другий *:

* (*p)[]

означає: ((змінна p - вказівник) на масив) покажчиків

Нарешті, у вас є оператор int (ім'я типу), який має найнижчий пріоритет:

int* (*p)[]

означає: (((змінна p - вказівник) на масив) покажчиків) на ціле число.

Отже вся система заснована на виразах типів з операторами, і кожен оператор має свої правила пріоритетності. Це дозволяє визначити дуже складні типи.

Це не так важко, коли ти починаєш думати, і мова С ніколи не була дуже легкою мовою. І int*[10]* pнасправді не простіше, ніж int* (*p)[10] І який тип k був биint*[10]* p, k;