なぜ配列インデックスの代わりにイテレータを使用するのですか？

次の2行のコードを見てください。

for (int i = 0; i < some_vector.size(); i++)
{
    //do stuff
}

この：

for (some_iterator = some_vector.begin(); some_iterator != some_vector.end();
    some_iterator++)
{
    //do stuff
}

2番目の方法が好ましいと言われています。これはなぜ正確なのですか？

最初の形式は、vector.size（）が高速な操作である場合にのみ効率的です。これはベクトルには当てはまりますが、たとえばリストには当てはまりません。また、ループの本体内で何を計画していますか？次のように要素にアクセスする予定の場合

T elem = some_vector[i];

次に、コンテナーがoperator[](std::size_t)定義されていることを前提としています。繰り返しますが、これはベクトルには当てはまりますが、他のコンテナには当てはまりません。

イテレータを使用すると、コンテナの独立性に近づくことができます。size()コンテナーにイテレーター機能があることだけを前提として、ランダムアクセス機能や高速操作については想定していません。

標準アルゴリズムを使用して、コードをさらに拡張できます。それはあなたが達成しようとしている何であるかに応じて、使用することを選択するかもしれないstd::for_each()、std::transform()というように。明示的なループではなく標準のアルゴリズムを使用することで、ホイールの再発明を回避できます。コードはより効率的で（適切なアルゴリズムが選択されている場合）、正しく、再利用可能です。

これは、最新のC ++教化プロセスの一部です。イテレータはほとんどのコンテナを反復する唯一の方法であるため、適切な考え方を身につけるために、ベクトルでも使用できます。真剣に、それが私がそれをする唯一の理由です-私は今までベクターを別の種類のコンテナーに置き換えたことはないと思います。

配列のインデックスの方が読みやすいと思います。これは、他の言語で使用されている構文、および旧式のC配列で使用されている構文と一致しています。また、それほど冗長ではありません。コンパイラーが優れていて、とにかくそれが問題になるケースがほとんどない場合、効率は洗い流されるべきです。

それでも、ベクトルでイテレータを頻繁に使用していることに気づきました。イテレータは重要な概念だと思うので、できる限りそれを促進します。

some_vectorリストの特定の実装にコードを結び付けていないからです。配列インデックスを使用する場合は、何らかの形式の配列である必要があります。イテレータを使用する場合、そのコードを任意のリスト実装で使用できます。

some_vectorがリンクリストで実装されていると想像してください。次に、i番目のアイテムを要求するには、ノードのリストをトラバースするためにi操作を実行する必要があります。イテレータを使用する場合、一般的に言えば、できるだけ効率的になるように最善を尽くします（リンクリストの場合、現在のノードへのポインタを維持し、各反復でそれを進めます。単一操作）。

したがって、次の2つが提供されます。

• 使用の抽象化：一部の要素を反復したいだけで、それを行う方法は気にしません
• パフォーマンス

私はここで悪魔の擁護者になり、反復子を推奨しません。その主な理由は、デスクトップアプリケーションの開発からゲーム開発までに取り組んだすべてのソースコードに、イテレータを使用する必要がなかったからです。常にそれらが必要とされるわけではなく、次にイテレータで得られる隠された仮定とコードの混乱とデバッグの悪夢は、速度を必要とするアプリケーションでそれを使用しない主要な例です。

メンテナンスの観点からも、それらは混乱しています。それらのためではなく、舞台裏で発生するすべてのエイリアシングのためです。標準とは完全に異なる何かを行う独自の仮想ベクトルまたは配列リストを実装していないことを知る方法 ランタイム中に現在、どのタイプなのか知っていますか？すべてのソースコードをチェックする時間がなかった演算子をオーバーロードしましたか？地獄私はあなたが使っているSTLのバージョンを知っていますか？

イテレータで次に発生する問題は、リークの多い抽象化ですが、これについて詳細に説明しているWebサイトは多数あります。

