C не так складно: void (* (* f []) ()) ()

Я щойно побачив фотографію сьогодні і думаю, що буду вдячний за пояснення. Отже ось малюнок:

Я вважав це заплутаним і цікавився, чи такі коди колись практичні. Я гуглив картинку і знайшов ще одну картинку у цій редакції reddit, і ось ця картинка:

Тож це "читання спірально" щось дійсне? Це як розбирати компілятори C?
Було б чудово, якщо є більш прості пояснення цього дивного коду.
Окрім усіх, чи можуть корисні такі коди? Якщо так, то де і коли?

Є питання про "правило спіралі", але я не просто запитую про те, як воно застосовується або як читаються вирази за допомогою цього правила. Я ставлю під сумнів використання таких виразів та дійсність правила спіралі. З приводу цього вже розміщено кілька приємних відповідей.

Існує правило, яке називається "Правило за годинниковою стрілкою / спіраль", яке допомагає знайти значення складної декларації.

Від c-faq :

Три наступні кроки:

1. Починаючи з невідомого елемента, рухайтесь у напрямку спіраль / за годинниковою стрілкою; при згадці наступні елементи замінюють їх відповідними англійськими висловлюваннями:

   [X]або []
   => Масив X розміром ... або Не визначений розмір масиву ...

   (type1, type2)
   => функція передачі type1 і type2, що повертається ...

   *
   => покажчик (и) на ...

2. Продовжуйте робити це в напрямку спіралі / за годинниковою стрілкою, поки всі жетони не будуть покриті.

3. Завжди спочатку вирішуйте що-небудь в дужках!

Ви можете перевірити посилання вище для прикладів.

Також зауважте, що для того, щоб допомогти вам, існує також веб-сайт під назвою:

http://www.cdecl.org

Ви можете ввести декларацію С, і це дасть її англійське значення. Для

void (*(*f[])())()

він виводить:

оголосити f як масив покажчика на функцію повернення вказівника на функцію, що повертається недійсною

Редагувати:

Як вказувалося в коментарях Random832 , правило спіралі не стосується масиву масивів і призведе до неправильного результату (більшості) цих декларацій. Наприклад, для int **x[1][2];спірального правила ігнорується той факт, який []має більшу перевагу над *.

Якщо перед масивом масивів, можна спочатку додати явні дужки перед застосуванням правила спіралі. Наприклад: int **x[1][2];те саме, що int **(x[1][2]);(також дійсне C) через пріоритет, і правило спіралі потім правильно читає його як "x - масив 1 масиву 2 вказівника на покажчик на int", що є правильним англійським оголошенням.

Зверніть увагу , що це питання також розглядається в цьому відповіді по Джеймс Kanze (вказав haccks в коментарях).

Вигляд правила "спіраль" випадає з таких правил пріоритету:

T *a[]    -- a is an array of pointer to T
T (*a)[]  -- a is a pointer to an array of T
T *f()    -- f is a function returning a pointer to T
T (*f)()  -- f is a pointer to a function returning T

Оператори []виклику індексів та функцій ()мають вищий пріоритет, ніж одинарний *, тому *f()аналізуються як *(f())і *a[]аналізуються як *(a[]).

Отже, якщо ви хочете, щоб вказівник на масив чи вказівник на функцію, вам потрібно явно згрупувати *ідентифікатор, як у (*a)[]або (*f)().

Тоді ви розумієте, що aі fможуть бути складніші вирази, ніж просто ідентифікатори; в T (*a)[N], aможе бути простим ідентифікатором, або це може бути функція виклику на зразок (*f())[N]( a-> f()), або це може бути масив на зразок (*p[M])[N]( a-> p[M]), або це може бути масив покажчиків на функції типу (*(*p[M])())[N]( a-> (*p[M])()), тощо.

Було б добре, якби оператор *непрямості був постфіксом замість унарного, що полегшило б читання декларацій зліва направо ( void f[]*()*();безумовно, протікає краще, ніж void (*(*f[])())()), але це не так.

