C++

Kenali C++ sebagai bahasa pemrograman compiled yang cepat: karakteristiknya, cara kerja compiler, dan contoh program pertama.

Menelusuri perjalanan C++ dari 'C with Classes' di Bell Labs tahun 1979 hingga standar C++26, dan memahami mengapa tiap fitur modern lahir.

Membandingkan C++, C, dan Rust secara netral: level abstraksi, manajemen memori, kompatibilitas, ekosistem, dan kapan masing-masing menjadi pilihan tepat.

Memetakan domain nyata yang memakai C++: game engine, browser, sistem operasi, database, sistem finansial, embedded, grafis, hingga infrastruktur machine learning.

Memahami ISO/IEC 14882, peran WG21, siklus tiga tahunan, feature test macro, serta perbedaan antara standar resmi dan implementasi compiler.

Mengenal compiler vs toolchain, karakteristik GCC, Clang, dan MSVC, pipeline preprocessor-compiler-assembler-linker, serta alat pendukung sekitarnya.

Membongkar anatomi file .cpp: directive preprocessor, konstanta global, fungsi, main(), statement vs directive, aturan return 0 implisit, dan argumen program.

Kriteria memilih compiler C++, perbandingan GCC, Clang, dan MSVC, serta cara bereksperimen cepat lewat Compiler Explorer.

Memasang GCC/g++ di Ubuntu-Debian, Fedora, Windows (MSYS2), dan macOS (Homebrew), verifikasi instalasi, serta anatomi direktorinya.

Mengenal Clang dan LLVM, instalasi Clang di tiap platform, verifikasi clang++, serta kapan Clang menjadi pilihan yang tepat.

Memasang Visual Studio Community dengan workload C++, memakai compiler cl.exe dan Developer Command Prompt, serta perbandingan flag-nya dengan g++.

Perbandingan Visual Studio, VS Code, CLion, Qt Creator, dan Neovim dengan clangd, plus apa yang sebenarnya diberikan IDE bagi pemula C++.

Anatomi perintah g++, flag penting (-std, -Wall, -Wextra, -g, -O0/-O2, -o), error vs warning, exit code kompilasi, dan kompilasi multi-file.

Empat tahap dari source code ke executable — preprocessor, kompilasi, assembler, dan linking — didemonstrasikan langsung dengan flag g++ pada tiap tahap.

Cara menjalankan executable di Linux/macOS dan Windows, peran PATH dan izin eksekusi, exit code, serta meneruskan argumen program lewat argv.

Arti flag -std=c++17/20/23, perbedaan mode ISO dan mode GNU (-std=gnu++23), kompatibilitas kode lama, dan rekomendasi standar untuk proyek baru.

Mengenal fungsi main() sebagai entry point program C++: bentuk-bentuk yang legal, arti return value, dan cara menerima argumen dari terminal.

Memahami header file, perbedaan #include <...> dan #include "...", header standar yang sering dipakai, serta cara preprocessor menyisipkan isinya.

Mengenal namespace sebagai wadah nama: menghindari tabrakan nama, kualifikasi std::, deklarasi using, namespace bersarang, dan namespace anonim.

Membedah unit terkecil program C++: pernyataan yang diakhiri titik koma, ekspresi yang menghasilkan nilai, blok { }, dan kebebasan format whitespace.

Menulis catatan di dalam kode C++: komentar satu baris dan blok, larangan komentar bersarang, serta kapan komentar diperlukan dan kapan kode cukup bicara sendiri.

Mencetak data ke terminal dengan std::cout: operator <<, chaining, endl versus , serta cara C++ menampilkan angka, karakter, dan boolean.

Membaca data dari pengguna dengan std::cin: operator >>, membaca beberapa nilai, perilaku string yang berhenti di whitespace, getline, dan pengenalan kegagalan input.

Mengenal std::cerr dan std::clog sebagai saluran pesan galat dan log: perbedaan dengan std::cout, arti stream tidak dibuffer, serta cara memisahkannya lewat redirect.

Menguasai escape sequences C++: baris baru, tab, backslash, kutip, karakter nul, carriage return, unicode escape, hingga raw string literal.

Menyatukan seluruh materi section: menyusun program sapa-pengguna, mengompilasinya dengan g++, memeriksa exit code, dan membaca pesan error nyata dari tiga kesalahan klasik pemula.

Mengenal anatomi deklarasi variabel di C++: kombinasi tipe dan nama, beberapa declarator dalam satu baris, perbedaan deklarasi dengan definisi, serta risiko variabel tanpa nilai awal.

Membedah tiga bentuk inisialisasi variabel di C++: copy initialization dengan =, direct initialization dengan tanda kurung, dan list initialization dengan kurung kurawal beserta pengaman narrowing-nya.

Syarat nama variabel yang sah menurut standar C++, pesan error untuk nama ilegal, kata kunci yang tak boleh dipakai, serta konvensi camelCase dan snake_case untuk kode yang mudah dibaca.

Peta lengkap tipe fundamental C++: keluarga integral, floating-point, character, boolean, dan void, serta perbedaan tipe objek dengan tipe fungsi.

Keluarga tipe integer di C++: short, int, long, dan long long beserta ukuran minimalnya, empat basis penulisan literal, dan digit separator sejak C++14.

Tipe floating-point di C++: float, double, dan long double, cara menulis literalnya, perilaku presisi default cout, serta kapan memilih double atau float.

Tipe char beserta keluarganya untuk teks Unicode, sifat char sebagai integer kecil, tipe bool dengan true dan false, serta manipulator boolalpha.

Perilaku tipe signed versus unsigned: rentang nilai, wrap-around yang terdefinisi, jebakan mencampur keduanya dalam perbandingan, suffix literal, dan rekomendasi praktis.

Kata kunci auto untuk variabel: aturan deduksi tipe oleh compiler, kehilangan reference dan const pada salinan, syarat initializer, serta sekilas decltype.

Kata kunci const untuk variabel read-only dan constexpr untuk perhitungan saat kompilasi, perbedaan keduanya, static_assert, serta pengantar literal type.

Cara nilai berpindah antar tipe di C++: konversi implisit dan promotion, integer division yang menyesatkan, static_cast sebagai konversi eksplisit, dan batas aman versus kehilangan data.

Konversi yang mempersempit tipe dan bisa mengubah nilai: mengapa bentuk = membiarkannya lewat tanpa suara, kurung kurawal menolaknya sejak kompilasi, dan static_cast sebagai pernyataan eksplisit.

Pelajari cara membuat nama baru untuk tipe data dengan using agar deklarasi panjang lebih mudah dibaca dan dipelihara.

Pelajari cara menanyakan ukuran tipe dengan sizeof dan batas nilai tiap tipe melalui numeric_limits pada platform Anda.

Gunakan operator +, -, *, /, dan % dengan benar: perbedaan pembagian integer dan floating-point, sisa bagi, serta unary minus.

Simpan nilai ke variabel dengan =, ringkas operasi berulang dengan compound assignment, dan pahami bahwa penugasan juga menghasilkan nilai.

Bandingkan dua nilai dengan ==, !=, <, >, <=, >= yang menghasilkan bool; kenali jebakan perbandingan floating-point dan operator spaceship <=>.

Tulis operator<=> kustom saat = default tidak mencukupi: pilih kategori urutan yang tepat, atur urutan member, dan lengkapi == agar enam operator perbandingan tersedia.

Gabungkan nilai bool dengan &&, ||, dan !; pahami short-circuit evaluation yang melewati sisi kanan ekspresi, serta urutan kekuatan ketiganya.

Naikkan dan turunkan nilai satu langkah dengan ++ dan --; pahami perbedaan prefix dan postfix serta kapan masing-masing dipakai.

Bekerja di level bit dengan &, |, ^, ~, <<, dan >>: logika per bit, geser sebagai kali/bagi pangkat dua, serta pola set, check, dan clear bit.

Pilih salah satu dari dua nilai berdasarkan kondisi dengan operator ternary ?: dan pahami aturan tipe kedua cabangnya.

Gunakan operator scope resolution :: untuk menunjuk nama global, nama namespace, dan nama class, serta atasi variabel yang saling menutupi (shadowing).

Ubah tipe secara eksplisit dengan static_cast, dan kenali dynamic_cast, const_cast, reinterpret_cast, serta alasan C-style cast dihindari.

Ukur ukuran tipe dan ekspresi dalam byte dengan operator sizeof, kenali jaminan sizeof(char) == 1, dan bandingkan dengan alignof.

Pahami urutan kekuatan operator (precedence) dan arah pengelompokannya (associativity), serta bedanya dengan urutan evaluasi operand.

Kenali batas tipe integer, perilaku wrap aritmetika unsigned yang modular, bahaya signed overflow sebagai undefined behavior, dan strategi menghitung dengan aman.

Pernyataan if untuk menjalankan blok kode hanya bila kondisi terpenuhi: bentuk dasar, aturan kondisi, kesalahan = vs ==, dan inisialisasi di dalam kondisi.