申し訳ありませんが、イテレータのポイントはまだ見ていません。彼らがあなたからリストまたはベクトルを抽象化している場合、実際にはあなたはすでにどのベクターを知っているべきか、そうでなければあなたが扱っているリストを知っているはずです。

反復処理中にベクターにアイテムを追加/削除する場合は、イテレーターを使用することをお勧めします。

some_iterator = some_vector.begin(); 
while (some_iterator != some_vector.end())
{
    if (/* some condition */)
    {
        some_iterator = some_vector.erase(some_iterator);
        // some_iterator now positioned at the element after the deleted element
    }
    else
    {
        if (/* some other condition */)
        {
            some_iterator = some_vector.insert(some_iterator, some_new_value);
            // some_iterator now positioned at new element
        }
        ++some_iterator;
    }
}

インデックスを使用している場合は、挿入と削除を処理するために、配列内でアイテムを上下にシャッフルする必要があります。

関心事の分離

ループの「コア」の懸念から反復コードを分離するのはとても良いことです。それはほとんど設計上の決定です。

実際、インデックスによる反復は、コンテナーの実装に結び付けられます。コンテナに開始と終了のイテレータを要求すると、ループコードが他のコンテナタイプで使用できるようになります。

また、std::for_each方法では、尋ねるのではなく、コレクションに何をすべきかを伝えます内部について何かで

0x標準はクロージャを導入する予定です。これにより、このアプローチがはるかに使いやすくなります。たとえば、Rubyの表現力を見てください [1..6].each { |i| print i; }。 ...

パフォーマンス

しかし、おそらく非常に見過ごされがちな問題は、このfor_eachアプローチを使用すると、反復を並列化する機会が得られることです。インテルスレッディングブロックは、システム内のプロセッサの数全体にコードブロックを分散できます。

注：algorithmsライブラリ、特にを発見した後foreach、私は2〜3か月間、途方もなく小さい「ヘルパー」演算子構造体を作成しました。これにより、他の開発者が夢中になります。この後、私は実用的なアプローチに戻りました-小さなループ本体はもはや価値がありませforeachん:)

イテレータに関する必読のリファレンスは、「Extended STL」という本です。

GoFには、イテレーターパターンの最後に小さな段落があり、このブランドの反復について説明しています。これは「内部イテレータ」と呼ばれます。見ているこちらも。

よりオブジェクト指向だからです。あなたが仮定しているインデックスで反復している場合：

a）それらのオブジェクトが順序付けされている
b）それらのオブジェクトがインデックスによって取得できる
c）インデックスの増分がすべてのアイテムにヒットする
d）そのインデックスがゼロから始まる

イテレータを使用すると、基礎となる実装が何であるかを知らなくても、「すべてを提供して、それで作業できるようにする」と言っていることになります。（Javaでは、インデックスを介してアクセスできないコレクションがあります）

また、イテレータを使用すると、配列の境界を超えることを心配する必要がありません。

イテレータのもう1つの優れた点は、const-preferenceをより適切に表現（および適用）できることです。この例では、ループの最中にベクターを変更しないようにします。

for(std::vector<Foo>::const_iterator pos=foos.begin(); pos != foos.end(); ++pos)
{
    // Foo & foo = *pos; // this won't compile
    const Foo & foo = *pos; // this will compile
}

他のすべての優れた答えは別として... intベクトルに対して十分な大きさではない場合があります。代わりに、インデックスを使用するsize_type場合は、コンテナにを使用します。

for (std::vector<Foo>::size_type i = 0; i < myvector.size(); ++i)
{
    Foo& this_foo = myvector[i];
    // Do stuff with this_foo
}

私はおそらくあなたが電話することもできることを指摘しなければなりません

std::for_each(some_vector.begin(), some_vector.end(), &do_stuff);

STLイテレータは主にそこにあるので、sortなどのSTLアルゴリズムはコンテナに依存しません。

ベクトルのすべてのエントリをループするだけの場合は、インデックスループスタイルを使用します。

