qui est meilleur “pour (int i = 0; i! = 5; ++ i)” ou “pour (int i = 0; i <= 5; i ++)”?

qui est meilleur for(int i = 0; i != 5; ++i) ou for(int i = 0; i <= 5; i++) ?

S’il vous plaît expliquer la raison, si possible.

J’ai lu quelque part que! = Opérateur est meilleur que les opérateurs de comparaison. De plus, l’opérateur de pré-incrémentation est préférable à l’opérateur de post-incrémentation, car aucune variable temporaire n’est requirejse pour stocker la valeur intermédiaire.

Existe-t-il une meilleure forme de boucle que ces deux-là?

ps: J’utilise l’ancien, comme suggéré par l’une des sources, dont je ne me souviens plus maintenant.

Il y a au moins deux différences:

  • le premier itérera 5 fois (de 0 à 4), tandis que le second itérera 6 fois (de 0 à 5).

    C’est une différence logique, et cela dépend de ce que vous devez faire.

    Si ce que vous vouliez dire dans le deuxième exemple était i<=4 (par rapport à i!=5 ), ne vous inquiétez pas: tout compilateur sera toujours en mesure d'optimiser une expression aussi sortingviale, même si les optimisations sont désactivées.

  • la deuxième différence est l'utilisation de l'opérateur ++ : dans un cas, vous utilisez la version préfixe, alors que dans l'autre, la version postfixée.

    Cela ne fait pas de différence pour les types natifs, mais pourrait faire la différence avec les types définis par l'utilisateur (classes, structs, enums, ...), car l'utilisateur pourrait surcharger l'opérateur, et l'opérateur postfixé ( var ++ ) pourrait être un peu plus lent parfois.

Utiliser “i <5" serait la forme que la plupart des gens s’attendraient à voir dans une boucle for basée sur un usage courant. Bien sûr, il n’ya rien de mal avec "i! = 5" ou "i <= 5" (attendez-vous à ce que le nombre de boucles soit différent), mais si je vois l’une de ces formes, je dois arrêter et réfléchir car ce n’est pas le plus courant. forme.

Donc j’écrivais toujours “i <5" à moins qu'il y ait une raison forte de faire autrement

Généralement, vous devriez écrire pour les gens et non pour l’ordinateur.

La forme “pour (i = 0; i <5; i ++)" indique très clairement que la plage valide est "0 à 4" et rien d'autre.

Et comme d’autres personnes l’ont dit, cette forme permet de s’assurer que le code amusant dans la boucle est beaucoup moins susceptible de provoquer une boucle infinie. Et comme d’autres personnes l’ont dit, utilisez le formulaire qui correspond à ce que vous voulez dire.

Notez que “inférieur à” est l’idiome couramment utilisé dans c (ce qui signifie que plus de programmeurs s’attendront à cela). C’est une autre raison de préférer la forme “pour (i = 0; i <5; i ++)".

Mon professeur de langage C ++ m’a dit d’utiliser les formes canoniques: for(int x=0; x != 5; ++i)

L’autre fonctionne très bien, mais supposons que vous souhaitiez utiliser la boucle sur un iterator. Alors <= ne doit pas être correctement défini et postfix inc pourrait faire passer votre programme beaucoup de temps à copier des objets.

Alors il nous a fait utiliser les formulaires

for(int i=begin; x != end; ++i) et for(int i=begin; end != i--; )

qui est meilleur pour (int i = 0; i! = 5; ++ i) ou pour (int i = 0; i <= 5; i ++)?

le 2e depuis son opérateur Bolian, alors ceci pour (int i = _ ; i <= __ ou etc; i ++ incrément)? -> il est largement utilisé comme maintenant, même quand on est débutant en programmation.

Vous devez utiliser le symbole < , <= != Etc. qui exprime le mieux la logique de votre application, mais s'il n'y a aucune raison de préférer un style particulier, soyez cohérent. En informant cette décision, les opérateurs < et != Ont l'avantage de permettre des comparaisons entre les index basés sur 0 et les valeurs size / length style STL, comme dans:

 for (size_t i = 0; i < my_vector.size(); ++i) ... 

Les opérateurs < et <= veillent parfois à ne pas dépasser la valeur finale (si vous avez une autre condition dans la boucle dans laquelle vous incrémentez / ajoutez-à i , ou s'il existe une disparité d'arrondi / de représentation à virgule flottante). Pas souvent réellement significatif, mais enregistrer un bug occasionnel vaut mieux que rien.

Étant donné que < communique également les états dans lesquels la boucle s'exécute ... une affirmation plus positive que le style != . En général, les assertions négatives sont découragées dans la programmation (par exemple, bool invalid est plus compliqué à comprendre que bool valid , en particulier dans les expressions booléennes complexes et lorsque des doubles négations sont introduites).

Ceci est bien sûr pour les types numériques. D'autres types peuvent impliquer d'autres styles ... par exemple, l'utilisation de != sentinel . Je préfère avoir le choix de l'aide de l'opérateur pour documenter ces implications d'utilisation du type, bien que ce soit un choix personnel et sans doute redondant.

Sinon, la préincrémentation peut être plus efficace pour les types compliqués que la post-instruction, car elle évite une perte temporaire.