Percabangan dua jalur dengan if-else: blok alternatif, bersarang, aturan kurung kurawal, dan bahaya dangling else.

Rantai else if untuk menguji banyak kondisi berurutan: evaluasi berhenti di kondisi pertama yang benar, urutan kondisi menentukan hasil, dan kapan switch menjadi alternatif.

Pernyataan switch untuk memilih aksi berdasarkan nilai tetap: case, break, default, perilaku fallthrough beserta atribut [[fallthrough]], dan batasannya pada tipe data.

Loop for dengan tiga klausa init, kondisi, dan iterasi: scope variabel loop, variasi multi-variabel dan klausa kosong, serta perbandingannya dengan while.

Loop while sebagai pre-test loop: mengulang selama kondisi benar, kapan lebih tepat daripada for, dan pola input sentinel dengan cin.

Loop do-while sebagai post-test loop: badan dijalankan minimal sekali, pola validasi input, dan program menu yang berulang.

Loop range-based for untuk mengunjungi setiap elemen koleksi: array, std::string, std::vector, by value versus by reference, dan initializer_list.

Kendali halus di dalam loop: break untuk keluar lebih awal, continue untuk melompati sisa putaran, perbedaannya pada for dan while, serta batasan penggunaannya.

Pernyataan return: mengakhiri fungsi main dengan exit code, pola early return, return pada fungsi void, dan perilakunya di dalam loop.

Loop di dalam loop: pola tabel dan matriks, hitungan iterasi berlipat, dan mengapa break hanya keluar dari loop terdalam beserta solusinya.

Di mana sebuah nama variabel boleh dipakai (scope) dan sampai kapan nilainya bertahan (lifetime): block scope, file scope, shadowing, static lokal, dan best practice.

Struktur definisi fungsi C++: return type, nama, parameter list, dan body, beserta aturan urutan penulisan terhadap main().

Bedah deklarasi (prototype) versus definisi fungsi, mengapa prototipe dibutuhkan, dan praktik menaruh prototipe di header.

Perbedaan parameter dan argumen, pemetaan posisi, serta desain fungsi dengan nol hingga beberapa parameter bertipe berbeda.

Tipe kembalian fungsi, return pada banyak jalur, aturan return type wajib di C++, dan kasus khusus main() tanpa return.

Mekanisme pass-by-value di C++: argumen disalin ke parameter, perubahan di dalam fungsi tidak memengaruhi pemanggil, dan biaya salinannya.

Parameter reference (int&) sebagai alias variabel pemanggil: perubahan terlihat, pola out parameter, dan kapan memakainya.

Parameter const& : kehematan reference tanpa risiko perubahan, aturan praktis memilih cara passing, dan penjagaan const oleh compiler.

Parameter dengan nilai bawaan: pemanggilan fleksibel, aturan bawaan dari kanan, posisi deklarasi vs definisi, dan jebakan bawaan yang tidak stabil.

Function overloading: nama sama dengan daftar parameter berbeda, cara compiler memilih (resolusi overload), dan benturan dengan default argument.

Kata kunci inline sebagai saran pada compiler, perbedaannya dengan makro #define yang berbahaya, dan peran inline di header.

Fungsi yang memanggil dirinya sendiri: base case, stack frame, bahaya stack overflow, kasus faktorial dan fibonacci, serta pembandingannya dengan loop.

Menyimpan dan memanggil fungsi lewat pointer, alias tipe dengan using, dan pola callback: fungsi sebagai parameter fungsi lain.

Lambda expression: fungsi tanpa nama yang ditulis langsung di tempat pemakaiannya — anatomi, penyimpanan di auto, pemanggilan langsung, dan for_each.

Pelajari cara lambda mengakses variabel luar melalui capture by value dan by reference, beserta aturan dan bahayanya.

Pelajari lambda generic dengan parameter auto (C++14) dan template parameter (C++20) untuk logika yang bekerja di banyak tipe.

Pelajari function template sebagai cetak biru fungsi untuk banyak tipe: deklarasi, deduksi tipe, instansiasi, dan batasannya.

Kenali array C-style: deklarasi, memori yang berurutan, ukuran tetap, dan indeks dari 0 sampai N-1.

Mengisi array C-style sejak awal: initializer list, perilaku nol pada elemen yang tak diisi, dan deduksi ukuran.

Membaca dan mengubah elemen array lewat indeks, pola penelusuran yang aman, dan bahaya akses di luar batas (undefined behavior).

Array dua dimensi untuk tabel dan matriks: inisialisasi nested, iterasi berlapis, dan tata letak memori row-major.

Mengirim array ke fungsi: array decay menjadi pointer, ukuran harus dikirim terpisah, dan perkenalan std::span sebagai solusi modern.

std::array: array ukuran tetap modern yang mengetahui ukurannya sendiri — size, at, operator[], fill, dan perbandingan dengan array C-style.

String di balik layar: array char berakhir '\0', fungsi strlen/strcpy/strcmp dari <cstring>, bahaya buffer overflow, dan kapan format ini masih ditemui.

std::string dari header <string>: konstruksi, assignment, concatenation dengan +, panjang .size(), akses per karakter, dan getline untuk membaca baris.

Kotak alat manipulasi std::string: substr, find, replace, insert, erase, starts_with/ends_with, serta konversi angka-ke-teks dan teks-ke-angka.

std::string_view: jendela baca-saja ke teks milik orang lain tanpa menyalin — cara pakai, konvensi parameter fungsi, dan bahaya view menggantung.

Pelajari std::vector sebagai container dinamis andalan: push_back, akses elemen, ukuran yang menyesuaikan, dan variasi inisialisasi.

Pahami perbedaan size dan capacity pada std::vector, cara vector menumbuhkan penyimpanannya, dan peran reserve.

Pelajari tiga gaya mengunjungi elemen array dan vector: loop indeks, range-based for, dan iterator eksplisit.

Panduan praktis memilih struktur data: array C-style, std::array, std::vector, std::string, dan string_view sesuai kebutuhan.

Memahami memori sebagai barisan byte, konsep alamat setiap variabel, operator address-of (&), dan cara membaca tampilan alamat dalam heksadesimal.

Mendeklarasikan pointer bertipe, mengisinya dengan alamat lewat &, mengganti sasarannya, dan membaca nilai yang ditunjuk lewat dereference.

Membaca dan menulis nilai melalui pointer dengan operator *, aturan precedence *p + 1 versus *(p+1), serta bahaya dereference pada pointer yang belum diinisialisasi.

Null pointer konstanta modern C++: mengapa nullptr lebih aman daripada NULL, cara memeriksa pointer kosong, dan bahaya dereference nullptr.

Hubungan erat array dan pointer: array decay ke pointer elemen pertama, akses elemen lewat notasi indeks maupun dereference, dan konsekuensi saat array dikirim ke fungsi.

Menggeser pointer dengan + dan -, menghitung selisih dua pointer, membandingkan pointer dalam array yang sama, serta batas-batas yang bila dilanggar menjadi undefined behavior.

Reference sebagai alias permanen variabel lain: deklarasi dan inisialisasi wajib, ketiadaan rebind, dan perbandingannya dengan pointer.

Tiga bentuk kombinasi const dan pointer — pointer to const, const pointer, dan const pointer to const — beserta cara membaca deklarasinya dari kanan ke kiri.

Mengirim pointer ke fungsi untuk mengubah nilai asli, pola OUT parameter, pemeriksaan null-safe di dalam fungsi, dan perbandingannya dengan parameter reference.

Deklarasi int** dan dereference bertingkat, kegunaannya untuk mengubah pointer di dalam fungsi dan array of pointers, serta posisinya di kode C++ modern.

void* sebagai pointer generik lintas tipe: mengapa tidak bisa didereference langsung, cara mengembalikannya ke tipe asal, use case API C, dan kapan sebaiknya dihindari.

Pointer yang menunjuk objek yang sudah tidak hidup: penyebab utamanya (variabel lokal yang selesai dan memori yang sudah di-delete) serta mitigasinya dengan nullptr dan smart pointer.

Peta lengkap pointer bermasalah — null, uninitialized, dangling, dan wild pointer — beserta cara mencegah masing-masing lewat kebiasaan defensif yang bisa dijadikan checklist.

Perbandingan lengkap pointer dan reference: sintaks, semantik rebind dan alias, nullability, panduan memilih, dan penutup Section Pointer dan Reference.

Mengenal struct sebagai tipe data komposit untuk mengelompokkan beberapa variabel terkait ke dalam satu kesatuan bernama.

Mendalami isi struct: aturan member variables, tipe apa saja yang boleh dijadikan member, serta bagaimana compiler menyusun ukuran memori struct.

Mengisi struct sejak lahir dengan daftar nilai: inisialisasi penuh, parsial, designated initializers C++20, inisialisasi bertingkat, dan syarat aggregate.

Mendefinisikan struct di dalam struct, mengakses member bertingkat, memilih lokasi definisi nested type, dan struct yang membawa container.