ほとんどの人間にとって、タイピングが少なく、解析が簡単です。C ++に、テンプレートマジックを使い果たすことなく、単純なforeachループがあればよいでしょう。

for( size_t i = 0; i < some_vector.size(); ++i )
{
   T& rT = some_vector[i];
   // now do something with rT
}
'

私はそれがベクトルに大きな違いをもたらすとは思いません。私はインデックスをより読みやすくするために自分で使用することを好みます。必要に応じて、6つのアイテムを前方にジャンプしたり後方にジャンプしたりするなど、ランダムアクセスを実行できます。

また、次のようにループ内のアイテムを参照するので、場所の周りに角括弧が多くありません。

for(size_t i = 0; i < myvector.size(); i++)
{
    MyClass &item = myvector[i];

    // Do stuff to "item".
}

将来的にベクターをリストに置き換える必要があり、STLフリークにはスタイリッシュに見える可能性がある場合は、イテレーターを使用することをお勧めしますが、他の理由は考えられません。

2番目の形式は、より正確に何をしているのかを表します。あなたの例では、あなたは本当にiの値を気にしません-欲しいのはイテレータの次の要素だけです。

この回答のテーマについてもう少し学んだ後、私はそれが少し単純化しすぎていることに気付きました。このループの違い：

for (some_iterator = some_vector.begin(); some_iterator != some_vector.end();
    some_iterator++)
{
    //do stuff
}

そしてこのループ：

for (int i = 0; i < some_vector.size(); i++)
{
    //do stuff
}

かなり最小限です。実際、この方法でループを実行する構文は、私には次のように成長しているようです。

while (it != end){
    //do stuff
    ++it;
}

イテレータはかなり強力な宣言型機能のいくつかをアンロックします。STLアルゴリズムライブラリと組み合わせると、配列インデックスの管理の範囲外であるかなりクールなことができます。

インデックス作成には追加のmul操作が必要です。たとえば、のvector<int> v場合、コンパイラはに変換v[i]され&v + sizeof(int) * iます。

イテレーション中、処理するアイテムの数を知る必要はありません。必要なのはアイテムだけで、イテレータはそのようなことを非常にうまく行います。

インデックスの利点の1つは、次のような連続したコンテナに追加しても無効にならないことです。 std::vectorことです。そのため、反復中にアイテムをコンテナに追加できます。

これはイテレータでも可能ですが、を呼び出すreserve()必要があるため、追加するアイテムの数を知る必要があります。

すでにいくつかの良い点があります。追加のコメントがいくつかあります。

1. 私たちがC ++標準ライブラリについて話していると仮定すると、「ベクター」は、C配列（ランダムアクセス、連続メモリレイアウトなど）が保証されているランダムアクセスコンテナーを意味します。「some_container」と言った場合、上記の回答の多くはより正確になります（コンテナーの独立性など）。

2. コンパイラの最適化への依存を排除​​するには、次のように、インデックス付きコードのループからsome_vector.size（）を移動します。

   const size_t numElems = some_vector.size（）;
   for（size_t i = 0; i 

3. 常に事前に増分する反復子と、事後の増分を例外的なケースとして扱います。

したがってstd::vector<>、コンテナーのようにインデックス付け可能であると仮定すると、コンテナーを順にたどりながら、どちらか一方を優先する理由はありません。古い要素または新しい要素のインデックスを頻繁に参照する必要がある場合は、インデックス付きバージョンの方が適切です。

一般に、アルゴリズムはイテレーターを使用し、イテレーターのタイプを変更することで動作を制御（および暗黙的に文書化）できるため、イテレーターの使用が推奨されます。配列の場所はイテレータの代わりに使用できますが、構文上の違いが際立ちます。

foreachステートメントを嫌うのと同じ理由で、イテレータを使用しません。複数の内部ループがある場合、ローカル値とイテレーター名をすべて覚えておく必要なしに、グローバル/メンバー変数を追跡するのは十分に困難です。私が便利だと思うのは、さまざまな場面で2セットのインデックスを使用することです。

