Question Pourquoi les programmeurs c ++ utilisent-ils! = Au lieu de <


Dans c ++ primer, page 95, l'auteur dit que les programmeurs c ++ ont tendance à utiliser! = De préférence à <lors de l'écriture de boucles.

for (vector<int>::size_type i = 0; i != 10; ++i) is preferred instead of 
for (vector<int>::size_type i = 0; i < 10; ++i) 

Je lis la même chose en c ++ accéléré. Quelqu'un peut-il expliquer la raison d'être de cette


25
2017-12-25 19:42


origine


Réponses:


Lorsque vous utilisez certains types d'itérateurs STL (ceux qui ne sont pas à accès aléatoire), vous doit utilisation !=:

for (map<int,int>::iterator i = a.begin(); i != a.end(); ++i) ...

Cependant, je ne vois aucune raison de préférer != pour les types scalaires bien ordonnés comme dans votre exemple. Je préférerais généralement < pour les types scalaires et != pour tous les types d'itérateurs.


42
2017-12-25 19:44



C'est une habitude pour la programmation générique; par exemple, vous pouvez facilement utiliser < avec des index, mais vous ne pouvez pas l'utiliser avec tous les types d'itérateurs. Un itérateur de liste ne peut pas implémenter efficacement < - toutefois, != peut être implémenté même pour les types d'itérateurs les plus simples. Par conséquent, il est recommandé de toujours utiliser la comparaison la plus générique - cela rend votre code plus résistant aux changements.


31
2017-12-25 19:46



Pensez au cas où il faut incrémenter de, disons 3 au lieu de 1.

for (vector<int>::size_type i = 0; i != 10; i+=3)

Cela fonctionnera pour toujours car il va sauter 10 et aller à 12 au lieu de cela et incrémenter pour toujours.

for (vector<int>::size_type i = 0; i < 10; i+=3) 

Cela fonctionnera très bien dans ce cas aussi. Donc, ce n'est pas toujours un bon choix.


10
2017-12-25 20:30



Parce que, en général, tous les itérateurs ne supportent pas l'opération "<". Voir Le manuel pour l'opération prise en charge par chaque type d'itérateur. Seuls les itérateurs à accès aléatoire (dont les simples pointeurs sont un sous-ensemble) supportent les comparaisons d'inégalité (<et>) entre les itérateurs


8
2017-12-25 19:46



Si vous écrivez !=, alors vous pouvez inverser l'itération de la boucle avec un changement minimal.

Supposons que vous écriviez d'abord:

for ( int i = m; i != n ; i++ )

Plus tard, vous l'inversez:

for ( int i = n ; i != m ; i-- )

Pas si attrayant, mais il faut quand même Moins analyse que "<" et ">".


7
2017-12-25 20:25



L'exigence d'être "comparable sur le plan relationnel" est beaucoup plus forte que l'exigence d'être "également comparable". Quand il s’agit d’itérer sur des conteneurs, la possibilité d’effectuer une comparaison relationnelle entre des itérateurs ou des index génériques (comme <, >, <= etc.) est fortement associé aux conteneurs à accès aléatoire, tandis que les comparaisons d’égalité sont plus universellement applicables (et souvent les seules disponibles lorsque vous travaillez avec des conteneurs à accès séquentiel).

En règle générale, il est recommandé de vous codifier le plus généra- En d'autres termes, si vous pouvez implémenter votre algorithme en utilisant uniquement des comparaisons d'égalité, il est préférable de le faire de cette manière, sans aucune comparaison relationnelle. De cette façon, il est possible de rendre votre algorithme plus utilisable avec un plus large éventail de structures de données sous-jacentes (conteneurs).

Bien sûr, si vous ne vous souciez pas de ce genre de générosité ou si vous n'en avez pas besoin, vous pouvez simplement ignorer ces considérations et utiliser l'une ou l'autre approche.


7
2017-12-25 20:25



Peut-être que ceux qui préfèrent cela sont parce qu'ils se sont habitués à vérifier la présence de null, etc.

if(x != null) { ... }

for(int i=0; i != 10; i++) { ... }

donc, pour tout le monde a tendance à être! = ou ==

lis ! =  comme DIFFERENT / NON EQUAL, suivant le même principe que ==  est ÉGAL,


0
2018-01-22 20:46