Коли ви зіткнетеся з такою волохатою декларацією, почніть з пошуку лівого лівого ідентифікатора та застосуйте правила пріоритетності, наведені вище, рекурсивно застосовуючи їх до будь-яких параметрів функції:

         f              -- f
         f[]            -- is an array
        *f[]            -- of pointers  ([] has higher precedence than *)
       (*f[])()         -- to functions
      *(*f[])()         -- returning pointers
     (*(*f[])())()      -- to functions
void (*(*f[])())();     -- returning void

signalФункція в стандартній бібліотеці, ймовірно , зразок типу для цього виду божевілля:

       signal                                       -- signal
       signal(                          )           -- is a function with parameters
       signal(    sig,                  )           --    sig
       signal(int sig,                  )           --    which is an int and
       signal(int sig,        func      )           --    func
       signal(int sig,       *func      )           --    which is a pointer
       signal(int sig,      (*func)(int))           --    to a function taking an int                                           
       signal(int sig, void (*func)(int))           --    returning void
      *signal(int sig, void (*func)(int))           -- returning a pointer
     (*signal(int sig, void (*func)(int)))(int)     -- to a function taking an int
void (*signal(int sig, void (*func)(int)))(int);    -- and returning void

На даний момент більшість людей кажуть "використовувати typedefs", що, безумовно, є варіантом:

typedef void outerfunc(void);
typedef outerfunc *innerfunc(void);

innerfunc *f[N];

Але ...

Як би ви використовували f в виразі? Ви знаєте, що це масив покажчиків, але як ви використовуєте його для виконання правильної функції? Ви повинні перейти над typedefs і загадувати правильний синтаксис. Навпаки, "гола" версія є досить очевидним, але вона точно говорить вам, як використовувати f в виразі (а саме (*(*f[i])())();, припускаючи, що жодна функція не бере аргументів).

У З, використання дзеркал декларації - саме так це визначено в стандарті. Декларація:

void (*(*f[])())()

Це твердження, що вираз (*(*f[i])())()створює результат типу void. Що означає:

• f повинен бути масивом, оскільки ви можете його індексувати:

  f[i]

• Елементи fmust повинні бути покажчиками, оскільки ви можете знецінити їх:

  *f[i]

• Ці вказівники повинні бути вказівниками на функції, які не мають аргументів, оскільки ви можете їх викликати:

  (*f[i])()

• Результати цих функцій також повинні бути покажчиками, оскільки ви можете знецінити їх:

  *(*f[i])()

• Ці вказівники також повинні бути вказівниками на функції, які не мають аргументів, оскільки ви можете їх викликати:

  (*(*f[i])())()

• Ці покажчики функцій повинні повернутися void

"Правило спіралі" - це просто мнемоніка, яка забезпечує інший спосіб розуміння одного і того ж.

Тож це "читання спірально" щось дійсне?

Застосування правила спіралі або використання cdecl не вірно завжди. І те, і інше не вдається. Правило спіралі працює у багатьох випадках, але воно не є універсальним .

Для розшифровки складних декларацій запам’ятайте ці два простих правила:

• Завжди читайте декларації зсередини назовні : Почніть з найпотужніших дужок, якщо такі є. Знайдіть ідентифікатор, який оголошується, і почніть розшифровувати декларацію звідти.

• Коли є вибір, завжди надайте перевагу []і ()знову* : Якщо *передує ідентифікатору і []слідує за ним, ідентифікатор представляє масив, а не вказівник. Так само, якщо *передує ідентифікатору і ()слідує за ним, ідентифікатор представляє функцію, а не вказівник. (Дужки завжди можна використовувати, щоб змінити звичайний пріоритет []і ()більше *.)

Це правило насправді включає зигзаг з однієї сторони ідентифікатора на іншу.

Тепер розшифруємо просту декларацію

int *a[10];

Правило застосування:

int *a[10];      "a is"  
     ^  

int *a[10];      "a is an array"  
      ^^^^ 

int *a[10];      "a is an array of pointers"
    ^