for(int i=0;i<anims.size();i++)
  for(int j=0;j<bones.size();j++)
  {
     int animIndex = i;
     int boneIndex = j;


     // in relatively short code I use indices i and j
     ... animation_matrices[i][j] ...

     // in long and complicated code I use indices animIndex and boneIndex
     ... animation_matrices[animIndex][boneIndex] ...


  }

たとえば、「animation_matrices [i]」のようなものをランダムな「anim_matrix」という名前のイテレータに省略したくありません。これは、この値がどの配列から由来しているかがはっきりとわからないためです。

• 金属に近いことが好きな場合、または実装の詳細を信頼しない場合は、イテレータを使用しないでください。
• 開発中にあるコレクションタイプを別のコレクションタイプに定期的に切り替える場合は、イテレータを使用します。
• さまざまな種類のコレクションを反復する方法を覚えるのが難しい場合（おそらく、使用中のいくつかの異なる外部ソースからの複数のタイプがある場合）、イテレータを使用して、要素の上を歩く方法を統一します。これは、リンクリストと配列リストを切り替える場合にも当てはまります。

本当に、これですべてです。どちらかといえば平均してどちらかというと簡潔さを増すつもりはありません。簡潔さが本当に目標であれば、いつでもマクロに頼ることができます。

C ++ 11機能にアクセスできる場合は、範囲ベースのforループを使用して、次のようにベクター（または他のコンテナー）を反復することもできます。

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

このループの利点はitem、インデックスをめちゃくちゃにしたり、イテレータを逆参照するときに間違いを犯したりするリスクを冒すことなく、変数を介してベクトルの要素に直接アクセスできることです。さらに、プレースホルダーautoを使用すると、コンテナー要素のタイプを繰り返す必要がなくなり、コンテナーに依存しないソリューションにさらに近づくことができます。

ノート：

• ループ内に要素インデックスが必要であり、operator[]コンテナに存在する（そして十分に高速である）場合は、最初の方法を使用することをお勧めします。
• 範囲ベースのforループは、コンテナーへの要素の追加/コンテナーからの要素の削除には使用できません。あなたがそれをしたいなら、ブライアン・マシューズによって与えられた解決策に固執してください。
• コンテナの要素を変更したくない場合はconst、次のようにキーワードを使用する必要がありますfor (auto const &item : some_vector) { ... }。

「何をすべきかをCPUに伝える」（命令型）よりも優れているのは、「ライブラリに必要なことを伝える」（機能的）ということです。

したがって、ループを使用する代わりに、stlに存在するアルゴリズムを学ぶ必要があります。

コンテナに依存しない

私の多くのアプリケーションは「サムネイル画像の表示」のようなものを必要とするため、私は常に配列インデックスを使用します。だから私はこのようなものを書きました：

some_vector[0].left=0;
some_vector[0].top =0;<br>

for (int i = 1; i < some_vector.size(); i++)
{

    some_vector[i].left = some_vector[i-1].width +  some_vector[i-1].left;
    if(i % 6 ==0)
    {
        some_vector[i].top = some_vector[i].top.height + some_vector[i].top;
        some_vector[i].left = 0;
    }

}

どちらの実装も正しいですが、私は「for」ループを好むでしょう。他のコンテナではなくベクターを使用することを決定したので、インデックスを使用するのが最良のオプションです。Vectorでイテレータを使用すると、オブジェクトを連続メモリブロックに配置して、アクセスを容易にするという非常に大きなメリットが失われます。

ここでの答えのどれも、コンテナへのインデックス付けに関する一般的な概念としてイテレータが好きな理由を説明していないと感じました。イテレーターを使用した私の経験のほとんどは、実際にはC ++からではなく、Pythonなどの高水準プログラミング言語からのものであることに注意してください。

イテレーターインターフェースは、関数のコンシューマーに課す要件が少ないため、コンシューマーはそれを使ってより多くのことができます。

