forループで1ずつインクリメントするときに、！=ではなく>（<）を使用する技術的な理由はありますか？

私はforこのようなループを見ることはほとんどありません：

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

ループで1ずつインクリメントするとき、>または<その代わりに使用する技術的な理由はありますか？それとももっと慣例なのでしょうか？!=for

while (time != 6:30pm) {
    Work();
}

午後6時31分です。いまいましい、次の家に帰るチャンスは明日です。:)

これは、より強い制限がリスクを軽減し、おそらくより直感的に理解できることを示しています。

技術的な理由はありません。しかし、リスクの軽減、保守性、およびコードのより良い理解があります。

<またはほとんどの場合>よりも強力な制限で!=あり、まったく同じ目的を果たします（すべての実際的な場合でも私は言います）。

ここに重複する質問があります。と1つの興味深い答え。

はい、理由があります。このような（古い古いインデックスベースの）forループを記述した場合

for (int i = a; i < b; ++i){}

その後、それはaandのすべての値に対して期待どおりに機能しますb（つまりa > b、を使用した場合、無限ではなくゼロの反復i == b;）。

一方、イテレータの場合は次のように記述します

for (auto it = begin; it != end; ++it) 

どのイテレータもを実装する必要operator!=がありますが、すべてのイテレータに対してではないため、を提供することが可能operator<です。

また、範囲ベースのforループ

for (auto e : v)

単なる派手な砂糖ではありませんが、間違ったコードを書く可能性をかなり減らします。

あなたは次のようなものを持つことができます

for(int i = 0; i<5; ++i){
    ...
    if(...) i++;
    ...
}

ループ変数が内部コードによって記述されている場合、i!=5そのループは中断されない可能性があります。これは、不等式をチェックする方が安全です。

読みやすさについて編集します。不等式フォームは、より頻繁に使用されます。したがって、理解する特別なことは何もないため、これは非常に高速に読み取ることができます（タスクが一般的であるため、脳の負荷が軽減されます）。したがって、読者がこれらの習慣を利用するのはクールです。

そして最後に重要なことですが、これは防御的プログラミングと呼ばれます。つまり、プログラムに影響を与える現在および将来のエラーを回避するために、常に最強のケースをとることを意味します。

防御的プログラミングが不要な唯一のケースは、事前条件と事後条件によって状態が証明されている場合です（ただし、これがすべてのプログラミングの中で最も防御的であることを証明します）。

私は次のような表現だと主張します

for ( int i = 0 ; i < 100 ; ++i )
{
  ...
}

以上で意思の表現であるより

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

前者は、条件が範囲の排他的な上限のテストであることを明確に示しています。後者は、終了条件のバイナリテストです。ループの本体が重要な場合、インデックスがforステートメント自体でのみ変更されていることは明らかではありません。

イテレータは、最も頻繁に!=表記を使用する場合の重要なケースです。

for(auto it = vector.begin(); it != vector.end(); ++it) {
 // do stuff
}

承知しました：実際には、私はに依存して同じことを書きますrange-for：

for(auto & item : vector) {
 // do stuff
}

ただし、要点は残っています。通常は、==またはを使用してイテレータを比較します!=。

ループ条件は強制ループ不変です。

ループの本体を見ていないとします。

for (int i = 0; i != 5; ++i)
{
  // ?
}

この場合、ループ反復の開始時にi等しくないことがわかります5。

for (int i = 0; i < 5; ++i)
{
  // ?
}

この場合には、あなたはループ反復の開始時に知っているiよりも少ないです5。

2つ目は1つ目よりもはるかに多くの情報です。現在、プログラマの意図は（ほぼ確実に）同じですが、バグを探している場合は、コード行を読み取ることから自信を持つことは良いことです。そして、2番目はその不変式を強制します。つまり、2番目のケースでは、最初のケースであなたに噛み付くようないくつかのバグが発生しない（またはメモリ破損を引き起こさない）ことを意味します。

より少ないコードを読み取ることで、を使用する<よりも、プログラムの状態について詳しく知ることができ!=ます。また、最近のCPUでは、違いがないのと同じ時間がかかります。