Mengenal unscoped enum sebagai konstanta bernama: nilai implisit dan eksplisit, serta masalah bocornya nama enumerator ke scope sekitar.

Mengenal enum class sebagai versi aman enumerasi: scope tertutup, tanpa konversi implisit, static_cast eksplisit, dan underlying type kustom.

Mengenal union yang berbagi satu area memori: aturan member aktif, ukuran memori, pola tagged union, anonymous union, dan alternatif modern std::variant.

Memberi nama bermakna pada struct, enum, dan tipe komposit lain lewat using, lengkap dengan perbandingan singkat terhadap typedef.

Fitur C++17 untuk mengurai isi struct, std::pair, std::tuple, dan std::array menjadi beberapa variabel bernama dalam satu pernyataan.

Pahami class sebagai cetak biru dan object sebagai instans nyata, lengkap dengan konsep state, behavior, dan alasan OOP dipakai untuk mengorganisasi program.

Pelajari sintaks definisi class di C++, aturan titik koma yang sering terlewat, serta perbedaan mendefinisikan member function di dalam dan di luar class.

Kendalikan siapa yang boleh mengakses member sebuah class memakai access specifiers, pahami default class versus struct, dan alasan data perlu disembunyikan.

Rancang isi class secara lengkap: deklarasi data member dengan in-class initializer, penulisan member function di dalam dan di luar class, serta pemanggilan lewat operator . dan ->.

Kenali constructor sebagai fungsi khusus yang mengisi object otomatis saat ia dibuat, lengkap dengan aturan penamaan dan teknik beberapa constructor dalam satu class.

Pahami default constructor: kapan compiler membuatnya secara otomatis, kapan ia menghilang, cara memaksa pembuatannya dengan = default, dan bahaya member tanpa nilai awal.

Kirim data ke object sejak detik pertama lewat constructor berparameter, kuasai overloading constructor, dan bandingkan sintaks pembuatan object dengan kurung dan kurawal.

Pelajari member initializer list: sintaks : member(nilai), alasan member const dan reference wajib memakainya, efisiensinya dibanding penugasan, serta aturan urutan inisialisasi.

Kurangi duplikasi antar constructor dengan delegating constructor: satu target constructor yang bekerja, sisanya meneruskan argumen kepadanya.

Kenali destructor: fungsi otomatis yang berjalan saat object berakhir, urutan destruksi yang kebalikan konstruksi, dan perannya saat object di heap dihapus dengan delete.

Pahami dua mekanisme penyalinan object — copy constructor yang menyalin saat object lahir dan copy assignment yang mengisi object lama — lengkap dengan deep copy, self-assignment guard, serta = default dan = delete.

Kenali this, pointer tersembunyi yang menunjuk object pemanggil: membedakan member dan parameter yang bernama sama, serta memicu method chaining lewat return *this.

Tandai method yang tidak mengubah object dengan const di akhir deklarasinya, pahami hubungannya dengan object const, dan hindari kesalahan umum lupa const.

Kenali static data member yang dibagi seluruh object dan static member function yang tidak punya this, termasuk definisi klasik di luar class dan inline static dari C++17.

Izinkan fungsi atau class tertentu mengakses member private melalui friend, pahami posisinya di luar urutan private/public, dan kenali kapan friend tepat serta kapan berbahaya.

Berikan makna operator seperti +, ==, [], ++, dan << pada class sendiri: pilih member atau free function, terapkan pola kanonik dengan return type yang tepat, dan kenali batas kapan overload justru merugikan.

Rangkai access specifier, constructor, dan getter/setter menjadi prinsip encapsulation: sembunyikan detail internal, buka hanya antarmuka yang bermakna, dan jaga invariant class.

Bangun class yang memiliki class lain sebagai bagian internalnya: member bertipe class, constructor member yang dipanggil otomatis, dan urutan konstruksi serta destruksinya.

Bangun class baru dari class yang sudah ada dengan inheritance: apa yang diwariskan, mengapa dasar dibangun lebih dulu, dan cara memanggil constructor dasar.

Pahami bagaimana access specifier pada penulisan inheritance — public, protected, dan private — mengubah status akses member dasar di class turunan, dan kapan tiap bentuk layak dipakai.

Mewarisi dua class dasar sekaligus: sintaks dan urutan konstruksinya, diamond problem yang menyertainya, serta virtual inheritance sebagai jalan keluarnya.

Kenali keyword virtual: cara satu baris ini mengubah pemilihan method dari saat kompilasi menjadi saat program berjalan, dan mekanisme vtable yang bekerja di baliknya.

Tulis ulang virtual function di class turunan dengan benar: aturan signature yang sama, keyword override yang menangkap kesalahan ketik, jebakan hiding, dan final yang menutup gerbang.

Rasakan buah dari virtual function: satu antarmuka, banyak perilaku — dikelola lewat container pointer dasar, plus peta kapan polimorfisme runtime atau compile-time yang tepat.

Gunakan pure virtual function untuk menjadikan class abstrak: tidak bisa diinstansiasi, hanya bisa diwarisi — kontrak antarmuka yang ditegakkan compiler sejak awal.

Bedah sintaks virtual ... = 0: kewajiban override bagi turunan, kemampuan pure virtual tetap punya implementasi default yang dipanggil lewat Dasar::nama, dan turunan yang tetap abstract bila lupa mengisi.

Menghapus object turunan lewat pointer class dasar hanya aman bila destructor class dasar virtual — chapter ini membuktikan perangkapnya, solusinya, dan aturan emas yang mengikutinya.

Menyalin object turunan ke variabel class dasar by value memotong seluruh bagian turunannya — mekanisme object slicing, bentuk-bentuknya yang menyamar, dan cara mencegahnya dengan reference, pointer, dan class dasar abstract.

Dua alat penyusun class dibandingkan secara tuntas: kapan is-a lewat inheritance, kapan has-a lewat composition — tabel keputusan, dua desain untuk satu masalah, dan penutup Section OOP.

Kenali dua wilayah memori utama program C++: stack yang otomatis dan cepat, heap yang fleksibel tetapi harus dikelola sendiri.

Storage duration menentukan berapa lama objek hidup: automatic mengikuti blok kode, dynamic bertahan sampai dilepas manual, static sepanjang program.

Alokasi memori dinamis di heap dengan operator new, pelepasannya dengan delete, aturan pasangan wajib, dan bahaya double delete.

Alokasi array dinamis dengan new T[n], pelepasan wajib dengan delete[], serta alternatif modern unique_ptr<T[]> dan std::vector.

Kebocoran memori: definisi, penyebab umum, deteksi dengan AddressSanitizer dan valgrind, serta pencegahannya dengan RAII.

Resource bukan hanya memori: pola acquire-use-release, masalah pelepasan manual, dan prinsip siapa mengalokasikan yang melepas.

Idiom RAII: mengikat umur resource ke umur objek sehingga pelepasan berjalan otomatis di semua jalur eksekusi, termasuk exception.

Smart pointer kepemilikan tunggal: make_unique, operator*, ->, get(), reset(), sifat tidak-bisa-disalin, dan zero overhead-nya.

Kepemilikan bersama dengan reference counting: make_shared, use_count(), biaya blok kontrol, dan kapan shared_ptr tepat dipakai.

Observer tanpa kepemilikan: weak_ptr memecah circular reference shared_ptr, dengan akses aman lewat lock() dan expired().

Meringkas semantik kepemilikan: unique untuk eksklusif, shared untuk bersama, weak sebagai observer, raw pointer hanya mengamati — plus konvensi passing antar fungsi.

Move = memindahkan kepemilikan resource tanpa menyalinnya: std::move pada unique_ptr, mengapa move penting, dan keadaan moved-from.

Exception melompati baris delete dan menciptakan kebocoran; RAII menjadikan pelepasan resource otomatis di jalur exception mana pun.

Rangkuman Section: aturan kode modern C++ — container dulu, unique_ptr sebagai default, shared_ptr hanya saat benar-benar dibagi, tanpa naked new/delete di kode aplikasi.

Kenali standard library C++: container, algorithm, iterator, utility, dan I/O, serta alasan mengapa kita memakainya di hampir setiap program.

Kuasai sisi praktis std::string: konversi string dan angka, keluarga find, substr, serta posisi string_view sebagai jendela baca-saja.

Operasi lanjutan std::array dan std::vector: fill, swap, insert, erase, perbedaan push_back dan emplace_back, serta kapan masing-masing dipakai.

Kenali std::deque yang cepat di kedua ujung dan std::list yang lincah di tengah, lengkap dengan perbandingan terhadap std::vector.

Gunakan adapter std::stack (LIFO) dan std::queue (FIFO) untuk pola tumpukan dan antrean, disertai pengantar std::priority_queue.

Simpan nilai unik yang selalu terurut dengan std::set, dan izinkan duplikat dengan std::multiset: insert, find, count, dan erase.

