IdentifiantMot de passe
Loading...
Mot de passe oublié ?Je m'inscris ! (gratuit)
Navigation

Inscrivez-vous gratuitement
pour pouvoir participer, suivre les réponses en temps réel, voter pour les messages, poser vos propres questions et recevoir la newsletter

Affichage des résultats du sondage: Que pensez-vous de l'utilisation de Goto ?

Votants
50. Vous ne pouvez pas participer à ce sondage.
  • Goto c'est formidable, il faudrait l'utiliser plus souvent

    12 24,00%
  • Goto, c'est plus performant que les procédures, les fonctions ou la POO

    8 16,00%
  • On ne doit pas utiliser Goto parce que mon prof l'a dit

    12 24,00%
  • Utiliser Goto augmente le risque de bogues

    11 22,00%
  • Utiliser Goto rend le code illisible

    19 38,00%
  • On ne doit pas utiliser Goto pour préserver la beauté du code

    8 16,00%
  • Je refuse de voter pour ce sondage idiot

    12 24,00%
  • Autre avis (précisez)

    3 6,00%
  • Pas d'avis

    2 4,00%
Sondage à choix multiple
Langages de programmation Discussion :

Trolldi : GOTO est formidable, elle permet d'accélérer 2 à 3 fois la vitesse d'exécution du code


Sujet :