あなたは場合はiループ本体で操作されなかった、そしてそれは常に1増加した、そしてそれは以下の開始しました5、何の違いもないでしょう。しかし、それが操作されたかどうかを知るためには、これらの各事実を確認する必要があります。

これらの事実のいくつかは比較的簡単ですが、間違える可能性があります。ただし、ループ全体を確認するのは面倒です。

C ++では、次のようなindexes型を記述できます。

for( const int i : indexes(0, 5) )
{
  // ?
}

上記の2つのforループのいずれかと同じことを行います。コンパイラーが同じコードに最適化するまでです。ただし、ここでは、コードがメモリを破壊することなく、宣言されているようにループの本体で操作できないことを知ってiいconstます。

コンテキストを理解しなくてもコード行から得られる情報が多いほど、問題の原因を追跡しやすくなります。 <整数ループの場合は、その行のコードの状態についてよりも多くの情報を提供します!=。

はい; OpenMPは、!=条件付きのループを並列化しません。

変数iがいくつかの大きな値に設定されている可能性があり、!=演算子を使用するだけの場合は、無限ループに陥ります。

他の多数の回答からわかるように、！=の代わりに<を使用する理由があります。これは、エッジケース、初期条件、意図しないループカウンターの変更などに役立ちます...

正直なところ、慣習の重要性を十分に強調できるとは思いません。この例では、他のプログラマーがあなたが何をしようとしているのかを簡単に確認できますが、それはダブルテイクを引き起こします。プログラミング中の仕事の1つは、できるだけ読みやすく親しみやすいものにすることです。そのため、誰かがコードを更新/変更しなければならない場合は、必然的に、さまざまなコードブロックで何をしていたのかを理解するのにそれほど労力を要しません。 。誰かがを使用しているのを見た場合!=、彼らが代わりにそれを使用した理由があった<と思います。それが大きなループであった場合、あなたがそれを必要とした理由を理解しようとする全体を調べます...そしてそれは時間を無駄にしました。

Ian Newsonがすでに述べたように、浮動変数を確実にループして、で終了することはできません!=。例えば、

for (double x=0; x!=1; x+=0.1) {}

0.1は浮動小数点で正確に表すことができないため、実際には永久にループします。したがって、カウンターは1をわずかに見逃します<。

（ただし、最後に受け入れられた数値として0.9999 ...が得られるかどうかは、基本的に定義されていない動作であることに注意してください。

私は形容詞「技術的」を、言語の動作/癖および生成されたコードのパフォーマンスなどのコンパイラーの副作用を意味すると解釈します。

そのための答えは、no（*）です。（*）は「プロセッサーのマニュアルを参照してください」です。エッジケースのRISCまたはFPGAシステムを使用している場合は、生成される命令とそのコストを確認する必要がある場合があります。あなたはかなり任意の従来の近代建築を使用している場合でも、そこの間にコストの有意なプロセッサレベル差はありませんlt、eq、neとgt。

場合あなたがエッジケースを使用している、あなたはそれが見つけることができる!=3つの操作（必要としcmp、not、beq2（VS）をcmp、blt xtr myo）。この場合も、RTMです。

ほとんどの場合、その理由は、特にポインターや複雑なループを操作する場合に、防御的/強化的です。検討する

// highly contrived example
size_t count_chars(char c, const char* str, size_t len) {
    size_t count = 0;
    bool quoted = false;
    const char* p = str;
    while (p != str + len) {
        if (*p == '"') {
            quote = !quote;
            ++p;
        }
        if (*(p++) == c && !quoted)
            ++count;
    }
    return count;
}

それほど工夫されていない例は、戻り値を使用して増分を実行し、ユーザーからデータを受け入れる場合です。

#include <iostream>
int main() {
    size_t len = 5, step;
    for (size_t i = 0; i != len; ) {
        std::cout << "i = " << i << ", step? " << std::flush;

        std::cin >> step;
        i += step; // here for emphasis, it could go in the for(;;)
    }
}

これを試して、値1、2、10、999を入力してください。

