L'équivalence
a[i] === *(a+i) === i[a] est la base du C, existe donc depuis le début.
Il existe un petit écart en C++, le résultat de
a[i] est une x-value au lieu d'une l-value si l'expression
a n'est pas une l-value, donc
a[i] n'est pas totalement équivalent à
i[a].
Ce qui change c'est que désormais l'ordre d'exécution est garanti, du moins depuis le C++17, je ne sais pas pour le C.
Donc pour
fct1()[ fct2() ], on sait quelle fonction est appelée en premier, c'est
fct1(). Mais par exemple pour
fct1() = fct2();, on commence par
fct2(). Ça me parait complexe de se souvenir de ça!
De plus, cette "astuce" me parait doublement contreproductive en C++, pour 2 raisons:
- on ne devrait pas utiliser l'arithmétique des pointeurs en C++. Il est préférable d'utiliser les objets faits pour cela.
- si on veut une chronologie précise. Il est bien plus lisible et sûr de décomposer l'expression:
1
2
3
| auto&& x = fct1();
auto&& y = fct2(); // ou dans l'ordre inverse
auto z = x[ y ]; |
Les analyseurs de code doivent systématiquement tagger une ligne
auto z = fct(1)[ fct2() ] comme étant dangereuse.
3 |
0 |
Envoyé par jmv
?
Qu'en pensez-vous ?
?