必要なのは、フォワードイテレートが可能である場合、開発者はインデックス可能なコンテナの使用に限定されずoperator++(T&)、operator*(T)とを実装する任意のクラスを使用できますoperator!=(const &T, const &T)。

#include <iostream>
template <class InputIterator>
void printAll(InputIterator& begin, InputIterator& end)
{
    for (auto current = begin; current != end; ++current) {
        std::cout << *current << "\n";
    }
}

// elsewhere...

printAll(myVector.begin(), myVector.end());

アルゴリズムは、必要な場合（ベクトルの反復処理）で機能しますが、必ずしも予期していないアプリケーションにも役立ちます。

#include <random>

class RandomIterator
{
private:
    std::mt19937 random;
    std::uint_fast32_t current;
    std::uint_fast32_t floor;
    std::uint_fast32_t ceil;

public:
    RandomIterator(
        std::uint_fast32_t floor = 0,
        std::uint_fast32_t ceil = UINT_FAST32_MAX,
        std::uint_fast32_t seed = std::mt19937::default_seed
    ) :
        floor(floor),
        ceil(ceil)
    {
        random.seed(seed);
        ++(*this);
    }

    RandomIterator& operator++()
    {
        current = floor + (random() % (ceil - floor));
    }

    std::uint_fast32_t operator*() const
    {
        return current;
    }

    bool operator!=(const RandomIterator &that) const
    {
        return current != that.current;
    }
};

int main()
{
    // roll a 1d6 until we get a 6 and print the results
    RandomIterator firstRandom(1, 7, std::random_device()());
    RandomIterator secondRandom(6, 7);
    printAll(firstRandom, secondRandom);

    return 0;
}

イテレータの実装は比較的簡単ですが、このイテレータに似た機能を実行する角かっこ演算子を実装しようとすると、不自然になります。角かっこ演算子は、クラスの機能（任意のポイントにインデックスを付けることができる）にも影響を与えます。これは、実装が困難または非効率的な場合があります。

イテレータは装飾にも適しています。人々は、コンストラクターでイテレーターを取り、その機能を拡張するイテレーターを作成できます。

template<class InputIterator, typename T>
class FilterIterator
{
private:
    InputIterator internalIterator;

public:
    FilterIterator(const InputIterator &iterator):
        internalIterator(iterator)
    {
    }

    virtual bool condition(T) = 0;

    FilterIterator<InputIterator, T>& operator++()
    {
        do {
            ++(internalIterator);
        } while (!condition(*internalIterator));

        return *this;
    }

    T operator*()
    {
        // Needed for the first result
        if (!condition(*internalIterator))
            ++(*this);
        return *internalIterator;
    }

    virtual bool operator!=(const FilterIterator& that) const
    {
        return internalIterator != that.internalIterator;
    }
};

template <class InputIterator>
class EvenIterator : public FilterIterator<InputIterator, std::uint_fast32_t>
{
public:
    EvenIterator(const InputIterator &internalIterator) :
        FilterIterator<InputIterator, std::uint_fast32_t>(internalIterator)
    {
    }

    bool condition(std::uint_fast32_t n)
    {
        return !(n % 2);
    }
};


int main()
{
    // Rolls a d20 until a 20 is rolled and discards odd rolls
    EvenIterator<RandomIterator> firstRandom(RandomIterator(1, 21, std::random_device()()));
    EvenIterator<RandomIterator> secondRandom(RandomIterator(20, 21));
    printAll(firstRandom, secondRandom);

    return 0;
}

これらのおもちゃはありふれたものに見えるかもしれませんが、イテレータやイテレータデコレータを使用してシンプルなインターフェースで強力なことを実行することを想像するのは難しくありません。 。これらのパターンにより、無限セットのメモリー効率の良い反復が可能になり、上で書いたようなフィルターを使用して、結果の遅延評価が行われる可能性があります。

C ++テンプレートの強力な機能の1つは、固定長のC配列などに適用すると、単純で効率的なポインター演算に減衰するイテレーターインターフェースであり、これを真にゼロコストの抽象化にします。