Journal Toujours plus de fun avec C

Posté par  (site Web personnel) . Licence CC By‑SA.
Étiquettes :
9
27
mar.
2020

Demat' iNal,

En regardant cette vidéo: https://www.youtube.com/watch?v=lkgszkPnV8g, j'ai découvert une de ces petites perles qui viennent rompre la monotonie d'un quotidien où l'on dérive constamment.

int(riguant);

Ce code C compile. C'est d'ailleurs aussi un code C++, qui compile également.

Mais pourquoi donc ?

  • # Pourquoi pas?

    Posté par  (site Web personnel) . Évalué à 10.

    C'est une déclaration de variable, comme int riguant.

    Je dirais que la partie gauche accepte les parenthèses pour permettre de grouper les choses, comme par exemple entre int *(foo[]) versus int (*foo)[]).

    En C (et C++), on peut voir la déclaration de type comme deux parties. La gauche, le type primitif, et la droite, comme "une expression qui permet d’accéder à ce type".

    Par exemple, int *p; signifie que *p permet d’accéder à un int. Donc p est un pointeur.

    En partant de là, si les parenthèses sont autorisées, pas de raison de les interdire dans le cas ou l'expression se réduit à un nom.

    • [^] # Re: Pourquoi pas?

      Posté par  . Évalué à 1. Dernière modification le 27/03/20 à 20:05.

      J'ai cru à une erreur au début, mais non, c'est bien une déclaration.
      Par contre, sans être Grand Gourou C/C++, j'ai tout de même découvert récemment une nouvelle forme de casting, et c'est ça qui m'a fait douter. Ça se passe comme ceci :

      int main(int argc, char *argv[])
      {
          int(riguant);
          double riguantriguant;
      
          riguant = 1;
          riguantriguant = double(riguant);
          riguantriguant /= 2;
      
          printf("       riguant : %d\n", riguant);
          printf("riguantriguant : %g\n", riguantriguant);
      
          return 0;
      }

      Avec comme résultat :

             riguant : 1
      riguantriguant : 0.5
      
  • # C du plaisir

    Posté par  . Évalué à 4.

    C'est toujours marrant de voir les choses qu'on connait écrites (ou présentées) un peu différemment. Celui que je n'avais pas compris la première que je l'ai vu c'est :

    a = b+++++c;

    • [^] # Re: C du plaisir

      Posté par  . Évalué à 2.

      J'ai l'impression que ca ne compile pas sur https://www.onlinegdb.com/online_c_compiler ? :)

      • [^] # Re: C du plaisir

        Posté par  . Évalué à 2.

        a = b++ + ++c; ou a = (b++)+(++c); devrait marcher.

        Si on attache tout, le lexer voit deux opérateurs ++ suivit d'un +.

    • [^] # Re: C du plaisir

      Posté par  . Évalué à 1.

      Comme il y a plusieurs manières d'accéder à un élément d'un tableau : pour int *t : t[5], 5[t] et *(t+5) désigne le même élément.

      Ca me fait penser à l'entrée de Korn pour l'IOCCC de 1987 :

      main() { printf(&unix["\021%six\012\0"],(unix)["have"]+"fun"-0x60);}

    • [^] # Re: C du plaisir

      Posté par  (site Web personnel) . Évalué à 4.

      Un autre que j'aime bien c'est l'opérateur flèche :
      if (c = a --> b) {

      }

  • # Bien sûr

    Posté par  . Évalué à 3. Dernière modification le 28/03/20 à 04:48.

    Bien sûr que ça compile. C est le Langage de Programmation de Dieu.

  • # C++ is hard

    Posté par  (site Web personnel) . Évalué à 2.

    En regardant cette vidéo: https://www.youtube.com/watch?v=lkgszkPnV8g (…)

    "Conclusion : C++ is hard" :-)

    Bon, aussi :

    • Tools are our best teaching weapons.
    • Invest in a good, extendable linter (e.g. clang-tidy)
    • ASAN is life.

Suivre le flux des commentaires

Note : les commentaires appartiennent à ceux qui les ont postés. Nous n’en sommes pas responsables.