Memilih array, vector, atau string

Section ini sudah mengenalkan lima struktur untuk menyimpan kumpulan data: array C-style, std::array, std::vector, std::string, dan std::string_view. Kini pertanyaannya bukan “bagaimana memakainya” melainkan “kapan memakai yang mana”. Pilihan yang tepat membuat kode lebih aman, lebih mudah dibaca, dan sering kali lebih cepat; pilihan yang keliru menyisakan buffer yang tidak terpantau atau alokasi yang tidak perlu. Chapter ini merangkum seluruh Section menjadi panduan keputusan yang dapat Anda pakai setiap kali memulai program baru.

Tabel Keputusan #

Struktur	Ukuran	Pemilik memori	Gunakan ketika	Hindari ketika
Array C-style	tetap, dari deklarasi	otomatis (stack)	interop dengan API C; array statis kecil	ukuran berubah; dikirim bolak-balik antar fungsi
`std::array`	tetap, bagian dari tipe	otomatis (stack)	ukuran tetap yang ingin dibawa antar fungsi tanpa decay	ukuran dinamis
`std::vector`	dinamis	dirinya sendiri (heap)	hampir semua kebutuhan koleksi	ukuran benar-benar beku dan butuh stack
`std::string`	dinamis	dirinya sendiri (heap)	teks yang dibangun, diubah, dimiliki program	hanya membaca teks yang sudah ada
`std::string_view`	tetap (pointer + panjang)	bukan pemilik	parameter baca teks dari sumber mana pun	teks harus disimpan lebih lama dari sumbernya

Dua kolom terakhir adalah intinya. Kebanyakan keputusan sehari-hari jatuh pada satu pertanyaan: apakah ukurannya berubah selama program berjalan? Bila ya, std::vector (atau std::string untuk teks) adalah jawabannya. Bila tidak, std::array memberi keamanan ukuran tanpa alokasi heap.

Panduan dalam Praktik #

Beberapa pola yang terbukti sehat di kode produksi:

Default modern: vector dan string. Keduanya mengelola memori sendiri, membawa ukuran, dan bekerja mulus dengan seluruh algoritma standard library. Mulailah dari sini, baru turun ke struktur lain bila ada alasan terukur.
Ukuran tetap → std::array. Ketika jumlah elemen memang konstanta (12 bulan, 3 axis vektor, 8 bit status), std::array<int, 12> membawa ukuran ke dalam tipenya: tanpa alokasi heap, tanpa decay ke pointer saat dikirim ke fungsi, dan tetap mendukung range-based for.
Parameter baca teks → std::string_view. Fungsi yang hanya membaca teks tidak perlu peduli apakah pemanggil mengirim std::string, literal, atau potongan string — std::string_view menerima semuanya tanpa menyalin. Aturannya satu: jangan menyimpan view lebih lama dari data sumbernya.
Array C-style hanya di batas interop. API C, buffer tetap, atau array yang didefinisikan pada scope file masih memakai bentuk lama ini. Segera bungkus dengan std::span atau salin ke vector begitu data masuk ke wilayah C++ murni.

Program kecil berikut menunjukkan ketiga pilihan utama dipakai pada situasi yang paling cocok untuk masing-masing:

cpp

#include <array>
#include <iostream>
#include <string>
#include <vector>

int main() {
    // Ukuran tetap & dikenal sejak awal -> std::array
    std::array<int, 3> bulanKuartal = {1, 2, 3};
    std::cout << "array  : size = " << bulanKuartal.size() << "\n";

    // Ukuran berubah mengikuti data -> std::vector
    std::vector<std::string> tugas;
    tugas.push_back("desain");
    tugas.push_back("uji");
    std::cout << "vector : size = " << tugas.size() << "\n";

    // Teks yang tumbuh -> std::string
    std::string salam = "Halo";
    salam += ", Budi";
    std::cout << "string : " << salam << "\n";

    return 0;
}

Output yang Dihasilkan:

text
array  : size = 3
vector : size = 2
string : Halo, Budi

Mari kita telaah apa yang terjadi pada baris-baris kode di atas:

Baris 8: jumlah bulan dalam kuartal memang selalu tiga — ukuran yang beku dan dikenal sejak kompilasi. std::array<int, 3> menyimpan fakta itu di dalam tipenya sehingga kesalahan ukuran tertangkap saat kompilasi.
Baris 12-14: daftar tugas tumbuh mengikuti kebutuhan. std::vector menyerap penambahan tanpa kita mengurus memori, dan size() selalu akurat.
Baris 18-19: sapaan dibangun bertahap dari dua potongan. std::string menangani penyambungan dan alokasinya sendiri; += memperpanjang isi dengan aman.

Biaya yang Ikut Pilihan #

Struktur yang berbeda membawa biaya berbeda, dan mengetahuinya membuat keputusan lebih berbobot. Array C-style dan std::array hidup di stack ketika menjadi variabel lokal: alokasinya nyaris tanpa biaya, tetapi ukurannya harus masuk akal karena stack berkapasitas terbatas. std::vector dan std::string menyimpan datanya di heap: ukuran bebas tumbuh, dengan biaya alokasi yang dibayar sekali per penataan ulang — mekanisme size versus capacity pada chapter sebelumnya menjelaskan seberapa jarang biaya itu muncul. std::string_view menonaktifkan salinan sama sekali, sehingga paling murah untuk dibaca, tetapi pengorbanannya adalah tanggung jawab umur data yang kini ada di tangan pemanggil.

Dengan panduan ini, Section Array dan String tuntas: Anda kini dapat menyimpan data berukuran tetap maupun berubah, memproses teks, dan memilih struktur yang sesuai. Section berikutnya, Pointer dan Reference, turun satu lapis lagi — membedah bagaimana C++ mengalamatkan data di memori, fondasi yang membuat semua struktur di Section ini bekerja.