Utilisez le “plus grand ou égal à” ou tout simplement “plus grand que”
Je me souviens de C jours que nous avons été encouragés à utiliser
i > -1
au lieu de
i >= 0
en raison de la performance.
Ceci est-il toujours s'appliquer dans le C# .NET monde? Quelles sont les implications sur les performances de l'utilisation de l'un sur l'autre avec les compilateurs? c'Est à dire le compilateur assez intelligent pour optimiser ces pour vous?
(En aparté essayer et le type de la question de "l'utilisation >= ou >" dans le champ de question sur un Débordement de Pile et de voir ce qui se passe.)
OriginalL'auteur Guy | 2008-10-23
Vous devez vous connecter pour publier un commentaire.
Non, il n'y a pas de problèmes de performances associés à des opérateurs de comparaison. Et de toute bonne compilateur d'optimiser quelque chose d'aussi trivial de toute façon.
Je ne suis pas sûr de l'endroit où vous avez obtenu la suggestion d'utiliser "i > -1" plutôt que de "i >= 0". Sur l'architecture x86, il ne fait aucune différence que vous utilisez: les deux cas, prend exactement deux instructions... un pour les comparer, et une pour le saut:
Sur la plupart des architectures RISC que je sais, "i >= 0" pourrait en fait être plus rapide car il y a habituellement dédiée mettre à zéro le registre, et "i > -1" peut exiger que le chargement d'une constante. Par exemple, MIPS ne dispose que d'un < instruction (n <=). Voici comment les deux constructions (naïvement!) exprimée en MIPS langage d'assemblage:
Ainsi, dans le naïf, le cas général, il sera effectivement une instruction plus rapide pour faire de "i >= 0" sur MIPS. Bien sûr, RISC code est donc largement optimisable qu'un compilateur serait susceptible de modifier l'une de ces instructions de séquences presque au-delà de la reconnaissance 🙂
Donc... la réponse courte est non non non, pas de différence.
(no no no, no difference) = !(!(!(!difference))) = !(!difference)) = difference
😉difficile d'argumenter avec qui. Maintenant, je suis un peu tenté d'ajouter un 5ème "non" 😛
OriginalL'auteur Dan Lenski
Tout à fait en dehors du fait que tout bon compilateur fait la bonne chose, et à part le fait que dans les architectures modernes il n'y a pas de différence de vitesse entre
>
et>=
de comparaison, l'image plus grande dit que c'est une "micro-optimisation" qui n'affecte pas les performances d'exécution dans la grande majorité des cas.Dans le cas de la comparaison, on n'a généralement pas d'incidence sur la lisibilité selon la manière dont vous l'écrivez, mais il y a des occasions lors de la sélection d'une limite sur l'autre est plus clair: par exemple,
contre
Je ne sais pas pour vous, mais je choisirais l'option 1, tous les jours. 🙂 Dans les cas qui ne sont pas sensiblement affecter la performance, telle que, le plus lisible option devrait gagner.
Notez que si str.size() renvoie un entier non signé de la quantité, les deux instructions ci-dessus ne sont pas équivalentes. En particulier, le dernier énoncé ne jamais évaluer la valeur true si str.size() est égale à zéro. J'ai parfois fait usage de ce code, si j'ajoute généralement un transtypage explicite non signé: si les tailles sont "court", "si (longueur > (unsigned short)(str.taille-1))" qui permettrait de le rendre clair que le code attendez le comportement d'habillage.
OriginalL'auteur Chris Jester-Young
Il y a une question très semblable (pas une critique implicite - comme vous le dites, à la recherche de symboles est délicat) ici: "Doit-on utiliser
<
ou<=
dans une boucle for"(Oui, il m'arrive d'être en mesure de trouver facilement, comme j'ai beaucoup de upvotes sur ma réponse...)
Fondamentalement, faire tout ce qui est plus lisible. Le jour où quelqu'un correctement devine que de faire un changement à l'écart de la plupart de forme lisible à la va résoudre un problème de performances (sans l'aide d'un profileur) est le jour où j'arrête de parler de performance 🙂
OriginalL'auteur Jon Skeet
Non, vous n'avez pas besoin de faire cela une fois de plus. Oui les compilateurs sont devenus beaucoup plus intelligents et les deux expressions ont pas de différences de performances.
Sonne comme une programmation légende urbaine
OriginalL'auteur Epaga
Êtes-vous sûr à ce sujet? J'ai travaillé avec des ordinateurs remontant au début des années '70 (oui, mon père genou...), et je n'ai jamais vu un CPU qui n'a pas pu traiter >= tout aussi rapide que l' >. (BH Branche "Haute" par rapport à la BNL "Branche Pas Faible" dans IBM360 parler).
Je pense que c'est un mythe commun. Je l'ai entendu de la part de collègues et vu sur internet quelques fois même dans les dernières années. Même sans le compilateur optimisant l'écart de la différence, qui est un énorme gaspillage d'efforts pour sauver un cpu d'instruction.
Comme tu le dis - c'était probablement quelque chose que j'ai été mal informé à propos de - grâce.
OriginalL'auteur James Curran
Que peut-être vrai pour certains ombragé langages de script qui décomposent a >= 2 comparaisons, mais celui qui vous a poussé à utiliser que pour des C... eh bien... vous devriez probablement essayer difficile d'oublier tout ce qu'ils ont déjà dit.
OriginalL'auteur Gerald
Cela me rappelle la recommandation d'utiliser ++i au lieu de i++ (pré-incrémentation vs post-incrémentation) parce que c'était soi-disant une instruction plus rapide. (J'ai oublié où je l'ai d'abord lu à ce sujet, mais c'était probablement le C/C++ Journal d'Utilisateurs ou Dr Dobb's Journal, mais je n'arrive pas à trouver une référence web.)
Je doute sérieusement que > ou >= est plus rapide ou plus lente; au lieu d'écrire du code pour plus de clarté.
Comme une note de côté, j'ai développé une préférence pour la pré-incrémentation (++i) de l'opérateur, même si la raison est potentiellement obsolètes.
OriginalL'auteur Ryan
Pour plus de zéro, il doit faire deux chèques. Il vérifie si le négatif est peu large et il vérifie si le bit zéro est éteint.
Pour supérieur ou égal à zéro, il n'a qu'à vérifier si le négatif est peu, car nous n'avons pas de soins si le bit zéro est activé ou désactivé.
OriginalL'auteur Scott Renz