Penjelasan Iterator C++: begin, end, dan Jenis Iterator

Apa Sebenarnya Iterator Itu

Setiap container standar, yaitu vector, string, map, set, list, menyimpan elemennya dengan cara yang berbeda di dalam. vector adalah blok yang bersambung, map adalah balanced tree, list adalah node yang tertaut. Namun kamu bisa melakukan perulangan pada semuanya dengan cara yang sama. Yang memungkinkan hal itu adalah iterator: objek kecil yang "menunjuk" ke satu elemen dan tahu cara melangkah ke elemen berikutnya.

Anggap iterator sebagai pointer yang diperluas. Kamu mendapatkannya dari begin(), membaca elemen yang ditunjuknya dengan *, dan memajukannya dengan ++. Potongan-potongan itu tersusun seperti ini:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {10, 20, 30};

    vector<int>::iterator it = v.begin();
    cout << *it << "\n";   // 10 - dereference reads the element

    ++it;                  // advance to the next element
    cout << *it << "\n";   // 20
}

v.begin() mengembalikan iterator ke elemen pertama; *it memberimu elemen itu; ++it berpindah ke elemen berikutnya. Ketiganya, yaitu dereference, memajukan, dan membandingkan, adalah seluruh model mentalnya.

begin(), end(), dan Range Setengah Terbuka

Separuh gambaran lainnya adalah end(). Yang penting, end() tidak menunjuk ke elemen terakhir; ia menunjuk ke posisi satu setelah elemen terakhir. Ini adalah range "setengah terbuka" yang disengaja, [begin, end): begin termasuk, end adalah tanda berhenti.

Desain itu membuat loop standarnya rapi, karena kamu berjalan sampai iterator sama dengan end():

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {3, 1, 4, 1, 5};

    for (auto it = v.begin(); it != v.end(); ++it) {
        cout << *it << " ";
    }
    cout << "\n";
}

Perhatikan it != v.end(), bukan it < v.end(). Sebagian besar iterator container (seperti map atau list) tidak mendukung <, hanya == dan !=, jadi != adalah pilihan yang portabel. Dan auto menghemat kamu dari menulis vector<int>::iterator secara manual, karena compiler menyimpulkannya.

Kasus container kosong tertangani dengan sendirinya: saat container kosong, begin() == end(), jadi isi loop tidak pernah berjalan. Tidak perlu penanganan khusus.

Jangan Pernah Dereference end()

Bug iterator yang paling umum adalah melakukan dereference pada end(). Karena ia menunjuk satu posisi setelah elemen terakhir, *v.end() membaca memori yang bukan milikmu. Ini undefined behavior, artinya crash atau sampah diam-diam, bukan error yang ramah:

vector<int> v = {1, 2, 3};
cout << *v.end();   // UNDEFINED BEHAVIOR - end() is not an element

Jebakan yang sama mengenai fungsi pencarian. std::find mengembalikan end() kalau tidak menemukan nilainya, jadi kamu harus mengecek sebelum melakukan dereference:

#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {2, 4, 6, 8};

    auto it = find(v.begin(), v.end(), 5);
    if (it != v.end()) {
        cout << "Found: " << *it << "\n";
    } else {
        cout << "5 is not in the vector\n";   // this runs
    }
}

Selalu bandingkan iterator yang dikembalikan dengan end() sebelum melakukan dereference. Lupa menulis if ini adalah salah satu sumber crash paling sering di kode STL buatan pemula.

const, cbegin, dan Reverse Iterator

Container menyediakan beberapa jenis iterator, tergantung kebutuhanmu:

• begin() / end(): iterator baca/tulis biasa (*it = ... berfungsi).
• cbegin() / cend(): const_iterator; kamu bisa membaca lewatnya tetapi tidak bisa mengubah elemennya.
• rbegin() / rend(): reverse iterator yang berjalan dari belakang ke depan; ++ sebenarnya bergerak mundur.