Petakan kunci ke nilai dengan std::map: operator[] vs at() vs insert, iterasi pair dengan structured bindings, dan multimap untuk banyak nilai per kunci.

std::unordered_set: keanggotaan O(1) rata-rata lewat hash, urutan iterasi yang tidak ditentukan, dan perbandingannya dengan std::set.

Petakan kunci-nilai dengan akses O(1) rata-rata: contains, count, find, emplace, dan insert_or_assign pada std::unordered_map.

Bungus beberapa nilai dalam satu objek dengan std::pair dan std::tuple: first/second, std::get, make_tuple, tuple_size, dan structured bindings.

Nyatakan 'mungkin tidak ada nilai' dengan std::optional: has_value, operator bool, value vs value_or, dan perbandingannya dengan sentinel.

Simpan salah satu dari beberapa tipe dengan aman lewat std::variant: holds_alternative, get_if, dan std::visit dengan lambda.

Tampung tipe apa pun dengan std::any: any_cast, pemeriksaan has_value dan type(), biaya runtime, dan kapan memilih any dibanding variant.

Jendela non-owning ke data kontigu lewat std::span: satu parameter fungsi menerima vector, std::array, dan array C, plus subspan untuk potongan tanpa salinan.

Kuasai penanganan waktu C++ lewat std::chrono: tiga konsep inti duration, clock, dan time_point, literal waktu C++14, konversi antar satuan, kalender C++20, hingga pengantar time zone.

Simpan callable apa pun — function pointer, lambda, functor — dalam satu wadah std::function: type erasure, cek keadaan kosong, biayanya, dan pola callback registry.

Cari, validasi, dan ganti pola teks dengan std::regex: regex_match, regex_search, regex_replace, regex_iterator, pilihan grammar, dan kapan parsing manual lebih tepat.

Kelola deret bit berukuran tetap dengan std::bitset: set, reset, test, flip, count, operasi bitwise, konversi ke string, dan use case flag.

Fungsi perhitungan dari header <numeric>: gcd dan lcm untuk bilangan bulat, midpoint (C++20) untuk titik tengah tanpa luapan, plus ringkasan seluruh isi header.

Fungsi utilitas dari <utility> dan <algorithm>: std::swap, std::exchange, std::min/max/clamp, helper std::pair, dan pratinjau std::move.

Kerangka keputusan memilih container: tabel perbandingan seluruh container yang dipelajari, pertanyaan kunci, demo satu data dengan empat pilihan berbeda, dan penutup Section Standard Library.

Mengenal iterator sebagai generalisasi pointer yang membuat satu algoritma bisa bekerja di semua container.

Lima kategori iterator — input, output, forward, bidirectional, dan random access — serta alasan algoritma menuntut kategori tertentu.

Member begin()/end() versus std::begin/std::end, dukungan array C-style, cbegin/cend, dan makna one past the last.

Adapter iterator back_inserter, front_inserter, inserter, serta istream/ostream_iterator: membuat container tumbuh sendiri dan menghadirkan stream dalam algoritma.

Memahami konvensi [first, last) yang dipakai semua algoritma STL dan pola pemakaiannya, termasuk pratinjau std::ranges::.

Menyortir vector<int> dan vector<string> dengan std::sort, kompleksitasnya, serta pratinjau comparator dan stable_sort.

Mencari elemen dengan std::find dan find_if, menafsirkan iterator yang dikembalikan, dan pola counting untuk menghitung kemunculan.

Pencarian logaritmik pada data terurut dengan std::binary_search, lower_bound, upper_bound, dan equal_range.

Mencari elemen terkecil dan terbesar dengan min_element, max_element, minmax_element, serta membandingkan dua nilai dengan std::min dan std::max.

Menghitung kemunculan nilai dan elemen yang lolos kondisi dengan std::count dan count_if, termasuk tipe kembalian ptrdiff_t.

Menyalin elemen dengan std::copy, copy_if, copy_n, memakai back_inserter, serta memindahkan elemen dengan algoritma std::move.

Mengubah setiap elemen lewat fungsi dengan std::transform — versi unary, binary, pemakaian in-place, dan kombinasi dengan back_inserter.

Menghapus elemen dari vector dengan idiom erase(remove(...)) — mengapa std::remove tidak menghapus, dan modernisasi std::erase_if C++20.

Membagi rentang menjadi dua kelompok menurut predikat dengan partition, stable_partition, dan mencari batasnya dengan partition_point.

Mengagregasi rentang menjadi satu nilai dengan accumulate (fold kiri yang deterministik) dan reduce (ramah paralel), termasuk nilai awal dan operasi khusus.

Mengisi deret dan mengagregasi pasangan elemen dengan iota, inner_product, partial_sum, dan adjacent_difference dari header numeric.

Menulis comparator sendiri sebagai fungsi bebas, lambda, atau function object — dengan syarat strict weak ordering dan pola multi-kriteria.

Functor sebagai class dengan operator(): state, penggunaan ulang, function object bawaan seperti std::greater, dan perbandingannya dengan lambda.

Mengolah data dengan C++20 Ranges: merangkai view filter, transform, dan take menjadi pipeline, memahami lazy evaluation, serta memakai algoritma std::ranges:: yang lebih ringkas.

Mendalami projection pada algoritma ranges, membedah batasan comparator versus projection, serta memakai fitur C++23: ranges::to, views::zip, dan views::enumerate.

Memetakan isi `<iostream>`: keluarga kelas istream/ostream, empat objek standar cout/cin/cerr/clog, abstraksi stream, serta perilaku buffer.

Mengatur tampilan output secara presisi: width, fill, dan precision pada cout, serta std::format dan std::print sebagai cara modern C++20/23.

Menggunakan manipulator dari <iomanip> dan <ios>: setw, setprecision, fixed, setfill, left/right, boolalpha, dan hex/dec/oct, plus perbandingan endl dengan '\n'.

Membentuk output yang type-safe dan mudah dibaca: format spec mini-language, argumen posisi, std::format_to, formatter custom, dan std::println.

Menangani kegagalan cin: memahami state stream, memulihkan dengan clear() dan ignore(), validasi angka dalam loop, serta perilaku num_get.

Mengenal <sstream>: istringstream untuk parsing, ostringstream untuk membangun string bertahap, dan pola pemakaian keduanya.

Membuka file dengan <fstream>: ifstream, ofstream, fstream, mode pembukaan ios::in/out/app/binary/trunc, is_open, dan penutupan otomatis lewat RAII.

Membaca file teks dengan benar: getline per baris, operator>> per token, pola loop yang tepat, dan jebakan eof yang sering menghantui pemula.

Menulis file teks dengan aman: ofstream mode trunc versus app, pemeriksaan keberhasilan tulis, flush, penamaan file, dan prinsip tidak menimpa data penting.

Akses file biner dengan ios::binary serta write/read bertumpu reinterpret_cast, termasuk risiko endianness, struct padding, dan portabilitasnya.

Mengenal <filesystem> (C++17): namespace std::filesystem, path, create_directory, exists, file_size, directory_iterator, dan remove untuk mengelola direktori serta file.

Membedah std::filesystem::path: operator/, parent_path, filename, stem, extension, konversi string(), absolute versus relative, serta recursive_directory_iterator.

Dua gaya kegagalan operasi file: exception filesystem_error versus overload std::error_code, pemeriksaan exists, masalah izin, dan pola tangguh membaca file dengan pesan yang jelas.

Konsep serialisasi: menyimpan vector<struct> ke file teks berlabel dan memuatnya kembali persis (round-trip), plus gambaran format biner dan library eksternal seperti cereal dan protobuf.

Mengenal tiga kategori kesalahan pada C++ — compile error, link error, dan runtime error — beserta strategi menggeser kesalahan ke waktu kompilasi.

Exception sebagai mekanisme pelaporan kegagalan yang memisahkan titik deteksi dari titik penanganan, beserta konsep stack unwinding.

Menulis blok try/catch: menangkap exception lewat const reference, menyusun beberapa handler, catch-all, dan urutan handler yang benar.

Pernyataan throw secara penuh: melempar by value dan menangkap by reference, rethrow dengan throw;, serta perilaku throw di dalam constructor.

Hierarki std::exception: what(), keluarga logic_error dan runtime_error, bad_alloc, bad_cast, dan cara memilih tipe yang tepat.

Membangun class exception sendiri dengan mewarisi std::exception atau std::runtime_error, meng-override what() noexcept, dan membawa data domain.

Tiga tingkat jaminan exception safety — basic, strong, dan noexcept — serta idiom copy-and-swap untuk mencapai jaminan kuat.

noexcept specifier dan operator, destruktor yang implicit noexcept, serta alasan move constructor noexcept mengubah perilaku realokasi vector.

Pelajari cara menjaga kontrak kode dengan assert untuk invariant runtime, static_assert untuk pemeriksaan compile time, dan efek NDEBUG pada build debug vs release.

Pelaporan kegagalan tanpa exception: errno yang lama, std::error_code dengan std::errc, dan overload filesystem yang menerima error_code.