あなたはこれを防ぐことができます：

#include <iostream>
int main() {
    size_t len = 5, step;
    for (size_t i = 0; i != len; ) {
        std::cout << "i = " << i << ", step? " << std::flush;
        std::cin >> step;
        if (step + i > len)
            std::cout << "too much.\n";
        else
            i += step;
    }
}

しかし、おそらくあなたが欲しかったのは

#include <iostream>
int main() {
    size_t len = 5, step;
    for (size_t i = 0; i < len; ) {
        std::cout << "i = " << i << ", step? " << std::flush;
        std::cin >> step;
        i += step;
    }
}

向けた条約バイアスの何かがある<標準コンテナ内の順序は、多くの場合に依存しているため、operator<いくつかのSTLコンテナでのインスタンスのハッシュが言って平等を決定するために、

if (lhs < rhs) // T.operator <
    lessthan
else if (rhs < lhs) // T.operator < again
    greaterthan
else
    equal

もしlhsおよびrhsユーザ定義のクラスは、このコードを書いているように

if (lhs < rhs) // requires T.operator<
    lessthan
else if (lhs > rhs) // requires T.operator>
    greaterthan
else
    equal

実装者は2つの比較関数を提供する必要があります。それで<、支持されたオペレーターになりました。

任意の種類のコードを（通常）記述する方法はいくつかありますが、この場合は2つの方法（<=と> =を数える場合は3つ）しかありません。

この場合、（バグのように）ループで予期しないことが起こっても無限にループしないようにするために、>と<が好まれます（BAD）。たとえば、次のコードを考えます。

for (int i = 1; i != 3; i++) {
    //More Code
    i = 5; //OOPS! MISTAKE!
    //More Code
}

（i <3）を使用すると、制限が大きくなるため、無限ループから安全になります。

プログラムでミスをして全体をシャットダウンしたり、バグのある場所で機能し続けたりするのは、本当にあなたの選択です。

これが役に立てば幸い！

使用する最も一般的な理由<は慣習です。多くのプログラマーは、このようなループを「インデックスが最後に到達するまで」ではなく、「インデックスが範囲内にある間」と考えています。できる限り、慣習に固執する価値があります。

一方、ここでの多くの回答は、<フォームを使用するとバグを回避するのに役立つと主張しています。多くの場合、これはバグを隠すのに役立つだけだと私は主張します。ループインデックスが終了値に到達するはずであり、実際にはそれを超えている場合は、誤動作（または別のバグの副作用）を引き起こす可能性のある予期しないことが発生しています。<おそらくバグの発見が遅れます。!=あなたが早くバグを見つけるのに役立ちますストール、ハング、あるいはクラッシュにつながる可能性が高いです。バグが見つかれば早くなるほど、修正コストは安くなります。

この規則は配列とベクトルのインデックス付けに固有であることに注意してください。他のほぼすべてのタイプのデータ構造をトラバースするときは、イテレーター（またはポインター）を使用して、終了値を直接確認します。これらの場合、イテレータが実際の最終値に到達し、オーバーシュートしないようにする必要があります。

たとえば、プレーンなC文字列をステップ実行している場合、通常は次のように記述します。

for (char *p = foo; *p != '\0'; ++p) {
  // do something with *p
}

より

int length = strlen(foo);
for (int i = 0; i < length; ++i) {
  // do something with foo[i]
}

1つには、文字列が非常に長い場合、2番目の形式はstrlen文字列を通過するもう1つのパスであるため、速度が遅くなります。

C ++ std :: stringを使用すると、長さがすぐに利用できる場合でも、範囲ベースのforループ、標準アルゴリズム、またはイテレーターを使用します。イテレータを使用している!=場合<、次のようにの代わりにを使用するのが慣例です。

for (auto it = foo.begin(); it != foo.end(); ++it) { ... }

同様に、ツリー、リスト、または両端キューの反復では、通常、インデックスが範囲内に残っているかどうかを確認するのではなく、nullポインターまたは他のセンチネルを監視します。