Langages de programmation

  1. #21
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par 23JFK Voir le message
    goto est l'équivalent assembleur de l'instruction JMP qui est l'une des commandes les plus utilisées dans un code exécutable. Par ailleurs, l'optimisation d'un code source par le compilateur repose largement sur l'ajout de JMP dans le code exécutable alors ce ne sont pas quelques goto pas trop mal placés dans le code source qui vont altérer la performance finale du code exécutable optimisé. Pour s'en convaincre, il suffit de désassembler un code exécutable issu d'une compilation optimisée à partir d'un fichier source qui n'utilise aucun goto pour constater que cela génère tout le temps du code spaghetti.
    Je ne comprends pas l'intérêt et la pertinence de ton message.

    Super les compilateurs transforment du codes haut niveau en bas niveau avec plein de gotos dedans. Donc faut en conclure que c'est tout bon pour utiliser des gotos en haut niveau !

    Les compilateurs transforment aussi les variables nommées en adresse brutes... je vais en faire autant cela ne doit pas être si mal.

    Et puis sortir des tautologies comme "quelques gotos pas trop mal placés" c'est bien parce que... bah ils sont pas trop mal placées alors évidemment qu'ils font de bonnes choses

    Alors je te répondrais que le danger c'est les gotos mal placés... je ne risque pas plus de me tromper.

  2. #22
    Inactif  

    Homme Profil pro
    Ingénieur test de performance
    Inscrit en
    Décembre 2003
    Messages
    1 986
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 49
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Ingénieur test de performance
    Secteur : High Tech - Éditeur de logiciels

    Informations forums :
    Inscription : Décembre 2003
    Messages : 1 986
    Points : 2 605
    Points
    2 605
    Par défaut
    Bonjour.

    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    if (shared) lock();
    if (data == INVALID) {
      log_error("blah %s:%i %s() -> %p\n", __FILE__, __LINE__ __FUNC__, data);
      return NULL;
    }
    // smallish body of code hunting through some nested tables using data
    if (shared) unlock();
    return realdata;
    Ce code est un troll. Si tu "lock" la ressource et retournes "NULL" avant le "unlock", c'est que tu n'étais pas réveillé ce jour là.

    Et puis le GOTO, c'est pour les développeurs qui se croient plus fort que le compilateur.

  3. #23
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 626
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 626
    Points : 10 542
    Points
    10 542
    Par défaut
    Citation Envoyé par ijk-ref Voir le message
    Je sais C'est une nouvelle fonctionnalité fort pratique... mais je continue à penser que l'avoir implémenter sous la forme d'un switch classique est un très très mauvais choix.
    Détrompe toi en cherchant sur les Internets, certains compilateurs replacent ton switch par une "jump table" (<- en gros ton switch est transformé en tableau et chaque case du tableau contient une adresse vers le bout de code du case)

    Après, ce n'est pas si simple et cela dépend du compilateur : il faut qu'il gère les trous, les cas dans le désordre, ...

  4. #24
    Membre confirmé Avatar de tpericard
    Homme Profil pro
    Ingénieur validation
    Inscrit en
    Octobre 2006
    Messages
    124
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Loire Atlantique (Pays de la Loire)

    Informations professionnelles :
    Activité : Ingénieur validation
    Secteur : High Tech - Produits et services télécom et Internet

    Informations forums :
    Inscription : Octobre 2006
    Messages : 124
    Points : 644
    Points
    644
    Par défaut
    Hello les gens,

    Ce qui compte surtout c'est l'usage du code écrit.
    - Si le temps d'exécution est vital, alors oui, toute optimisation est bonne à prendre,
    - Sinon, c'est la maintenabilité du code qui doit primer.

    Et dans ce dernier cas, faut bien avouer qu'un GOTO ou un ALTER TRAITEMENT (en cobol) ne sont pas vraiment faits pour rendre clairs un code ...
    Comme anecdote, et comme on parlait du Cobol, il existe en Cobol MicroFocus des instructions analogues à un GOTO du type EXIT PARAGRAPH ou EXIT SECTION qui pouvaient parfois rendre service mais rien qui ne soit pas remplaçable par une autre façon de programmer.

    En bref, le GOTO, GO TO HELL

  5. #25
    Expert confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2012
    Messages
    1 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2012
    Messages : 1 711
    Points : 4 442
    Points
    4 442
    Par défaut
    Citation Envoyé par CS FS Voir le message
    J’ai trois lourds secrets. Et le second c’est que j’ai déjà utilisé un goto en C#, une fois, UNE SEULE FOIS... sur le coup, j’ai même trouvé la solution élégante. Ça donnait un truc du style :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    switch (status)
    {
        case Status.Initialisation:
            db.Init();
            goto case Status.BlaBla;
        case Status.BlaBla:
            // Du code, du code, du code.
            break;
        case Status.BlaBla2:
            // Du code, du code, du code.
            break;
    }
    J'ai eu récemment le même problème.
    Je comprend pas vraiment cette limitation du C# sur les switch
    Code C# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    14
    15
    16
    17
    18
    19
    20
    21
    22
    23
    24
    25
    26
    27
    28
    29
    30
    31
    32
    33
    34
    35
    36
    37
    38
    39
    40
    int i;
     
    switch(i) {
    case 0:
    case 1:
       doSomethingWhen0Or1();
       break;
    default:
       doSomethingElse();
       break;
    }
    // OK
     
    switch(i) {
    case 0:
       doSomethingWhen0();
    case 1:
       doSomethingWhen0Or1();
       break;
    default:
       doSomethingElse();
       break;
    }
    // Erreur : break manquant
     
    switch(i) {
    case 0:
       doSomethingWhen0();
       doSomethingWhen0Or1();
       break;
    case 1:
       doSomethingWhen0Or1();
       break;
    default:
       doSomethingElse();
       break;
    }
    // OK
    // Ce qu'on est obligé de faire du coup (je trouve la répétition ici plus lisible qu'un goto,
    // mais l'idéal serait de ne pas forcer la présence du break).

    Lee problème du goto c'est qu'on s'attend à un jump, alors qu'ici il sert simplement à dire "fait marcher les switch comme en C / C++".

  6. #26
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par foetus Voir le message
    Détrompe toi en cherchant sur les Internets, certains compilateurs replacent ton switch par une "jump table" (<- en gros ton switch est transformé en tableau et chaque case du tableau contient une adresse vers le bout de code du case)
    Je sais cela en quoi je me trompe ?
    Citation Envoyé par Iradrille Voir le message
    J'ai eu récemment le même problème. Je comprend pas vraiment cette limitation du C# sur les switch (...)
    Lee problème du goto break c'est qu'on s'attend à un jump, alors qu'ici il sert simplement à dire "fait marcher les switch comme en C / C++".
    C'est bien une preuve que cette implémentation est absurde en C#

    Partout ailleurs un bloque de code se place entre accolades... et là avec ce foutu "switch" c'est entre deux points et un break


    "break" devrait être uniquement une instruction pour sortir d'une boucle.

  7. #27
    Membre habitué
    Profil pro
    Travail non informatique
    Inscrit en
    Décembre 2010
    Messages
    102
    Détails du profil
    Informations personnelles :
    Localisation : France, Val d'Oise (Île de France)

    Informations professionnelles :
    Activité : Travail non informatique

    Informations forums :
    Inscription : Décembre 2010
    Messages : 102
    Points : 179
    Points
    179
    Par défaut Comme le piment !
    J'ai appris à coder en BASIC.
    Le GOTO peut aider un peu, mais il ne faut pas en abuser.


    On peut simuler un GOTO, mais au prix d'une illisibilité abominable.
    PS : GOSUB est bien aussi, mais un peu seulement.

  8. #28
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 626
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 626
    Points : 10 542
    Points
    10 542
    Par défaut
    Citation Envoyé par ijk-ref Voir le message
    Je sais cela en quoi je me trompe ?
    Donc tu as plus un problème avec les switch du C#

    Parce que en C/ C++, les switch sont flexibles: omettre le break pour passez au cas suivant, bloc avec des accolades pour déclarer des variables.
    Le seul réel avantage des if else if c'est de pouvoir faire des intervalles.

    Sinon, même si je n'aime pas trop la syntaxe du switch, si le développeur fait attention et que le compilateur n'est pas trop bête, en théorie, ton switch est optimisé.

  9. #29
    Expert confirmé
    Inscrit en
    Avril 2008
    Messages
    2 564
    Détails du profil
    Informations personnelles :
    Âge : 64

    Informations forums :
    Inscription : Avril 2008
    Messages : 2 564
    Points : 4 438
    Points
    4 438
    Par défaut
    bonjour
    J'ai commencé à programmer avec Fortran et l'un des intérêts du GO TO est qu'il évitait de factoriser le code ,ce qui est le pensum du programmeur ...
    Car dans les langages modernes de haut niveau qui ont suivi leur vénérable ancêtre Fortran, le moindre écureuil de code vous fait accuser d' "erreur de conception" ,alors qu'en Fortran vous ajouter un caillou "GOTO" sur le chemin de code et votre travail est terminé...
    "Ah , ca ne marche pas chef ,on n' as pas prévu ce cas eh bien voilà :une variable globale avec COMMON et un petit GOTO bien placé suffisent "...
    Le fait même que ce vénérable GOTO ait précédé et pallier l'absence de tant de "boucles structurées et tutti quanti" ,doit attirer notre attention sur un autre fait remarquable :comment un simple GOTO peut-il remplacer autant d'instructions de structuration du code ...
    Et cela démontre ,à mon avis, que le GOTO est le rasoir d'Occam du code !!!

  10. #30
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par foetus Voir le message
    (...)Sinon, même si je n'aime pas trop la syntaxe du switch, si le développeur fait attention et que le compilateur n'est pas trop bête, en théorie, ton switch est optimisé.
    J'ai toujours uniquement parlé du choix de la syntaxe du switch en C#, jamais de l'optimisation par le compilateur qui à mon avis fait parfaitement son travail.

  11. #31
    Membre averti
    Homme Profil pro
    Ingénieur développement logiciels
    Inscrit en
    Novembre 2016
    Messages
    129
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Gironde (Aquitaine)

    Informations professionnelles :
    Activité : Ingénieur développement logiciels
    Secteur : Santé

    Informations forums :
    Inscription : Novembre 2016
    Messages : 129
    Points : 443
    Points
    443
    Par défaut
    Honnêtement, moi ça ne me choque pas ; les concepteurs du C# ont pris le parti de rajouter un garde-fou sur le switch en rendant le break obligatoire (sauf sur les cases vides bien évidemment), et de mon point de vu ça évite de se retrouver avec ce genre de cas de figure :
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    switch (operation)
    {
        case Operation.Addition:
            r = x + y;
        case Operation.Soustraction:
            r = x - y;
            break;
    }
    L’erreur est humaine et un break est vite oublié.

    Et si vraiment on veut outrepasser le comportement du switch (ce qui, normalement, ne devrait pas arriver souvent), il nous reste le vilain goto dont il est question ici =P (ou bien une refacto en bonnes et dues formes).

  12. #32
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par CS FS Voir le message
    Honnêtement, moi ça ne me choque pas ; les concepteurs du C# ont pris le parti de rajouter un garde-fou sur le switch en rendant le break obligatoire (sauf sur les cases vides bien évidemment)
    Encore une incompréhension (Je ne dois pas savoir m'exprimer ! )

    Ce garde fou est une très bonne chose et je n'ai jamais prétendu le contraire. Maintenant réfléchis trois secondes : C'est parfaitement équivalant à un block de codes alors pourquoi ne pas utiliser simplement l'écriture d'un block de codes !?


    Ca serait un milliard de fois plus propre d'écrire (par exemple)
    Code : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
     switch (test)
                {
                    case(0, 1)
                    {
                        int i = 8 + test;
                        Console.WriteLine("Oh la jolie variable locale claire : " + i);
                    }
                    case(2) Console.WriteLine("Là j'écris une seule instruction");
                    default Console.WriteLine("Là aussi");
                }

    Bah non avec l'écriture d'aujourd'hui tu te retrouves à écrire obligatoirement un "break" pour une seule instruction qui en plus te le rend inutilisable pour sortir d'une boucle et ne respecte pas les conventions d'écritures de portées - une variable locale se distingue partout en étant entre crochets... mais pas là. Là c'est entre ":" et "break" - cultivons la différence.

  13. #33
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 626
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 626
    Points : 10 542
    Points
    10 542
    Par défaut
    Citation Envoyé par ijk-ref Voir le message
    ....
    Je ne comprends pas tout surtout la partie variable locale entre crochets.

    Mais en C/ C++, le parti à été de pouvoir faire à la suite les cas. Donc il te faut un mot-clef pour dire "arrête ici".
    À partir de là, tu l'appliques partout même pour les cas à 1 seule instruction.

    C'est vrai l'intervalle manque (je l'ai dit). Surtout que ton switch ne s'applique que sur un type entier (les flottants ne passent pas il me semble )
    Est-ce pour simplifier la vie du compilateur? Est-ce pour éviter les cas qui se chevauchent? (par exemple, un cas de 1 à 7 et un autre de 5 à 9)


    Et il me semble que ton problème c'est que tu codes une boucle dans un cas avec un joli break
    Moi je n'utilise jamais le mot-clef break ailleurs que dans un switch et j'utilise un booléen à l'ancienne pour interrompre une boucle

  14. #34
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Citation Envoyé par foetus Voir le message
    Je ne comprends pas tout surtout la partie variable locale entre crochets.

    Mais en C/ C++, le parti à été de pouvoir faire à la suite les cas. Donc il te faut un mot-clef pour dire "arrête ici".
    À partir de là, tu l'appliques partout même pour les cas à 1 seule instruction.

    C'est vrai l'intervalle manque (je l'ai dit). Surtout que ton switch ne s'applique que sur un type entier (les flottants ne passent pas il me semble )
    Est-ce pour simplifier la vie du compilateur? Est-ce pour éviter les cas qui se chevauchent? (par exemple, un cas de 1 à 7 et un autre de 5 à 9)


    Et il me semble que ton problème c'est que tu codes une boucle dans un cas avec un joli break
    Moi je n'utilise jamais le mot-clef break ailleurs que dans un switch et j'utilise un booléen à l'ancienne pour interrompre une boucle
    As-tu réellement lu toutes mes réponses et celles des autres ?

    Car je penses avoir été assez clair que je ne parle absolument pas d'optimisations (bonnes ou mauvaises) pour le compilateur.

    L'exemple de code que je donne juste au dessus montre que ma syntaxe permettrait de faire TOUT ce que permet la syntaxe d'aujourd'hui. Oui TOUT comme la suite de cas et ça sans ce foutu "break" et non il n'y absolument pas besoin de "arrête ici".

    Si tu me crois pas donne moi plutôt un exemple de code C# que tu ne crois pas possible avec, ça sera plus rapide et clair que de se lancer dans un discours.

    Je ne comprends même pas ton problème de type. Où vois-tu que je me limiterais forcement qu'aux entiers !?

    Mon problème (mental) est juste d'avoir un code et langage C# le plus propre possible. Pour moi c'est comme s'ils avaient choisi de completer l'instruction "foreach" avec les mots "begin" et "end" ! Heureusement qu'ils ont choisi naturellement "{" et "}". C'est pourtant ce mauvais choix fait avec l'instruction "switch" où break" n'est qu'un vulgaire "end". Svp ne me ressors pas son historique et le pourquoi de ce (mauvais) choix je le connais.

  15. #35
    Expert confirmé
    Homme Profil pro
    Étudiant
    Inscrit en
    Juin 2012
    Messages
    1 711
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France

    Informations professionnelles :
    Activité : Étudiant

    Informations forums :
    Inscription : Juin 2012
    Messages : 1 711
    Points : 4 442
    Points
    4 442
    Par défaut
    Citation Envoyé par CS FS Voir le message
    Honnêtement, moi ça ne me choque pas ; les concepteurs du C# ont pris le parti de rajouter un garde-fou sur le switch en rendant le break obligatoire (sauf sur les cases vides bien évidemment), et de mon point de vu ça évite de se retrouver avec ce genre de cas de figure :
    [...]
    L’erreur est humaine et un break est vite oublié.

    Et si vraiment on veut outrepasser le comportement du switch (ce qui, normalement, ne devrait pas arriver souvent), il nous reste le vilain goto dont il est question ici =P (ou bien une refacto en bonnes et dues formes).
    Mais du coup ça rend le langage pas cohérent (niveau syntaxe) :
    Code C# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    int i;
    switch(i) {
       case 0: // pas de goto
       case 1:
          doSomething();
          goto case 2; // un goto ce coup-ci (bonne syntaxe ?)
       case 2:
          doSomethingElse();
          break;
       default:
          doSomethingElseV2();
    }

    Sinon, niveau refacto, ya une meilleure solution que des ifs imbriqués ?
    Code C# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    int i;
    if(i == 0 || i == 1 || i == 2) {
       if(i == 0 || i == 1) {
          doSomething();
       }
       doSomethingElse();
    }
    else {
       doSomethingElseV2();
    }
    (Qui est quand même moins lisible)

  16. #36
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Par contre ceci ne fonctionne pas :
    Code C# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    int i;
    switch(i) {
       case 0: // pas de goto
       case 1:
          int tmp = i + 3;
          doSomething(tmp);
          goto case 2; // un goto ce coup-ci (bonne syntaxe ?)
       case 2:
          doSomethingElse(tmp); // erreur : variable locale 'tmp' non assignée
          break;
       default:
          doSomethingElseV2();
    }
    Ce n'est pas une mauvaise chose en soit. Mais ça montre que ce genre d'écriture avec 'goto' est surtout du bricolage

    Sinon ton exemple avec des if :
    Code C# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    13
    int i;
    if(i<=2)
    {
       if(i != 2)
       {
          doSomething();
       }
        doSomethingElse();
    }
    else 
    {
       doSomethingElseV2();
    }

    Même si je n'en suis pas convaincu. Car j'imagine que le compilateur aura plus de mal à l'optimiser plutôt qu'avec le switch


    edit : en fait non j'en pense que ça reviens strictement au même.

    Si quelqu'un pouvait trouver un véritable exemple sur la pertinence de l'écriture avec 'goto case' que je change d'avis sur celui ci

  17. #37
    Expert éminent sénior
    Homme Profil pro
    Analyste/ Programmeur
    Inscrit en
    Juillet 2013
    Messages
    4 626
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Localisation : France, Bouches du Rhône (Provence Alpes Côte d'Azur)

    Informations professionnelles :
    Activité : Analyste/ Programmeur

    Informations forums :
    Inscription : Juillet 2013
    Messages : 4 626
    Points : 10 542
    Points
    10 542
    Par défaut
    Pour votre gouverne, officiellement en fin d'instruction on peut mettre break, goto case, return ou throw.

    switch (Référence C#)

    Et en plus, le switch C# prend des chaînes littérales (en plus des entiers/ énumérations)

    Donc, même s'il y a cette contrainte obligatoire d'avoir 1 instruction en fin de cas, je le trouve plus flexible que celui du C++

    Quoique, il me semble qu'en C++, on peut faire un test dans un cas pour faire un break (<- avant la fin du cas). Peut-être un truc à vérifier en C++ et en C#

  18. #38
    Membre éclairé
    Profil pro
    Inscrit en
    Avril 2008
    Messages
    467
    Détails du profil
    Informations personnelles :
    Localisation : France

    Informations forums :
    Inscription : Avril 2008
    Messages : 467
    Points : 681
    Points
    681
    Par défaut
    Merci fœtus, il est vrai que "ma syntaxe" rend impossible le traitement des "goto case". Je le trouve tellement peu "orthodoxe".


    Va valoir que j'essaie avec le dernier C# s'il permet d'écrire "goto case Rectangle s when (s.Length == s.Height)"


    En fait je change d'avis maintenant je comprends parfaitement l'utilisation du mot "break" puisqu'on peut faire des boucles dans un "switch"
    Code C# : Sélectionner tout - Visualiser dans une fenêtre à part
    1
    2
    3
    4
    5
    6
    switch (t)
    {
      default:
        doSomething();
        goto default;
    }
    Et ça c'est le moins tordu des cas

  19. #39
    Invité
    Invité(e)
    Par défaut
    Ah mes vieux codes sur TI-83, des GOTO partout

  20. #40
    Membre actif
    Homme Profil pro
    Développeur informatique
    Inscrit en
    Juillet 2014
    Messages
    125
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 73
    Localisation : France, Aisne (Picardie)

    Informations professionnelles :
    Activité : Développeur informatique
    Secteur : Santé

    Informations forums :
    Inscription : Juillet 2014
    Messages : 125
    Points : 230
    Points
    230
    Par défaut goto n'est pas noir goto n'est pas blanc
    j'utilise goto exceptionnellement, dans une sub et le code est lisible si l'étiquette est dans la même sub c'est rapide et concis, avec les microcontrôleurs c'est important
    mais je le déconseille à mes élèves du fablab.
    jp

Discussions similaires

  1. Réponses: 6
    Dernier message: 26/09/2008, 11h04
  2. Réponses: 3
    Dernier message: 04/03/2007, 10h34
  3. Une liste déroulante est-elle toujours en 1er plan ?
    Par Marc365 dans le forum Balisage (X)HTML et validation W3C
    Réponses: 5
    Dernier message: 01/05/2006, 21h16
  4. Réponses: 4
    Dernier message: 04/10/2005, 15h37

Partager

Partager
  • Envoyer la discussion sur Viadeo
  • Envoyer la discussion sur Twitter
  • Envoyer la discussion sur Google
  • Envoyer la discussion sur Facebook
  • Envoyer la discussion sur Digg
  • Envoyer la discussion sur Delicious
  • Envoyer la discussion sur MySpace
  • Envoyer la discussion sur Yahoo