std::expected<T,E> dari C++23: membawa nilai atau galat dalam satu return value, akses has_value/value/error/value_or, operator bool, dan operasi monadic and_then, transform, or_else.

Matriks keputusan antara exception dan pelaporan lewat nilai (error_code/expected): jenis kegagalan, biaya zero-cost versus mahal saat throw, dan gaya codebase.

Pendalaman function template: beberapa parameter tipe, deduksi return type dengan auto, dan pratinjau spesialisasi eksplisit.

Bangun class generik dengan template: Kotak<T>, member function di dalam dan di luar class, instansiasi eksplisit, dan std::vector sebagai contoh klasik.

Kenali tiga jenis parameter template: typename/class, default template argument, dan template template parameter.

Parameter template tidak harus tipe: pelajari NTTP, dari std::array<int, 5> sampai auto NTTP dan konstanta constexpr.

Berikan perilaku khusus untuk tipe tertentu: full specialization pada class template dan function template.

Spesialisasi sebagian: pola Kotak<T*>, spesialisasi member, dan alasan function template tidak mendukung partial specialization.

Template dengan jumlah argumen bebas: parameter pack, pack expansion, pola rekursi, dan sizeof...(Args).

Anatomi pack expansion: pola perluasan sederhana sampai pemanggilan fungsi, forwarding pack ke fungsi lain, dan emplace_back.

Empat bentuk fold expression C++17 untuk memproses parameter pack tanpa rekursi: penjumlahan, pencetakan, dan pengujian logika.

Periksa dan manipulasi tipe pada saat kompilasi: is_integral_v, is_pointer_v, remove_reference_t, decay_t, dan enable_if.

Fungsi constexpr boleh dihitung compiler saat kompilasi dan fungsi consteval wajib dihitung saat kompilasi: pelajari aturan pemilihannya, bukti static_assert, serta std::vector dan algoritma constexpr di C++20/23.

Kendala template C++20: concept baku dan buatan, auto dengan concept, serta pesan error yang akhirnya menjelaskan diri sendiri.

Menulis kendala ad-hoc dengan requires expression: mengecek keberadaan operasi, empat jenis requirement, dan pola requires requires.

static_assert dengan pesan sendiri, kendala pada class template, dan if constexpr untuk memilih perilaku per tipe — tanpa SFINAE manual.

Pola-pola puncak kode generik: policy-based design, tag dispatch, CRTP, dan type erasure — plus kapan generik lebih tepat daripada OOP.

Peta fitur C++11 yang membuka era modern C++: auto, range-based for, lambda, smart pointer, move semantics, nullptr, uniform initialization, dan constexpr.

C++14 memoles C++11: generic lambda, return type deduction, binary literal, digit separator, [[deprecated]], dan relaxed constexpr.

C++17: structured bindings, if constexpr, if/switch dengan initializer, std::optional/variant/any, inline variables, fold expressions, [[nodiscard]], dan string_view.

C++20: concepts, ranges, three-way comparison, span, format, jthread, designated initializers, plus pengantar coroutines dan modules.

C++23: std::print/println, std::expected, deducing this, multidimensional subscript, std::generator, static operator(), if consteval, dan std::mdspan.

Isi C++26 (reflection, contracts, std::hive, std::inplace_vector, pack indexing, placeholder _), status standar Maret 2026, dan cara mengecek dukungan compiler dengan feature-test macro.

Sintaks {} untuk semua tipe: menolak narrowing, aggregate init, jebakan constructor std::initializer_list (vector{3} vs vector(3)), dan most vexing parse yang terselesaikan.

Aturan deduksi auto untuk variabel, kembalian, dan parameter, ditambah decltype, decltype(auto), dan structured bindings sebagai keluarga auto.

Pendalaman range-based for: perluasan yang dibangun compiler, init-statement C++20, umur temporary yang berbahaya, dan cara membuat class sendiri mendukung loop ini.

Fitur lambda era modern: init-capture dan move-capture (C++14), template parameter lambda (C++20), mutable, dan immediately-invoked lambda.

Konsep move semantics secara pragmatis: perbedaan copy dan move, peran std::move, kapan move terjadi otomatis, dan aturan pakai di kode sehari-hari.

Meneruskan argumen dari wrapper generik tanpa salinan ekstra: forwarding reference T&&, deduksi lvalue vs rvalue, std::forward, dan pola emplace-style.

Pendalaman structured bindings: membongkar struct, std::tuple, dan std::array, aturan by value versus referensi, dan use case iterasi std::map.

Tur atribut standar C++ pada deklarasi: nodiscard, maybe_unused, deprecated, fallthrough, likely dan unlikely, no_unique_address, serta atribut khusus compiler.

Cabang yang dipilih compiler saat kompilasi: satu template untuk banyak tipe tanpa tag dispatch maupun SFINAE, berpasangan dengan type traits.

Sinergi dua fitur C++20: concepts menjaga syarat tipe, ranges menyediakan algoritma ter-constrain dan pipeline view — ditulis sekali, divalidasi compiler.

Konsep coroutine dengan co_yield, co_await, dan co_return — serta std::generator C++23 untuk deret malas tanpa menulis promise type sendiri.

Fitur C++20 yang menggantikan header tradisional: masalah #include, sintaks export module dan import, keuntungan, status dukungan compiler, serta strategi migrasi bertahap.

Ringkasan gaya penulisan C++ modern — auto, structured bindings, uniform init, smart pointer, ranges, concepts, const, constexpr — dibuktikan lewat refactor nyata dari kode lama ke kode modern.

Perbedaan praktis lvalue (objek dengan identitas) dan rvalue (nilai sementara), bukti lewat operator & dan pilihan overload compiler.

Taksonomi resmi C++17: prvalue, xvalue, dan lvalue, plus klasifikasi ekspresi yang dibuktikan lewat decltype dan static_assert.

Referensi T&& yang mengikat nilai sementara, aturan perpanjangan umur temporary, dan pilihan overload antara const T& dan T&&.

Menulis move constructor `Nama(Nama&&) noexcept`: transfer pointer resource, moved-from state yang valid, dan bukti biayanya konstan.

Menulis operator=(T&&) noexcept: guard self-assignment, melepas resource lama dulu, dan peran noexcept pada realokasi std::vector.

std::move tidak memindahkan apa pun — ia hanyalah cast ke rvalue; kesalahan umum, perilaku pada tipe fundamental, dan larangan di return.

Meneruskan argumen generik tanpa merusak kualitasnya: masalah overload berlipat ganda, deduksi T&& pada lvalue vs rvalue, dan std::forward.

Kapan T&& menjadi forwarding reference: konteks deduksi, auto&&, dan bedanya dengan rvalue reference murni pada member class.

Aturan runtuhnya referensi ke referensi: empat kombinasi, perannya dalam std::forward, dan collapsing pada alias template.

C++17 menjamin prvalue dikonstruksi langsung di tujuan tanpa copy/move — bukti dengan class tanpa copy/move constructor, dan batasan elision.

RVO versus NRVO: kapan dijamin standar, kapan opsional, batasan NRVO pada pernyataan bercabang, dan anti-pola return std::move.

Kapan menulis lima fungsi khusus, kapan cukup delegasi ke member, dan kapan melarang copy — aturan desain penutup section Move Semantics.

Perbedaan proses dan thread, memori bersama di dalam satu proses, konteks switching, dan kapan multithreading tepat dipakai.

Membuat thread dari fungsi dan lambda, mengirim argumen by value dan by reference dengan std::ref, join(), serta bahaya detach dan std::terminate.

State thread dari baru sampai selesai, makna joinable vs joined, hardware_concurrency(), dan identitas thread lewat get_id().

Data race tanpa mutex, critical section, dan pola lock()/unlock() yang benar dengan std::mutex pada penghitung bersama.

RAII locking dengan lock_guard, fleksibilitas unique_lock (defer, owns_lock, timed), serta shared_mutex dan shared_lock untuk banyak pembaca.

Empat kondisi deadlock, pola dua mutex dengan urutan berbeda yang saling mengunci, dan pencegahannya dengan std::lock serta scoped_lock.

Menunggu kondisi tanpa busy waiting: condition_variable, wait dengan predicate, spurious wakeup, notify_one vs notify_all, dan pola producer-consumer.

Alat sinkronisasi modern C++20 dalam satu tur: sinyal berbasis penghitung, titik kumpul sekali pakai, dan titik kumpul berulang, lengkap dengan panduan memilih di antara mereka.

std::atomic untuk penghitung bersama: fetch_add, load, store, exchange, compare_exchange, atomic_flag, dan kapan atomic cukup tanpa mutex.

Happens-before secara ringan, memory_order (seq_cst default, acquire/release, relaxed), dan demo deterministik pasangan release-acquire.

Definisi data race menurut standar C++, kenapa ia undefined behavior, deteksi dengan ThreadSanitizer, dan pola desain yang bebas data race.