この構造を使用しない理由の1つは、浮動小数点数です。!=数値が同じに見えてもtrueと評価されることはめったにないため、floatで使用するのは非常に危険な比較です。<または>このリスクを取り除きます。

この慣習に従う理由は2つあります。どちらも、プログラミング言語は結局のところ、（とりわけ）人間によって読まれる言語であるという事実に関係しています。

（1）冗長性のビット。自然言語では、通常、エラー訂正コードのように、必要以上に多くの情報を提供します。ここでの追加情報は、ループ変数ですi（ここで冗長性をどのように使用したかを参照してください。「ループ変数」の意味がわからない場合、または変数の名前を忘れた場合は、「ループ変数i」を読んだ後、完全な情報）は、ループ中に5未満であり、5と異なるだけではありません。冗長性により、読みやすさが向上します。

（2）条約。言語には、特定の状況を表現するための特定の標準的な方法があります。確立された言い回しに従わない場合でも理解できますが、特定の最適化が機能しないため、メッセージの受信者の努力は大きくなります。例：

ホットマッシュについて話さないでください。難しさを明らかにするだけです！

最初の文はドイツ語のイディオムの直訳です。2つ目は、一般的な英語のイディオムで、主語が同義語に置き換えられています。結果はわかりやすいですが、これよりも理解するのに時間がかかります。

茂みの周りを殴らないでください。問題を説明してください！

これは、最初のバージョンで使用された同義語が、英語の慣用句の従来の単語よりも状況にうまく適合する場合でも当てはまります。プログラマーがコードを読み取るときも、同様の力が働いています。これが理由もある5 != iと5 > i、それを置くの奇妙な方法がありますしない限り、あなたはより正常交換するための標準的である環境で作業しているi != 5とi < 5、このようにしています。そのような方言コミュニティは確かに存在します。おそらく一貫性があると5 == i、自然でエラーが発生しやすくなるのではなく、書くことを覚えやすくなるためですi == 5。

このような場合に関係比較を使用することは、他の何よりも一般的な習慣です。イテレータのカテゴリや比較可能性などの概念的な考慮事項が高い優先度と見なされなかった時代に、その人気が高まりました。

等価比較は比較される値に課せられる要件が少ないため、可能な場合は常にリレーショナル比較ではなく等価比較を使用することをお勧めします。ビーイングEqualityComparableがあることよりも低い要件ですLessThanComparable。

このようなコンテキストでの同等性比較の幅広い適用性を示す別の例は、unsignedまでの反復を実装することでよくある難問0です。それは次のように行うことができます

for (unsigned i = 42; i != -1; --i)
  ...

上記は、署名付きと符号なしの両方の反復に等しく適用できますが、リレーショナルバージョンは、符号なしの型に分類されます。

例のほかに、ループ変数が（意図しない）本体内で変化する場合、小なり演算子または大なり演算子を使用する他の理由があります。

• 否定はコードを理解しにくくします
• <または>1文字だけですが、!=2

リスクを軽減すると述べたさまざまな人々に加えて、さまざまな標準ライブラリコンポーネントとのやり取りに必要な関数のオーバーロードの数も削減します。例として、型をに保存できるようstd::setにしたり、のキーとしてstd::map使用したり、一部の検索および並べ替えアルゴリズムで使用しstd::lessたりしたい場合、ほとんどのアルゴリズムは厳密な弱い順序付けのみを必要とするため、通常、標準ライブラリはオブジェクトの比較に使用します。したがって、<比較の代わりに!=比較を使用することは良い習慣になります（もちろん、それが理にかなっている場合）。

構文の観点から問題はありませんが、その式の背後にあるロジック 5!=iは適切ではありません。

私の意見で!=は、forループの境界を設定するためにを使用しても、forループは反復インデックスをインクリメントまたはデクリメントするため、論理的に適切ではありません。!=することは、適切な実装。

それは動作しますが、使用している場合、境界データの取り扱いが失われているので、それが誤動作を起こしやすい!=インクリメンタル問題のために（あなたは最初から知っていることを意味ならば、それ増減）の代わりに、なぜだ、使用されています。!=<>>==>