int *a[10];      "a is an array of pointers to `int`".  
^^^      

Давайте розшифруємо складну декларацію на кшталт

void ( *(*f[]) () ) ();  

застосовуючи вищезазначені правила:

void ( *(*f[]) () ) ();        "f is"  
          ^  

void ( *(*f[]) () ) ();        "f is an array"  
           ^^ 

void ( *(*f[]) () ) ();        "f is an array of pointers" 
         ^    

void ( *(*f[]) () ) ();        "f is an array of pointers to function"   
               ^^     

void ( *(*f[]) () ) ();        "f is an array of pointers to function returning pointer"
       ^   

void ( *(*f[]) () ) ();        "f is an array of pointers to function returning pointer to function" 
                    ^^    

void ( *(*f[]) () ) ();        "f is an array of pointers to function returning pointer to function returning `void`"  
^^^^

Ось GIF, що демонструє, як ви рухаєтесь (натисніть на зображення для збільшення зображення):

_{Правила, згадані тут, взяті з книги " Програмування сучасного підходу" КН КІНГ .}

Це лише "спіраль", тому що в цій декларації буває лише один оператор з кожної сторони в межах кожного рівня дужок. Стверджуючи, що ви переходите "по спіралі", як правило, пропонується вам чергувати масиви та покажчики в декларації, int ***foo[][][]коли насправді всі рівні масиву переходять до будь-якого з рівнів вказівника.

Сумніваюсь, подібні конструкції можуть мати будь-яку користь у реальному житті. Я навіть вважаю їх питаннями інтерв'ю для звичайних розробників (ймовірно, добре для авторів-компіляторів). замість цього слід використовувати typedefs.

Як випадковий дріб'язковий факт, вам може бути забавно знати, що в англійській мові є фактичне слово, яке описує, як читаються декларації C: Бустрофедонічно , тобто чергування справа наліво з ліворуч на право.

Довідка: Ван дер Лінден, 1994 - Сторінка 76

Щодо корисності цього, працюючи з shellcode, ви багато бачите цю конструкцію:

int (*ret)() = (int(*)())code;
ret();

Хоча це не так синтаксично складно, ця конкретна закономірність з'являється багато.

Більш повний приклад у цьому питанні.

Тому хоча корисність оригінальної картини сумнівна (я б припустив, що будь-який виробничий код повинен бути різко спрощений), є деякі синтаксичні конструкції, які дійсно з'являються зовсім небагато.

Декларація

void (*(*f[])())()

це лише незрозумілий спосіб висловлювання

Function f[]

з

typedef void (*ResultFunction)();

typedef ResultFunction (*Function)();

На практиці потрібні більш описові назви замість ResultFunction та Function . Якщо можливо, я б також вказав списки параметрів як void.

Я знайшов метод, описаний Брюсом Еккелем, як корисний і простий у дотриманні:

Визначення покажчика функції

Щоб визначити покажчик на функцію, яка не має аргументів і не повертає значення, ви говорите:

void (*funcPtr)();

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