Mengirim hasil dan exception antar thread lewat kanal satu arah std::promise dan std::future, plus shared_future untuk banyak pembaca.

Menjalankan tugas dan mengambil hasilnya: launch policy async vs deferred, exception yang diantar future, dan catatan portabilitas policy default.

Merakit thread pool mini dari mutex, condition variable, dan future: antrian tugas, worker loop, shutdown bersih, serta cara memilih ukuran pool.

std::jthread dengan join otomatis, penghentian kooperatif lewat stop_token dan stop_source, serta stop_callback sebagai reaksi sinyal.

Execution policy pada algoritma standar (std::execution::par), ketergantungan TBB di GCC, dan alternatif teruji: partisi manual dengan std::thread.

Menghadapi bug konkuren: heisenbug, logging disiplin, reduksi reproduksi, uji invariant, dan checklist desain program multithread yang aman.

Pahami alamat IP dan port, perbedaan TCP dan UDP, socket sebagai API sistem operasi, serta peta protokol umum sebelum menulis kode jaringan.

Tulis server dan client TCP dengan POSIX Socket API: alur socket, bind, listen, accept, connect, serta pola port ephemeral dengan getsockname.

Kirim dan terima datagram UDP dengan sendto dan recvfrom, pahami sifat pesan terpisah yang bisa hilang, dan kenali kapan UDP lebih tepat daripada TCP.

TCP hanyalah aliran byte tanpa batas pesan: pelajari framing length-prefix dan delimiter, loop recv sampai cukup, penanganan partial send/recv, hingga protokol biner mini yang diuji.

Bedah format pesan HTTP lewat client mentah berbasis socket yang diuji di loopback, lalu kenali easy interface libcurl — curl_easy_init, CURLOPT_URL, WRITEFUNCTION — untuk client HTTP produksi.

Kenapa thread per koneksi tidak skalabel, bagaimana io_context dan handler callback menjawabnya, callback vs coroutine C++20, serta status standalone Asio dan Boost.Asio — lengkap dengan event loop mini yang diuji.

Perbedaan perilaku unsigned modular dan signed yang berujung undefined behavior saat overflow, cara mendeteksinya sebelum terjadi, dan strategi memilih tipe yang lebih besar.

Bagaimana IEEE 754 menyimpan floating-point dalam sign, exponent, dan mantissa; perbedaan float 32-bit dan double 64-bit; serta nilai khusus infinity dan NaN.

Presisi signifikan floating-point, kasus klasik 0.1 + 0.2 tidak sama dengan 0.3, makna std::numeric_limits::epsilon, dan cara membandingkan floating-point dengan toleransi absolut maupun relatif.

Bagaimana pembulatan menumpuk dalam penjumlahan panjang, kehilangan signifikansi saat nilai kecil masuk ke akumulator besar, dan perkenalan Kahan summation sebagai penangkalnya.

Pendalaman std::numeric_limits dari header <limits>: max, lowest, min, epsilon, round_error, infinity, quiet_NaN, denorm_min, has_infinity, serta perbedaan digits10 dan max_digits10.

Bilangan acak modern dengan header <random>: engine std::mt19937 dan distribusi uniform_int_distribution serta normal_distribution, seed deterministik untuk pengujian, dan mengapa rand() tidak layak dipakai lagi.

Bilangan complex dengan std::complex<double>: operasi aritmetika, konjugat, modulus, argumen, dan perkalian sebagai rotasi — lengkap dengan contoh teruji dan artefak floating-point-nya.

Tiga cara menyimpan vektor dan matriks di C++ — std::array, vector nested, dan flat vector dengan indeks i*cols+j — plus dot product, perkalian matriks, dan implikasi cache locality-nya.

Tur `<cmath>`: sqrt, pow, exp, log, trigonometri, fabs, fmod vs remainder, penanganan NaN dari domain tak sah, dan konversi angka antar tipe dengan aman.

Studi kasus metode stabil vs tidak stabil pada persamaan kuadrat, uji acuan dengan nilai yang diketahui dan toleransi, prinsip uang pakai integer sen, serta penutup Section Pemrograman Numerik.

Menilai biaya algoritma lewat jumlah operasi dan penggunaan memori, dilengkapi teknik pencatatan operasi dan pengukuran waktu dengan chrono.

Notasi Big-O untuk meringkas pertumbuhan biaya algoritma: O(1), O(log n), O(n), O(n log n), O(n^2), plus aturan menghitungnya dari kode dan best/average/worst case.

Perbedaan array statis dan dynamic array, mekanisme doubling di balik std::vector, serta implementasi mini DynamicArray<int> dari nol.

Membangun singly linked list manual: struct Node, insert head/tail, delete, traverse, dan search, serta perbandingannya dengan std::vector.

Konsep LIFO dan implementasi stack berbasis std::vector, disertai aplikasi klasik: pemeriksa kurung seimbang.

Konsep FIFO, implementasi circular buffer manual, simulasi antrian dengan std::queue, dan pengantar deque dua ujung.

Konsep hashing, penanganan collision dengan chaining, hash function untuk string, serta load factor dan rehash pada hash table mini.

Terminologi tree (root, leaf, depth, height), pembangunan binary tree dengan struct Node, dan tiga traversal rekursif: pre-order, in-order, post-order.

Properti BST, insert dan search O(log n), in-order traversal yang menghasilkan data terurut, penghapusan dengan tiga kasus, dan bahaya tree degenerate.

Properti min-heap dan max-heap, representasi heap di array, sift-up dan sift-down manual, serta std::priority_queue dengan ordering-nya.

Graf sebagai simpul dan busur, perbandingan adjacency list dengan adjacency matrix, serta penjelajahan BFS dan DFS dengan urutan visit yang deterministik.

Implementasi linear search manual dengan penghitung perbandingan, best case dan worst case, kapan algoritma ini cukup, serta pratinjau binary search.

Implementasi binary search iteratif dan rekursif, syarat data terurut, jebakan overflow pada perhitungan mid, serta kaitannya dengan lower_bound.

Selection sort, insertion sort, dan merge sort diimplementasikan manual dengan penghitung perbandingan, tabel kompleksitas, serta recap std::sort.

Pola pilih-jelajahi-urungkan pada backtracking, diterapkan pada semua permutasi dan N-Queens 4x4 dengan hasil deterministik.

Algoritma greedy pada coin change dan interval scheduling, termasuk contoh nyata kapan greedy gagal mencapai optimum.

Pola bagi-selesaikan-gabungkan, merge sort sebagai templatnya, dan studi kasus max subarray tiga cara dibandingkan dengan Kadane.

Memoization lawan tabulation, fibonacci tiga cara dengan penghitung panggilan, coin change minimum, dan LIS dengan rekonstruksi jawaban.

Dijkstra dengan adjacency list dan priority_queue untuk jarak terpendek, rekonstruksi jalur, serta deteksi siklus dengan DFS tiga warna.

Satu beban kerja diuji pada empat struktur, tabel keputusan struktur data dan padanan STL, pertimbangan pola akses, serta rangkuman section.

Mengapa debugger lebih unggul daripada printf debugging, dan panduan dasar gdb: run, break, next, step, print, serta backtrace.

Penempatan breakpoint yang cerdas, breakpoint bersyarat, dan watchpoint untuk melacak siapa yang mengubah sebuah variabel.

Membedah stack trace dari gdb, laporan crash Linux, exception, dan std::stacktrace C++23 untuk menemukan lokasi bug.

Membaca peringatan compiler dengan -Wall -Wextra -Wpedantic, memilah yang berbahaya dari yang minor, dan menegakkannya dengan -Werror.

Cara kerja AddressSanitizer, UndefinedBehaviorSanitizer, ThreadSanitizer, dan LeakSanitizer: instrumentasi, overhead, dan kapan dipakai.

Mendeteksi heap-buffer-overflow, use-after-free, dan double-free dengan -fsanitize=address, plus cara membaca laporannya secara sistematis.

Mendeteksi signed overflow, shift di luar rentang, dan pointer tak sejajar dengan -fsanitize=undefined, serta cara mengubahnya menjadi error nyata.

Mendeteksi data race antar thread dengan -fsanitize=thread: membaca laporannya, memahami prinsip kerjanya, dan memperbaikinya dengan atomic.

Kenali fuzzing berumpan-balik cakupan: konsep corpus dan mutasi, fuzz target libFuzzer, kombinasi dengan AddressSanitizer, hingga membedah input yang memicu crash.

Analisis statis dengan g++ -fanalyzer: menemukan bug tanpa menjalankan program, dipadu cppcheck dan posisinya terhadap sanitizer.

Mengapa format konsisten penting, cara kerja berkas .clang-format, style bawaan seperti Google dan LLVM, serta integrasi editor dengan format-on-save.

Cara kerja clang-tidy: kategori check bugprone, performance, modernize, dan readability; membaca laporan, mengonfigurasi .clang-tidy, dan mengintegrasikannya ke CI.

