Pourquoi la syntaxe C des tableaux, des pointeurs et des fonctions a-t-elle été conçue de cette façon?

Après avoir vu (et posé!) Tant de questions similaires à

Que int (*f)(int (*a)[5])signifie en C?

et même en voyant qu'ils avaient fait un programme pour aider les gens à comprendre la syntaxe C, je ne peux m'empêcher de me demander:

Pourquoi la syntaxe de C a-t-elle été conçue de cette façon?

Par exemple, si je concevais des pointeurs, je traduirais "un pointeur vers un tableau de 10 éléments de pointeurs" en

int*[10]* p;

et non

int* (*p)[10];

ce que je pense que la plupart des gens seraient d'accord est beaucoup moins simple.

Je me demande donc pourquoi la, euh, syntaxe non intuitive? Y a-t-il un problème spécifique résolu par la syntaxe (peut-être une ambiguïté?) Que je ne connais pas?

Ma compréhension de l'histoire de celui-ci est basée sur deux points principaux ...

Premièrement, les auteurs du langage ont préféré rendre la syntaxe centrée sur les variables plutôt que centrée sur le type. Autrement dit, ils voulaient qu'un programmeur regarde la déclaration et pense "si j'écris l'expression *func(arg), cela se traduira par un int; si j'écris, *arg[N]j'aurai un flotteur" plutôt que " funcdoit être un pointeur vers une fonction prenant ceci et le retour que ».

L' entrée C sur Wikipedia affirme que:

L'idée de Ritchie était de déclarer les identifiants dans des contextes ressemblant à leur utilisation: "la déclaration reflète l'utilisation".

... citant la p122 de K & R2 que, hélas, je n'ai pas besoin de trouver pour vous trouver le devis étendu.

Deuxièmement, il est vraiment très difficile de trouver une syntaxe de déclaration cohérente lorsque vous avez affaire à des niveaux d'indirection arbitraires. Votre exemple pourrait bien fonctionner pour exprimer le type que vous avez pensé au départ, mais est-il adapté à une fonction prenant un pointeur vers un tableau de ces types et renvoyant un autre désordre hideux? (Peut-être que oui, mais avez-vous vérifié? Pouvez-vous le prouver? ).

Rappelez-vous, une partie du succès de C est due au fait que les compilateurs ont été écrits pour de nombreuses plates-formes différentes, et il aurait donc été préférable d'ignorer un certain degré de lisibilité pour faciliter l'écriture des compilateurs.

Cela dit, je ne suis pas un expert en grammaire linguistique ou en écriture de compilateur. Mais j'en sais assez pour savoir qu'il y a beaucoup à savoir;)

Beaucoup de bizarreries du langage C s'expliquent par le fonctionnement des ordinateurs lors de sa conception. Il y avait des quantités très limitées de mémoire de stockage, il était donc très important de minimiser la taille des fichiers de code source eux-mêmes. La pratique de la programmation dans les années 70 et 80 consistait à s'assurer que le code source contenait le moins de caractères possible, et de préférence aucun commentaire excessif sur le code source.

C'est bien sûr ridicule aujourd'hui, avec un espace de stockage pratiquement illimité sur les disques durs. Mais cela fait partie de la raison pour laquelle C a une syntaxe si étrange en général.

En ce qui concerne spécifiquement les pointeurs de tableau, votre deuxième exemple devrait être int (*p)[10];(ouais la syntaxe est très déroutante). Je pourrais peut-être lire cela comme "un pointeur int sur un tableau de dix" ... ce qui est quelque peu logique. Sinon pour la parenthèse, le compilateur l'interpréterait comme un tableau de dix pointeurs à la place, ce qui donnerait à la déclaration une signification entièrement différente.

Étant donné que les pointeurs de tableau et les pointeurs de fonction ont tous deux une syntaxe assez obscure en C, la chose raisonnable à faire est de taper la bizarrerie. Peut-être comme ça:

Exemple obscur:

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

Exemple équivalent non obscur:

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

Les choses peuvent devenir encore plus obscures si vous avez affaire à des tableaux de pointeurs de fonction. Ou le plus obscur d'entre eux: des fonctions renvoyant des pointeurs de fonction (légèrement utiles). Si vous n'utilisez pas de typedefs pour de telles choses, vous deviendrez rapidement fou.

C'est assez simple: int *psignifie que *pc'est un int; int a[5]signifie que a[i]c'est un int.

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

Signifie que *fc'est une fonction, *aest un tableau de cinq entiers, tout fcomme une fonction prenant un pointeur sur un tableau de cinq entiers, et retournant int. Cependant, en C, il n'est pas utile de passer un pointeur sur un tableau.

Les déclarations C se compliquent très rarement.

En outre, vous pouvez clarifier l'utilisation de typedefs:

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

Je pense que vous devez considérer * [] comme des opérateurs attachés à une variable. * est écrit avant une variable, [] après.

Lisons l'expression de type

int* (*p)[10];

L'élément le plus intérieur est p, une variable, donc

p

signifie: p est une variable.

Avant la variable, il y a un *, l'opérateur * est toujours placé avant l'expression à laquelle il fait référence, par conséquent,

(*p)

signifie: la variable p est un pointeur. Sans (), l'opérateur [] à droite aurait une priorité plus élevée, c'est-à-dire

**p[]

serait analysé comme

*(*(p[]))

L'étape suivante est []: puisqu'il n'y a pas d'autre (), [] a une priorité plus élevée que l'extérieur *, donc

(*p)[]

signifie: (la variable p est un pointeur) vers un tableau. Ensuite, nous avons le deuxième *:

* (*p)[]

signifie: ((la variable p est un pointeur) vers un tableau) de pointeurs

Enfin, vous avez l'opérateur int (un nom de type), qui a la priorité la plus faible:

int* (*p)[]

signifie: (((la variable p est un pointeur) vers un tableau) de pointeurs) en entier.

Ainsi, l'ensemble du système est basé sur des expressions de type avec des opérateurs, et chaque opérateur a ses propres règles de priorité. Cela permet de définir des types très complexes.

Ce n'est pas si difficile quand vous commencez à penser et C n'a jamais été un langage très facile. Et int*[10]* pce n'est vraiment pas plus facile que int* (*p)[10] Et quel type de k seraitint*[10]* p, k;