Щоб ознайомитись, "починайте з середини" ("funcPtr - це ..."), перейдіть праворуч (нічого там - вас зупиняє права дужка), перейдіть ліворуч і знайдіть "*" (" ... вказівник на ... "), перейдіть праворуч і знайдіть порожній список аргументів (" ... функція, яка не бере аргументів ... "), перейдіть ліворуч і знайдіть порожнечу (" funcPtr is вказівник на функцію, яка не бере аргументів і повертає недійсність ”).

Вам може бути цікаво, чому * funcPtr вимагає дужок. Якщо ви їх не використовували, компілятор побачив би:

void *funcPtr();

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

Складні декларації та визначення

Крім того, коли ви зрозумієте, як працює синтаксис декларацій C і C ++, ви зможете створити набагато складніші елементи. Наприклад:

//: C03:ComplicatedDefinitions.cpp

/* 1. */     void * (*(*fp1)(int))[10];

/* 2. */     float (*(*fp2)(int,int,float))(int);

/* 3. */     typedef double (*(*(*fp3)())[10])();
             fp3 a;

/* 4. */     int (*(*f4())[10])();


int main() {} ///:~ 

Пройдіться по кожному з них та скористайтеся орієнтацією праворуч-ліворуч, щоб визначити це. Число 1 говорить, що "fp1 - вказівник на функцію, яка приймає цілий аргумент і повертає вказівник на масив з 10 недійсних покажчиків".

Число 2 говорить, що "fp2 - вказівник на функцію, яка бере три аргументи (int, int і float) і повертає вказівник на функцію, яка приймає цілий аргумент і повертає поплавок".

Якщо ви створюєте безліч складних визначень, можливо, ви хочете використовувати typedef. Число 3 показує, як typedef економить, вводячи складний опис кожного разу. У ньому сказано: "fp3 - це вказівник на функцію, яка не бере аргументів, і повертає вказівник на масив з 10 покажчиків на функції, які не беруть аргументів і повертають парні". Потім він говорить: "a - це один із цих типів fp3". typedef загалом корисний для складання складних описів із простих.

Число 4 - це оголошення функції замість визначення змінної. У ньому сказано, що "f4 - це функція, яка повертає вказівник на масив з 10 покажчиків на функції, які повертають цілі числа".

Ви рідко, якщо коли-небудь знадобиться, такі складні декларації та визначення, як ці. Однак, якщо ви перейдете до вправ їх з'ясувати, ви навіть не будете злегка турбуватися злегка складними, з якими ви можете зіткнутися в реальному житті.

Взято з: Думка в C ++ Том 1, друге видання, глава 3, розділ "Функціональні адреси" Брюса Еккеля.

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

За винятком модифікованих дужок, звичайно. І зауважте, що синтаксис для оголошення цих точно відображає синтаксис використання цієї змінної для отримання екземпляра базового класу.

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

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

Це може бути і гірше, ви знаєте. Була легальна заява PL / I, яка починалася з чогось типу:

if if if = then then then = else else else = if then ...

Я, мабуть, є оригінальним автором спірального правила, про яке я писав так багато років тому (коли у мене було багато волосся :) і був шанований, коли його додали до cfaq.

Я написав правило спіралі як спосіб полегшити моїм студентам та колегам читання декларацій С "у голові"; тобто без використання програмних засобів, таких як cdecl.org тощо. Ніколи не було наміру заявляти, що правило спіралі є канонічним способом розбору виразів C. Я, хоча, радий бачити, що це правило допомогло буквально тисячам студентів та практиків програмування на С!

Для запису,

На багатьох сайтах було "правильно" виявлено багато разів, зокрема Лінус Торвальдс (той, кого я дуже поважаю), що є ситуації, коли моє правило спіралі "ламається". Найпоширеніша істота:

char *ar[10][10];

Як вказували інші в цій темі, правило можна оновити, щоб сказати, що коли ви стикаєтесь з масивами, просто споживайте всі індекси так, ніби написані так:

char *(ar[10][10]);

Тепер, дотримуючись правила спіралі, я отримаю:

"ar - двовимірний масив вказівників 10x10 на char"

Я сподіваюся, що спіральне правило продовжує свою корисність у навчанні С!

PS:

Мені подобається образ "С не важко" :)

• порожнеча (*(*f[]) ()) ()

Розв’язання void>>

• (*(*f[]) ()) () = недійсна

Відновлення ()>>

• (* (*f[]) ()) = функція, що повертається (недійсна)

Розв’язання *>>

• (*f[]) () = вказівник на (функція, що повертається (недійсна))

Розв’язання ()>>

• (* f[]) = функція, що повертається (вказівник на (функція, що повертається (недійсна)))

Розв’язання *>>

• f[] = вказівник на (функція, що повертається (вказівник на (функція, що повертається (недійсна))))

Розв’язання [ ]>>

• f = масив (вказівник на (функція, що повертається (вказівник на (функція повернення (недійсна))))))