Konsep unit testing, pola Arrange-Act-Assert, sketsa GoogleTest dan Catch2, serta mini test harness sendiri dengan macro CHECK yang benar-benar kita jalankan.

Naik kelas dari mini harness buatan sendiri ke framework standar industri: makro TEST dan TEST_F, keluarga EXPECT dan ASSERT, matcher, filter binary uji, hingga integrasi CMake/CTest — semua dijalankan dengan GoogleTest 1.14 sungguhan.

Perbedaan unit test dan integration test, konsep fixture setup-teardown, dan mini integration test tulis-baca berkas yang benar-benar kita jalankan, plus pola job CI.

Katalog lima error memori klasik C++ beserta alat deteksinya, laporan LeakSanitizer, pencegahan dengan RAII, dan checklist penutup section debugging.

Pembagian kode ke file .h dan .cpp — apa yang boleh di header, apa yang harus di source file, dan aturan include yang minimal.

Perbedaan deklarasi dan definisi, variabel extern, aturan ODR, plus dua kasus khusus: const di header dan fungsi static.

Mengapa header perlu pelindung dari double include — pola #ifndef/#define/#endif, penamaan guard yang unik, dan demonstrasi error tanpa pelindung.

Satu baris pengganti include guard — cara kerja #pragma once, portabilitasnya di compiler utama, dan kapan memilih mana.

Model kompilasi terpisah C++ — translation unit, dari .cpp ke object file lalu link, dan kenapa incremental build penting.

Bagaimana linker menyatukan object file lewat simbol — defined vs undefined, tool nm, dan anatomi error undefined reference.

Membuat static library (.a) dengan ar dan dynamic library (.so) dengan -fPIC -shared — lengkap dengan cara link, menjalankan, dan kapan memilih masing-masing.

Otomatisasi build dengan make — target, dependencies, recipe, variabel, pattern rule, dan incremental build yang kita jalankan sungguhan.

Arsitektur CMake — generator yang menghasilkan build system native, CMakeLists.txt minimal, alur configure-build, dan cara memasangnya.

Vokabuler inti CMake — add_executable, add_library, target_link_libraries, dan target_include_directories dengan properti modern per target.

Tiga jalur resmi CMake untuk menarik library dari luar proyek — add_subdirectory, find_package, dan FetchContent — beserta cara kerja dan kapan masing-masing dipakai.

vcpkg sebagai manajer paket C++ — pemasangan, mode klasik vs manifest vcpkg.json, integrasi toolchain dengan CMake, dan kapan vcpkg menjadi pilihan tepat.

Conan sebagai manajer paket C++ berbasis profil — conanfile.txt dan conanfile.py, conan install, integrasi CMake lewat generator, dan perbandingannya dengan vcpkg.

Strategi mengelola dependensi C++ — vendor, git submodule, package manager, FetchContent — beserta trade-offs, ringkasan Semantic Versioning, dan prinsip minimal dependencies.

CTest sebagai pelari tes bawaan CMake — anatomi program tes, enable_testing dan add_test, plus test runner mini yang dijalankan sungguhan di lingkungan praktikum.

Memindahkan rangkaian build-tes-lapor ke mesin lain: pipeline GitHub Actions untuk C++ dengan matrix compiler, cache, sanitizer, lint, dan artefak, plus skrip CI mini yang dijalankan sungguhan.

Debug vs Release — tingkat optimasi -O0 sampai -Os, informasi debug -g, dan bagaimana NDEBUG membuat assert ikut menghilang di build release, semuanya diuji di lingkungan praktikum.

Susunan folder proyek C++ — include, src, tests, docs, build — aturan penempatan header, flat vs nested, dan rangkuman penutup section Build System dan Project Structure.

Kriteria membagi program — responsibility, kohesi, coupling — dan refactor nyata dari satu fungsi main() monolitik menjadi tiga class yang terpisah.

Antarmuka vs implementasi, level abstraction, dan idiom PIMPL — menyembunyikan implementasi di balik pointer dengan unique_ptr dan forward declaration, lengkap dengan keuntungan kompilasinya.

Memisahkan parsing, logika bisnis, dan presentasi menjadi tiga lapisan — refactor nyata program laporan, arah dependensi, dan pengujian per bagian.

Arah dependensi antar modul, kopling erat vs kopling longgar, masalah circular dependency dan solusinya, inversion, serta antarmuka minimal — semua di level desain, bukan alat build.

Lima prinsip desain — SRP, OCP, LSP, ISP, DIP — masing-masing dengan potongan kode C++ nyata, ditutup satu program demonstratif multi-class dan tabel ringkas.

Recap keputusan is-a vs has-a lalu pendalaman praktis: decorator via composition, strategy lewat antarmuka runtime vs template policy, dan tabel keputusan desain.

Pola GoF yang paling relevan untuk C++ modern — Strategy, Observer, Factory Method, Adapter, dan Singleton beserta kritiknya — dengan tiga pola teruji dalam satu program.

Mengirim dependensi dari luar lewat constructor injection — antarmuka, implementasi nyata, test double (stub dan fake) untuk unit test — semuanya tanpa framework.

Mendesain antarmuka function dan class yang mudah dipakai dan sulit disalahgunakan: nama eksplisit, parameter minim, return type yang jujur, noexcept dan const correctness, sampai versi dan dokumentasinya.

Fungsi khusus sebagai bagian tak terlihat dari API class: Rule of Zero sebagai pilihan default, kapan Rule of Five benar-benar diperlukan, serta = default dan = delete untuk menyatakan niat.

Refactoring terencana: empat code smell yang paling sering muncul, langkah aman kecil-berurutan-teruji, dan refactor before/after dengan output yang dibuktikan identik.

Membedah biaya program sebagai waktu, memori, dan energi melalui empat level keputusan, lengkap dengan demo penghitungan biaya yang deterministik.

Menemukan bagian program yang paling menyita waktu memakai profiler manual, gprof, dan pola pengukuran chrono.

Memahami apa yang benar-benar dikerjakan compiler optimizer, mengapa semantik program tidak boleh berubah, dan kapan constexpr menjadi optimizer manual.

Menakar perbedaan perilaku, ukuran, dan jebakan tiap level optimasi GCC: dari -O0 untuk debugging sampai -Ofast yang mengubah aritmetika.

Membaca biaya akses memori melalui hierarki cache dan cache line 64 byte, dengan perbandingan traversal baris versus kolom pada matriks.

Membongkar tata letak byte objek C++: stack versus heap, padding dan alignment antar member, serta false sharing pada program multithread.

Merancang tata letak data mengikuti pola akses hot loop, dengan perbandingan konkret array of struct versus struct of array.

Membuktikan biaya salinan yang bisa dihindari dengan penghitung alokasi: reserve sebelum push_back, emplace_back, idiom pass by value plus move, dan membangun string secara bertahap.

Menghitung biaya alokasi heap di dalam loop, memanfaatkan Small String Optimization, memakai ulang buffer, dan mengenal arena allocator sebagai cara mengelompokkan alokasi.

Mengukur kecepatan secara jujur: mencegah dead-code elimination dengan idiom doNotOptimize, disiplin pemanasan dan pengulangan, harness mini berbasis chrono, dan pengenalan Google Benchmark.

Biaya tersembunyi instruksi cabang: pipeline prosesor dan prediksi yang salah pada demo klasik array acak versus terurut, cara berpikir branchless, serta petunjuk [[likely]] dan [[unlikely]].

Satu instruksi memproses banyak data: konsep SIMD, auto-vectorization GCC yang bisa kita periksa dengan -fopt-info-vec, intrinsics _mm_add_ps pertama, dan kapan SIMD layak dipakai.

Kapan optimasi layak dilakukan: kutipan Knuth dalam konteks yang sehat, keterbacaan sebagai fitur, keputusan berbasis profil, checklist praktis, dan penutup section Performa dan Optimasi.

Mengapa standar C++ menolak menjamin perilaku sebagian program, kategori UB yang paling sering, dan cara mendeteksinya dengan UBSan sebelum menimpa pengguna.

Membedakan implementation-defined, unspecified, dan undefined behavior, membaca keputusan implementasi di platform ini, dan kebiasaan menulis kode portabel.

Akses di luar batas array dan vector: perbedaan pembacaan dan penulisan, jebakan operator[], dan mitigasi dengan at(), span, serta pemeriksaan batas.

Mengakses memori setelah delete: mengapa blok yang sudah dilepas tetap berbahaya, pola kode yang memicunya, dan mitigasi dengan kepemilikan tunggal serta smart pointer.

Meluapnya buffer tetap di stack dan heap, fungsi C berbahaya versus lebih aman, dan cara modern C++ menyingkirkan kelas bug ini dengan std::string dan snprintf.

Luapan bilangan bulat dan konversi diam dari sudut pandang keamanan: overflow sebagai pintu masuk, aritmetika yang memeriksa dirinya, dan parsing angka yang menolak sampah.

Mekanisme format specifier injection pada printf, mengapa iostream dan std::format tidak mewarisi masalahnya, dan kebiasaan format-literal yang menutup celahnya.

