Opérateur flèche vs opérateur point
Il me semble que l'opérateur de flèche de C (->) n'est pas nécessaire. L'opérateur point (.) Devrait être suffisant. Prenez le code suivant:
typedef struct {
int member;
} my_type;
my_type foo;
my_type * bar;
int val;
val = foo.member;
val = bar->member;
On voit que l'opérateur flèche doit être utilisé pour déréférencer la barre. Cependant, je préférerais écrire
val = bar.member;
Il n'y a aucune ambiguïté quant à savoir si j'essaye d'extraire "membre" d'une structure ou d'un pointeur vers la structure. Mais il est facile d'utiliser le mauvais opérateur, en particulier lors de la refactorisation du code. (Par exemple, je fais peut-être des opérations complexes sur foo, donc je déplace le code dans une nouvelle fonction et je passe un pointeur sur foo). Je ne pense pas avoir besoin de me soucier de savoir si foo est un pointeur ou non; le compilateur peut se soucier des détails.
Donc la question: ne serait-il pas plus simple d'éliminer -> du langage C?
L'opérateur "flèche" est le sucre syntaxique. bar->member est le même que (*bar).member. Une des raisons de la différence est la maintenabilité. L'opérateur flèche étant distinct de l'opérateur point, il devient beaucoup plus facile de savoir quelles variables sont des pointeurs et lesquelles ne le sont pas. Il peut être possible de toujours utiliser . et demander au compilateur d'essayer de faire la bonne chose, mais je doute que cela rendrait le langage plus simple. Faire confiance au compilateur pour interpréter ce que vous signifiait au lieu de ce que vous littéralement écrit se révèle généralement mal.
Non, il serait pas plus facile à éliminer -> à partir de la langue, pour la simple raison que des mégatonnes de code devraient être réécrites si c'était le cas. Cependant on pourrait définir que p.x est équivalent à p->x si p est un pointeur. Ce serait une modification rétrocompatible car ce code est actuellement illégal.