Perché la sintassi C per array, puntatori e funzioni è stata progettata in questo modo?

Dopo aver visto (e posto!) Tante domande simili a

Cosa int (*f)(int (*a)[5])significa in C?

e anche visto che avevano creato un programma per aiutare le persone a capire la sintassi C, non posso fare a meno di chiedermi:

Perché la sintassi di C è stata progettata in questo modo?

Ad esempio, se stavo progettando puntatori, tradurrei "un puntatore a un array di puntatori a 10 elementi" in

int*[10]* p;

e non

int* (*p)[10];

che penso che la maggior parte delle persone concorderebbe è molto meno semplice.

Quindi mi chiedo, perché la sintassi non intuitiva? C'è stato un problema specifico che la sintassi risolve (forse un'ambiguità?) Di cui non sono a conoscenza?

La mia comprensione della storia è che si basa su due punti principali ...

In primo luogo, gli autori del linguaggio hanno preferito rendere la sintassi incentrata sulla variabile piuttosto che sul tipo. Cioè, volevano che un programmatore guardasse la dichiarazione e pensasse "se scrivo l'espressione *func(arg), ciò si tradurrà in un int; se scrivo *arg[N]avrò un float" piuttosto che " funcdeve essere un puntatore a una funzione che prende questo e restituendo quella ".

La voce C su Wikipedia afferma che:

L'idea di Ritchie era di dichiarare gli identificatori in contesti simili al loro uso: "la dichiarazione riflette l'uso".

... citando p122 di K & R2 che, purtroppo, non ho bisogno di trovare la citazione estesa per te.

In secondo luogo, è davvero molto difficile trovare una sintassi per la dichiarazione che sia coerente quando si ha a che fare con livelli arbitrari di indiretta. Il tuo esempio potrebbe funzionare bene per esprimere il tipo che hai pensato fuori di testa lì, ma si adatta a una funzione che prende un puntatore a una matrice di quei tipi e restituisce qualche altro casino orribile? (Forse lo fa, ma hai controllato? Puoi provarlo? ).

Ricorda, parte del successo di C è dovuto al fatto che i compilatori sono stati scritti per molte piattaforme diverse, e quindi sarebbe stato meglio ignorare un certo grado di leggibilità per rendere i compilatori più facili da scrivere.

Detto questo, non sono un esperto di grammatica o scrittura di compilatori. Ma so abbastanza per sapere che c'è molto da sapere;)

Molte delle stranezze del linguaggio C possono essere spiegate dal modo in cui i computer funzionavano quando è stato progettato. C'erano quantità molto limitate di memoria di archiviazione, quindi era molto importante ridurre al minimo le dimensioni dei file di codice sorgente stessi. La pratica di programmazione negli anni '70 e '80 era quella di assicurarsi che il codice sorgente contenesse il minor numero possibile di caratteri e preferibilmente nessun commento eccessivo sul codice sorgente.

Questo è ovviamente ridicolo oggi, con spazio di archiviazione praticamente illimitato su hard disk. Ma fa parte del motivo per cui C ha una sintassi così strana in generale.

Per quanto riguarda specificamente i puntatori di array, il tuo secondo esempio dovrebbe essere int (*p)[10];(sì, la sintassi è molto confusa). Potrei forse leggerlo come "puntatore int a array di dieci" ... il che ha un po 'senso. Se non fosse per la parentesi, il compilatore lo interpreterebbe come una matrice di dieci puntatori, il che darebbe alla dichiarazione un significato completamente diverso.

Poiché i puntatori a matrice e i puntatori a funzione hanno entrambi una sintassi abbastanza oscura in C, la cosa sensata da fare è di eliminare la stranezza. Forse così:

Esempio oscuro:

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);
}

Esempio non oscuro, equivalente:

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);
}

Le cose possono diventare ancora più oscure se si ha a che fare con array di puntatori a funzioni. O il più oscuro di tutti: funzioni che restituiscono puntatori a funzioni (leggermente utili). Se non usi typedef per tali cose, diventerai rapidamente pazzo.

È piuttosto semplice: int *psignifica che *pè un int; int a[5]significa che a[i]è un int.

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

Significa che *fè una funzione, *aè un array di cinque numeri interi, quindi fè una funzione che prende un puntatore a un array di cinque numeri interi e restituisce int. Tuttavia, in C non è utile passare un puntatore a un array.

Le dichiarazioni C raramente lo complicano.

Inoltre, puoi chiarire usando typedefs:

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

Penso che devi considerare * [] come operatori collegati a una variabile. * è scritto prima di una variabile, [] dopo.

Leggiamo l'espressione del tipo

int* (*p)[10];

L'elemento più interno è p, una variabile, quindi

p

significa: p è una variabile.

Prima della variabile c'è un *, l'operatore * viene sempre messo prima dell'espressione a cui fa riferimento, quindi,

(*p)

significa: la variabile p è un puntatore. Senza () l'operatore [] a destra avrebbe una precedenza più alta, vale a dire

**p[]

sarebbe analizzato come

*(*(p[]))

Il prossimo passo è []: poiché non esiste ulteriore (), [] ha quindi una precedenza maggiore rispetto a quella esterna *, quindi

(*p)[]

significa: (la variabile p è un puntatore) a un array. Quindi abbiamo il secondo *:

* (*p)[]

significa: ((la variabile p è un puntatore) a un array) di puntatori

Finalmente hai l'operatore int (un nome di tipo), che ha la precedenza più bassa:

int* (*p)[]

significa: (((la variabile p è un puntatore) a un array) di puntatori) a numero intero.

Quindi l'intero sistema si basa su espressioni di tipo con operatori e ogni operatore ha le proprie regole di precedenza. Ciò consente di definire tipi molto complessi.

Non è così difficile quando inizi a pensare e C non è mai stato un linguaggio molto semplice. E int*[10]* pdavvero non è più facile di int* (*p)[10] E in che tipo di k sarebbeint*[10]* p, k;