Reverse iterator adalah cara yang rapi untuk melakukan perulangan secara terbalik tanpa perhitungan indeks yang merepotkan:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {1, 2, 3, 4};

    for (auto it = v.rbegin(); it != v.rend(); ++it) {
        cout << *it << " ";   // 4 3 2 1
    }
    cout << "\n";
}

Dengan reverse iterator kamu tetap menulis ++it untuk maju; iterator-nya menangani arah "mundur" secara internal. Pakai cbegin()/cend() (atau referensi const ke container) saat sebuah loop hanya perlu membaca, supaya compiler mencegahmu menulis secara tidak sengaja.

Iterator Map Menghasilkan Pair

Tidak setiap iterator hanyalah pembungkus tipis di atas pointer. Iterator std::map menelusuri sebuah tree, dan dereference padanya memberimu std::pair berisi key dan value, yang diakses lewat ->first dan ->second (sama seperti pointer, iterator mendukung ->):

#include <iostream>
#include <map>
#include <string>
using namespace std;

int main() {
    map<string, int> ages = {{"Ada", 36}, {"Grace", 85}};

    for (auto it = ages.begin(); it != ages.end(); ++it) {
        cout << it->first << " -> " << it->second << "\n";
    }
}

Range-based for loop dibangun langsung di atas begin()/end(), jadi untuk perulangan maju yang biasa kamu umumnya akan memakai itu. Iterator eksplisit berguna saat kamu butuh penelusuran mundur, posisi sebuah elemen, atau meneruskan sebuah range ke algoritma.

Jebakan Besar: Iterator Invalidation

Inilah jebakan yang cepat atau lambat menjebak semua orang. Saat kamu mengubah struktur container, iterator yang sudah ada bisa menjadi tidak valid (invalidated): ia menunjuk ke memori yang sudah dibebaskan atau dipindahkan. Memakainya adalah undefined behavior.

Untuk vector, push_back bisa merealokasi seluruh buffer untuk memperbesarnya, sehingga setiap iterator yang masih dipegang menjadi tidak valid. Menghapus elemen di tengah loop bahkan lebih terkenal; ini crash yang klasik:

vector<int> v = {1, 2, 3, 4};
for (auto it = v.begin(); it != v.end(); ++it) {
    if (*it % 2 == 0)
        v.erase(it);   // BUG - erase invalidates it, then ++it is UB
}

Solusinya: erase mengembalikan iterator yang valid ke elemen setelah elemen yang dihapus. Majukan iterator hanya kalau kamu tidak menghapus apa pun:

#include <iostream>
#include <vector>
using namespace std;

int main() {
    vector<int> v = {1, 2, 3, 4, 5, 6};

    for (auto it = v.begin(); it != v.end(); ) {
        if (*it % 2 == 0)
            it = v.erase(it);   // erase returns the next valid iterator
        else
            ++it;               // only advance when nothing was removed
    }

    for (int x : v) cout << x << " ";   // 1 3 5
    cout << "\n";
}

Perhatikan bahwa header for tidak punya ++it; isi loop yang memutuskan apakah iterator dimajukan. (Di kode nyata, idiom erase-remove atau std::erase_if dari C++20 melakukan ini dalam satu baris.) Aturan yang perlu diingat: operasi apa pun yang menambah atau menghapus elemen bisa membuat iterator tidak valid, jadi jangan berpegangan pada iterator lama melewati perubahan seperti itu.

Berikutnya: Algoritma

Sekarang setelah kamu bisa menggambarkan sebuah range sebagai pasangan begin/end, kamu sudah membuka seluruh library algoritma STL. Fungsi seperti sort, find, count, dan accumulate tidak peduli container apa yang kamu punya; mereka bekerja pada range iterator, jadi pemanggilan yang sama berfungsi pada vector, array, atau potongan dari salah satunya. Berikutnya kita akan memakai iterator-iterator itu dan membiarkan standard library melakukan perulangan untukmu.