Memvalidasi input dari luar secara menyeluruh — panjang, format, dan rentang — dengan whitelist dan prinsip fail-closed, memakai std::from_chars sebagai gerbang parsing yang ketat.

Mengelola memori dari sisi keamanan: membersihkan rahasia sebelum dilepas, mencegah kebocoran dengan kepemilikan otomatis, dan menangani std::bad_alloc dengan tenang.

Membuka berkas tanpa membuka celah: validasi path traversal dengan normalisasi leksikal dan pemeriksaan awalan, plus catatan ringkas tentang TOCTOU dan symlink.

Membaca entri CWE di cwe.mitre.org, memetakan lima kerentanan C++ yang paling sering muncul beserta mitigasinya, dan menyusun mitigasi berlapis.

Menutup section dengan guideline resmi — SEI CERT C++, C++ Core Guidelines, AUTOSAR — tooling pemeriksaannya, dan checklist sebelum rilis.

Memanggil kode C dari C++: extern "C", name mangling, library C standar, dan kompilasi campuran gcc/g++ yang bisa Anda coba langsung.

Apa itu ABI, mengapa C ABI stabil sedangkan C++ ABI tidak, dan kapan perbedaan ini menjadi masalah nyata pada plugin dan library biner.

Anatomi konsumsi library eksternal di C++: header + file library, instalasi sistem vs vendored vs package manager, dan praktik header-only library buatan sendiri.

Membangun library C++ ber-C ABI dan memanggilnya dari Python dengan ctypes — lengkap dengan pemetaan tipe dan perbandingan jalur binding.

Mengekspos fungsi dan class C++ ke Python dengan pybind11: anatomi PYBIND11_MODULE, konversi tipe otomatis, perbandingan dengan ctypes, dan GIL.

Menggunakan SQLite sebagai database embedded di C++: pola C API open/prepare/bind/step/finalize dan wrapper RAII mini yang diuji sungguhan.

Berbicara lewat jaringan dari C++: siklus hidup BSD sockets yang diuji sungguhan, error koneksi yang deterministik, asio, dan kapan memilih level API yang mana.

Bekerja dengan JSON di C++: pola nlohmann/json dan RapidJSON sebagai display, plus writer dan parser JSON mini buatan sendiri yang diuji sungguhan.

Mengenal OpenCV dan cv::Mat sebagai pusat computer vision C++, pola operasi dasar, instalasi, dan simulasi grayscale pada buffer piksel yang diuji sungguhan.

Menjalankan model machine learning di C++ dengan ONNX Runtime: konsep session dan tensor, pola C API sebagai display, dan pipeline inferensi mini yang diuji sungguhan.

Menulis C++ yang bertahan lintas platform: jalur file, endianness, line endings, #ifdef, perbedaan compiler, CMake, dan matriks CI — penutup section Interoperabilitas dan Ecosystem.

Apa saja yang dibutuhkan sebuah executable untuk bisa berjalan di mesin lain — dynamic linker, libc, libstdc++ — dan cara memeriksanya dengan file, ldd, serta readelf.

Membuat shared library sendiri, mengatasi 'libkalkulator.so => not found' dengan LD_LIBRARY_PATH dan rpath $ORIGIN, serta menempatkan library bersama aplikasi.

Dua strategi menyatukan program dengan library-nya: ukuran, update keamanan, startup, dan kemudahan distribusi — semuanya dibuktikan dengan biner statis dan dinamis yang dibangun nyata.

Checklist build untuk pengguna: flag -O2 dan -DNDEBUG, strip untuk membuang simbol, menyimpan debug info terpisah, penyematan versi, dan konsep reproducible builds.

Membangun biner untuk arsitektur lain dari mesin yang sama: target triple, toolchain terpisah, sysroot, toolchain file CMake, dan verifikasi hasil dengan file.

Membawa kode C++ ke browser lewat WebAssembly: kapan porting masuk akal, cara kerja emcc, batasan sandbox memori dan I/O, serta fungsi komputasi murni yang diuji dengan g++.

Menyalurkan aplikasi ke pengguna Linux: struktur FHS, merakit paket .deb sungguhan dengan dpkg-deb, tarball reproducible, dan bundle mandiri AppImage.

Aturan distribusi aplikasi C++ di Windows: pilihan toolchain, runtime MSVC dan vcredist, penempatan DLL, installer WiX/NSIS, portable apps, dan code signing.

Menyalurkan aplikasi ke pengguna macOS: bundle .app dan Info.plist, Gatekeeper, alur codesign dan notarization, universal binary dengan lipo, serta distribusi via Homebrew.

Mengelola identitas rilis: semantic versioning MAJOR.MINOR.PATCH, changelog, git tag, release notes, janji API/ABI, dan otomasi pemeriksaan versi.

Merakit paket rilis utuh: struktur bin/lib/share, metainformasi, tarball reproducible dengan checksum dan tanda tangan, mekanisme pembaruan, dan checklist rilis lengkap penutup section.

Membungkus aplikasi C++ beserta toolchain dan libc-nya ke dalam image: Dockerfile multi-stage, pemisahan image build dan runtime, volume data, serta sesi build-run terdokumentasi.

Petakan toolkit GUI C++ — Qt, GTK, SFML/SDL, dan Dear ImGui — beserta kriteria memilih, lalu buktikan paradigma event-driven dengan event loop mini yang diuji di terminal.

Buat jendela pertama dengan QApplication dan QWidget, pahami kontrak signal-slot yang melonggarkan coupling, serta dua fondasi teknisnya: moc dan ownership pohon QObject.

Kenal widget inti Qt — QLabel, QPushButton, QLineEdit, QListWidget — pahami mengapa layout menggantikan koordinat absolut, lalu hitung sendiri distribusi lebar kolom dengan stretch factor.

Mengapa semua widget hidup di satu thread UI, di mana kerja berat harus dieksekusi dengan QThread dan worker object, dan bagaimana queued signal-slot melaporkan progres kembali ke antarmuka.

Bandingkan dua model mental UI — retained mode Qt vs immediate mode Dear ImGui — pelajari boilerplate minimalnya, dan buktikan mekanismenya dengan simulasi draw list yang dibangun ulang tiap frame.

Bangun kalkulator CLI interaktif: parsing input, operasi aritmetika, validasi, dan penanganan kesalahan yang rapi.

Bangun aplikasi inventaris berbasis terminal: model data, CRUD produk, pencarian dan filter, persistensi ke file, serta pengujian.

Bangun sistem perpustakaan dengan class dan relasi antarobjek, alur peminjaman dan pengembalian, serta persistensi data ke file.

Bangun alat analisis data CSV: pembaca file, validasi baris, statistik deskriptif, dan pembuatan laporan ringkas.

Bangun simulasi antrean (queue) diskrit: model kedatangan, struktur data antrean, eksekusi simulasi, dan analisis hasil.

Bangun alat pembanding algoritma: implementasi searching dan sorting, analisis kompleksitas, dan pengukuran performa nyata.

Bangun pengelola file berbasis terminal dengan std::filesystem: penjelajahan direktori, pencarian, metadata, dan penanganan error.

Bangun aplikasi multithreaded: pembagian pekerjaan, sinkronisasi data dengan mutex dan atomic, serta pengujian kebenaran dan performa.

Bangun server chat TCP localhost: socket POSIX, satu thread per client, protokol line-based, broadcast tersinkronisasi, hingga shutdown bersih.

Bangun engine aplikasi catatan — CRUD, pencarian, persistensi file, dan antrean kejadian — yang seluruh logikanya diuji dengan g++ tanpa GUI, lalu sambungkan ke sketsa antarmuka Qt.

Memetakan dokumentasi resmi C++: cppreference.com, isocpp.org, draft standar, dan dokumentasi compiler — beserta cara membacanya secara efektif.

Peta halaman cppreference.com untuk standard library per kategori, halaman yang paling sering dipakai, dan kebiasaan membaca complexity serta requirements.

Kurasi lima buku klasik C++ beserta edisi dan sasaran pembacanya, dan cara menyusun urutan baca sesuai tahap belajar.

Menelusuri jalur sebuah fitur C++ dari proposal WG21 hingga compiler, termasuk cara membaca proposal bernomor P dan memeriksa dukungan lewat feature test macro.

Peta dokumentasi resmi GCC, Clang, MSVC, Compiler Explorer, sanitizer, dan build system — plus cara membaca profil compiler lewat macro.

Kurasi library pihak ketiga per kategori — testing, JSON, networking, graphics, GUI, dan ML — beserta kriteria memilih: lisensi, maintenance, dan dokumentasi.

Sumber contoh kode C++ yang terpercaya, metode membaca kode orang lain, dan lisensi yang perlu diperiksa sebelum meniru — dengan program ceklis baca kecil.

Kamus istilah penting course C++ dari A sampai Z beserta rujukan section-nya, ditutup program lookup kecil yang mencari arti istilah dari input pengguna.